Алгоритм нечеткого сравнения строк

    public class StringSimilarComparer : IEqualityComparer<string>
    {
        public bool Equals(string x, string y)
        {
            return AreSimilar(x, y);
        }
 
        public int GetHashCode(string obj)
        {
            return obj.GetHashCode();
        }
 
        public static bool AreSimilar(string s1, string s2)
        {
            if (s1 == null) return false;// throw new ArgumentNullException("s1");
            if (s2 == null) return false;//throw new ArgumentNullException("s2");
 
            if (s1 == String.Empty || s2 == string.Empty)
                return false;
 
            StringBuilder strMax, strMin;
            if (s1.Length >= s2.Length)
            {
                strMax = new StringBuilder(s1);
                strMin = new StringBuilder(s2);
            }
            else
            {
                strMax = new StringBuilder(s2);
                strMin = new StringBuilder(s1);
            }
 
            int ind1, ind2;
            var lastSub = LongestCommonSubstring(strMax, strMin, out ind1, out ind2);
 
            if (lastSub <= 0) //вообще нет ничего общего
                return false;
 
            if (lastSub >= strMin.Length)
                return true;//наименьшая строка полностью входит в наибольшую, либо равна ей
 
            const int strong = 1;
            const int strong2 = 1;
 
            int length = 0;
 
            do
            {
                length += lastSub;
                strMax.Remove(ind1, lastSub);
                strMin.Remove(ind2, lastSub);
                lastSub = LongestCommonSubstring(strMax, strMin, out ind1, out ind2);
 
            } while ((lastSub >= 2 + strong ) || (lastSub > 0 && char.IsDigit(strMax[ind1])));
 
 
            int length1 = s1.Length;
            int length2 = s2.Length;
 
            int min1 = (int)(length1 * 0.20f); //20% от общей длины строки
            int min2 = (int)(length2 * 0.20f);
 
            return ((length1 - min1 + strong <= length) || (length2 - min2 + strong <= length));
        }
 
        private static int LongestCommonSubstring(StringBuilder str1, StringBuilder str2, out int str1Offset, out int str2Offset)
        {
            if (str1 == null) throw new ArgumentNullException("str1");
            if (str2 == null) throw new ArgumentNullException("str2");
 
 
            if (str1.Length <= 0 || str2.Length <= 0)
            {
                str1Offset = -1;
                str2Offset = -1;
                return 0;
            }
 
            int[,] num = new int[str1.Length, str2.Length];
 
            int maxlen = 0;
            int saveIndexI = 0;
            int saveIndexJ = 0;
 
            for (int i = 0; i < str1.Length; i++)
            {
                for (int j = 0; j < str2.Length; j++)
                {
                    if (char.ToLower(str1[i]) != char.ToLower(str2[j]))
                    {
                        num[i, j] = 0;
                    }
                    else
                    {
                        if ((i == 0) || (j == 0))
                        {
                            num[i, j] = 1;
                        }
                        else
                        {
                            num[i, j] = 1 + num[i - 1, j - 1];
                        }
 
                        if (num[i, j] > maxlen)
                        {
                            maxlen = num[i, j];
                            saveIndexI = i;
                            saveIndexJ = j;
                        }
                    }
                }
            }
 
            str1Offset = saveIndexI - maxlen + 1;
            str2Offset = saveIndexJ - maxlen + 1;
 
            return maxlen;
        }
    }