Сравнение строк с допуском

Question

Я ищу способ сравнить строку с массивом строк. Конечно, выполнить точный поиск довольно просто, но я хочу, чтобы моя программа допускала орфографические ошибки, пропущенные части строки и т. Д.

Есть ли какая-то структура, которая может выполнять такой поиск? Я имею в виду, что алгоритм поиска будет возвращать несколько результатов в процентном соотношении или что-то вроде этого.

Answer 1

Вы можете использовать алгоритм Левенштейна .

"Расстояние Левенштейна между двумя строками определяется как минимальное количество правок, необходимых для преобразования одной строки в другую, с допустимыми операциями редактирования, такими как вставка, удаление или замена одного символа." * - Wikipedia.com

Это от dotnetperls.com :

using System;

/// <summary>
/// Contains approximate string matching
/// </summary>
static class LevenshteinDistance
{
    /// <summary>
    /// Compute the distance between two strings.
    /// </summary>
    public static int Compute(string s, string t)
    {
        int n = s.Length;
        int m = t.Length;
        int[,] d = new int[n + 1, m + 1];

        // Step 1
        if (n == 0)
        {
            return m;
        }

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

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

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

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

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

class Program
{
    static void Main()
    {
        Console.WriteLine(LevenshteinDistance.Compute("aunt", "ant"));
        Console.WriteLine(LevenshteinDistance.Compute("Sam", "Samantha"));
        Console.WriteLine(LevenshteinDistance.Compute("flomax", "volmax"));
    }
}

На самом деле вы можете предпочесть использовать алгоритм расстояния Дамерау-Левенштейна , который также позволяет транспонировать символы, что является обычной человеческой ошибкой при вводе данных. Вы найдете его реализацию на C # здесь .

Answer 2

В платформе .NET нет ничего, что помогло бы вам с этим из коробки.

Наиболее распространенными орфографическими ошибками являются те, в которых буквы являются приличным фонетическим представлением слова, но не являются правильным написанием слова.

Например, можно утверждать, что слова sword и sord (да, это слово) имеют одинаковые фонетические корни (они звучат одинаково, когда вы произносите их).

При этом существует ряд алгоритмов, которые вы можете использовать для перевода слов (даже ошибочных) в фонетические варианты.

Первый - Soundex . Это довольно просто реализовать, и существует значительное количество .NET-реализаций этого алгоритма . Это довольно просто, но дает реальные значения, которые вы можете сравнить друг с другом.

Другой - Метафон . Хотя я не могу найти нативную реализацию .NET для Metaphone, предоставленная ссылка содержит ссылки на ряд других реализаций, которые можно преобразовать. Самым простым для преобразования, вероятно, была бы реализация Java алгоритма Metaphone .

.

Следует отметить, что алгоритм Metaphone прошел ревизии. Существует Двойной метафон (который имеет реализацию .NET ) и Метафон 3 . Metaphone 3 является коммерческим приложением, но имеет точность 98% по сравнению с 89% точностью алгоритма Double Metaphone при работе с базой данных общих английских слов. В зависимости от ваших потребностей, вы можете найти (в случае Double Metaphone) или купить (в случае Metaphone 3) исходный код для алгоритма и преобразовать или получить к нему доступ через уровень P / Invoke (есть реализации C ++). имеются в большом количестве).

Метафон и Soundex отличаются в том смысле, что Soundex производит цифровые клавиши фиксированной длины, тогда как Metaphone производит ключи различной длины, поэтому результаты будут разными. В конце концов, оба сделают для вас одинаковое сравнение, вам просто нужно выяснить, что лучше всего соответствует вашим потребностям, учитывая ваши требования и ресурсы (и, конечно, уровни нетерпимости к орфографическим ошибкам).

Answer 3

Вот реализация метода LevenshteinDistance, который использует гораздо меньше памяти при получении тех же результатов. Это адаптация псевдокода на C #, описанная в статье в википедии под заголовком «Итеративный с двумя строками матрицы».

public static int LevenshteinDistance(string source, string target)
{
    // degenerate cases
    if (source == target) return 0;
    if (source.Length == 0) return target.Length;
    if (target.Length == 0) return source.Length;

    // create two work vectors of integer distances
    int[] v0 = new int[target.Length + 1];
    int[] v1 = new int[target.Length + 1];

    // initialize v0 (the previous row of distances)
    // this row is A[0][i]: edit distance for an empty s
    // the distance is just the number of characters to delete from t
    for (int i = 0; i < v0.Length; i++)
        v0[i] = i;

    for (int i = 0; i < source.Length; i++)
    {
        // calculate v1 (current row distances) from the previous row v0

        // first element of v1 is A[i+1][0]
        //   edit distance is delete (i+1) chars from s to match empty t
        v1[0] = i + 1;

        // use formula to fill in the rest of the row
        for (int j = 0; j < target.Length; j++)
        {
            var cost = (source[i] == target[j]) ? 0 : 1;
            v1[j + 1] = Math.Min(v1[j] + 1, Math.Min(v0[j + 1] + 1, v0[j] + cost));
        }

        // copy v1 (current row) to v0 (previous row) for next iteration
        for (int j = 0; j < v0.Length; j++)
            v0[j] = v1[j];
    }

    return v1[target.Length];
}

Вот функция, которая даст вам сходство в процентах.

/// <summary>
/// Calculate percentage similarity of two strings
/// <param name="source">Source String to Compare with</param>
/// <param name="target">Targeted String to Compare</param>
/// <returns>Return Similarity between two strings from 0 to 1.0</returns>
/// </summary>
public static double CalculateSimilarity(string source, string target)
{
    if ((source == null) || (target == null)) return 0.0;
    if ((source.Length == 0) || (target.Length == 0)) return 0.0;
    if (source == target) return 1.0;

    int stepsToSame = LevenshteinDistance(source, target);
    return (1.0 - ((double)stepsToSame / (double)Math.Max(source.Length, target.Length)));
}

Answer 4

Другой вариант - фонетическое сравнение с использованием Soundex или Metaphone. Я только что закончил статью, в которой представлен код C # для обоих алгоритмов. Вы можете просмотреть его на http://www.blackbeltcoder.com/Articles/algorithms/phonetic-string-comparison-with-soundex.

Answer 5

Вот два метода, которые вычисляют Расстояние Левенштейна между строками.

Расстояние Левенштейна между двумя строками определяется как минимальное количество правок, необходимых для преобразования одной строки в другую, при этом допустимыми операциями редактирования являются вставка, удаление или подстановка одного символа.

Как только вы получите результат, вам нужно будет определить, какое значение вы хотите использовать в качестве порога для совпадения или нет. Запустите функцию для набора образцов данных, чтобы получить представление о том, как она работает, чтобы помочь определиться с вашим конкретным порогом.

    /// <summary>
    /// Calculates the Levenshtein distance between two strings--the number of changes that need to be made for the first string to become the second.
    /// </summary>
    /// <param name="first">The first string, used as a source.</param>
    /// <param name="second">The second string, used as a target.</param>
    /// <returns>The number of changes that need to be made to convert the first string to the second.</returns>
    /// <remarks>
    /// From http://www.merriampark.com/ldcsharp.htm
    /// </remarks>
    public static int LevenshteinDistance(string first, string second)
    {
        if (first == null)
        {
            throw new ArgumentNullException("first");
        }
        if (second == null)
        {
            throw new ArgumentNullException("second");
        }

        int n = first.Length;
        int m = second.Length;
        var d = new int[n + 1, m + 1]; // matrix

        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 = (second.Substring(j - 1, 1) == first.Substring(i - 1, 1) ? 0 : 1); // cost
                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];
    }

Answer 6

Вы можете найти реализации soundex и алгоритмов расстояния Левенштейна в открытом коде Проект CommonLibrary.NET .