Merge pull request #1 from hollance/master

update

Author: DavidBenko

Boyer-Moore/README.markdown

@@ -137,4 +137,51 @@ The closer a character is to the end of the pattern, the smaller the skip amount
 
 Credits: This code is based on the article ["Faster String Searches" by Costas Menico](http://www.drdobbs.com/database/faster-string-searches/184408171) from Dr Dobb's magazine, July 1989 -- Yes, 1989! Sometimes it's useful to keep those old magazines around.
 
+See also: [a detailed analysis](http://www.inf.fh-flensburg.de/lang/algorithmen/pattern/bmen.htm) of the algorithm.
+
+## Boyer-Moore-Horspool algorithm
+
+A variation on the above algorithm is the [Boyer-Moore-Horspool algorithm](https://en.wikipedia.org/wiki/Boyer%E2%80%93Moore%E2%80%93Horspool_algorithm).
+
+Like the regular Boyer-Moore algorithm, it uses the `skipTable` to skip ahead a number of characters. The difference is in how we check partial matches. In the above version, it a partial match is found but it's not a complete match, we skip ahead by just one character. In this revised version, we also use the skip table in that situation.
+
+Here's an implementation of the Boyer-Moore-Horspool algorithm:
+
+```swift
+extension String {
+  public func indexOf(pattern: String) -> String.Index? {
+    let patternLength = pattern.characters.count
+    assert(patternLength > 0)
+    assert(patternLength <= self.characters.count)
+
+    var skipTable = [Character: Int]()
+    for (i, c) in pattern.characters.dropLast().enumerate() {
+      skipTable[c] = patternLength - i - 1
+    }
+
+    var index = self.startIndex.advancedBy(patternLength - 1)
+
+    while index < self.endIndex {
+      var i = index
+      var p = pattern.endIndex.predecessor()
+
+      while self[i] == pattern[p] {
+        if p == pattern.startIndex { return i }
+        i = i.predecessor()
+        p = p.predecessor()
+      }
+
+      let advance = skipTable[self[index]] ?? patternLength
+      index = index.advancedBy(advance)
+    }
+
+    return nil
+  }
+}
+```
+
+In practice, the Horspool version of the algorithm tends to perform a little better than the original. However, it depends on the tradeoffs you're willing to make.
+
+Credits: This code is based on the paper: [R. N. Horspool (1980). "Practical fast searching in strings". Software - Practice & Experience 10 (6): 501–506.](http://www.cin.br/~paguso/courses/if767/bib/Horspool_1980.pdf)
+
 *Written for Swift Algorithm Club by Matthijs Hollemans*

Combinatorics/Combinatorics.playground/Contents.swift

@@ -117,6 +117,24 @@ for i in 1...20 {
 
 
 
+/*
+  Calculates C(n, k), or "n-choose-k", i.e. the number of ways to choose
+  k things out of n possibilities.
+*/
+func quickBinomialCoefficient(n: Int, _ k: Int) -> Int {
+  var result = 1
+    
+  for i in 0..<k {
+    result *= (n - i)
+    result /= (i + 1)
+  }
+  return result
+}
+
+quickBinomialCoefficient(8, 2)
+quickBinomialCoefficient(30, 15)
+
+
 
 /* Supporting code because Swift doesn't have a built-in 2D array. */
 struct Array2D<T> {
@@ -165,3 +183,4 @@ func binomialCoefficient(n: Int, _ k: Int) -> Int {
 
 binomialCoefficient(30, 15)
 binomialCoefficient(66, 33)
+

Combinatorics/Combinatorics.playground/timeline.xctimeline

@@ -78,6 +78,20 @@ func combinations(n: Int, _ k: Int) -> Int {
   return permutations(n, k) / factorial(k)
 }
 
+/*
+  Calculates C(n, k), or "n-choose-k", i.e. the number of ways to choose
+  k things out of n possibilities.
+*/
+func quickBinomialCoefficient(n: Int, _ k: Int) -> Int {
+  var result = 1
+    
+  for i in 0..<k {
+    result *= (n - i)
+    result /= (i + 1)
+  }
+  return result
+}
+
 /*
   Calculates C(n, k), or "n-choose-k", i.e. the number of ways to choose
   k things out of n possibilities.

Combinatorics/Combinatorics.swift

@@ -304,7 +304,43 @@ combinations(28, 5)    // prints 98280
 
 Because this uses the `permutations()` and `factorial()` functions under the hood, you're still limited by how large these numbers can get. For example, `combinations(30, 15)` is "only" `155,117,520` but because the intermediate results don't fit into a 64-bit integer, you can't calculate it with the given function.
 
-Here is an algorithm that uses dynamic programming to overcome the need for calculating factorials. It is based on Pascal's triangle:
+There's a faster approach to calculate `C(n, k)` in **O(k)** time and **O(1)** extra space. The idea behind it is that the formula for `C(n, k)` is:
+
+                   n!                      n * (n - 1) * ... * 1
+    C(n, k) = ------------- = ------------------------------------------
+              (n - k)! * k!      (n - k) * (n - k - 1) * ... * 1 * k!
+
+After the reduction of fractions, we get the following formula:
+
+                   n * (n - 1) * ... * (n - k + 1)         (n - 0) * (n - 1) * ... * (n - k + 1)
+    C(n, k) = --------------------------------------- = -----------------------------------------
+                               k!                          (0 + 1) * (1 + 1) * ... * (k - 1 + 1)
+
+We can implement this formula as follows:
+
+```swift
+func quickBinomialCoefficient(n: Int, _ k: Int) -> Int {
+  var result = 1
+  for i in 0..<k {
+    result *= (n - i)
+    result /= (i + 1)
+  }
+  return result
+}
+```
+
+This algorithm can create larger numbers than the previous method. Instead of calculating the entire numerator (a potentially huge number) and then dividing it by the factorial (also a very large number), here we already divide in each step. That causes the temporary results to grow much less quickly.
+
+Here's how you can use this improved algorithm:
+
+```swift
+quickBinomialCoefficient(8, 2)     // prints 28
+quickBinomialCoefficient(30, 15)   // prints 155117520
+```
+
+This new method is quite fast but you're still limited in how large the numbers can get. You can calculate `C(30, 15)` without any problems, but something like `C(66, 33)` will still cause integer overflow in the numerator.
+
+Here is an algorithm that uses dynamic programming to overcome the need for calculating factorials and doing divisions. It is based on Pascal's triangle:
 
 	0:               1
 	1:             1   1
@@ -351,10 +387,9 @@ func binomialCoefficient(n: Int, _ k: Int) -> Int {
 
 This uses [Array2D](../Array2D/) as helper code because Swift doesn't have a built-in two-dimensional array. The algorithm itself is quite simple: the first loop fills in the 1s at the outer edges of the triangle. The other loops calculate each number in the triangle by adding up the two numbers from the previous row.
 
-Now you can calculate `C(30, 15)` without any problems:
+Now you can calculate `C(66, 33)` without any problems:
 
 ```swift
-binomialCoefficient(30, 15)   // prints 155117520
 binomialCoefficient(66, 33)   // prints a very large number
 ```
 
@@ -364,4 +399,4 @@ You may wonder what the point is in calculating these permutations and combinati
 
 Wirth's and Sedgewick's permutation algorithms and the code for counting permutations and combinations are based on the Algorithm Alley column from Dr.Dobb's Magazine, June 1993. The dynamic programming binomial coefficient algorithm is from The Algorithm Design Manual by Skiena.
 
-*Written for Swift Algorithm Club by Matthijs Hollemans*
+*Written for Swift Algorithm Club by Matthijs Hollemans and [Kanstantsin Linou](https://github.com/nuts23)*

Combinatorics/README.markdown

@@ -3,7 +3,7 @@
 public class LinkedListNode<T> {
   var value: T
   var next: LinkedListNode?
-  var previous: LinkedListNode?
+  weak var previous: LinkedListNode?
 
   public init(value: T) {
     self.value = value
@@ -155,10 +155,10 @@ extension LinkedList: CustomStringConvertible {
 extension LinkedList {
   public func reverse() {
     var node = head
-    while node != nil {
-      swap(&node!.next, &node!.previous)
-      head = node
-      node = node!.previous
+    while let currentNode = node {
+      node = currentNode.next
+      swap(&currentNode.next, &currentNode.previous)
+      head = currentNode
     }
   }
 }

Linked List/LinkedList.playground/Contents.swift

@@ -6,7 +6,7 @@
 public class LinkedListNode<T> {
   var value: T
   var next: LinkedListNode?
-  var previous: LinkedListNode?
+  weak var previous: LinkedListNode?
 
   public init(value: T) {
     self.value = value
@@ -159,9 +159,9 @@ extension LinkedList {
   public func reverse() {
     var node = head
     while let currentNode = node {
-        swap(&currentNode.next, &currentNode.previous)
-        head = currentNode
-        node = currentNode.previous
+      node = currentNode.next
+      swap(&currentNode.next, &currentNode.previous)
+      head = currentNode
     }
   }
 }

Linked List/LinkedList.playground/timeline.xctimeline

@@ -58,7 +58,7 @@ We'll start by defining a type to describe the nodes:
 public class LinkedListNode<T> {
   var value: T
   var next: LinkedListNode?
-  var previous: LinkedListNode?
+  weak var previous: LinkedListNode?
 
   public init(value: T) {
     self.value = value
@@ -70,6 +70,8 @@ This is a generic type, so `T` can be any kind of data that you'd like to store
 
 Ours is a doubly-linked list and each node has a `next` and `previous` pointer. These can be `nil` if there are no next or previous nodes, so these variables must be optionals. (In what follows, I'll point out which functions would need to change if this was just a singly- instead of a doubly-linked list.)
 
+> **Note:** To avoid ownership cycles, we declare the `previous` pointer to be weak. If you have a node `A` that is followed by node `B` in the list, then `A` points to `B` but also `B` points to `A`. In certain circumstances, this ownership cycle can cause nodes to be kept alive even after you deleted them. We don't want that, so we make one of the pointers `weak` to break the cycle.
+
 Let's start building `LinkedList`. Here's the first bit:
 
 ```swift
@@ -450,9 +452,9 @@ How about reversing a list, so that the head becomes the tail and vice versa? Th
   public func reverse() {
     var node = head
     while let currentNode = node {
+      node = currentNode.next
       swap(&currentNode.next, &currentNode.previous)
       head = currentNode
-      node = currentNode.previous
     }
   }
 ```
@@ -465,8 +467,6 @@ This loops through the entire list and simply swaps the `next` and `previous` po
 	 nil <---|        |--->|        |--->|        |--->|        |<--- head
 	         +--------+    +--------+    +--------+    +--------+
 
-You may be wondering why the last statement says `node = currentNode.previous` to go to the next node instead of `currentNode.next` like you'd expect, but remember that we just swapped those pointers!
-
 Arrays have `map()` and `filter()` functions, and there's no reason why linked lists shouldn't either.
 
 ```swift

Linked List/LinkedList.swift

@@ -0,0 +1,30 @@
+//: # Example 1 with type Int
+
+var mySet = OrderedSet<Int>()
+
+// Insert random numbers into the set
+for _ in 0..<50 {
+  mySet.insert(random(50, max: 500))
+}
+
+print(mySet)
+
+print("\nMaximum:")
+print(mySet.max())
+
+print("\nMinimum:")
+print(mySet.min())
+
+// Print the 5 largest values
+print("\n5 Largest:")
+for k in 1...5 {
+  print(mySet.kLargest(k))
+}
+
+// Print the 5 lowest values
+print("\n5 Smallest:")
+for k in 1...5 {
+  print(mySet.kSmallest(k))
+}
+
+//: [Next](@next)