swift 3 fix

Author: matteo-dunnhofer

Knuth-Morris-Pratt/KnuthMorrisPratt.playground/Contents.swift

@@ -10,7 +10,7 @@ func ZetaAlgorithm(ptnr: String) -> [Int]? {
         return nil
     }
 
-    var zeta: [Int] = [Int](count: patternLength, repeatedValue: 0)
+    var zeta: [Int] = [Int](repeating: 0, count: patternLength)
 
     var left: Int = 0
     var right: Int = 0
@@ -71,15 +71,15 @@ extension String {
             return nil
         }
 
-        var suffixPrefix: [Int] = [Int](count: patternLength, repeatedValue: 0)
+        var suffixPrefix: [Int] = [Int](repeating: 0, count: patternLength)
         var textIndex: Int = 0
         var patternIndex: Int = 0
         var indexes: [Int] = [Int]()
 
         /* Pre-processing stage: computing the table for the shifts (through Z-Algorithm) */
-        let zeta = ZetaAlgorithm(ptnr)
+        let zeta = ZetaAlgorithm(ptnr: ptnr)
 
-        for patternIndex in (1 ..< patternLength).reverse() {
+        for patternIndex in (1 ..< patternLength).reversed() {
             textIndex = patternIndex + zeta![patternIndex] - 1
             suffixPrefix[textIndex] = zeta![patternIndex]
         }
@@ -116,7 +116,7 @@ extension String {
 /* Examples */
 
 let dna = "ACCCGGTTTTAAAGAACCACCATAAGATATAGACAGATATAGGACAGATATAGAGACAAAACCCCATACCCCAATATTTTTTTGGGGAGAAAAACACCACAGATAGATACACAGACTACACGAGATACGACATACAGCAGCATAACGACAACAGCAGATAGACGATCATAACAGCAATCAGACCGAGCGCAGCAGCTTTTAAGCACCAGCCCCACAAAAAACGACAATFATCATCATATACAGACGACGACACGACATATCACACGACAGCATA"
-dna.indexesOf("CATA")   // [20, 64, 130, 140, 166, 234, 255, 270]
+dna.indexesOf(ptnr: "CATA")   // [20, 64, 130, 140, 166, 234, 255, 270]
 
 let concert = "🎼🎹🎹🎸🎸🎻🎻🎷🎺🎤👏👏👏"
-concert.indexesOf("🎻🎷")   // [6]
+concert.indexesOf(ptnr: "🎻🎷")   // [6]

Knuth-Morris-Pratt/KnuthMorrisPratt.playground/timeline.xctimeline

@@ -9,54 +9,54 @@
 import Foundation
 
 extension String {
-
+    
     func indexesOf(ptnr: String) -> [Int]? {
-
+        
         let text = Array(self.characters)
         let pattern = Array(ptnr.characters)
-
+        
         let textLength: Int = text.count
         let patternLength: Int = pattern.count
-
+        
         guard patternLength > 0 else {
             return nil
         }
-
-        var suffixPrefix: [Int] = [Int](count: patternLength, repeatedValue: 0)
+        
+        var suffixPrefix: [Int] = [Int](repeating: 0, count: patternLength)
         var textIndex: Int = 0
         var patternIndex: Int = 0
         var indexes: [Int] = [Int]()
-
+        
         /* Pre-processing stage: computing the table for the shifts (through Z-Algorithm) */
-        let zeta = ZetaAlgorithm(ptnr)
-
-        for patternIndex in (1 ..< patternLength).reverse() {
+        let zeta = ZetaAlgorithm(ptnr: ptnr)
+        
+        for patternIndex in (1 ..< patternLength).reversed() {
             textIndex = patternIndex + zeta![patternIndex] - 1
             suffixPrefix[textIndex] = zeta![patternIndex]
         }
-
+        
         /* Search stage: scanning the text for pattern matching */
         textIndex = 0
         patternIndex = 0
-
+        
         while textIndex + (patternLength - patternIndex - 1) < textLength {
-
+            
             while patternIndex < patternLength && text[textIndex] == pattern[patternIndex] {
                 textIndex = textIndex + 1
                 patternIndex = patternIndex + 1
             }
-
+            
             if patternIndex == patternLength {
                 indexes.append(textIndex - patternIndex)
             }
-
+            
             if patternIndex == 0 {
                 textIndex = textIndex + 1
             } else {
                 patternIndex = suffixPrefix[patternIndex - 1]
             }
         }
-
+        
         guard !indexes.isEmpty else {
             return nil
         }

Knuth-Morris-Pratt/KnuthMorrisPratt.swift

@@ -9,53 +9,53 @@
 import Foundation
 
 func ZetaAlgorithm(ptrn: String) -> [Int]? {
-
+    
     let pattern = Array(ptrn.characters)
     let patternLength: Int = pattern.count
-
+    
     guard patternLength > 0 else {
         return nil
     }
-
-    var zeta: [Int] = [Int](count: patternLength, repeatedValue: 0)
-
+    
+    var zeta: [Int] = [Int](repeating: 0, count: patternLength)
+    
     var left: Int = 0
     var right: Int = 0
     var k_1: Int = 0
     var betaLength: Int = 0
     var textIndex: Int = 0
     var patternIndex: Int = 0
-
+    
     for k in 1 ..< patternLength {
         if k > right {
             patternIndex = 0
-
+            
             while k + patternIndex < patternLength  &&
                 pattern[k + patternIndex] == pattern[patternIndex] {
-                patternIndex = patternIndex + 1
+                    patternIndex = patternIndex + 1
             }
-
+            
             zeta[k] = patternIndex
-
+            
             if zeta[k] > 0 {
                 left = k
                 right = k + zeta[k] - 1
             }
         } else {
             k_1 = k - left + 1
             betaLength = right - k + 1
-
+            
             if zeta[k_1 - 1] < betaLength {
                 zeta[k] = zeta[k_1 - 1]
             } else if zeta[k_1 - 1] >= betaLength {
                 textIndex = betaLength
                 patternIndex = right + 1
-
+                
                 while patternIndex < patternLength && pattern[textIndex] == pattern[patternIndex] {
                     textIndex = textIndex + 1
                     patternIndex = patternIndex + 1
                 }
-
+                
                 zeta[k] = patternIndex - k
                 left = k
                 right = patternIndex - 1

Z-Algorithm/ZAlgorithm.swift

@@ -10,7 +10,7 @@ func ZetaAlgorithm(ptrn: String) -> [Int]? {
         return nil
     }
 
-    var zeta: [Int] = [Int](count: patternLength, repeatedValue: 0)
+    var zeta: [Int] = [Int](repeating: 0, count: patternLength)
 
     var left: Int = 0
     var right: Int = 0
@@ -63,7 +63,7 @@ extension String {
 
     func indexesOf(pattern: String) -> [Int]? {
         let patternLength: Int = pattern.characters.count
-        let zeta = ZetaAlgorithm(pattern + "💲" + self)
+        let zeta = ZetaAlgorithm(ptrn: pattern + "💲" + self)
 
         guard zeta != nil else {
             return nil
@@ -89,7 +89,7 @@ extension String {
 /* Examples */
 
 let str = "Hello, playground!"
-str.indexesOf("ground")   // [11]
+str.indexesOf(pattern: "ground")   // [11]
 
 let traffic = "🚗🚙🚌🚕🚑🚐🚗🚒🚚🚎🚛🚐🏎🚜🚗🏍🚒🚲🚕🚓🚌🚑"
-traffic.indexesOf("🚑") // [4, 21]
+traffic.indexesOf(pattern: "🚑") // [4, 21]

Z-Algorithm/ZetaAlgorithm.playground/Contents.swift

@@ -9,24 +9,28 @@
 import Foundation
 
 extension String {
-
+    
     func indexesOf(pattern: String) -> [Int]? {
         let patternLength: Int = pattern.characters.count
-        let zeta = ZetaAlgorithm(pattern + "💲" + self)
-
+        let zeta = ZetaAlgorithm(ptrn: pattern + "💲" + self)
+        
+        guard zeta != nil else {
+            return nil
+        }
+        
         var indexes: [Int] = [Int]()
-
+        
         /* Scan the zeta array to find matched patterns */
-        for index in indexes {
-            if index == patternLength {
-                indexes.append(index)
+        for i in 0 ..< zeta!.count {
+            if zeta![i] == patternLength {
+                indexes.append(i - patternLength - 1)
             }
         }
-
+        
         guard !indexes.isEmpty else {
             return nil
         }
-
+        
         return indexes
     }
 }