Der Baeza-Yates-Gonnet-Algorithmus bzw. Shift-or-Algorithmus, der auch unter den Namen Shift-and oder Bitap bekannt ist, löst das String-Matching-Problem, indem er einen nichtdeterministischen Automaten simuliert. Unter anderem wird eine Abwandlung dieses Algorithmus bei dem Unix-Tool grep benutzt.

Da die Implementierung auf Bit-Operationen zurückgeführt werden kann, ist der Algorithmus alleine von der Ausführung her bereits sehr effizient. Kombiniert man dies mit dem zu Grunde liegenden System (im Preprocessing einmal Schleife über das Muster, während der Suche einmal Schleife über den Text) ergibt sich ein extrem effizienter Algorithmus.

Grundlage des Algorithmus bildet eine Menge von Vektoren ${\displaystyle R_{j}}$ mit folgender Definition:

${\displaystyle R_{j+1}[i]={\begin{cases}1,&{\mbox{falls }}i=0\\1,&{\text{falls }}R_{j}[i-1]=1{\text{ und }}\mathrm {Musterzeichen} _{i}=\mathrm {Eingabezeichen} _{j+1}\\0&{\text{sonst}}\end{cases}}}$

Anschaulich bedeutet dies, dass ${\displaystyle R_{j}[i]}$ genau dann ${\displaystyle 1}$ ist, wenn nach der Verarbeitung von ${\displaystyle j}$ Zeichen des Textes die letzten ${\displaystyle i}$ Zeichen mit den ersten ${\displaystyle i}$ Zeichen des Suchmusters übereinstimmen.

Ein Treffer für ein Suchmuster mit Länge ${\displaystyle m}$ ist demnach gefunden, falls ${\displaystyle R_{j}[m]=1}$.

Weiterhin werden die charakteristischen Vektoren für alle möglicherweise im Text vorkommenden Zeichen benötigt:

${\displaystyle s_{a}[i]={\begin{cases}1,&{\text{falls im Suchmuster an Stelle }}i{\text{ das Zeichen }}a{\text{ steht}}\\0&{\text{sonst}}\end{cases}}}$

Beispiel:

Suchmuster ${\displaystyle abcac}$, Länge ${\displaystyle m=5}$

Charakteristische Vektoren:

${\displaystyle {\begin{matrix}&s_{a}&s_{b}&s_{c}&s_{d}&...\\a&1&0&0&0&...\\b&0&1&0&0&...\\c&0&0&1&0&...\\a&1&0&0&0&...\\c&0&0&1&0&...\end{matrix}}}$

Um den Ablauf zu vereinfachen, wird zunächst eine spezielle Bit-Operation Bitshift bzw. ${\displaystyle \gg }$ für den Vektor ${\displaystyle R}$ eingeführt: ${\displaystyle R={\begin{matrix}0\\0\\0\\0\\0\end{matrix}}\quad {\stackrel {\mathrm {Bitshift} }{\longrightarrow }}\quad {\begin{matrix}1\\0\\0\\0\\0\end{matrix}}\quad {\stackrel {\mathrm {Bitshift} }{\longrightarrow }}\quad {\begin{matrix}1\\1\\0\\0\\0\end{matrix}}\quad {\stackrel {\mathrm {Bitshift} }{\longrightarrow }}\quad {\begin{matrix}1\\1\\1\\0\\0\end{matrix}}}$

Der Algorithmus für exakte Übereinstimmungen lässt sich nun auf wenige einfache Schritte reduzieren:

1. Initialisiere den ${\displaystyle R}$-Vektor mit 0 (für alle Positionen) und beginne mit dem ersten Zeichen des zu durchsuchenden Textes
2. Verschiebe alle Bits in ${\displaystyle R}$ mittels Bitshift um eine Position nach rechts.
3. Führe eine ${\displaystyle UND}$-Verknüpfung von ${\displaystyle R}$ und dem charakteristischen Vektor des aktuellen Textzeichens durch.
4. Gehe zum nächsten Textzeichen. Falls Ende erreicht, breche ab, sonst gehe zu (2)

Die Schritte (2) und (3) führen bei genauer Betrachtung genau die Berechnungsvorschrift für ${\displaystyle R}$ aus: Durch das Shiften wird aus dem „alten“ ${\displaystyle R}$ das Zeichen an Stelle ${\displaystyle i}$ an die Stelle ${\displaystyle i+1}$ angelegt (entspricht in Kombination mit ${\displaystyle UND}$ der Bedingung ${\displaystyle R_{j}[i]=1}$). Der charakteristische Vektor des aktuellen Textzeichens enthält an der Stelle ${\displaystyle i+1}$ genau dann eine ${\displaystyle 1}$, falls Muster und Text hier übereinstimmen. Durch das ${\displaystyle UND}$ werden beide Bedingungen verknüpft.

Muster: ${\displaystyle abcac}$, ${\displaystyle m=5}$

Text: ${\displaystyle abcabcac}$

${\displaystyle {\begin{vmatrix}i\setminus &R_{0}&\gg &s_{a}&R_{1}\\1&0&1&1&1\\2&0&0&0&0\\3&0&0&0&0\\4&0&0&1&0\\5&0&0&0&0\end{vmatrix}}{\begin{vmatrix}\gg &s_{b}&R_{2}\\1&0&0\\1&1&1\\0&0&0\\0&0&0\\0&0&0\end{vmatrix}}{\begin{vmatrix}\gg &s_{c}&R_{3}\\1&0&0\\0&0&0\\1&1&1\\0&0&0\\0&1&0\end{vmatrix}}{\begin{vmatrix}\gg &s_{a}&R_{4}\\1&1&1\\0&0&0\\0&0&0\\1&1&1\\0&0&0\end{vmatrix}}{\begin{vmatrix}\gg &s_{b}&R_{5}\\1&0&0\\1&1&1\\0&0&0\\0&0&0\\1&0&0\end{vmatrix}}{\begin{vmatrix}\gg &s_{c}&R_{6}\\1&0&0\\0&0&0\\1&1&1\\0&0&0\\0&1&0\end{vmatrix}}{\begin{vmatrix}\gg &s_{a}&R_{7}\\1&1&1\\0&0&0\\0&0&0\\1&1&1\\0&0&0\end{vmatrix}}{\begin{vmatrix}\gg &s_{c}&R_{8}\\1&0&0\\1&0&0\\0&1&0\\0&0&0\\1&1&1\end{vmatrix}}}$

