Improved logic of Boyer Moore & added few edge cases in test (williamfiset#187)

sharoha · web-flow · commit 5ff004e003d8 · 2020-06-07T22:48:11.000-07:00
diff --git a/src/main/java/com/williamfiset/algorithms/strings/BoyerMooreStringSearch.java b/src/main/java/com/williamfiset/algorithms/strings/BoyerMooreStringSearch.java
@@ -17,35 +17,43 @@ public class BoyerMooreStringSearch {
    * @return List of indexes where the pattern occurs
    */
   public List<Integer> findOccurrences(String text, String pattern) {
-    if (isNull(text) || isNull(pattern)) {
+    if (isNull(text)
+        || isNull(pattern)
+        || pattern.length() > text.length()
+        || pattern.length() == 0) {
       return new ArrayList<>();
     }
     List<Integer> occurrences = new ArrayList<>();
-
-    Map<Character, Integer> skipTable = new HashMap<>();
-    for (int i = 0; i < pattern.length(); i++) {
-      skipTable.put(pattern.charAt(i), pattern.length() - i - 1);
-    }
+    Map<Character, Integer> skipTable = generateSkipTable(pattern);
 
     int textIndex = pattern.length() - 1;
+    int patternIndex = pattern.length() - 1;
     while (textIndex < text.length()) {
-      int patternIndex = 0;
-      boolean match = true;
-      while (patternIndex < pattern.length() && match) {
-        if (text.charAt(textIndex - patternIndex)
-            != pattern.charAt(pattern.length() - patternIndex - 1)) {
-          match = false;
-          textIndex +=
-              skipTable.getOrDefault(text.charAt(textIndex - patternIndex), pattern.length());
+      if (patternIndex >= 0 && pattern.charAt(patternIndex) == text.charAt(textIndex)) {
+        if (patternIndex == 0) {
+          occurrences.add(textIndex);
+        } else {
+          textIndex--;
         }
-        patternIndex++;
-      }
-      if (match) {
-        occurrences.add(textIndex - (pattern.length() - 1));
-        textIndex += pattern.length();
+        patternIndex--;
+      } else {
+        textIndex =
+            textIndex
+                + pattern.length()
+                - Math.min(
+                    Math.max(patternIndex, 0),
+                    1 + skipTable.getOrDefault(text.charAt(textIndex), 0));
+        patternIndex = pattern.length() - 1;
       }
     }
-
     return occurrences;
   }
+
+  private Map<Character, Integer> generateSkipTable(String pattern) {
+    Map<Character, Integer> characterIndexMap = new HashMap<>();
+    for (int charIndex = 0; charIndex < pattern.length(); charIndex++) {
+      characterIndexMap.put(pattern.charAt(charIndex), charIndex);
+    }
+    return characterIndexMap;
+  }
 }
diff --git a/src/test/java/com/williamfiset/algorithms/strings/BoyerMooreStringSearchTest.java b/src/test/java/com/williamfiset/algorithms/strings/BoyerMooreStringSearchTest.java
@@ -1,17 +1,24 @@
 package com.williamfiset.algorithms.strings;
 
 import static com.google.common.truth.Truth.assertThat;
+import static java.util.Objects.isNull;
 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
 import org.junit.Before;
 import org.junit.Test;
 
 public class BoyerMooreStringSearchTest {
 
   private BoyerMooreStringSearch underTest;
+  private Random random;
+  private final int MAX_ITERATION = 20;
 
   @Before
   public void setup() {
     underTest = new BoyerMooreStringSearch();
+    random = new Random();
   }
 
   @Test
@@ -35,12 +42,78 @@ public void shouldReturnOneOccurrence() {
   }
 
   @Test
-  public void shouldReturnMultiplyOccurrences() {
+  public void shouldReturnMultipleOccurrences() {
+    assertThat(underTest.findOccurrences("SAAT TE", "TE")).containsExactly(5);
     assertThat(
             underTest.findOccurrences("Sample text for testing the Boyer-Moore algorithm.", "te"))
         .containsExactly(7, 16);
     assertThat(underTest.findOccurrences("Sample text for testing the Boyer-Moore algorithm.", " "))
         .containsExactly(6, 11, 15, 23, 27, 39);
+    assertThat(underTest.findOccurrences("AABAACAADAABAABA", "AABA")).containsExactly(0, 9, 12);
+    assertThat(underTest.findOccurrences("AAAAAAA", "AA")).containsExactly(0, 1, 2, 3, 4, 5);
+  }
+
+  @Test
+  public void shouldReturnEmptyForPatternLengthLargerThenText() {
+    assertThat(underTest.findOccurrences("This is a Test Text", "This is a test Pattern"))
+        .isEmpty();
+  }
+
+  @Test
+  public void shouldReturnDynamicString() {
+    int runLength = random.nextInt(MAX_ITERATION) + 1;
+    for (int run = 0; run < runLength; run++) {
+      int upperCharText = random.nextInt(3);
+      int upperCharPattern = random.nextInt(3);
+      int maxLengthText =
+          random.nextInt(1000) + 100; // random length of the string between [100=1000]
+      int maxLengthPattern = random.nextInt(10);
+      String text = generateRandomString(upperCharText, maxLengthText);
+      String pattern = generateRandomString(upperCharPattern, maxLengthPattern);
+      assertThat(underTest.findOccurrences(text, pattern))
+          .containsExactlyElementsIn(getOccurrencesBruteForce(text, pattern));
+    }
+  }
+
+  /**
+   * @param text the text being searched in
+   * @param pattern the pattern that needs to be searched in text
+   * @return a list of beginning index of text where pattern exits
+   */
+  private List<Integer> getOccurrencesBruteForce(String text, String pattern) {
+    if (isNull(text)
+        || isNull(pattern)
+        || text.length() < pattern.length()
+        || pattern.length() == 0) {
+      return new ArrayList<>();
+    }
+    List<Integer> occurrences = new ArrayList<>();
+    for (int textIndex = 0; textIndex < text.length() - pattern.length() + 1; textIndex++) {
+      boolean match = true;
+      for (int patIndex = 0; patIndex < pattern.length(); patIndex++) {
+        if (text.charAt(textIndex + patIndex) != pattern.charAt(patIndex)) {
+          match = false;
+          break;
+        }
+      }
+      if (match) {
+        occurrences.add(textIndex);
+      }
+    }
+    return occurrences;
+  }
+
+  /**
+   * @param upperLimitAscii Largest element in the random string
+   * @param length Length of the random string
+   * @return Returns a random string containing character between [a-z]
+   */
+  private String generateRandomString(int upperLimitAscii, int length) {
+    return random
+        .ints('a', 'a' + upperLimitAscii + 1)
+        .limit(length)
+        .collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append)
+        .toString();
   }
 
   // TODO(william): Add a test that compares this implementation of Boyermoore
