比較 C# 中兩個不同長度字符串中的字符

Question

在 C# 中，我試圖比較兩個字符串並找出有多少字符不同。

我試過這個：

static void Main(String[] args)
{
    var strOne = "abcd";
    var strTwo = "bcd";

    var arrayOne = strOne.ToCharArray();
    var arrayTwo = strTwo.ToCharArray();

    var differentChars = arrayOne.Except(arrayTwo);

    foreach (var character in differentChars)
        Console.WriteLine(character);  //Will print a
}

但這有問題：

1. 如果字符串包含相同的字符但在字符串中的不同位置
2. 它消除了重復的出現

如果字符串的長度相同，我會一一比較字符，但如果一個大於另一個，則位置不同

Answer 1

這個怎么樣？ Append 將兩個字符串合二為一並將它們分組，您將獲得字符數，> 1 將給出重復值，= 0 將給出唯一值。

var strOne = "abcd";
var strTwo = "bcd";

var arrayOne = strOne.Concat(strTwo).GroupBy(x => x).Select(x => new { Key = x.Key, Count = x.Count() });

foreach (var character in arrayOne) {
    if (character.Count > 1)
    {
        Console.WriteLine(character.Key); // the repeating chars
    }
}

如果同一個字符在同一個字符串中出現兩次，

 var strOne = "abbcdd";
 var strTwo = "cd";

 var arrayTwo = strOne.Select(x => new { Key = x, IsExists = strTwo.Any(y => y == x) });

 foreach (var character in arrayTwo) {
     if (character.IsExists)
     {
        Console.WriteLine(character.Key);
     }
 }

Answer 2

您可能想看看Leventshtein Distance Algorithm 。

正如文章所說

兩個單詞之間的 Levenshtein 距離是將一個單詞更改為另一個單詞所需的最小單字符編輯（插入、刪除或替換）次數

您可以在 Internet 上找到許多參考實現，例如此處或此處。

public static int LevenshteinDistance(string s, string t)
    {
        int n = s.Length;
        int m = t.Length;
        int[,] d = new int[n + 1, m + 1];

        if (n == 0)
        {
            return m;
        }

        if (m == 0)
        {
            return n;
        }

        for (int i = 0; i <= n; d[i, 0] = i++)
        {
        }

        for (int j = 0; j <= m; d[0, j] = j++)
        {
        }

        for (int i = 1; i <= n; i++)
        {
            for (int j = 1; j <= m; j++)
            {
                int cost = (t[j - 1] == s[i - 1]) ? 0 : 1;

                d[i, j] = Math.Min(
                    Math.Min(d[i - 1, j] + 1, d[i, j - 1] + 1),
                    d[i - 1, j - 1] + cost);
            }
        }
        return d[n, m];
    }
}