Rabin-Karp-Algorithmus in Python

Wir werden den Rabin-Karp-Algorithmus in Python vorstellen und diskutieren, wie wir ihn in unseren Python-Programmen verwenden können.

Rabin-Karp-Algorithmus in Python

Der Rabin-Karp-Algorithmus findet bestimmte Zahlen, Buchstaben oder Muster aus einer gegebenen Eingabe oder einem gegebenen Wert. Algorithmen für maschinelles Lernen sind oft die erste Wahl in der Datenwissenschaft, wenn Sie Erkenntnisse aus Daten extrahieren müssen, aber nicht alle Algorithmen gleich sind.

Einige sind besser als andere darin, die richtigen Erkenntnisse zu finden, und einige sind besser als andere darin, falsch positive Ergebnisse zu vermeiden. Einer der leistungsstärksten Algorithmen für maschinelles Lernen, um die richtigen Erkenntnisse zu finden, ist der Rabin-Karp-Algorithmus.

Der Rabin-Karp-Algorithmus wird verwendet, um die beste Übereinstimmung zwischen einer Reihe von Texten und möglichen Passwörtern zu finden. Es wird hauptsächlich in Software verwendet, um Benutzern zu helfen, ihre Passwörter zu finden, wenn sie sie vergessen haben.

Es wurde ursprünglich entwickelt, um E-Mail-Adressen in Text zu finden, und wird seitdem in vielen anderen Anwendungen verwendet, z. B. zum Suchen von Telefonnummern, Extrahieren von Text aus PDFs und vielem mehr. Es wurde von Richard M. Rabin und Abraham S. Karp entworfen.

Komplexität des Rabin-Karp-Algorithmus in Python

Der Rabin-Karp-Algorithmus ist eine Methode zum effizienten Finden einer minimalen Anzahl unterschiedlicher Werte in einem Array. Es hat sich als asymptotisch schneller erwiesen als andere gängige Algorithmen zur Minimumfindung wie binäre Suche, quadratisches Sondieren und sequentielle Suche.

Der Rabin-Karp-Algorithmus ist jedoch oft viel komplexer als seine theoretische Worst-Case-Komplexität von (O(n)), wobei n die Anzahl der unterschiedlichen Werte im Sucharray ist. Wir haben diese Komplexität, weil der Rabin-Karp-Algorithmus jeden Wert im Sucharray wiederholt besuchen muss, bis er den erforderlichen Wert findet.

Implementieren Sie den Rabin-Karp-Algorithmus in Python

Lassen Sie uns nun verstehen, wie der Rabin-Karp-Algorithmus in unseren Python-Beispielen implementiert wird.

Wir geben ein Zeichenmuster und prüfen dann die Möglichkeit des gegebenen Musters zu den vorhandenen Elementen. Wenn das Muster gefunden wird, geben Sie es als Ausgabe aus.

Zuerst weisen wir den Wert der Anzahl der hinzugefügten Zeichen als Eingabe zu. In unserem Fall weisen wir 15 zu, wie unten gezeigt.

# python
numOfChar = 15

Wir werden eine Funktion als searchPattern definieren, die drei Argumente annehmen wird. Das erste Argument ist das Muster, das wir mit dem Rabin-Karp-Algorithmus finden möchten.

Das zweite Argument ist der Text, in dem wir nach einem Muster suchen. Und das letzte Argument wird die Primzahl sein.

Wir werden die Länge des Musters und des Textes Variablen zuweisen, damit wir die Länge später verwenden können. Wir werden auch den Hashwert für das Muster und den Text festlegen.

Wir werden die Variablen a und b in den for-Schleifen definieren.

# python
def searchPattern(pattern, text, primeNum):
    patLen = len(pattern)
    txtLen = len(text)
    a = 0
    b = 0
    p = 0  # hash value for pattern
    t = 0  # hash value for txt
    h = 1

Aus dem Rabin-Karp-Algorithmus finden wir zuerst den Wert von h mit der Formel pow(numOfChar, patLen-1)% primeNum, wie unten gezeigt.

# python
for a in xrange(patLen - 1):
    h = (h * numOfChar) % primeNum

Jetzt finden wir den Hashwert des Musters und das erste Fenster des Textes, wie unten gezeigt.

# python
for a in xrange(patLen):
    p = (numOfChar * p + ord(pattern[a])) % primeNum
    t = (numOfChar * t + ord(text[a])) % primeNum

Wir erstellen eine weitere for-Schleife, um das Muster nacheinander über den Text zu schieben. Innerhalb dieser for-Schleife prüfen wir den Hash-Wert des aktuellen Text- und Musterfensters.

Wenn die Hash-Werte übereinstimmen, werden wir nacheinander nach den Zeichen suchen, wie unten gezeigt.

# python
for a in range(txtLen - patLen + 1):

    if p == t:
        for b in range(patLen):
            if text[a + b] != pattern[b]:
                break

        b += 1
        if b == patLen:
            print("Pattern found at index " + str(a))

    if a < txtLen - patLen:
        t = (numOfChar * (t - ord(text[a]) * h) + ord(text[a + patLen])) % primeNum

        if t < 0:
            t = t + primeNum

Lassen Sie uns nun den Parametern Werte zuweisen und die Funktion aufrufen, um zu überprüfen, wie sie funktioniert, wie unten gezeigt.

# python
text = "ABBAABCDEAABBDCAABB"
pattern = "ABB"
primeNum = 101
searchPattern(pattern, text, primeNum)

Ausgang:

Wie Sie sehen können, wurde unser Muster an drei verschiedenen Orten gefunden. Mit dem Rabin-Karp-Algorithmus können wir Muster in einem bestimmten Text an mehreren Stellen finden.