# Python Program for Coin Change

Given a value N, if we want to make change for N cents, and we have infinite supply of each of S = { S1, S2, .. , Sm} valued coins, how many ways can we make the change? The order of coins doesn\’t matter. For example, for N = 4 and S = {1,2,3}, there are four solutions: {1,1,1,1},{1,1,2},{2,2},{1,3}. So output should be 4. For N = 10 and S = {2, 5, 3, 6}, there are five solutions: {2,2,2,2,2}, {2,2,3,3}, {2,2,6}, {2,3,5} and {5,5}. So the output should be 5.

## Python3

 `# Dynamic Programming Python implementation of Coin ` `# Change problem` `def` `count(S, m, n):` `    ``# We need n+1 rows as the table is constructed ` `    ``# in bottom up manner using the base case 0 value` `    ``# case (n = 0)` `    ``table ``=` `[[``0` `for` `x ``in` `range``(m)] ``for` `x ``in` `range``(n``+``1``)]`   `    ``# Fill the entries for 0 value case (n = 0)` `    ``for` `i ``in` `range``(m):` `        ``table[``0``][i] ``=` `1`   `    ``# Fill rest of the table entries in bottom up manner` `    ``for` `i ``in` `range``(``1``, n``+``1``):` `        ``for` `j ``in` `range``(m):`   `            ``# Count of solutions including S[j]` `            ``x ``=` `table[i ``-` `S[j]][j] ``if` `i``-``S[j] >``=` `0` `else` `0`   `            ``# Count of solutions excluding S[j]` `            ``y ``=` `table[i][j``-``1``] ``if` `j >``=` `1` `else` `0`   `            ``# total count` `            ``table[i][j] ``=` `x ``+` `y`   `    ``return` `table[n][m``-``1``]`   `# Driver program to test above function` `arr ``=` `[``1``, ``2``, ``3``]` `m ``=` `len``(arr)` `n ``=` `4` `print``(count(arr, m, n))`   `# This code is contributed by Bhavya Jain`

Output

`4`

Time complexity: O(mn) where m is the number of coin denominations and n is the target amount.
Auxiliary space complexity: O(mn) as a 2D table of size mxn is created to store the number of ways to make the target amount using the coin denominations.

## Python3

 `# Dynamic Programming Python implementation of Coin ` `# Change problem` `def` `count(S, m, n):`   `    ``# table[i] will be storing the number of solutions for` `    ``# value i. We need n+1 rows as the table is constructed` `    ``# in bottom up manner using the base case (n = 0)` `    ``# Initialize all table values as 0` `    ``table ``=` `[``0` `for` `k ``in` `range``(n``+``1``)]`   `    ``# Base case (If given value is 0)` `    ``table[``0``] ``=` `1`   `    ``# Pick all coins one by one and update the table[] values` `    ``# after the index greater than or equal to the value of the` `    ``# picked coin` `    ``for` `i ``in` `range``(``0``,m):` `        ``for` `j ``in` `range``(S[i],n``+``1``):` `            ``table[j] ``+``=` `table[j``-``S[i]]`   `    ``return` `table[n]`   `# Driver program to test above function` `arr ``=` `[``1``, ``2``, ``3``]` `m ``=` `len``(arr)` `n ``=` `4` `x ``=` `count(arr, m, n)` `print` `(x)`   `# This code is contributed by Afzal Ansari`

Output

`4`

#### Complexity Analysis:

For both solutions the time and space complexity is the same:

Time Complexity: O(n*m)
Auxiliary Space: O(n)

Though the first solution might be a little slow as it has multiple loops.

Approach: Recursion + Memoization.

In this approach, we first define a memo dictionary to store the results of previously computed subproblems.

• We then define a helper function that takes in the current amount and the current coin index.
• The function helper is a recursive function that checks all the possible combinations of coins to reach the target sum.
• Then we print the possible ways to make the target sum using the given set of coins.

## Python3

 `def` `count_coins(coins, target):` `    ``memo ``=` `{}`   `    ``def` `helper(amount, idx):` `        ``# Check if the solution for this subproblem already exists` `        ``if` `(amount, idx) ``in` `memo:` `            ``return` `memo[(amount, idx)]` `        `  `        ``# Base case: If the target sum is reached` `        ``if` `amount ``=``=` `0``:` `            ``return` `1` `        `  `        ``# Base case: If the target sum cannot be reached using remaining coins` `        ``if` `amount < ``0` `or` `idx >``=` `len``(coins):` `            ``return` `0` `        `  `        ``# Recursively calculate the number of possible ways using the current coin or skipping it` `        ``memo[(amount, idx)] ``=` `helper(amount ``-` `coins[idx], idx) ``+` `helper(amount, idx ``+` `1``)` `        ``return` `memo[(amount, idx)]` `    `  `    ``# Call the recursive function with the initial parameters` `    ``return` `helper(target, ``0``)`   `# Test the function` `arr ``=` `[``1``, ``2``, ``3``]` `n ``=` `4` `x ``=` `count_coins(arr, n)` `print``(x)`

Output

`4`

Time Complexity: O(mn),  where ‘m’ is the number of coins and ‘n’ is the target sum.

Auxiliary Space: O(n), as we are using a table of size (n+1) to store the subproblem solutions.

Please refer complete article on Dynamic Programming | Set 7 (Coin Change) for more details!

Whether you're preparing for your first job interview or aiming to upskill in this ever-evolving tech landscape, GeeksforGeeks Courses are your key to success. We provide top-quality content at affordable prices, all geared towards accelerating your growth in a time-bound manner. Join the millions we've already empowered, and we're here to do the same for you. Don't miss out - check it out now!

Previous
Next