Da ${\displaystyle R_{8}[5]=1}$ liegt ein Treffer bei ${\displaystyle 8-5+1}$ (Position − Musterlänge + Korrektur für erstes Zeichen) vor.

Der Algorithmus kann durch leichte Modifikationen eine fehlertolerante Suche durchführen. Hierfür wird der Vektor ${\displaystyle R}$ aufgeteilt:

1. ${\displaystyle R_{j}^{0}[i]}$: entspricht dem vorherigen ${\displaystyle R_{j}[i]}$; Der Index ${\displaystyle 0}$ steht für die Anzahl der aufgetretenen Fehler.
2. ${\displaystyle R_{j}^{1}[i]}$: Bezeichnet einen ${\displaystyle R}$-Vektor, der auf Treffer mit maximal einem Fehler ausgerichtet ist.
3. ...
4. ${\displaystyle R_{j}^{k}[i]}$: Bezeichnet einen ${\displaystyle R}$-Vektor, der auf Treffer mit maximal ${\displaystyle k}$ Fehlern ausgerichtet ist.

Achtung: Bei den fehlerbehafteten Vektoren ist die obige Interpretation mit „nach j Zeichen stimmen die letzten i mit den ersten i des Musters überein“ schwierig und nicht mehr unbedingt einleuchtend.

Die Berechnungsvorschrift für ${\displaystyle R_{j}^{0}[i]}$ bleibt unverändert. Für Fehlervektoren ${\displaystyle R_{j+1}^{k}}$wird nach der verursachenden Aktion unterschieden:

${\displaystyle R_{j+1}^{k}=({\mathit {Bitshift}}(R_{j}^{k})\ \wedge \ s_{x})\quad \vee \ R_{j}^{k-1}}$

Erläuterung: Der erste Teil des Ausdrucks beschreibt den Fall, dass bereits ${\displaystyle k}$ Fehler vorhanden sind, aber das aktuelle Zeichen von Text und Muster übereinstimmen. Der zweite Teil beschreibt den Fehlerfall: Bisher (in ${\displaystyle j}$) lagen nur ${\displaystyle k-1}$ Fehler vor, das aktuelle Zeichen kann also in das Muster eingefügt werden.

Interpretation: ${\displaystyle R_{j}^{k}[i]=1}$, falls nach ${\displaystyle j}$ Zeichen der Eingabe von den letzten ${\displaystyle i+k}$ Zeichen mindestens ${\displaystyle i}$ Zeichen mit dem Suchmuster übereinstimmen und der Rest durch Einfügen der fehlenden Zeichen zur Übereinstimmung gebracht werden kann.

${\displaystyle R_{j+1}^{k}=({\mathit {Bitshift}}(R_{j}^{k})\ \wedge \ s_{x})\quad \vee \ {\mathit {Bitshift}}(R_{j+1}^{k-1})}$

Erläuterung: Der erste Teil des Ausdrucks beschreibt den Fall, dass bereits ${\displaystyle k}$ Fehler vorhanden sind, aber das aktuelle Zeichen von Text und Muster übereinstimmen. Der zweite Teil beschreibt den Fehlerfall: Schaut man sich bei ${\displaystyle j+1}$ Zeichen des Textes nicht die ersten ${\displaystyle i}$ Zeichen an, sondern nur die ersten ${\displaystyle i-1}$ (im Vektor die Position darüber), so stimmt das Muster bis auf ${\displaystyle k-1}$ Fehler überein. Das ${\displaystyle i.}$ Zeichen des Musters wird daraufhin einfach gelöscht.

${\displaystyle R_{j+1}^{k}=({\mathit {Bitshift}}(R_{j}^{k})\ \wedge \ s_{x})\quad \vee \ {\mathit {Bitshift}}(R_{j}^{k-1})}$

Erläuterung: Der erste Teil des Ausdrucks beschreibt den Fall, dass bereits ${\displaystyle k}$ Fehler vorhanden sind, aber das aktuelle Zeichen von Text und Muster übereinstimmen. Der zweite Teil beschreibt den Fehlerfall: Nach ${\displaystyle j}$ Zeichen stimmten die letzten ${\displaystyle i-1}$ Zeichen überein. Ersetzt man nun also das ${\displaystyle i.}$ Zeichen im Muster durch das ${\displaystyle j+1.}$ Zeichen des Textes, stimmen auch nach ${\displaystyle j+1}$ Zeichen die letzten ${\displaystyle i}$ Zeichen mit den ersten ${\displaystyle i}$ Zeichen des „neuen“ Musters überein.

Die Varianten können mittels bitweisem oder beliebig verknüpft werden.

• Ricardo A. Baeza-Yates, Gaston H. Gonnet: A New Approach to Text Searching. In: Communications of the ACM. Band 35, Nr. 10, Oktober 1992, ISSN 0001-0782, S. 74–82, doi:10.1145/135239.135243. 

• StringSearch – high-performance pattern matching algorithms in Java (Implementierungen des Shift-Or-Algorithmus in Java; englisch)
• BNDM-Algorithmus (PDF; 289 kB)