Improve Boyer–Moore search: fix shifting, add bad-char table, doctests

Author: itspavant

strings/boyer_moore_search.py

@@ -1,101 +1,92 @@
 """
-The algorithm finds the pattern in given text using following rule.
+Boyer-Moore string search (bad-character rule) - improved and compatible.
 
-The bad-character rule considers the mismatched character in Text.
-The next occurrence of that character to the left in Pattern is found,
+This module provides both a function API `boyer_moore_search(text, pattern)`
+and a class `BoyerMooreSearch` with method `bad_character_heuristic()` so it
+remains compatible with existing usage while improving correctness, clarity,
+and performance.
 
-If the mismatched character occurs to the left in Pattern,
-a shift is proposed that aligns text block and pattern.
+- Precomputes the bad-character table for O(1) lookup per mismatch.
+- Uses a while-loop with proper shifting logic.
+- Handles edge-cases (empty pattern matches at all positions).
+- Includes doctests for typical cases and edge cases.
 
-If the mismatched character does not occur to the left in Pattern,
-a shift is proposed that moves the entirety of Pattern past
-the point of mismatch in the text.
-
-If there is no mismatch then the pattern matches with text block.
-
-Time Complexity : O(n/m)
-    n=length of main string
-    m=length of pattern string
+Author: your-github-username
+License: MIT
 """
 
+from __future__ import annotations
 
-class BoyerMooreSearch:
-    """
-    Example usage:
-
-        bms = BoyerMooreSearch(text="ABAABA", pattern="AB")
-        positions = bms.bad_character_heuristic()
-
-    where 'positions' contain the locations where the pattern was matched.
-    """
-
-    def __init__(self, text: str, pattern: str):
-        self.text, self.pattern = text, pattern
-        self.textLen, self.patLen = len(text), len(pattern)
-
-    def match_in_pattern(self, char: str) -> int:
-        """
-        Finds the index of char in pattern in reverse order.
+# We intentionally use built-in `dict` and `list` annotations (PEP 585).
 
-        Parameters :
-            char (chr): character to be searched
 
-        Returns :
-            i (int): index of char from last in pattern
-            -1 (int): if char is not found in pattern
+def _build_bad_char_table(pattern: str) -> dict[str, int]:
+    """Build mapping char -> last index in pattern."""
+    table: dict[str, int] = {}
+    for i, ch in enumerate(pattern):
+        table[ch] = i
+    return table
 
-        >>> bms = BoyerMooreSearch(text="ABAABA", pattern="AB")
-        >>> bms.match_in_pattern("B")
-        1
-        """
 
-        for i in range(self.patLen - 1, -1, -1):
-            if char == self.pattern[i]:
-                return i
-        return -1
+def boyer_moore_search(text: str, pattern: str) -> list[int]:
+    """Return list of start indices where pattern occurs in text.
 
-    def mismatch_in_text(self, current_pos: int) -> int:
-        """
-        Find the index of mis-matched character in text when compared with pattern
-        from last.
+    >>> _build_bad_char_table("abcab")
+    {'a': 3, 'b': 4, 'c': 2}
+    >>> boyer_moore_search("abacaabaccabacaba", "aba")
+    [0, 5, 10, 14]
+    >>> boyer_moore_search("aaaaa", "aa")
+    [0, 1, 2, 3]
+    >>> boyer_moore_search("hello", "world")
+    []
+    >>> boyer_moore_search("", "")
+    [0]
+    >>> boyer_moore_search("abc", "")
+    [0, 1, 2, 3]
+    >>> boyer_moore_search("", "a")
+    []
+    """
+    if pattern == "":
+        return list(range(len(text) + 1))
+    if text == "" or len(pattern) > len(text):
+        return []
+
+    n, m = len(text), len(pattern)
+    bad = _build_bad_char_table(pattern)
+
+    results: list[int] = []
+    s = 0  # shift of the pattern with respect to text
+    while s <= n - m:
+        j = m - 1
+        while j >= 0 and pattern[j] == text[s + j]:
+            j -= 1
+        if j < 0:
+            results.append(s)
+            # allow overlapping matches: shift by 1 to check next possible start
+            s += 1
+        else:
+            last = bad.get(text[s + j], -1)
+            shift = j - last
+            s += shift if shift > 0 else 1
+    return results
 
-        Parameters :
-            current_pos (int): current index position of text
 
-        Returns :
-            i (int): index of mismatched char from last in text
-            -1 (int): if there is no mismatch between pattern and text block
+class BoyerMooreSearch:
+    """Compatibility wrapper class around boyer_moore_search.
 
-        >>> bms = BoyerMooreSearch(text="ABAABA", pattern="AB")
-        >>> bms.mismatch_in_text(2)
-        3
-        """
+    Example:
+    >>> bms = BoyerMooreSearch(text="ABAABA", pattern="AB")
+    >>> bms.bad_character_heuristic()
+    [0, 3]
+    """
 
-        for i in range(self.patLen - 1, -1, -1):
-            if self.pattern[i] != self.text[current_pos + i]:
-                return current_pos + i
-        return -1
+    def __init__(self, text: str, pattern: str) -> None:
+        self.text = text
+        self.pattern = pattern
 
     def bad_character_heuristic(self) -> list[int]:
-        """
-        Finds the positions of the pattern location.
-
-        >>> bms = BoyerMooreSearch(text="ABAABA", pattern="AB")
-        >>> bms.bad_character_heuristic()
-        [0, 3]
-        """
-
-        positions = []
-        for i in range(self.textLen - self.patLen + 1):
-            mismatch_index = self.mismatch_in_text(i)
-            if mismatch_index == -1:
-                positions.append(i)
-            else:
-                match_index = self.match_in_pattern(self.text[mismatch_index])
-                i = (
-                    mismatch_index - match_index
-                )  # shifting index lgtm [py/multiple-definition]
-        return positions
+        """Return match positions using bad-character heuristic."""
+        return boyer_moore_search(self.text, self.pattern)
 
 
 if __name__ == "__main__":