两个字符串中的唯一字符对

Question

所以我需要一些锻炼帮助，我被困住了！放轻松，我对此很陌生。练习如下：

给定两个长度相等的 char 数组，确定第一个数组中的每个字符是否可以唯一地替换为第二个数组中的字符，以使两个数组相等。显示两个数组之间的字符对。

示例 1： 给定以下输入：aab 和 ttd，控制台将显示：

True
a => t
b => d

示例 2： 给定以下输入：aba 和 ttd，控制台将显示：

False

在第二个示例中，答案是 False，因为字符 a 没有唯一的替换符：t 和 d 都对应。

我一直在为此烦恼，老实说，我觉得我什至无法再思考了。已经对代码进行了很多次调整，以至于我几乎不再理解它了。虽然它仍然通过了第一个测试，但似乎一直未能通过更长的字符串输入的测试。例如输入：ala bala portocala 和cuc dcuc efghijcuc，控制台显示True，然后是对，这是不对的。下面你有我的 POS 码，欢迎任何建议。

static void Main(string[] args)
    {
        string a = Console.ReadLine();
        string b = Console.ReadLine();

        string one = string.Empty;
        string two = string.Empty;

        bool res = false;
        int count = 0;

        for (int i = 0; i < a.Length; i++) 
        {
            if (!one.Contains(a[i].ToString()))
            {
                if (!two.Contains(b[i].ToString())) 
                {
                    one += a[i];
                    two += b[i];
                }
            }
        }

        char[] firstPhrase = new char[one.Length];
        char[] scndPhrase = new char[two.Length];

        for(int i = 0; i < one.Length; i++) 
        {
            bool temp = false;
            for(int j = 0; j < two.Length; j++) 
            {
                if(firstPhrase[j] != one[i]) 
                {
                    for(int k = 0; k < scndPhrase.Length; k++) 
                    {
                        if(scndPhrase[j] == two[i]) { res = true; break; }

                    }
                    if(res == true) { break; }
                    else { continue; }
                }
                if(firstPhrase[j] == one[i]) 
                {
                    if (scndPhrase[j] == two[i]) { temp = true; continue; }
                    else { res = true; break; }
                }

            }
            if(temp == false) 
            {
                firstPhrase[count] = one[i];
                scndPhrase[count] = two[i];
                count++;
            }
            if(res == true) { break; }
        }


        if (res == true)
            Console.WriteLine(res);
        else
        {
            Console.WriteLine(!res);
            for (int i = 0; i < firstPhrase.Length; i++)
            {
                Console.WriteLine($"{firstPhrase[i]} => {scndPhrase[i]}");
            }
        }
        Console.Read();
    }

期待您的批评，祝大家复活节快乐！

编辑：忘了提，对不起各位。测试不允许使用 LINQ 或任何其他指令，LINQ 实际上是我想尝试的第一件事。

Answer 1

这是一个仅使用 System 命名空间的解决方案。

这里的重要部分是先将两个数组中的字符都更改为标记。

这意味着，对于“ala bala portocala”，我们将拥有：

{ 0, 1, 0, 2, 3, 0, 1, 0, 2, 4, 5, 6, 7, 5, 8, 0, 1, 0 }

所以每当找到一个新字符（以前没有出现过）时，我们都会将数字加 1。

您可以看到，从这个有趣的角度来看，这可以很好地评估两个 char 数组是否匹配。

static int[] Tokenize(char[] array)
{
    int length = array.Length;
    int[] distinctArray = new int[length];
    int offset = 0;
    for (int i = 0; i < length; i++)
    {
        bool appearedBefore = false;
        for (int j = 0; j < i; j++)
        {
            if (array[j] == array[i])
            {
                appearedBefore = true;
                distinctArray[i] = distinctArray[j];
                break;
            }
        }
        if (!appearedBefore)
        {
            distinctArray[i] = offset;
            offset++;
        }
    }
    return distinctArray;
}

然后是测试方法：

static void Test(char[] array1, char[] array2)
{
    Console.WriteLine("[{0}] VS [{1}]", new string(array1), new string(array2));

    int[] array1Tokenized = Tokenize(array1);
    int[] array2Tokenized = Tokenize(array2);

    for (int i = 0; i < array1.Length; i++)
    {
        if (array1Tokenized[i] != array2Tokenized[i])
        {
            Console.WriteLine("False");
            return;
        }
    }

    Console.Write("True");
    for (int i = 0; i < array1.Length; i++)
    {
        bool appearedBefore = false;
        for (int j = 0; j < i; j++)
        {
            if (array1[j] == array1[i])
            {
                appearedBefore = true;
                break;
            }
        }
        if (!appearedBefore && array1[i] != array2[i])
        {
            Console.Write(" {0} => {1}", array1[i], array2[i]);
        }
    }
    Console.WriteLine();
}

