Merge branch 'set-cover'

Author: mrael2

Set Cover (Unweighted)/README.markdown

@@ -10,16 +10,22 @@ For example, suppose you have a universe of `{1, 5, 7}` and you want to find the
 > {2}
 > {1, 2, 3}
 
-You can see that the sets `{3, 1} {7, 6, 5, 4}` when unioned together will cover the universe of `{1, 5, 7}`. Yes, there may be additional elements in the sets returned by the algorithm, but every element in the universe is represented.
+You can see that the sets `{3, 1} {7, 6, 5, 4}` when unioned together will cover the universe of `{1, 5, 7}`. Yes, there may be additional elements in the sets returned by the algorithm, but every element in the universe is represented in the cover itself.
 
-If there is no cover within the group of sets, the function returns nil. For example, if your universe is `{7, 9}`, there is no combination of sets within the grouping above that will yield a cover.
+There may be cases where no cover exists. For example, if your universe is `{7, 9}`, there is no combination of sets within the group above that will yield a cover.
 
 ## The algorithm
 
-The Greedy Set Cover algorithm (unweighted) is provided here. It's known as greedy because it uses the largest intersecting set from the group of sets first before examining other sets in the group.
+The Greedy Set Cover algorithm (unweighted) is provided here. It's known as greedy because it uses the largest intersecting set from the group of sets first before examining other sets in the group. This is part of the reason why the cover may have additional elements which are not part of the universe.
 
 The function (named `cover`) is provided as an extension of the Swift type `Set`. The function takes a single parameter, which is an array of sets. This array represents the group, and the set itself represents the universe.
 
+One of the first things done in `cover` is to make a copy of the universe in `remainingSet`. Then, the algorithm enters a `while` loop in which a call to `largestIntersectingSet` is made. The value returned from `largestIntersectingSet` is the set which has the most elements in common with the remaining universe identified by `remainingSet`. If all sets have nothing in common, `largestIntersectingSet` returns `nil`.
+
+If the result from `largestIntersectingSet` is not nil, that result is subtracted from `remainingSet` (reducing its size), and the loop continues until `remainingSet` has zero length (meaning a cover has been found) or until `largestIntersectingSet` returns `nil`.
+
+If there is no cover within the group of sets, `cover` returns `nil`.
+
 ## See also
 
 [Set cover problem on Wikipedia](https://en.wikipedia.org/wiki/Set_cover_problem)

Set Cover (Unweighted)/SetCover.playground/Contents.swift

@@ -1,31 +1,31 @@
 let universe1 = Set(1...7)
 let array1 = randomArrayOfSets(covering: universe1)
-let cover1 = universe1.cover(from: array1)
+let cover1 = universe1.cover(within: array1)
 
 let universe2 = Set(1...10)
 let array2: Array<Set<Int>> = [[1,2,3,4,5,6,7], [8,9]]
-let cover2 = universe2.cover(from: array2)
+let cover2 = universe2.cover(within: array2)
 
 let universe3 = Set(["tall", "heavy"])
 let array3: Array<Set<String>> = [["tall", "light"], ["short", "heavy"], ["tall", "heavy", "young"]]
-let cover3 = universe3.cover(from: array3)
+let cover3 = universe3.cover(within: array3)
 
 let universe4 = Set(["tall", "heavy", "green"])
-let cover4 = universe4.cover(from: array3)
+let cover4 = universe4.cover(within: array3)
 
 let universe5: Set<Int> = [16, 32, 64]
 let array5: Array<Set<Int>> = [[16,17,18], [16,32,128], [1,2,3], [32,64,128]]
-let cover5 = universe5.cover(from: array5)
+let cover5 = universe5.cover(within: array5)
 
 let universe6: Set<Int> = [24, 89, 132, 90, 22]
 let array6 = randomArrayOfSets(covering: universe6)
-let cover6 = universe6.cover(from: array6)
+let cover6 = universe6.cover(within: array6)
 
 let universe7: Set<String> = ["fast", "cheap", "good"]
 let array7 = randomArrayOfSets(covering: universe7, minArraySizeFactor: 20.0, maxSetSizeFactor: 0.7)
-let cover7 = universe7.cover(from: array7)
+let cover7 = universe7.cover(within: array7)
 
 let emptySet = Set<Int>()
-let coverTest1 = emptySet.cover(from: array1)
-let coverTest2 = universe1.cover(from: Array<Set<Int>>())
-let coverTest3 = emptySet.cover(from: Array<Set<Int>>())
+let coverTest1 = emptySet.cover(within: array1)
+let coverTest2 = universe1.cover(within: Array<Set<Int>>())
+let coverTest3 = emptySet.cover(within: Array<Set<Int>>())

Set Cover (Unweighted)/SetCover.playground/Sources/SetCover.swift

@@ -1,5 +1,5 @@
 public extension Set {
-  func cover(from array: Array<Set<Element>>) -> Array<Set<Element>>? {
+  func cover(within array: Array<Set<Element>>) -> Array<Set<Element>>? {
     var result: [Set<Element>]? = [Set<Element>]()
     var remainingSet = self
 

Set Cover (Unweighted)/SetCover.swift

@@ -1,5 +1,5 @@
 extension Set {
-  func cover(from array: Array<Set<Element>>) -> Array<Set<Element>>? {
+  func cover(within array: Array<Set<Element>>) -> Array<Set<Element>>? {
     var result: [Set<Element>]? = [Set<Element>]()
     var remainingSet = self