it-swarm.com.de

Entfernung in Python bearbeiten

Ich programmiere ein Programm zur Rechtschreibprüfung in Python. Ich habe eine Liste gültiger Wörter (das Wörterbuch), und ich muss eine Liste von Wörtern aus diesem Wörterbuch ausgeben, die einen Bearbeitungsabstand von 2 von einem bestimmten ungültigen Wort haben. 

Ich weiß, dass ich zunächst eine Liste mit einem Bearbeitungsabstand von eins aus dem ungültigen Wort generieren muss (und dann erneut alle generierten Wörter ausführen muss). Ich habe drei Methoden, Einfügungen (...), Löschungen (...) und Änderungen (...), die eine Liste von Wörtern mit einem Bearbeitungsabstand von 1 ausgeben sollen, wobei Einfügungen alle gültigen Wörter mit einem Buchstaben mehr als ausgeben Bei dem gegebenen Wort, löschungen werden alle gültigen Wörter mit einem Buchstaben weniger ausgegeben, und bei Änderungen werden alle gültigen Wörter mit einem anderen Buchstaben ausgegeben.

Ich habe eine Reihe von Orten überprüft, aber ich finde anscheinend keinen Algorithmus, der diesen Prozess beschreibt. Alle Ideen, die ich mir ausgedacht habe, beinhalten ein mehrmaliges Durchlaufen der Wörterbuchliste, was extrem zeitaufwändig sein würde. Wenn jemand Einblicke bieten könnte, wäre ich sehr dankbar.

23
Mel

Die Sache, die Sie betrachten, wird als Bearbeitungsentfernung bezeichnet und hier ist eine Schöne Erklärung im Wiki . Es gibt viele Möglichkeiten, um einen Abstand zwischen den beiden Wörtern zu definieren, und der, den Sie möchten, heißt Levenshtein-Abstand. Hier ist eine DP-Implementierung in Python.

def levenshteinDistance(s1, s2):
    if len(s1) > len(s2):
        s1, s2 = s2, s1

    distances = range(len(s1) + 1)
    for i2, c2 in enumerate(s2):
        distances_ = [i2+1]
        for i1, c1 in enumerate(s1):
            if c1 == c2:
                distances_.append(distances[i1])
            else:
                distances_.append(1 + min((distances[i1], distances[i1 + 1], distances_[-1])))
        distances = distances_
    return distances[-1]

Und ein ein paar weitere Implementierungen sind hier .

42
Salvador Dali

Hier ist meine Version für Levenshtein Entfernung

 def edit_distance (s1, s2): 
 m = len (s1) +1 
 n = len (s2) +1 

 tbl = {} 
 für i im Bereich (m): tbl [i, 0] = i 
 für j im Bereich (n): tbl [0, j] = j 
 für i im Bereich (1, m): 
 für j im Bereich (1, n): 
 cost = 0, wenn s1 [i-1] == s2 [j-1] andernfalls 1 
 tbl [i, j] = min (tbl [i, j-1] + 1, tbl [i-1, j] + 1, tbl [i-1, j-1] + Kosten). return tbl [i, j] 

 print (edit_distance ("Helloworld", "HalloWorld")) 
10
Santosh
#this calculates edit distance not levenstein edit distance
Word1="rice"

Word2="ice"

len_1=len(Word1)

len_2=len(Word2)

x =[[0]*(len_2+1) for _ in range(len_1+1)]#the matrix whose last element ->edit distance

for i in range(0,len_1+1): #initialization of base case values

    x[i][0]=i
for j in range(0,len_2+1):

    x[0][j]=j
for i in range (1,len_1+1):

    for j in range(1,len_2+1):

        if Word1[i-1]==Word2[j-1]:
            x[i][j] = x[i-1][j-1] 

        else :
            x[i][j]= min(x[i][j-1],x[i-1][j],x[i-1][j-1])+1

print x[i][j]
7
ishaan arora

difflib in der Standardbibliothek enthält verschiedene Dienstprogramme für den Sequenzabgleich, einschließlich des get_close_matches Methode, die Sie verwenden könnten. Es verwendet einen von Ratcliff und Obershelp adaptierten Algorithmus.

Aus den Dokumenten

from difflib import get_close_matches

# Yields ['Apple', 'ape']
get_close_matches('appel', ['ape', 'Apple', 'Peach', 'puppy'])
1
ryanjdillon

Der von Ihnen beschriebene spezifische Algorithmus wird als Levenshtein-Abstand bezeichnet. Ein schnelles Google wirft mehrere Python-Bibliotheken und Rezepte zur Berechnung auf.

1
Daniel Roseman

Sie benötigen für diese Aufgabe einen Mindestbearbeitungsabstand.

Nachfolgend meine Version von MED a.k.a Levenshtein Distance.

def MED_character(str1,str2):
    cost=0
    len1=len(str1)
    len2=len(str2)

    #output the length of other string in case the length of any of the string is zero
    if len1==0:
        return len2
    if len2==0:
        return len1

    accumulator = [[0 for x in range(len2)] for y in range(len1)] #initializing a zero matrix

    # initializing the base cases
    for i in range(0,len1):
        accumulator[i][0] = i;
    for i in range(0,len2):
        accumulator[0][i] = i;

    # we take the accumulator and iterate through it row by row. 
    for i in range(1,len1):
        char1=str1[i]
        for j in range(1,len2):
            char2=str2[j]
            cost1=0
            if char1!=char2:
                cost1=2 #cost for substitution
            accumulator[i][j]=min(accumulator[i-1][j]+1, accumulator[i][j-1]+1, accumulator[i-1][j-1] + cost1 )

    cost=accumulator[len1-1][len2-1]
    return cost
1
Inaam Ilahi

Statt mit Levenshtein distance algo zu arbeiten, verwenden Sie BK tree oder TRIE, da diese Algorithmen eine geringere Komplexität haben als der Editierabstand. Ein gutes Durchsuchen dieses Themas liefert eine detaillierte Beschreibung.

Dieser Link hilft Ihnen bei der Rechtschreibprüfung.

0
jt26