Fix and optimizations

Author: JacopoMangiavacchi

MinimumCoinChange/Sources/MinimumCoinChange.swift

@@ -1,76 +1,91 @@
 //
-//  Minimum Coin Change Problem 
+//  Minimum Coin Change Problem Playground
 //  Compare Greedy Algorithm and Dynamic Programming Algorithm in Swift
 //
 //  Created by Jacopo Mangiavacchi on 04/03/17.
 //
 
 import Foundation
 
+public enum MinimumCoinChangeError: Error {
+    case noRestPossibleForTheGivenValue
+}
+
 public struct MinimumCoinChange {
-    private let sortedCoinSet: [Int]
-    private var cache: [Int : [Int]]
+    internal let sortedCoinSet: [Int]
 
     public init(coinSet: [Int]) {
         self.sortedCoinSet = coinSet.sorted(by: { $0 > $1} )
-        self.cache = [:]
     }
 
     //Greedy Algorithm
-    public func changeGreedy(_ value: Int) -> [Int] {
+    public func changeGreedy(_ value: Int) throws -> [Int] {
+        guard value > 0 else { return [] }
+
         var change:  [Int] = []
         var newValue = value
-        
+
         for coin in sortedCoinSet {
             while newValue - coin >= 0 {
                 change.append(coin)
                 newValue -= coin
             }
 
-            if newValue  == 0 {
+            if newValue == 0 {
                 break
             }
         }
 
+        if newValue > 0 { 
+            throw MinimumCoinChangeError.noRestPossibleForTheGivenValue 
+        } 
+
         return change
     }
 
     //Dynamic Programming Algorithm
-    public mutating func changeDynamic(_ value: Int) -> [Int] {
-        if value <= 0 {
-            return []
-        }
+    public func changeDynamic(_ value: Int) throws -> [Int] {
+        guard value > 0 else { return [] }
 
-        if let cached = cache[value] {
-            return cached
-        }
-        
-        var change:  [Int] = []
-        
-        var potentialChangeArray: [[Int]] = []
-        
-        for coin in sortedCoinSet {
-            if value - coin >= 0 {
-                var potentialChange: [Int] = []
-                 potentialChange.append(coin)
-                let newPotentialValue = value - coin
+        var cache: [Int : [Int]] = [:]
 
-                if value  > 0 {
-                    potentialChange.append(contentsOf: changeDynamic(newPotentialValue))
-                }
+        func _changeDynamic(_ value: Int) -> [Int] {
+            guard value > 0 else { return [] }
 
-                //print("value: \(value) coin: \(coin) potentialChange: \(potentialChange)")
-                potentialChangeArray.append(potentialChange)
+            if let cached = cache[value] {
+                return cached
             }
+            
+            var change: [Int] = []
+            
+            var potentialChangeArray: [[Int]] = []
+            
+            for coin in sortedCoinSet {
+                if value - coin >= 0 {
+                    var potentialChange: [Int] = [coin]
+                    potentialChange.append(contentsOf: _changeDynamic(value - coin))
+                    potentialChangeArray.append(potentialChange)
+                }
+            }
+            
+            if potentialChangeArray.count > 0 {
+                let sortedPotentialChangeArray = potentialChangeArray.sorted(by: { $0.count < $1.count })
+                change = sortedPotentialChangeArray[0]
+            }
+            
+            if change.reduce(0, +) == value { 
+                cache[value] = change
+            } 
+
+            return change
         }
-        
-        if potentialChangeArray.count > 0 {
-            let sortedPotentialChangeArray = potentialChangeArray.sorted(by: { $0.count < $1.count })
-            change = sortedPotentialChangeArray[0]
-        }
-        
-        cache[value] = change
+
+        let change: [Int] = _changeDynamic(value)
+
+        if change.reduce(0, +) != value { 
+            throw MinimumCoinChangeError.noRestPossibleForTheGivenValue 
+        } 
+
         return change
     }
 }
-

MinimumCoinChange/Tests/MinimumCoinChangeTests/MinimumCoinChangeTests.swift

@@ -3,16 +3,24 @@ import XCTest
 
 class MinimumCoinChangeTests: XCTestCase {
     func testExample() {
-        var mcc = MinimumCoinChange(coinSet: [1, 2, 5, 10, 20, 25])
+        let mcc = MinimumCoinChange(coinSet: [1, 2, 5, 10, 20, 25])
+        print("Coin set: \(mcc.sortedCoinSet)")
 
-        for i in 0..<100 {
-            let greedy = mcc.changeGreedy(i)
-            let dynamic = mcc.changeDynamic(i)
+        do {
+            for i in 0..<100 {
+                let greedy = try mcc.changeGreedy(i)
+                let dynamic = try mcc.changeDynamic(i)
 
-            if greedy.count != dynamic.count {
-                print("\(i): greedy = \(greedy) dynamic = \(dynamic)")
+                XCTAssertEqual(greedy.reduce(0, +), dynamic.reduce(0, +), "Greedy and Dynamic return two different changes")
+
+                if greedy.count != dynamic.count {
+                    print("\(i): greedy = \(greedy) dynamic = \(dynamic)")
+                }
             }
         }
+        catch {
+            XCTFail("Test Failed: impossible to change with the given coin set")
+        }
     }
 
     static var allTests = [