C# 合并字符串检查器（自定义规则）

编写一个算法，检查给定字符串

s

是否可以由另外两个字符串

part1

和

part2

组成

限制是

part1

和

part2

中的字符顺序与

s

中的相同

例如：

'codewars' is a merge from 'cdw' and 'oears':

s:  c o d e w a r s   = codewars
part1:  c   d   w         = cdw
part2:    o   e   a r s   = oears

但是在测试用例中，要让它工作起来并不那么容易

规则说它们必须是相同的长度和顺序，但是对于随机测试用例，它们也被放在随机顺序中。。 所以规则与规则冲突，那么我如何才能让它工作

遵循规则的测试用例：

[Test]
public void SadPath2()
{
    Assert.IsFalse(StringMerger.isMerge("codewars", "code", "wasr"), "Codewars can't be created from code and wasr");
}
SadPath2 == false;

[Test]
public void SadPath1()
{
    Assert.IsFalse(StringMerger.isMerge("codewars", "cod", "wars"), "Codewars are not codwars");
}
SadPath1 == false;

[Test]
public void HappyPath2()
{
     Assert.IsTrue(StringMerger.isMerge("codewars", "cdwr", "oeas"), "codewars can be created from cdwr and oeas");
}
HappyPath2 == true;

[Test]
public void HappyPath1()
{
     Assert.IsTrue(StringMerger.isMerge("codewars", "code", "wars"), "codewars can be created from code and wars");
}
HappyPath1 == true;

一些可能不完全遵循规则的随机测试：

[Test]
public void RandomTest()
{
    Assert.IsTrue(StringMerger.isMerge("[W`meSnw(R1qaLLqc[=]=UAvTa_3%", "W`mnwqaLL]=va%", "[eS(R1qc[=UAT_3"), "'[W`meSnw(R1qaLLqc[=]=UAvTa_3%' is a merge of 'W`mnwqaLL]=va%' and '[eS(R1qc[=UAT_3'");
}    
RandomTest == true;

[Test]
public void RandomTest2()
{
    Assert.IsTrue(StringMerger.isMerge("]ftUNn7-XoX4AZ3i1+", "U7oX4A1+", "]ftNn-XZ3i"), "']ftUNn7-XoX4AZ3i1+' is a merge of 'U7oX4A1+' and ']ftNn-XZ3i");
}
RandomTest2 == true;

在我的类上的第一个示例中，它可以成功运行除SadPath2之外的所有测试：

public class StringMerger
{
    public static bool isMerge(string s, string part1, string part2)
    {
        int num = 0;
        string txt1 = "";
        Console.WriteLine("S - " + s + " - P1 - " + part1 + " - P2 - " + part2);

        #region Sorting
        foreach (var itm in s)
        {
            if (part1.Contains(itm.ToString()))
                num++;
            else if (part2.Contains(itm.ToString()))
                num++;
        }
        #endregion

        if (num == s.Length && num == (part1.Length + part2.Length))
                return true;


        return false;
    }
}

第二个示例，它可以运行除随机测试以外的所有测试：

public class StringMerger
{
    public static bool isMerge(string s, string part1, string part2)
    {
        int num = 0;
        int P1 = 0;
        int P2 = 0;
        bool p2 = false;
        string txt1 = "";

        #region Sorting
        foreach (var itm in s)
        {
            if (part1.Contains(itm.ToString()))
                num++;
            else if (part2.Contains(itm.ToString()))
                num++;

            try
            {
                if (p2 == false)
                {
                    txt1 = txt1 + GetLetterP1(part1, itm.ToString(), P1);
                    P1++;
                    p2 = true;
                }
                else
                {
                    txt1 = txt1 + GetLetterP2(part2, itm.ToString(), P2);
                    P2++;
                    p2 = false;
                }
            }
            catch { }
        }
        #endregion

        if (num == s.Length && num == (part1.Length + part2.Length))
        {
            if (s.Contains(part1 + part2))
                return true;
            else if (txt1 == s)
                return true;
        }


        return false;
    }

    static string GetLetterP1(string p1, string letter, int n)
    {
        string itm = "";
        if (p1.Contains(letter))
            itm = p1[n].ToString();
        return itm;
    }

    static string GetLetterP2(string p2, string letter, int n)
    {
        string itm = "";
        if (p2.Contains(letter))
            itm = p2[n].ToString();
        return itm;
    }
}

