Merge pull request #426 from JacopoMangiavacchi/master

Minimum Coin Change Problem - Dynamic Programming in Swift

Author: narrativium

MinimumCoinChange/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Jacopo Mangiavacchi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

MinimumCoinChange/Package.swift

@@ -0,0 +1,7 @@
+// swift-tools-version:3.1
+
+import PackageDescription
+
+let package = Package(
+    name: "MinimumCoinChange"
+)

MinimumCoinChange/README.md

@@ -0,0 +1,41 @@
+# Minimum Coin Change
+Minimum Coin Change problem algorithm implemented in Swift comparing dynamic programming algorithm design to traditional greedy approach.
+
+Written for Swift Algorithm Club by Jacopo Mangiavacchi
+
+![Coins](eurocoins.gif)
+
+# Introduction
+
+In the traditional coin change problem you have to find all the different ways to change some given money in a particular amount of coins using a given amount of set of coins (i.e. 1 cent, 2 cents, 5 cents, 10 cents etc.).
+
+For example using Euro cents the total of 4 cents value of money can be changed in these possible ways:
+
+- Four 1 cent coins
+- Two 2 cent coins
+- One 2 cent coin and two 1 cent coins
+
+The minimum coin change problem is a variation of the generic coin change problem where you need to find the best option for changing the money returning the less number of coins.
+
+For example using Euro cents the best possible change for 4 cents are two 2 cent coins with a total of two coins.
+
+
+# Greedy Solution
+
+A simple approach for implementing the Minimum Coin Change algorithm in a very efficient way is to start subtracting from the input value the greater possible coin value from the given amount of set of coins available and iterate subtracting the next greater possible coin value on the resulting difference.
+
+For example from the total of 4 Euro cents of the example above you can subtract initially 2 cents as  the other biggest coins value (from 5 cents to above) are to bigger for the current 4 Euro cent value. Once used the first 2 cents coin you iterate again with the same logic for the rest of 2 cents and select another 2 cents coin and finally return the two 2 cents coins as the best change.
+
+Most of the time the result for this greedy approach is optimal but for some set of coins the result will not be the optimal.
+
+Indeed, if we use the a set of these three different coins set with values 1, 3 and 4 and execute this  greedy algorithm for asking the best change for the value 6 we will get one coin of 4 and two coins of 1 instead of two coins of 3.
+
+
+# Dynamic Programming Solution
+
+A classic dynamic programming strategy will iterate selecting in order a possible coin from the given amount of set of coins and finding using recursive calls the minimum coin change on the difference from the passed value and the selected coin. For any interaction the algorithm select from all possible combinations the one with the less number of coins used.
+
+The dynamic programming approach will always select the optimal change but it will require a number of steps that is at least quadratic in the goal amount to change.
+
+In this Swift implementation in order to optimize the overall performance we use an internal data structure for caching the result for best minimum coin change for previous values.
+

MinimumCoinChange/Sources/MinimumCoinChange.swift

@@ -0,0 +1,89 @@
+//
+//  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 {
+    internal let sortedCoinSet: [Int]
+    
+    public init(coinSet: [Int]) {
+        self.sortedCoinSet = coinSet.sorted(by: { $0 > $1} )
+    }
+
+    //Greedy Algorithm
+    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 {
+                break
+            }
+        }
+        
+        if newValue > 0 { 
+            throw MinimumCoinChangeError.noRestPossibleForTheGivenValue 
+        } 
+
+        return change
+    }
+
+    //Dynamic Programming Algorithm
+    public func changeDynamic(_ value: Int) throws -> [Int] {
+        guard value > 0 else { return [] }
+        
+        var cache: [Int : [Int]] = [:]
+
+        func _changeDynamic(_ value: Int) -> [Int] {
+            guard value > 0 else { return [] }
+
+            if let cached = cache[value] {
+                return cached
+            }
+            
+            var potentialChangeArray: [[Int]] = []
+            
+            for coin in sortedCoinSet {
+                if value - coin >= 0 {
+                    var potentialChange: [Int] = [coin]
+                    potentialChange.append(contentsOf: _changeDynamic(value - coin))
+
+                    if potentialChange.reduce(0, +) == value { 
+                        potentialChangeArray.append(potentialChange)
+                    } 
+                }
+            }
+            
+            if potentialChangeArray.count > 0 {
+                let sortedPotentialChangeArray = potentialChangeArray.sorted(by: { $0.count < $1.count })
+                cache[value] = sortedPotentialChangeArray[0]
+                return sortedPotentialChangeArray[0]
+            }
+            
+            return []
+        }
+
+        let change: [Int] = _changeDynamic(value)
+
+        if change.reduce(0, +) != value { 
+            throw MinimumCoinChangeError.noRestPossibleForTheGivenValue 
+        } 
+
+        return change
+    }
+}

MinimumCoinChange/Tests/LinuxMain.swift

@@ -0,0 +1,6 @@
+import XCTest
+@testable import MinimumCoinChangeTests
+
+XCTMain([
+    testCase(MinimumCoinChangeTests.allTests),
+])

MinimumCoinChange/Tests/MinimumCoinChangeTests/MinimumCoinChangeTests.swift

@@ -0,0 +1,29 @@
+import XCTest
+@testable import MinimumCoinChange
+
+class MinimumCoinChangeTests: XCTestCase {
+    func testExample() {
+        let mcc = MinimumCoinChange(coinSet: [1, 2, 5, 10, 20, 25])
+        print("Coin set: \(mcc.sortedCoinSet)")
+
+        do {
+            for i in 0..<100 {
+                let greedy = try mcc.changeGreedy(i)
+                let dynamic = try mcc.changeDynamic(i)
+
+                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 = [
+        ("testExample", testExample),
+    ]
+}