Merge branch 'master' of https://github.com/raywenderlich/swift-algorithm-club

"Catching up with new PRs"

Author: Kelvin Lau

.travis.yml

@@ -38,4 +38,5 @@ script:
 # - xcodebuild test -project ./Shortest\ Path\ \(Unweighted\)/Tests/Tests.xcodeproj -scheme Tests
 # - xcodebuild test -project ./Single-Source\ Shortest\ Paths\ \(Weighted\)/SSSP.xcodeproj -scheme SSSPTests
 - xcodebuild test -project ./Stack/Tests/Tests.xcodeproj -scheme Tests
-# - xcodebuild test -project ./Topological\ Sort/Tests/Tests.xcodeproj -scheme Tests
+- xcodebuild test -project ./Topological\ Sort/Tests/Tests.xcodeproj -scheme Tests
+- xcodebuild test -project ./Treap/Treap/Treap.xcodeproj -scheme Tests

Boyer-Moore/BoyerMoore.playground/Contents.swift

@@ -7,20 +7,20 @@ extension String {
     assert(patternLength <= self.characters.count)
 
     var skipTable = [Character: Int]()
-    for (i, c) in pattern.characters.enumerate() {
+    for (i, c) in pattern.characters.enumerated() {
       skipTable[c] = patternLength - i - 1
     }
 
-    let p = pattern.endIndex.predecessor()
+    let p = pattern.index(before: pattern.endIndex)
     let lastChar = pattern[p]
-    var i = self.startIndex.advancedBy(patternLength - 1)
+    var i = self.index(startIndex, offsetBy: patternLength - 1)
 
     func backwards() -> String.Index? {
       var q = p
       var j = i
       while q > pattern.startIndex {
-        j = j.predecessor()
-        q = q.predecessor()
+        j = index(before: j)
+        q = index(before: q)
         if self[j] != pattern[q] { return nil }
       }
       return j
@@ -30,21 +30,19 @@ extension String {
       let c = self[i]
       if c == lastChar {
         if let k = backwards() { return k }
-        i = i.successor()
+        i = index(after: i)
       } else {
-        i = i.advancedBy(skipTable[c] ?? patternLength)
+        i = index(i, offsetBy: skipTable[c] ?? patternLength)
       }
     }
     return nil
   }
 }
 
-
-
 // A few simple tests
 
 let s = "Hello, World"
-s.indexOf("World")  // 7
+s.indexOf(pattern: "World")  // 7
 
 let animals = "🐶🐔🐷🐮🐱"
-animals.indexOf("🐮")  // 6
+animals.indexOf(pattern: "🐮")  // 6

Boyer-Moore/BoyerMoore.playground/timeline.xctimeline

@@ -2,5 +2,20 @@
 <Timeline
    version = "3.0">
    <TimelineItems>
+      <LoggerValueHistoryTimelineItem
+         documentLocation = "#CharacterRangeLen=1&amp;CharacterRangeLoc=345&amp;EndingColumnNumber=37&amp;EndingLineNumber=9&amp;StartingColumnNumber=9&amp;StartingLineNumber=9&amp;Timestamp=497585369.829471"
+         selectedRepresentationIndex = "0"
+         shouldTrackSuperviewWidth = "NO">
+      </LoggerValueHistoryTimelineItem>
+      <LoggerValueHistoryTimelineItem
+         documentLocation = "#CharacterRangeLen=0&amp;CharacterRangeLoc=345&amp;EndingColumnNumber=26&amp;EndingLineNumber=9&amp;StartingColumnNumber=9&amp;StartingLineNumber=9&amp;Timestamp=497585369.82964"
+         selectedRepresentationIndex = "0"
+         shouldTrackSuperviewWidth = "NO">
+      </LoggerValueHistoryTimelineItem>
+      <LoggerValueHistoryTimelineItem
+         documentLocation = "#CharacterRangeLen=1&amp;CharacterRangeLoc=345&amp;EndingColumnNumber=25&amp;EndingLineNumber=9&amp;StartingColumnNumber=9&amp;StartingLineNumber=9&amp;Timestamp=497585369.82978"
+         selectedRepresentationIndex = "0"
+         shouldTrackSuperviewWidth = "NO">
+      </LoggerValueHistoryTimelineItem>
    </TimelineItems>
 </Timeline>

Boyer-Moore/README.markdown

@@ -9,14 +9,14 @@ For example:
 ```swift
 // Input: 
 let s = "Hello, World"
-s.indexOf("World")
+s.indexOf(pattern: "World")
 
 // Output:
 <String.Index?> 7
 
 // Input:
 let animals = "🐶🐔🐷🐮🐱"
-animals.indexOf("🐮")
+animals.indexOf(pattern: "🐮")
 
 // Output:
 <String.Index?> 6
@@ -32,7 +32,7 @@ Here's how you could write it in Swift:
 
 ```swift
 extension String {
-  func indexOf(pattern: String) -> String.Index? {
+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
@@ -42,57 +42,58 @@ extension String {
     // 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.enumerate() {
-      skipTable[c] = patternLength - i - 1
+    for (i, c) in pattern.characters.enumerated() {
+    skipTable[c] = patternLength - i - 1
     }
 
     // This points at the last character in the pattern.
-    let p = pattern.endIndex.predecessor()
+    let p = 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.startIndex.advancedBy(patternLength - 1)
+    var i = index(self.startIndex, offsetBy: patternLength - 1)
 
-    // This is a helper function that steps backwards through both strings 
+    // 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 = j.predecessor()
-        q = q.predecessor()
-        if self[j] != pattern[q] { return nil }
-      }
-      return j
+    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 < 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 = i.successor()
-      } 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 = i.advancedBy(skipTable[c] ?? patternLength)
-      }
+    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)
+    }
     }
     return nil
