Merge branch 'master' into Update-Protocols

Author: ahmedrezik

.travis.yml

@@ -124,9 +124,8 @@ Below are some examples for each category of performance:
   func solveHanoi(n: Int, from: String, to: String, spare: String) {
     guard n >= 1 else { return }
     if n > 1 {
-      solveHanoi(n: n - 1, from: from, to: spare, spare: to)
-    } else {
-      solveHanoi(n: n - 1, from: spare, to: to, spare: from)
+        solveHanoi(n: n - 1, from: from, to: spare, spare: to)
+        solveHanoi(n: n - 1, from: spare, to: to, spare: from)
     }
   }
   ```

Big-O Notation.markdown

@@ -557,7 +557,7 @@ As a result, doing `tree.search(100)` gives nil.
 You can check whether a tree is a valid binary search tree with the following method:
 
 ```swift
-  public func isBST(minValue minValue: T, maxValue: T) -> Bool {
+  public func isBST(minValue: T, maxValue: T) -> Bool {
     if value < minValue || value > maxValue { return false }
     let leftBST = left?.isBST(minValue: minValue, maxValue: value) ?? true
     let rightBST = right?.isBST(minValue: value, maxValue: maxValue) ?? true

Binary Search Tree/README.markdown

@@ -25,7 +25,7 @@ In code this looks as follows:
 func countOccurrences<T: Comparable>(of key: T, in array: [T]) -> Int {
   var leftBoundary: Int {
     var low = 0
-    var high = a.count
+    var high = array.count
     while low < high {
       let midIndex = low + (high - low)/2
       if a[midIndex] < key {
@@ -39,7 +39,7 @@ func countOccurrences<T: Comparable>(of key: T, in array: [T]) -> Int {
 
   var rightBoundary: Int {
     var low = 0
-    var high = a.count
+    var high = array.count
     while low < high {
       let midIndex = low + (high - low)/2
       if a[midIndex] > key {
@@ -62,7 +62,7 @@ To test this algorithm, copy the code to a playground and then do:
 ```swift
 let a = [ 0, 1, 1, 3, 3, 3, 3, 6, 8, 10, 11, 11 ]
 
-countOccurrencesOfKey(3, inArray: a)  // returns 4
+countOccurrences(of: 3, in: a)  // returns 4
 ```
 
 > **Remember:** If you use your own array, make sure it is sorted first!

Count Occurrences/README.markdown

@@ -1,23 +1,23 @@
-// last checked with Xcode 10.0 (10A255)
+// Last checked with Xcode Version 11.4.1 (11E503a)
 
 func fizzBuzz(_ numberOfTurns: Int) {
-  for i in 1...numberOfTurns {
-    var result = ""
-
-    if i % 3 == 0 {
-      result += "Fizz"
+    guard numberOfTurns >= 1 else {
+        print("Number of turns must be >= 1")
+        return
     }
-
-    if i % 5 == 0 {
-      result += (result.isEmpty ? "" : " ") + "Buzz"
+    
+    for i in 1...numberOfTurns {
+        switch (i.isMultiple(of: 3), i.isMultiple(of: 5)) {
+        case (false, false):
+            print("\(i)")
+        case (true, false):
+            print("Fizz")
+        case (false, true):
+            print("Buzz")
+        case (true, true):
+            print("Fizz Buzz")
+        }
     }
-
-    if result.isEmpty {
-      result += "\(i)"
-    }
-
-    print(result)
-  }
 }
 
-fizzBuzz(100)
+fizzBuzz(15)

Fizz Buzz/FizzBuzz.playground/Contents.swift

@@ -1,19 +1,21 @@
-func fizzBuzz(_ numberOfTurns: Int) {
-  for i in 1...numberOfTurns {
-    var result = ""
-
-    if i % 3 == 0 {
-      result += "Fizz"
-    }
+// Last checked with Xcode Version 11.4.1 (11E503a)
 
-    if i % 5 == 0 {
-      result += (result.isEmpty ? "" : " ") + "Buzz"
+func fizzBuzz(_ numberOfTurns: Int) {
+    guard numberOfTurns >= 1 else {
+        print("Number of turns must be >= 1")
+        return
     }
-
-    if result.isEmpty {
-      result += "\(i)"
+    
+    for i in 1...numberOfTurns {
+        switch (i.isMultiple(of: 3), i.isMultiple(of: 5)) {
+        case (false, false):
+            print("\(i)")
+        case (true, false):
+            print("Fizz")
+        case (false, true):
+            print("Buzz")
+        case (true, true):
+            print("Fizz Buzz")
+        }
     }
-
-    print(result)
-  }
-}
+}

Fizz Buzz/FizzBuzz.playground/contents.xcplayground

@@ -16,46 +16,48 @@ The modulus operator `%` is the key to solving fizz buzz.
 
 The modulus operator returns the remainder after an integer division. Here is an example of the modulus operator:
 
-| Division      | Division Result            | Modulus         | Modulus Result  |
-| ------------- | -------------------------- | --------------- | ---------------:|
-| 1 / 3       | 0 with a remainder of 3  | 1 % 3         | 1             |
-| 5 / 3       | 1 with a remainder of 2  | 5 % 3         | 2             |
-| 16 / 3      | 5 with a remainder of 1  | 16 % 3        | 1             |
+| Division    | Division Result       | Modulus       | Modulus Result|
+| ----------- | --------------------- | ------------- | :-----------: |
+| 1 / 3       | 0 with a remainder of 3 | 1 % 3         | 1             |
+| 5 / 3       | 1 with a remainder of 2 | 5 % 3         | 2             |
+| 16 / 3      | 5 with a remainder of 1 | 16 % 3        | 1             |
 
 A common approach to determine if a number is even or odd is to use the modulus operator:
 
-| Modulus       | Result          | Swift Code                      | Swift Code Result | Comment                                       |
-| ------------- | ---------------:| ------------------------------- | -----------------:| --------------------------------------------- |
-| 6 % 2       | 0               | `let isEven = (number % 2 == 0)`  | `true`            | If a number is divisible by 2 it is *even*    |
-| 5 % 2       | 1               | `let isOdd = (number % 2 != 0)`   | `true`            | If a number is not divisible by 2 it is *odd* |
+| Modulus  | Result | Swift Code                       | Swift Code<br>Result | Comment                                    |
+| -------- | :-----:| -------------------------------- | :----------------:| --------------------------------------------- |
+| 6 % 2    | 0      | `let isEven = (number % 2 == 0)` | `true`            | If a number is divisible by 2 it is *even*    |
+| 5 % 2    | 1      | `let isOdd = (number % 2 != 0)`  | `true`            | If a number is not divisible by 2 it is *odd* |
+
+Alternatively, Swift's built in function .isMultiple(of:) can be used, i.e. 6.isMultiple(of: 2) will return true, 5.isMultiple(of: 2) will return false
 
 ## Solving fizz buzz
 
-Now we can use the modulus operator `%` to solve fizz buzz.
+Now we can use the modulus operator `%` or .isMultiple(of:) method to solve fizz buzz.
 
 Finding numbers divisible by three:
 
-| Modulus | Modulus Result | Swift Code    | Swift Code Result |
-| ------- | --------------:| ------------- |------------------:|
-| 1 % 3 | 1            | `1 % 3 == 0`  | `false`           |
-| 2 % 3 | 2            | `2 % 3 == 0`  | `false`           |
-| 3 % 3 | 0            | `3 % 3 == 0`  | `true`            |
-| 4 % 3 | 1            | `4 % 3 == 0`  | `false`           |
+| Modulus | Modulus<br>Result | Swift Code<br>using Modulo | Swift Code<br>using .isMultiple(of:) | Swift Code<br>Result |
+| ------- | :---------------: | -------------------------- | ------------------------------------ | ------------------- |
+|1 % 3    | 1                 | `1 % 3 == 0`               | `1.isMultiple(of: 3)`                | `false`              |
+|2 % 3    | 2                 | `2 % 3 == 0`               | `2.isMultiple(of: 3)`                | `false`              |
+|3 % 3    | 0                 | `3 % 3 == 0`               | `3.isMultiple(of: 3)`                | `true`               |
+|4 % 3    | 1                 | `4 % 3 == 0`               | `4.isMultiple(of: 3)`                | `false`              |
 
 Finding numbers divisible by five:
 
-| Modulus | Modulus Result | Swift Code    | Swift Code Result |
-| ------- | --------------:| ------------- |------------------:|
-| 1 % 5 | 1            | `1 % 5 == 0`  | `false`           |
-| 2 % 5 | 2            | `2 % 5 == 0`  | `false`           |
-| 3 % 5 | 3            | `3 % 5 == 0`  | `false`           |
-| 4 % 5 | 4            | `4 % 5 == 0`  | `false`           |
-| 5 % 5 | 0            | `5 % 5 == 0`  | `true`            |
-| 6 % 5 | 1            | `6 % 5 == 0`  | `false`           |
+| Modulus | Modulus<br>Result | Swift Code<br>using Modulo | Swift Code<br>using .isMultiple(of:) | Swift Code<br>Result |
+| ------- | :---------------: | -------------------------- | ------------------------------------ | -------------------- |
+| 1 % 5   | 1                 | `1 % 5 == 0`               | `1.isMultiple(of: 5)`                | `false`              |
+| 2 % 5   | 2                 | `2 % 5 == 0`               | `2.isMultiple(of: 5)`                | `false`              |
+| 3 % 5   | 3                 | `3 % 5 == 0`               | `3.isMultiple(of: 5)`                | `false`              |
+| 4 % 5   | 4                 | `4 % 5 == 0`               | `4.isMultiple(of: 5)`                | `false`              |
+| 5 % 5   | 0                 | `5 % 5 == 0`               | `5.isMultiple(of: 5)`                | `true`               |
+| 6 % 5   | 1                 | `6 % 5 == 0`               | `6.isMultiple(of: 5)`                | `false`              |
 
 ## The code
 
-Here is a simple implementation in Swift:
+Here is a simple implementation in Swift using Modulus approach
 
 ```swift
 func fizzBuzz(_ numberOfTurns: Int) {
@@ -79,18 +81,57 @@ func fizzBuzz(_ numberOfTurns: Int) {
 }
 ```
 
-Put this code in a playground and test it like so:
+Here is simple implementation in Swift using .isMultiple(of:) and switch statement
+
+```swift
+func fizzBuzz(_ numberOfTurns: Int) {
+    guard numberOfTurns >= 1 else {
+        print("Number of turns must be >= 1")
+        return
+    }
+    
+    for i in 1...numberOfTurns {
+        switch (i.isMultiple(of: 3), i.isMultiple(of: 5)) {
+        case (false, false):
+            print("\(i)")
+        case (true, false):
+            print("Fizz")
+        case (false, true):
+            print("Buzz")
+        case (true, true):
+            print("Fizz Buzz")
+        }
+    }
+}
+```
+
+Put either code in a playground and test it like so:
 
 ```swift
 fizzBuzz(15)
 ```
 
 This will output:
 
-	1, 2, Fizz, 4, Buzz, Fizz, 7, 8, Fizz, Buzz, 11, Fizz, 13, 14, Fizz Buzz
+1    
+2   
+Fizz   
+4   
+Buzz    
+Fizz  
+7   
+8   
+Fizz   
+Buzz   
+11   
+Fizz  
+13   
+14    
+Fizz Buzz  
 
 ## See also
 
 [Fizz buzz on Wikipedia](https://en.wikipedia.org/wiki/Fizz_buzz)
 
-*Written by [Chris Pilcher](https://github.com/chris-pilcher)*
+*Originally written by [Chris Pilcher](https://github.com/chris-pilcher)*<br>
+*Updated by [Lance Rettberg](https://github.com/l-rettberg)*

Fizz Buzz/FizzBuzz.playground/playground.xcworkspace/contents.xcworkspacedata

@@ -29,7 +29,6 @@ extension Edge: CustomStringConvertible {
 
 extension Edge: Hashable {
 
-
     public func hash(into hasher: inout Hasher) {
               hasher.combine(from)
               hasher.combine(to)
@@ -38,6 +37,7 @@ extension Edge: Hashable {
              }
             }
 
+
 }
 
 public func == <T>(lhs: Edge<T>, rhs: Edge<T>) -> Bool {

Fizz Buzz/FizzBuzz.playground/playground.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist

@@ -25,13 +25,16 @@ extension Vertex: CustomStringConvertible {
 extension Vertex: Hashable {
 
 
+
 
     public func hasher(into hasher: inout Hasher){
 
         hasher.combine(data)
         hasher.combine(index)
     }
 
+
+
 }
 
 public func ==<T>(lhs: Vertex<T>, rhs: Vertex<T>) -> Bool {

Fizz Buzz/FizzBuzz.swift

@@ -1,6 +1,6 @@
 import UIKit
 
-func haversineDinstance(la1: Double, lo1: Double, la2: Double, lo2: Double, radius: Double = 6367444.7) -> Double {
+func haversineDistance(la1: Double, lo1: Double, la2: Double, lo2: Double, radius: Double = 6367444.7) -> Double {
 
     let haversin = { (angle: Double) -> Double in
         return (1 - cos(angle))/2
@@ -27,4 +27,4 @@ let amsterdam = (52.3702, 4.8952)
 let newYork = (40.7128, -74.0059)
 
 // Google says it's 5857 km so our result is only off by 2km which could be due to all kinds of things, not sure how google calculates the distance or which latitude and longitude google uses to calculate the distance.
-haversineDinstance(la1: amsterdam.0, lo1: amsterdam.1, la2: newYork.0, lo2: newYork.1)
+haversineDistance(la1: amsterdam.0, lo1: amsterdam.1, la2: newYork.0, lo2: newYork.1)

Fizz Buzz/README.markdown

@@ -42,7 +42,7 @@ As you can see, the largest items are making their way to the back. We repeat th
 
 > **Note:** This process is very similar to [selection sort](../Selection%20Sort/), which repeatedly looks for the minimum item in the remainder of the array. Extracting the minimum or maximum value is what heaps are good at.
 
-Performance of heap sort is **O(n lg n)** in best, worst, and average case. Because we modify the array directly, heap sort can be performed in-place. But it is not a stable sort: the relative order of identical elements is not preserved.
+Performance of heap sort is **O(n log n)** in best, worst, and average case. Because we modify the array directly, heap sort can be performed in-place. But it is not a stable sort: the relative order of identical elements is not preserved.
 
 Here's how you can implement heap sort in Swift: