Updated readme based on code changes.

Author: kelvinlauKL

3Sum and 4Sum/README.md

@@ -29,19 +29,15 @@ Since you pre-sort the array, duplicates will be adjacent to each other. You jus
 ```
 extension Collection where Element: Equatable {
   
-  /// Returns next index with unique value. Works only on sorted arrays.
+  /// In a sorted collection, replaces the given index with a successor mapping to a unique element.
   ///
-  /// - Parameter index: The current index.
-  /// - Returns: The new index. Will return `nil` if new index happens to be the `endIndex` (out of bounds)
-  func uniqueIndex(after index: Index) -> Index? {
-    guard index < endIndex else { return nil }
-    var index = index
-    var nextIndex = self.index(after: index)
-    while nextIndex < endIndex && self[index] == self[nextIndex] {
+  /// - Parameter index: A valid index of the collection. `index` must be less than `endIndex`
+  func formUniqueIndex(after index: inout Index) {
+    var prev = index
+    repeat {
+      prev = index
       formIndex(after: &index)
-      formIndex(after: &nextIndex)
-    }
-    return nextIndex != endIndex ? nextIndex : nil
+    } while index < endIndex && self[prev] == self[index]
   }
 }
 ```
@@ -51,16 +47,15 @@ A similar implementation is used to get the unique index *before* a given index:
 ```
 extension BidirectionalCollection where Element: Equatable {
   
-  /// Returns next index with unique value. Works only on sorted arrays.
+  /// In a sorted collection, replaces the given index with a predecessor that maps to a unique element.
   ///
-  /// - Parameter index: The current index.
-  /// - Returns: The new index. Will return `nil` if new index happens to come before the `startIndex` (out of bounds)
-  func uniqueIndex(before index: Index) -> Index? {
-    return indices[..<index].reversed().first { index -> Bool in
-      let nextIndex = self.index(after: index)
-      guard nextIndex >= startIndex && self[index] != self[nextIndex] else { return false }
-      return true
-    }
+  /// - Parameter index: A valid index of the collection. `index` must be greater than `startIndex`.
+  func formUniqueIndex(before index: inout Index) {
+    var prev = index
+    repeat {
+      prev = index
+      formIndex(before: &index)
+    } while index > startIndex && self[prev] == self[index]
   }
 }
 ```
@@ -78,40 +73,36 @@ You'll keep track of 3 indices to represent the 3 numbers. The sum at any given
 The premise is quite straightforward (given that you're familiar with 2Sum). You'll iterate `l` through the array. For every iteration, you also apply the 2Sum algorithm to elements after `l`. You'll check the sum every time you moving the indices to check if you found match. Here's the algorithm:
 
 ```
-func threeSum<T: BidirectionalCollection>(_ c: T, target: T.Element) -> [[T.Element]] where T.Element: Numeric & Comparable {
-  let sorted = c.sorted()
+func threeSum<T: BidirectionalCollection>(_ collection: T, target: T.Element) -> [[T.Element]] where T.Element: Numeric & Comparable {
+  let sorted = collection.sorted()
   var ret: [[T.Element]] = []
+  var l = sorted.startIndex
   
-  for l in sequence(first: sorted.startIndex, next: sorted.uniqueIndex(after:)) {
+  while l < sorted.endIndex {
     var m = sorted.index(after: l)
     var r = sorted.index(before: sorted.endIndex)
     
-    while m < r {
+    while m < r && r < sorted.endIndex {
       let sum = sorted[l] + sorted[m] + sorted[r]
-      switch sum {
-      case target:
+      switch target {
+      case sum:
         ret.append([sorted[l], sorted[m], sorted[r]])
-        guard let nextM = sorted.uniqueIndex(after: m), let nextR = sorted.uniqueIndex(before: r) else { break }
-        m = nextM
-        r = nextR
+        sorted.formUniqueIndex(after: &m)
+        sorted.formUniqueIndex(before: &r)
       case ..<target:
-        guard let nextM = sorted.uniqueIndex(after: m) else { break }
-        m = nextM
+        sorted.formUniqueIndex(after: &m)
       case target...:
-        guard let nextR = sorted.uniqueIndex(before: m) else { break }
-        r = nextR
-      default: fatalError()
+        sorted.formUniqueIndex(before: &r)
+      default: fatalError("Swift isn't smart enough to detect that this switch statement is exhausive")
       }
     }
+    sorted.formUniqueIndex(after: &l)
   }
   
   return ret
 }
 ```
 
-
-
-
 ## 4Sum
 Given an array S of n integers, find all subsets of the array with 4 values where the 4 values sum up to a target number.