-  }
+    }
 }
+
 ```
 
 The algorithm works as follows. You line up the search pattern with the source string and see what character from the string matches the *last* character of the search pattern:
@@ -149,34 +150,42 @@ Here's an implementation of the Boyer-Moore-Horspool algorithm:
 
 ```swift
 extension String {
-  public func indexOf(pattern: String) -> String.Index? {
+    func indexOf(pattern: String) -> String.Index? {
     let patternLength = pattern.characters.count
     assert(patternLength > 0)
     assert(patternLength <= self.characters.count)
 
     var skipTable = [Character: Int]()
-    for (i, c) in pattern.characters.dropLast().enumerate() {
-      skipTable[c] = patternLength - i - 1
+    for (i, c) in pattern.characters.enumerated() {
+    skipTable[c] = patternLength - i - 1
     }
 
-    var index = self.startIndex.advancedBy(patternLength - 1)
-
-    while index < self.endIndex {
-      var i = index
-      var p = pattern.endIndex.predecessor()
-
-      while self[i] == pattern[p] {
-        if p == pattern.startIndex { return i }
-        i = i.predecessor()
-        p = p.predecessor()
-      }
+    let p = pattern.index(before: pattern.endIndex)
+    let lastChar = pattern[p]
+    var i = self.index(startIndex, offsetBy: patternLength - 1)
 
-      let advance = skipTable[self[index]] ?? patternLength
-      index = index.advancedBy(advance)
+    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
     }
 
+    while i < self.endIndex {
+    let c = self[i]
+    if c == lastChar {
+    if let k = backwards() { return k }
+    i = index(after: i)
+    } else {
+    i = index(i, offsetBy: skipTable[c] ?? patternLength)
+    }
+    }
     return nil
-  }
+    }
 }
 ```
 

Longest Common Subsequence/README.markdown

@@ -152,15 +152,15 @@ func backtrack(_ matrix: [[Int]]) -> String {
 	}
   }
 
-  return String(lcs.characters.reverse())
+  return String(lcs.characters.reversed())
 }
 ```  
 
 This backtracks from `matrix[n+1][m+1]` (bottom-right corner) to `matrix[1][1]` (top-right corner), looking for characters that are common to both strings. It adds those characters to a new string, `lcs`.
 
 The `charInSequence` variable is an index into the string given by `self`. Initially this points to the last character of the string. Each time we decrement `i`, we also move back `charInSequence`. When the two characters are found to be equal, we add the character at `self[charInSequence]` to the new `lcs` string. (We can't just write `self[i]` because `i` may not map to the current position inside the Swift string.)
 
-Due to backtracking, characters are added in reverse order, so at the end of the function we call `reverse()` to put the string in the right order. (Appending new characters to the end of the string and then reversing it once is faster than always inserting the characters at the front of the string.)
+Due to backtracking, characters are added in reverse order, so at the end of the function we call `reversed()` to put the string in the right order. (Appending new characters to the end of the string and then reversing it once is faster than always inserting the characters at the front of the string.)
 
 ## Putting it all together
 

README.markdown

@@ -10,7 +10,7 @@ The goal of this project is to **explain how algorithms work**. The focus is on
 
 All code is compatible with **Xcode 7.3** and **Swift 2.2**. We'll keep this updated with the latest version of Swift.
 
-This is a work in progress. More algorithms will be added soon. :-) 
+This is a work in progress. More algorithms will be added soon. :-)
 
 :heart_eyes: **Suggestions and contributions are welcome!** :heart_eyes:
 
