Update code and README for Swift 3.0

Author: jsbean

Minimum Edit Distance/MinimumEditDistance.swift renamed to Minimum Edit Distance/MinimumEditDistance.playground/Contents.swift

@@ -1,34 +1,36 @@
 extension String {
-
+    
     public func minimumEditDistance(other: String) -> Int {
         let m = self.characters.count
         let n = other.characters.count
-        var matrix = [[Int]](count: m+1, repeatedValue: [Int](count: n+1, repeatedValue: 0))
-
-
+        var matrix = [[Int]](repeating: [Int](repeating: 0, count: n + 1), count: m + 1)
+        
         // initialize matrix
         for index in 1...m {
             // the distance of any first string to an empty second string
-            matrix[index][0]=index
+            matrix[index][0] = index
         }
+        
         for index in 1...n {
             // the distance of any second string to an empty first string
-            matrix[0][index]=index
+            matrix[0][index] = index
         }
-
+        
         // compute Levenshtein distance
-        for (i, selfChar) in self.characters.enumerate() {
-            for (j, otherChar) in other.characters.enumerate() {
+        for (i, selfChar) in self.characters.enumerated() {
+            for (j, otherChar) in other.characters.enumerated() {
                 if otherChar == selfChar {
                     // substitution of equal symbols with cost 0
-                    matrix[i+1][j+1] = matrix[i][j]
+                    matrix[i + 1][j + 1] = matrix[i][j]
                 } else {
-                    // minimum of the cost of insertion, deletion, or substitution added to the already computed costs in the corresponding cells
-                    matrix[i+1][j+1] = min(matrix[i][j]+1, matrix[i+1][j]+1, matrix[i][j+1]+1)
+                    // minimum of the cost of insertion, deletion, or substitution 
+                    // added to the already computed costs in the corresponding cells
+                    matrix[i + 1][j + 1] = min(matrix[i][j] + 1, matrix[i + 1][j] + 1, matrix[i][j + 1] + 1)
                 }
-
             }
         }
         return matrix[m][n]
     }
 }
+
+"Door".minimumEditDistance(other: "Dolls")

Minimum Edit Distance/MinimumEditDistance.playground/contents.xcplayground

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<playground version='5.0' target-platform='ios'>
+    <timeline fileName='timeline.xctimeline'/>
+</playground>

Minimum Edit Distance/MinimumEditDistance.playground/playground.xcworkspace/contents.xcworkspacedata

@@ -6,7 +6,7 @@ The minimum edit distance is a possibility to measure the similarity of two stri
 
 A common distance measure is given by the *Levenshtein distance*, which allows the following three transformation operations:
 
-* **Inseration** (*ε→x*) of a single symbol *x* with **cost 1**,
+* **Insertion** (*ε→x*) of a single symbol *x* with **cost 1**,
 * **Deletion** (*x→ε*) of a single symbol *x* with **cost 1**, and
 * **Substitution** (*x→y*) of two single symbols *x, y* with **cost 1** if *x≠y* and with **cost 0** otherwise.
 
@@ -15,37 +15,38 @@ When transforming a string by a sequence of operations, the costs of the single
 To avoid exponential time complexity, the minimum edit distance of two strings in the usual is computed using *dynamic programming*. For this in a matrix
 
 ```swift
-var matrix = [[Int]](count: m+1, repeatedValue: [Int](count: n+1, repeatedValue: 0))
+var matrix = [[Int]](repeating: [Int](repeating: 0, count: n + 1), count: m + 1)
 ```
 
 already computed minimal edit distances of prefixes of *w* and *u* (of length *m* and *n*, respectively) are used to fill the matrix. In a first step the matrix is initialized by filling the first row and the first column as follows:
 
 ```swift
 // initialize matrix
 for index in 1...m {
-    // the distance of any prefix of the first string to an empty second string
-    matrix[index][0]=index
+    // the distance of any first string to an empty second string
+    matrix[index][0] = index
 }
+
 for index in 1...n {
-    // the distance of any prefix of the second string to an empty first string
-    matrix[0][index]=index
+    // the distance of any second string to an empty first string
+    matrix[0][index] = index
 }
 ```
+
 Then in each cell the minimum of the cost of insertion, deletion, or substitution added to the already computed costs in the corresponding cells is chosen. In this way the matrix is filled iteratively:
 
 ```swift
 // compute Levenshtein distance
-for (i, selfChar) in self.characters.enumerate() {
-    for (j, otherChar) in other.characters.enumerate() {
+for (i, selfChar) in self.characters.enumerated() {
+    for (j, otherChar) in other.characters.enumerated() {
         if otherChar == selfChar {
             // substitution of equal symbols with cost 0
-            matrix[i+1][j+1] = matrix[i][j]
+            matrix[i + 1][j + 1] = matrix[i][j]
         } else {
-            // minimum of the cost of insertion, deletion, or substitution added 
-            // to the already computed costs in the corresponing cells
-            matrix[i+1][j+1] = min(matrix[i][j]+1, matrix[i+1][j]+1, matrix[i][j+1]+1)
-        }
-                
+            // minimum of the cost of insertion, deletion, or substitution 
+            // added to the already computed costs in the corresponding cells
+            matrix[i + 1][j + 1] = min(matrix[i][j] + 1, matrix[i + 1][j] + 1, matrix[i][j + 1] + 1)
+        } 
     }
 }
 ```
@@ -58,8 +59,6 @@ return matrix[m][n]
 
 This algorithm has a time complexity of Θ(*mn*).
 
-### Other distance measures
-
-**todo**
+**TODO**: Other distance measures.
 
-*Written for Swift Algorithm Club by Luisa Herrmann*
+*Written for Swift Algorithm Club by Luisa Herrmann*