使用

Kvam的结果

回答：（使用最新的修复程序）

使用

Max的结果

回答：（使用最新修复）

使用

codersl的结果

回答：（使用最新修复）

---

我认为这应该涵盖需求，尽管您可能希望重写它以避免到处创建字符串

public bool IsMatch(string target, string part1, string part2)
{
    if (target.Length != part1.Length + part2.Length)
    {
        return false;
    }
    if (target == "")
    {
        return true;
    }

    if (part1.Length > 0 && target[0] == part1[0])
    {
        if (IsMatch(target.Substring(1), part1.Substring(1), part2.Substring(0)))
        {
            return true;
        }
    }
    if (part2.Length > 0 && target[0] == part2[0])
    {
        if (IsMatch(target.Substring(1), part1.Substring(0), part2.Substring(1)))
        {
            return true;
        }
    }

    return false;
}

这是我的2美分

public bool IsMerge(string target, string part1, string part2)
{
    if (String.IsNullOrEmpty(target))
    {
        throw new ArgumentNullException("target");
    }

    if (String.IsNullOrEmpty(part1))
    {
        throw new ArgumentNullException("part1");
    }

    if (String.IsNullOrEmpty(part2))
    {
        throw new ArgumentNullException("part2");
    }

    if (target.Length == (part1.Length + part2.Length))
    {
        return this.IsPart(target, part1) && this.IsPart(target, part2);
    }

    return false;
}

private bool IsPart(string target, string part)
{
    int idx = -1;
    int lastIdx = 0;

    for (int i = 0; i < part.Length; i++)
    {
        idx = (target.IndexOf(part[i], lastIdx));
        if (!(idx > -1))
        {
            return false;
        }

        lastIdx = idx;
    }

    return true;
}

public bool IsMerge（字符串目标、字符串部分1、字符串部分2）
{
if（String.IsNullOrEmpty（目标））
{
抛出新的ArgumentNullException（“目标”）；
}
if（String.IsNullOrEmpty（part1））
{
抛出新的ArgumentNullException（“part1”）；
}
if（String.IsNullOrEmpty（第2部分））
{
抛出新的ArgumentNullException（“part2”）；
}
if（target.Length==（part1.Length+part2.Length））
{
返回此.IsPart（target，part1）和&this.IsPart（target，part2）；
}
返回false；
}
私有bool IsPart（字符串目标，字符串部分）
{
intidx=-1；
int lastIdx=0；
对于（int i=0；i-1））
{
返回false；
}
lastIdx=idx；
}
返回true；
}

我的2美分

public static void Main()
{
    Console.WriteLine(Check("codewars", "code", "wasr")); //false
    Console.WriteLine(Check("codewars", "cod", "wars")); //false
    Console.WriteLine(Check("codewars", "cdwr", "oeas"));
    Console.WriteLine(Check("codewars", "code", "wars"));
    Console.WriteLine(Check("[W`meSnw(R1qaLLqc[=]=UAvTa_3%", "W`mnwqaLL]=va%", "[eS(R1qc[=UAT_3"));
    Console.WriteLine(Check("]ftUNn7-XoX4AZ3i1+", "U7oX4A1+", "]ftNn-XZ3i"));
    Console.WriteLine(Check("acab", "ab", "ac"));
    Console.WriteLine(Check("b]aDw- !oKJnOJ", "b]aDwoKJ", "- !nOJ"));
    Console.WriteLine(Check("codewars", "codewarss", "")); //false
    Console.WriteLine(Check("codewars", "", "")); //false
    Console.WriteLine(Check("codewars", "codewars", null));
    Console.WriteLine(Check("Bananas from Bahamas", "Bahas", "Bananas from am"));
}

