Update as requested in code review.

Author: mmazzei

Boyer-Moore/BoyerMoore.playground/Contents.swift

@@ -1,72 +1,91 @@
 //: Playground - noun: a place where people can play
 
+/*
+  Boyer-Moore string search
+
+  This code is based on the article "Faster String Searches" by Costas Menico
+  from Dr Dobb's magazine, July 1989.
+  http://www.drdobbs.com/database/faster-string-searches/184408171
+*/
 extension String {
-  func indexOf(pattern: String) -> String.Index? {
-    // Cache the length of the search pattern because we're going to
-    // use it a few times and it's expensive to calculate.
-    let patternLength = pattern.characters.count
-    assert(patternLength > 0)
-    assert(patternLength <= characters.count)
-    
-    // Make the skip table. This table determines how far we skip ahead
-    // when a character from the pattern is found.
-    var skipTable = [Character: Int]()
-    for (i, c) in pattern.characters.enumerated() {
-      skipTable[c] = patternLength - i - 1
-    }
-    
-    // This points at the last character in the pattern.
-    let p = pattern.index(before: pattern.endIndex)
-    let lastChar = pattern[p]
-    
-    // The pattern is scanned right-to-left, so skip ahead in the string by
-    // the length of the pattern. (Minus 1 because startIndex already points
-    // at the first character in the source string.)
-    var i = index(startIndex, offsetBy: patternLength - 1)
-    
-    // This is a helper function that steps backwards through both strings
-    // until we find a character that doesn’t match, or until we’ve reached
-    // the beginning of the pattern.
-    func backwards() -> String.Index? {
-      var q = p
-      var j = i
-      while q > pattern.startIndex {
-        j = index(before: j)
-        q = index(before: q)
-        if self[j] != pattern[q] { return nil }
-      }
-      return j
-    }
-    
-    // The main loop. Keep going until the end of the string is reached.
-    while i < endIndex {
-      let c = self[i]
-      
-      // Does the current character match the last character from the pattern?
-      if c == lastChar {
-        
-        // There is a possible match. Do a brute-force search backwards.
-        if let k = backwards() { return k }
-        
-        // If no match, we can only safely skip one character ahead.
-        i = index(after: i)
-      } else {
-        // The characters are not equal, so skip ahead. The amount to skip is
-        // determined by the skip table. If the character is not present in the
-        // pattern, we can skip ahead by the full pattern length. However, if
-        // the character *is* present in the pattern, there may be a match up
-        // ahead and we can't skip as far.
-        i = index(i, offsetBy: skipTable[c] ?? patternLength)
-      }
+    func index(of pattern: String, usingHorspoolImprovement: Bool = false) -> Index? {
+        // There are no possible match in an empty string
+        guard !isEmpty else { return nil }
+
+        // Cache the length of the search pattern because we're going to
+        // use it a few times and it's expensive to calculate.
+        let patternLength = pattern.characters.count
+        guard patternLength > 0, patternLength <= characters.count else { return nil }
+
+        // Make the skip table. This table determines how far we skip ahead
+        // when a character from the pattern is found.
+        var skipTable = [Character: Int]()
+        for (i, c) in pattern.characters.enumerated() {
+            skipTable[c] = patternLength - i - 1
+        }
+
+        // This points at the last character in the pattern.
+        let p = pattern.index(before: pattern.endIndex)
+        let lastChar = pattern[p]
+
+        // The pattern is scanned right-to-left, so skip ahead in the string by
+        // the length of the pattern. (Minus 1 because startIndex already points
+        // at the first character in the source string.)
+        var i = index(startIndex, offsetBy: patternLength - 1)
+
+        // This is a helper function that steps backwards through both strings
+        // until we find a character that doesn’t match, or until we’ve reached
+        // the beginning of the pattern.
+        func backwards() -> Index? {
+            var q = p
+            var j = i
+            while q > pattern.startIndex {
+                j = index(before: j)
+                q = index(before: q)
+                if self[j] != pattern[q] { return nil }
+            }
+            return j
+        }
+
+        // The main loop. Keep going until the end of the string is reached.
+        while i < endIndex {
+            let c = self[i]
+
+            // Does the current character match the last character from the pattern?
+            if c == lastChar {
+
+                // There is a possible match. Do a brute-force search backwards.
+                if let k = backwards() { return k }
+
+                if !usingHorspoolImprovement {
+                    // If no match, we can only safely skip one character ahead.
+                    i = index(after: i)
+                } else {
+                    // Ensure to jump at least one character (this is needed because the first
+                    // character is in the skipTable, and `skipTable[lastChar] = 0`)
+                    let jumpOffset = max(skipTable[c] ?? patternLength, 1)
+                    i = index(i, offsetBy: jumpOffset, limitedBy: endIndex) ?? endIndex
+                }
+            } else {
+                // The characters are not equal, so skip ahead. The amount to skip is
+                // determined by the skip table. If the character is not present in the
+                // pattern, we can skip ahead by the full pattern length. However, if
+                // the character *is* present in the pattern, there may be a match up
+                // ahead and we can't skip as far.
+                i = index(i, offsetBy: skipTable[c] ?? patternLength, limitedBy: endIndex) ?? endIndex
+            }
+        }
+        return nil
     }
-    return nil
-  }
 }
 
 // A few simple tests
 
-let s = "Hello, World"
-s.indexOf(pattern: "World")  // 7
+let str = "Hello, World"
+str.index(of: "World")  // 7
 
 let animals = "🐶🐔🐷🐮🐱"
-animals.indexOf(pattern: "🐮")  // 6
+animals.index(of: "🐮")  // 6
+
+let lorem = "Lorem ipsum dolor sit amet"
+lorem.index(of: "sit", usingHorspoolImprovement: true)  // 18

Boyer-Moore/BoyerMoore.swift

@@ -6,33 +6,35 @@
   http://www.drdobbs.com/database/faster-string-searches/184408171
 */
 extension String {
-    func indexOf(pattern: String, useHorspoolImprovement: Bool = false) -> String.Index? {
+    func index(of pattern: String, usingHorspoolImprovement: Bool = false) -> Index? {
+        // There are no possible match in an empty string
+        guard !isEmpty else { return nil }
+
         // Cache the length of the search pattern because we're going to
         // use it a few times and it's expensive to calculate.
         let patternLength = pattern.characters.count
-        assert(patternLength > 0)
-        assert(patternLength <= self.characters.count)
-        
+        guard patternLength > 0, patternLength <= characters.count else { return nil }
+
         // Make the skip table. This table determines how far we skip ahead
         // when a character from the pattern is found.
         var skipTable = [Character: Int]()
         for (i, c) in pattern.characters.enumerated() {
             skipTable[c] = patternLength - i - 1
         }
-        
+
         // This points at the last character in the pattern.
         let p = pattern.index(before: pattern.endIndex)
         let lastChar = pattern[p]
-        
+
         // The pattern is scanned right-to-left, so skip ahead in the string by
         // the length of the pattern. (Minus 1 because startIndex already points
         // at the first character in the source string.)
-        var i = self.index(startIndex, offsetBy: patternLength - 1)
-        
+        var i = index(startIndex, offsetBy: patternLength - 1)
+
         // This is a helper function that steps backwards through both strings
         // until we find a character that doesn’t match, or until we’ve reached
         // the beginning of the pattern.
-        func backwards() -> String.Index? {
+        func backwards() -> Index? {
             var q = p
             var j = i
             while q > pattern.startIndex {
@@ -42,22 +44,21 @@ extension String {
             }
             return j
         }
-        
+
         // The main loop. Keep going until the end of the string is reached.
-        while i < self.endIndex {
+        while i < endIndex {
             let c = self[i]
-            
+
             // Does the current character match the last character from the pattern?
             if c == lastChar {
-                
+
                 // There is a possible match. Do a brute-force search backwards.
                 if let k = backwards() { return k }
-                
-                if !useHorspoolImprovement {
+
+                if !usingHorspoolImprovement {
                     // If no match, we can only safely skip one character ahead.
                     i = index(after: i)
-                }
-                else {
+                } else {
                     // Ensure to jump at least one character (this is needed because the first
                     // character is in the skipTable, and `skipTable[lastChar] = 0`)
                     let jumpOffset = max(skipTable[c] ?? patternLength, 1)

Boyer-Moore/README.markdown

@@ -32,12 +32,14 @@ Here's how you could write it in Swift:
 
 ```swift
 extension String {
-    func indexOf(pattern: String) -> String.Index? {
+    func index(of pattern: String) -> Index? {
+        // There are no possible match in an empty string
+        guard !isEmpty else { return nil }
+
         // Cache the length of the search pattern because we're going to
         // use it a few times and it's expensive to calculate.
         let patternLength = pattern.characters.count
-        assert(patternLength > 0)
-        assert(patternLength <= self.characters.count)
+        guard patternLength > 0, patternLength <= characters.count else { return nil }
 
         // Make the skip table. This table determines how far we skip ahead
         // when a character from the pattern is found.
@@ -53,12 +55,12 @@ extension String {
         // The pattern is scanned right-to-left, so skip ahead in the string by
         // the length of the pattern. (Minus 1 because startIndex already points
         // at the first character in the source string.)
-        var i = self.index(startIndex, offsetBy: patternLength - 1)
+        var i = index(startIndex, offsetBy: patternLength - 1)
 
         // This is a helper function that steps backwards through both strings
         // until we find a character that doesn’t match, or until we’ve reached
         // the beginning of the pattern.
-        func backwards() -> String.Index? {
+        func backwards() -> Index? {
             var q = p
             var j = i
             while q > pattern.startIndex {
@@ -70,7 +72,7 @@ extension String {
         }
 
         // The main loop. Keep going until the end of the string is reached.
-        while i < self.endIndex {
+        while i < endIndex {
             let c = self[i]
 
             // Does the current character match the last character from the pattern?
@@ -157,12 +159,14 @@ Here's an implementation of the Boyer-Moore-Horspool algorithm:
 
 ```swift
 extension String {
-    func indexOf(pattern: String) -> String.Index? {
+    func index(of pattern: String) -> Index? {
+        // There are no possible match in an empty string
+        guard !isEmpty else { return nil }
+
         // Cache the length of the search pattern because we're going to
         // use it a few times and it's expensive to calculate.
         let patternLength = pattern.characters.count
-        assert(patternLength > 0)
-        assert(patternLength <= self.characters.count)
+        guard patternLength > 0, patternLength <= characters.count else { return nil }
 
         // Make the skip table. This table determines how far we skip ahead
         // when a character from the pattern is found.
@@ -178,12 +182,12 @@ extension String {
         // The pattern is scanned right-to-left, so skip ahead in the string by
         // the length of the pattern. (Minus 1 because startIndex already points
         // at the first character in the source string.)
-        var i = self.index(startIndex, offsetBy: patternLength - 1)
+        var i = index(startIndex, offsetBy: patternLength - 1)
 
         // This is a helper function that steps backwards through both strings
         // until we find a character that doesn’t match, or until we’ve reached
         // the beginning of the pattern.
-        func backwards() -> String.Index? {
+        func backwards() -> Index? {
             var q = p
             var j = i
             while q > pattern.startIndex {
@@ -195,7 +199,7 @@ extension String {
         }
 
         // The main loop. Keep going until the end of the string is reached.
-        while i < self.endIndex {
+        while i < endIndex {
             let c = self[i]
 
             // Does the current character match the last character from the pattern?

Boyer-Moore/Tests/BoyerMooreTests.swift

@@ -17,12 +17,12 @@ class BoyerMooreTest: XCTestCase {
     }
 
     func assert(pattern: String, doesNotExistsIn string: String) {
-        let index = string.indexOf(pattern: pattern, useHorspoolImprovement: useHorspoolImprovement)
+        let index = string.index(of: pattern, usingHorspoolImprovement: useHorspoolImprovement)
         XCTAssertNil(index)
     }
 
     func assert(pattern: String, existsIn string: String) {
-        let index = string.indexOf(pattern: pattern, useHorspoolImprovement: useHorspoolImprovement)
+        let index = string.index(of: pattern, usingHorspoolImprovement: useHorspoolImprovement)
         XCTAssertNotNil(index)
 
         let startIndex = index!
@@ -31,6 +31,24 @@ class BoyerMooreTest: XCTestCase {
         XCTAssertEqual(match, pattern)
     }
 
+    func testSearchPatternInEmptyString() {
+        let string = ""
+        let pattern = "ABCDEF"
+        assert(pattern: pattern, doesNotExistsIn: string)
+    }
+
+    func testSearchEmptyPatternString() {
+        let string = "ABCDEF"
+        let pattern = ""
+        assert(pattern: pattern, doesNotExistsIn: string)
+    }
+
+    func testSearchPatternLongerThanString() {
+        let string = "ABC"
+        let pattern = "ABCDEF"
+        assert(pattern: pattern, doesNotExistsIn: string)
+    }
+
     func testSearchTheSameString() {
         let string = "ABCDEF"
         let pattern = "ABCDEF"