结果：

static void Main(string[] args)
{
    Test("ala bala portocala".ToCharArray(), "cuc dcuc efghijcuc".ToCharArray());

    Test("ala bala portocala".ToCharArray(), "cuc dcuc efghfjcuc".ToCharArray());

    Test("aab".ToCharArray(), "ttd".ToCharArray());
}

输出：

[ala bala portocala] VS [cuc dcuc efghijcuc]
False

[ala bala portocala] VS [cuc dcuc efghfjcuc]
True a => c l => u b => d p => e o => f r => g t => h c => j

[aab] VS [ttd]
True a => t b => d

Answer 2

这是一个仅使用 System 命名空间的简短解决方案。基本上，我们需要做的就是并行遍历字符串一次，并为每个位置检查每个字符串中的字符是否相互映射。分三种情况：

1. 字符之前没有被映射，此时我们将它们相互映射；
2. 字符已经相互映射，在这种情况下我们继续；
3. 其中一个字符已经映射，但没有映射到另一个字符，在这种情况下没有有效的解决方案，所以我们返回 null。

为了跟踪映射，我们使用两个并行数组，mappings 和 reverseMappings。由于字符只是数字，我们可以使用第一个字符的值作为映射数组的索引，并将该值设置为等于第二个字符。反向映射也是一样，但字符相反。 （只要映射数组足够大，可以处理我们期望的每个可能的字符值，这将起作用。对于 ASCII，128 是所需的最大大小。对于 Unicode，它需要是 65536。）我们继续计数到目前为止我们已经看到了多少对。这是必要的，以便我们知道返回数组（数组的 n×2 数组）有多大，它将包含输出所需的实际字符对。我们通过扫描一次映射数组来构造它，查找所有具有非零值的映射。

public char[][] GetCharacterMappings(string s1, string s2)
{
    if (s1 == null || s2 == null || s1.Length != s2.Length) return null;

    // I'm assuming the inputs can only be in the ASCII character set;
    // If they can have any Unicode character, make this value larger (e.g. 65536) 
    const int maxCharValue = 128;
    char[] mappings = new char[maxCharValue];
    char[] reverseMappings = new char[maxCharValue];
    int pairCount = 0;

    for (int i = 0; i < s1.Length; i++)
    {
        char c1 = s1[i];
        char c2 = s2[i];

        if (mappings[c1] == 0 && reverseMappings[c2] == 0)
        {
            // these characters have not been mapped before
            mappings[c1] = c2;
            reverseMappings[c2] = c1;
            pairCount++;
        }
        else if (mappings[c1] != c2 || reverseMappings[c2] != c1)
        {
            // either character is already mapped to some other character
            return null;
        }
    }

    char[][] pairs = new char[pairCount][];
    int p = 0;
    for (int i = 0; i < maxCharValue; i++)
    {
        if (mappings[i] != 0)
            pairs[p++] = new char[] { (char)i, mappings[i] };
    }

    return pairs;
}

输出例程只检查配对是否为空，如果不是，则将它们全部转储：

public void WriteResult(char[][] pairs)
{
    Console.WriteLine(pairs != null);
    if (pairs != null)
    {
        for (int i = 0; i < pairs.Length; i++)
        {
            Console.WriteLine(pairs[i][0] + " => " + pairs[i][1]);
        }
    }
}

这是一个工作演示：https://dotnetfiddle.net/lBHKUY

Answer 3

这是一个使用 LINQ 的解决方案：

var result = str1.Zip(str2, (f, s) =>  f.ToString() + s.ToString())
                 .GroupBy(c => c[0])
                 .Where(c => c.Select(d => d[1]).Distinct()
                 .Skip(1).Any()).Any() ? false : true;

您只需将using System.Linq 添加到您的 using 指令即可。

您可以在这里在线查看结果：https://dotnetfiddle.net/OF2cnO

Answer 4

考虑使用 .NET 字典。当下面的函数返回 null 时，没有一致的映射。当它返回一个字典时，它的内容将是映射。我编译了这个，我没有测试它..

public static Dictionary<char, char> BuildMapping(string s1, string s2)
{
    if (s1.Length != s2.Length) return null;
    Dictionary<char, char> result= new Dictionary<char, char>();
    for (int i = 0; i < s2.Length; i++)
    {
        if (result.ContainsKey(s1[i]))
            if (result[s1[i]] == s2[i]) continue;
            else return null;
        result[s1[i]] = s2[i];
    }
    return result;
}