private static bool Check(string s, string part1, string part2)
{
    if (part1 == null)
        part1 = "";

    if (part2 == null)
        part2 = "";

    var part1Index = 0;
    var part2Index = 0;
    var bothMatch = "";

    foreach(var c in s)
    {
        // handle both strings matching
        if (part1Index < part1.Length && part2Index < part2.Length && c == part1[part1Index] && c == part2[part2Index])
        {
            bothMatch += c;
            part1Index++;
            part2Index++;
            continue;
        }

        if (bothMatch.Length > 0 && c == part1[part1Index])
        {
            // part2 doesn't match anymore so roll back its index
            part2Index -= bothMatch.Length;
            bothMatch = "";
        }
        else if (bothMatch.Length > 0 && c == part2[part2Index])
        {
            // part1 doesn't match anymore so roll back its index
            part1Index -= bothMatch.Length;
            bothMatch = "";
        }

        // handle one string matching
        if (part1Index < part1.Length && c == part1[part1Index])
        {
            //Console.WriteLine("c={0}, p1={1}", c, part1[part1Index]);
            part1Index++;
            continue;
        }
        if (part2Index < part2.Length && c == part2[part2Index])
        {
            //Console.WriteLine("c={0}, p2={1}", c, part2[part2Index]);
            part2Index++;
            continue;
        }

        //Console.WriteLine("c={0}, p1={1}, p2={2}, both={3}", c, part1[part1Index], part2[part2Index], bothMatch);
        return false;
    }
    return (part1Index == part1.Length) && (part2Index == part2.Length);
}

publicstaticvoidmain（）
{
Console.WriteLine（检查（“代码战争”、“代码”、“wasr”）；//false
Console.WriteLine（检查（“codewars”、“cod”、“wars”）；//false
控制台写入线（检查（“代码战争”、“cdwr”、“oeas”）；
控制台写入线（检查（“代码战争”，“代码”，“战争”））；
控制台写入线（勾选“[W`meSnw（R1qaLLqc[=]=UAvTa_3%，“W`mnwqaLL]=va%，[eS（R1qc[=UAT_3”）；
控制台写入线（检查“]ftUNn7-XoX4AZ3i1+”、“U7oX4A1+”、“]ftNn-XZ3i”）；
控制台写入线（检查（“acab”、“ab”、“ac”）；
控制台写入线（检查“b]aDw-！oKJnOJ”，“b]aDwoKJ”，“-！nOJ”）；
Console.WriteLine（检查（“代码战争”，“代码战争”，“代码战争”）；//false
Console.WriteLine（检查（“代码战争”，“代码战争”，“代码战争”）；//false
控制台.WriteLine（检查（“代码战争”，“代码战争”，null））；
控制台。书写线（勾选（“来自巴哈马群岛的香蕉”、“巴哈马群岛的香蕉”、“来自am的香蕉”）；
}
专用静态布尔检查（字符串s、字符串部分1、字符串部分2）
{
if（part1==null）
第1部分=”；
if（part2==null）
第2部分=”；
var Part1指数=0；
var Part2指数=0；
var bothMatch=“”；
foreach（s中的变量c）
{
//处理两个匹配的字符串
如果（part1索引0&&c==part1[part1Index]）
{
//第2部分不再匹配，因此回滚其索引
第2部分索引-=两个匹配长度；
bothMatch=“”；
}
否则如果（bothMatch.Length>0&&c==part2[part2Index]）
{
//part1不再匹配，因此请回滚其索引
第1部分索引-=两个匹配长度；
bothMatch=“”；
}
//处理一个字符串匹配
如果（part1索引

让我说清楚。你有一个由两个字符串合并而成的字符串，你想检查一个特定的字符串是否由两个字符串合并作为输入？例如，以你的例子。

codewars

是

code

和

wars

的合并，所以用

codewars

和

wars

进行检查是否应返回true，其中

codewars

，

cdoe

，

wars

应返回false？@Bauss从问题的第一行开始：“'codewars'是'cdw'和'oears'的合并”，所以不仅是子字符串，而且是子特许权为了公平起见，如果Max的程序为CanHandleEmpty抛出一个参数null异常，我看不出Kvam是如何通过测试的——尽管我认为在这种情况下从未指定过正确的行为。无论如何，这很有趣！）初看效果很好，但无法处理所有的随机性。不完美，但有一个好的开始。你的代码几乎完美，只是有两个

索引超出范围

错误。现在在开始时添加了一个长度相等的检查，应该可以修复超出范围的错误。我不确定如何处理，但你的代码一开始运行不正常，但后来突然运行起来了很明显，对于输入s：“acab”，第1部分：“ab”，第2部分：“ac”，这将失败。什么是“香蕉”？s“来自巴哈马的香蕉”—P1“巴哈马”—P2“来自am的香蕉”—这次得到了！…）