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)*