@@ -26,7 +26,7 @@ This is a work in progress. More algorithms will be added soon. :-)
 
 [How to contribute](How to Contribute.markdown). Report an issue to leave feedback, or submit a pull request.
 
-[Under construction](Under Construction.markdown). Algorithms that are under construction. 
+[Under construction](Under Construction.markdown). Algorithms that are under construction.
 
 ## Where to start?
 
@@ -213,6 +213,7 @@ Other algorithm repositories:
 - [@lorentey](https://github.com/lorentey/). Production-quality Swift implementations of common algorithms and data structures.
 - [Rosetta Code](http://rosettacode.org). Implementations in pretty much any language you can think of.
 - [AlgorithmVisualizer](http://jasonpark.me/AlgorithmVisualizer/). Visualize algorithms on your browser.
+- [Swift Structures](https://github.com/waynewbishop/SwiftStructures) Data Structures with directions on how to use them [here](http://waynewbishop.com/swift)
 
 ## Credits
 

Shell Sort/Tests/Tests.xcodeproj/project.pbxproj

@@ -91,6 +91,7 @@
 				TargetAttributes = {
 					7B2BBC7F1C779D720067B71D = {
 						CreatedOnToolsVersion = 7.2;
+						LastSwiftMigration = 0800;
 					};
 				};
 			};
@@ -224,6 +225,7 @@
 				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/../Frameworks @loader_path/../Frameworks";
 				PRODUCT_BUNDLE_IDENTIFIER = swift.algorithm.club.Tests;
 				PRODUCT_NAME = "$(TARGET_NAME)";
+				SWIFT_VERSION = 3.0;
 			};
 			name = Debug;
 		};
@@ -235,6 +237,7 @@
 				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/../Frameworks @loader_path/../Frameworks";
 				PRODUCT_BUNDLE_IDENTIFIER = swift.algorithm.club.Tests;
 				PRODUCT_NAME = "$(TARGET_NAME)";
+				SWIFT_VERSION = 3.0;
 			};
 			name = Release;
 		};

Shell Sort/shellsort.swift

@@ -20,8 +20,8 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
-public func insertionSort(inout list: [Int], start: Int, gap: Int) {
-  for i in (start + gap).stride(to: list.count, by: gap) {
+public func insertionSort(_ list: inout [Int], start: Int, gap: Int) {
+  for i in stride(from: (start + gap), to: list.count, by: gap) {
     let currentValue = list[i]
     var pos = i
     while pos >= gap && list[pos - gap] > currentValue {
@@ -32,7 +32,7 @@ public func insertionSort(inout list: [Int], start: Int, gap: Int) {
   }
 }
 
-public func shellSort(inout list: [Int]) {
+public func shellSort(_ list: inout [Int]) {
   var sublistCount = list.count / 2
   while sublistCount > 0 {
     for pos in 0..<sublistCount {

Topological Sort/Graph.swift

@@ -7,7 +7,7 @@ public class Graph: CustomStringConvertible {
     adjacencyLists = [Node : [Node]]()
   }
 
-  public func addNode(value: Node) -> Node {
+  public func addNode(_ value: Node) -> Node {
     adjacencyLists[value] = []
     return value
   }