Fixed up indentation and removed a few self references.

Author: Kelvin Lau

Boyer-Moore/BoyerMoore.playground/Contents.swift

@@ -1,66 +1,66 @@
 //: Playground - noun: a place where people can play
 
 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 <= self.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 = self.index(startIndex, offsetBy: patternLength - 1)
+  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 {
 
-        // 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
-        }
+        // There is a possible match. Do a brute-force search backwards.
+        if let k = backwards() { return k }
 
-        // The main loop. Keep going until the end of the string is reached.
-        while i < self.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 = self.index(i, offsetBy: skipTable[c] ?? patternLength)
-            }
-        }
-        return nil
+        // 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)
+      }
     }
+    return nil
+  }
 }
 
 // A few simple tests