Text tweaks

Author: hollance

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> {
@@ -166,21 +184,3 @@ func binomialCoefficient(n: Int, _ k: Int) -> Int {
 binomialCoefficient(30, 15)
 binomialCoefficient(66, 33)
 
-
-
-/*
-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(30, 15)
-quickBinomialCoefficient(8, 2)

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,54 +387,16 @@ 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
 ```
 
-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)
-
-So the following code calculates the `C(n, k)` you're looking for:
-
-```swift
-func quickBinomialCoefficient(n: Int, _ k: Int) -> Int {
-  var result = 1
-
-  for i in 0..<k {
-    result *= (n - i)
-    result /=  (i + 1)
-  }
-  return result
-}
-```
-
-As there're the divisors for numbers from `1...k` among `k` consecutive numbers, what is exactly we've got in the numerator of our fast formula every time we devide `result` by `(i + 1)` we won't have a real number.
-
-Here's how you can use it:
-
-```swift
-quickBinomialCoefficient(30, 15)   // prints 155117520
-quickBinomialCoefficient(8, 2)   // prints 28
-```
-
 You may wonder what the point is in calculating these permutations and combinations, but many algorithm problems are really combinatorics problems in disguise. Often you may need to look at all possible combinations of your data to see which one gives the right solution. If that means you need to search through `n!` potential solutions, you may want to consider a different approach -- as you've seen, these numbers become huge very quickly!
 
 ## References
 
 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)*