Integrated all code for Set Cover algorithm.

Merge branch 'set-cover'

Author: mrael2

Set Cover (Unweighted)/README.markdown

@@ -0,0 +1,13 @@
+# Set Cover (Unweighted)
+
+A cover 
+
+If you have a set (also called the universe in the mathematical descriptions of the problem)
+
+## The algorithm
+
+## See also
+
+[Set cover problem on Wikipedia](https://en.wikipedia.org/wiki/Set_cover_problem)
+
+*Written for Swift Algorithm Club by [Michael C. Rael](https://github.com/mrael2)*

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

@@ -0,0 +1,31 @@
+let universe1 = Set(1...7)
+let array1 = randomArrayOfSets(covering: universe1)
+let cover1 = universe1.cover(from: 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 universe3 = Set(["tall", "heavy"])
+let array3: Array<Set<String>> = [["tall", "light"], ["short", "heavy"], ["tall", "heavy", "young"]]
+let cover3 = universe3.cover(from: array3)
+
+let universe4 = Set(["tall", "heavy", "green"])
+let cover4 = universe4.cover(from: 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 universe6: Set<Int> = [24, 89, 132, 90, 22]
+let array6 = randomArrayOfSets(covering: universe6)
+let cover6 = universe6.cover(from: 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 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>>())

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

@@ -0,0 +1,43 @@
+import Foundation
+
+public func randomArrayOfSets<T>(covering universe: Set<T>,
+                              minArraySizeFactor: Double = 0.8,
+                              maxSetSizeFactor: Double = 0.6) -> Array<Set<T>> {
+  var result = [Set<T>]()
+  var ongoingUnion = Set<T>()
+  
+  let minArraySize = Int(Double(universe.count) * minArraySizeFactor)
+  var maxSetSize = Int(Double(universe.count) * maxSetSizeFactor)
+  if maxSetSize > universe.count {
+    maxSetSize = universe.count
+  }
+  
+  while true {
+    var generatedSet = Set<T>()
+    let targetSetSize = Int(arc4random_uniform(UInt32(maxSetSize)) + 1)
+    
+    while true {
+      let randomUniverseIndex = Int(arc4random_uniform(UInt32(universe.count)))
+      for (setIndex, value) in universe.enumerate() {
+        if setIndex == randomUniverseIndex {
+          generatedSet.insert(value)
+          break
+        }
+      }
+      
+      if generatedSet.count == targetSetSize {
+        result.append(generatedSet)
+        ongoingUnion = ongoingUnion.union(generatedSet)
+        break
+      }
+    }
+    
+    if result.count >= minArraySize {
+      if ongoingUnion == universe {
+        break
+      }
+    }
+  }
+  
+  return result
+}

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

@@ -0,0 +1,33 @@
+public extension Set {
+  func cover(from array: Array<Set<Element>>) -> Array<Set<Element>>? {
+    var result: [Set<Element>]? = [Set<Element>]()
+    var remainingSet = self
+    
+    func largestIntersectingSet() -> Set<Element>? {
+      var largestIntersectionLength = 0
+      var largestSet: Set<Element>?
+      
+      for set in array {
+        let intersectionLength = remainingSet.intersect(set).count
+        if intersectionLength > largestIntersectionLength {
+          largestIntersectionLength = intersectionLength
+          largestSet = set
+        }
+      }
+      
+      return largestSet
+    }
+    
+    while remainingSet.count != 0 {
+      guard let largestSet = largestIntersectingSet() else { break }
+      result!.append(largestSet)
+      remainingSet = remainingSet.subtract(largestSet)
+    }
+    
+    if remainingSet.count != 0 || self.count == 0 {
+      result = nil
+    }
+    
+    return result
+  }
+}

Set Cover (Unweighted)/SetCover.playground/contents.xcplayground

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<playground version='5.0' target-platform='osx'>
+    <timeline fileName='timeline.xctimeline'/>
+</playground>

Set Cover (Unweighted)/SetCover.swift

@@ -0,0 +1,33 @@
+extension Set {
+  func cover(from array: Array<Set<Element>>) -> Array<Set<Element>>? {
+    var result: [Set<Element>]? = [Set<Element>]()
+    var remainingSet = self
+    
+    func largestIntersectingSet() -> Set<Element>? {
+      var largestIntersectionLength = 0
+      var largestSet: Set<Element>?
+      
+      for set in array {
+        let intersectionLength = remainingSet.intersect(set).count
+        if intersectionLength > largestIntersectionLength {
+          largestIntersectionLength = intersectionLength
+          largestSet = set
+        }
+      }
+      
+      return largestSet
+    }
+    
+    while remainingSet.count != 0 {
+      guard let largestSet = largestIntersectingSet() else { break }
+      result!.append(largestSet)
+      remainingSet = remainingSet.subtract(largestSet)
+    }
+    
+    if remainingSet.count != 0 || self.count == 0 {
+      result = nil
+    }
+    
+    return result
+  }
+}