Merge pull request kodecocodes#335 from cruisediary/master

vincentngo · web-flow · commit e8a7141739eb · 2016-12-29T08:45:44.000-05:00
Updating to Swift3 (enum lowercase)
diff --git a/Binary Search Tree/Solution 2/BinarySearchTree.playground/Contents.swift b/Binary Search Tree/Solution 2/BinarySearchTree.playground/Contents.swift
@@ -1,7 +1,7 @@
 //: Playground - noun: a place where people can play
 
 // Each time you insert something, you get back a completely new tree.
-var tree = BinarySearchTree.Leaf(7)
+var tree = BinarySearchTree.leaf(7)
 tree = tree.insert(newValue: 2)
 tree = tree.insert(newValue: 5)
 tree = tree.insert(newValue: 10)
diff --git a/Binary Search Tree/Solution 2/BinarySearchTree.playground/Sources/BinarySearchTree.swift b/Binary Search Tree/Solution 2/BinarySearchTree.playground/Sources/BinarySearchTree.swift
@@ -4,25 +4,25 @@
   The tree is immutable. Any insertions or deletions will create a new tree.
 */
 public enum BinarySearchTree<T: Comparable> {
-  case Empty
-  case Leaf(T)
-  indirect case Node(BinarySearchTree, T, BinarySearchTree)
+  case empty
+  case leaf(T)
+  indirect case node(BinarySearchTree, T, BinarySearchTree)
 
   /* How many nodes are in this subtree. Performance: O(n). */
   public var count: Int {
     switch self {
-    case .Empty: return 0
-    case .Leaf: return 1
-    case let .Node(left, _, right): return left.count + 1 + right.count
+    case .empty: return 0
+    case .leaf: return 1
+    case let .node(left, _, right): return left.count + 1 + right.count
     }
   }
 
   /* Distance of this node to its lowest leaf. Performance: O(n). */
   public var height: Int {
     switch self {
-    case .Empty: return 0
-    case .Leaf: return 1
-    case let .Node(left, _, right): return 1 + max(left.height, right.height)
+    case .empty: return 0
+    case .leaf: return 1
+    case let .node(left, _, right): return 1 + max(left.height, right.height)
     }
   }
 
@@ -32,21 +32,21 @@ public enum BinarySearchTree<T: Comparable> {
   */
   public func insert(newValue: T) -> BinarySearchTree {
     switch self {
-    case .Empty:
-      return .Leaf(newValue)
+    case .empty:
+      return .leaf(newValue)
 
-    case .Leaf(let value):
+    case .leaf(let value):
       if newValue < value {
-        return .Node(.Leaf(newValue), value, .Empty)
+        return .node(.leaf(newValue), value, .empty)
       } else {
-        return .Node(.Empty, value, .Leaf(newValue))
+        return .node(.empty, value, .leaf(newValue))
       }
 
-    case .Node(let left, let value, let right):
+    case .node(let left, let value, let right):
       if newValue < value {
-        return .Node(left.insert(newValue: newValue), value, right)
+        return .node(left.insert(newValue: newValue), value, right)
       } else {
-        return .Node(left, value, right.insert(newValue: newValue))
+        return .node(left, value, right.insert(newValue: newValue))
       }
     }
   }
@@ -57,11 +57,11 @@ public enum BinarySearchTree<T: Comparable> {
   */
   public func search(x: T) -> BinarySearchTree? {
     switch self {
-    case .Empty:
+    case .empty:
       return nil
-    case .Leaf(let y):
+    case .leaf(let y):
       return (x == y) ? self : nil
-    case let .Node(left, y, right):
+    case let .node(left, y, right):
       if x < y {
         return left.search(x: x)
       } else if y < x {
@@ -82,11 +82,11 @@ public enum BinarySearchTree<T: Comparable> {
   public func minimum() -> BinarySearchTree {
     var node = self
     var prev = node
-    while case let .Node(next, _, _) = node {
+    while case let .node(next, _, _) = node {
       prev = node
       node = next
     }
-    if case .Leaf = node {
+    if case .leaf = node {
       return node
     }
     return prev
@@ -98,11 +98,11 @@ public enum BinarySearchTree<T: Comparable> {
   public func maximum() -> BinarySearchTree {
     var node = self
     var prev = node
-    while case let .Node(_, _, next) = node {
+    while case let .node(_, _, next) = node {
       prev = node
       node = next
     }
-    if case .Leaf = node {
+    if case .leaf = node {
       return node
     }
     return prev
@@ -112,9 +112,9 @@ public enum BinarySearchTree<T: Comparable> {
 extension BinarySearchTree: CustomDebugStringConvertible {
   public var debugDescription: String {
     switch self {
-    case .Empty: return "."
-    case .Leaf(let value): return "\(value)"
-    case .Node(let left, let value, let right):
+    case .empty: return "."
+    case .leaf(let value): return "\(value)"
+    case .node(let left, let value, let right):
       return "(\(left.debugDescription) <- \(value) -> \(right.debugDescription))"
     }
   }
diff --git a/Binary Search Tree/Solution 2/BinarySearchTree.swift b/Binary Search Tree/Solution 2/BinarySearchTree.swift
@@ -4,25 +4,25 @@
   The tree is immutable. Any insertions or deletions will create a new tree.
 */
 public enum BinarySearchTree<T: Comparable> {
-  case Empty
-  case Leaf(T)
-  indirect case Node(BinarySearchTree, T, BinarySearchTree)
+  case empty
+  case leaf(T)
+  indirect case node(BinarySearchTree, T, BinarySearchTree)
 
   /* How many nodes are in this subtree. Performance: O(n). */
   public var count: Int {
     switch self {
-    case .Empty: return 0
-    case .Leaf: return 1
-    case let .Node(left, _, right): return left.count + 1 + right.count
+    case .empty: return 0
+    case .leaf: return 1
+    case let .node(left, _, right): return left.count + 1 + right.count
     }
   }
 
   /* Distance of this node to its lowest leaf. Performance: O(n). */
   public var height: Int {
     switch self {
-    case .Empty: return 0
-    case .Leaf: return 1
-    case let .Node(left, _, right): return 1 + max(left.height, right.height)
+    case .empty: return 0
+    case .leaf: return 1
+    case let .node(left, _, right): return 1 + max(left.height, right.height)
     }
   }
 
@@ -32,21 +32,21 @@ public enum BinarySearchTree<T: Comparable> {
   */
   public func insert(newValue: T) -> BinarySearchTree {
     switch self {
-    case .Empty:
-      return .Leaf(newValue)
+    case .empty:
+      return .leaf(newValue)
 
-    case .Leaf(let value):
+    case .leaf(let value):
       if newValue < value {
-        return .Node(.Leaf(newValue), value, .Empty)
+        return .node(.leaf(newValue), value, .empty)
       } else {
-        return .Node(.Empty, value, .Leaf(newValue))
+        return .node(.empty, value, .leaf(newValue))
       }
 
-    case .Node(let left, let value, let right):
+    case .node(let left, let value, let right):
       if newValue < value {
-        return .Node(left.insert(newValue), value, right)
+        return .node(left.insert(newValue), value, right)
       } else {
-        return .Node(left, value, right.insert(newValue))
+        return .node(left, value, right.insert(newValue))
       }
     }
   }
@@ -57,11 +57,11 @@ public enum BinarySearchTree<T: Comparable> {
   */
   public func search(x: T) -> BinarySearchTree? {
     switch self {
-    case .Empty:
+    case .empty:
       return nil
-    case .Leaf(let y):
+    case .leaf(let y):
       return (x == y) ? self : nil
-    case let .Node(left, y, right):
+    case let .node(left, y, right):
       if x < y {
         return left.search(x)
       } else if y < x {
@@ -82,11 +82,11 @@ public enum BinarySearchTree<T: Comparable> {
   public func minimum() -> BinarySearchTree {
     var node = self
     var prev = node
-    while case let .Node(next, _, _) = node {
+    while case let .node(next, _, _) = node {
       prev = node
       node = next
     }
-    if case .Leaf = node {
+    if case .leaf = node {
       return node
     }
     return prev
@@ -98,11 +98,11 @@ public enum BinarySearchTree<T: Comparable> {
   public func maximum() -> BinarySearchTree {
     var node = self
     var prev = node
-    while case let .Node(_, _, next) = node {
+    while case let .node(_, _, next) = node {
       prev = node
       node = next
     }
-    if case .Leaf = node {
+    if case .leaf = node {
       return node
     }
     return prev
@@ -112,9 +112,9 @@ public enum BinarySearchTree<T: Comparable> {
 extension BinarySearchTree: CustomDebugStringConvertible {
   public var debugDescription: String {
     switch self {
-    case .Empty: return "."
-    case .Leaf(let value): return "\(value)"
-    case .Node(let left, let value, let right):
+    case .empty: return "."
+    case .leaf(let value): return "\(value)"
+    case .node(let left, let value, let right):
       return "(\(left.debugDescription) <- \(value) -> \(right.debugDescription))"
     }
   }
diff --git a/Counting Sort/CountingSort.playground/Contents.swift b/Counting Sort/CountingSort.playground/Contents.swift
@@ -1,12 +1,12 @@
 //: Playground - noun: a place where people can play
 
 enum CountingSortError: Error {
-  case ArrayEmpty
+  case arrayEmpty
 }
 
 func countingSort(array: [Int]) throws -> [Int] {
   guard array.count > 0 else {
-    throw CountingSortError.ArrayEmpty
+    throw CountingSortError.arrayEmpty
   }
 
   // Step 1
@@ -38,4 +38,4 @@ func countingSort(array: [Int]) throws -> [Int] {
 }
 
 
-try countingSort(array: [10, 9, 8, 7, 1, 2, 7, 3])
+try countingSort(array: [10, 9, 8, 7, 1, 2, 7, 3])
diff --git a/Counting Sort/CountingSort.swift b/Counting Sort/CountingSort.swift
@@ -7,12 +7,12 @@
 //
 
 enum CountingSortError: ErrorType {
-  case ArrayEmpty
+  case arrayEmpty
 }
 
 func countingSort(array: [Int]) throws -> [Int] {
   guard array.count > 0 else {
-    throw CountingSortError.ArrayEmpty
+    throw CountingSortError.arrayEmpty
   }
 
   // Step 1
diff --git a/Linked List/README.markdown b/Linked List/README.markdown
@@ -526,8 +526,8 @@ It is possible to implement a linked list with value semantics using an enum. Th
 
 ```swift
 enum ListNode<T> {
-  indirect case Node(T, next: ListNode<T>)
-  case End
+  indirect case node(T, next: ListNode<T>)
+  case end
 }
 ```
 
diff --git a/Shunting Yard/ShuntingYard.playground/Contents.swift b/Shunting Yard/ShuntingYard.playground/Contents.swift
diff --git a/Shunting Yard/ShuntingYard.swift b/Shunting Yard/ShuntingYard.swift

Original file line number	Diff line number	Diff line change
`@@ -1,12 +1,12 @@`
`1`	`1`	`//: Playground - noun: a place where people can play`
`2`	`2`
`3`	`3`	`enum CountingSortError: Error {`
`4`		`- case ArrayEmpty`
	`4`	`+ case arrayEmpty`
`5`	`5`	`}`
`6`	`6`
`7`	`7`	`func countingSort(array: [Int]) throws -> [Int] {`
`8`	`8`	`guard array.count > 0 else {`
`9`		`- throw CountingSortError.ArrayEmpty`
	`9`	`+ throw CountingSortError.arrayEmpty`
`10`	`10`	`}`
`11`	`11`
`12`	`12`	`// Step 1`
`@@ -38,4 +38,4 @@ func countingSort(array: [Int]) throws -> [Int] {`
`38`	`38`	`}`
`39`	`39`
`40`	`40`
`41`		`-try countingSort(array: [10, 9, 8, 7, 1, 2, 7, 3])`
	`41`	`+try countingSort(array: [10, 9, 8, 7, 1, 2, 7, 3])`
Original file line number	Diff line number	Diff line change
`@@ -7,12 +7,12 @@`
`7`	`7`	`//`
`8`	`8`
`9`	`9`	`enum CountingSortError: ErrorType {`
`10`		`- case ArrayEmpty`
	`10`	`+ case arrayEmpty`
`11`	`11`	`}`
`12`	`12`
`13`	`13`	`func countingSort(array: [Int]) throws -> [Int] {`
`14`	`14`	`guard array.count > 0 else {`
`15`		`- throw CountingSortError.ArrayEmpty`
	`15`	`+ throw CountingSortError.arrayEmpty`
`16`	`16`	`}`
`17`	`17`
`18`	`18`	`// Step 1`
Original file line number	Diff line number	Diff line change
`@@ -526,8 +526,8 @@ It is possible to implement a linked list with value semantics using an enum. Th`
`526`	`526`
`527`	`527`	```swift
`528`	`528`	`enum ListNode<T> {`
`529`		`- indirect case Node(T, next: ListNode<T>)`
`530`		`- case End`
	`529`	`+ indirect case node(T, next: ListNode<T>)`
	`530`	`+ case end`
`531`	`531`	`}`
`532`	`532`	```
`533`	`533`