Coin Change II - Practice Coding Problems

Coin Change II - Problem

Coin Change II presents a classic dynamic programming challenge in combinatorics. You're given an array of coins representing different denominations and an integer amount representing a target sum. Your goal is to find how many different ways you can combine these coins to make exactly that amount.

Key points:
• You have an unlimited supply of each coin type
• Order doesn't matter - [1,2] and [2,1] count as the same combination
• If the amount cannot be made, return 0
• The result fits in a 32-bit integer

For example, with coins [1, 2, 5] and amount 5, there are 4 ways: [5], [2,2,1], [2,1,1,1], [1,1,1,1,1].

Input & Output

example_1.py — Basic Case

$ Input: coins = [1,2,5], amount = 5

› Output: 4

💡 Note: There are 4 ways to make amount 5: [5], [2,2,1], [2,1,1,1], [1,1,1,1,1]

example_2.py — No Solution

$ Input: coins = [2], amount = 3

› Output: 0

💡 Note: Amount 3 cannot be made with only coin value 2 (odd amount with even coins)

example_3.py — Zero Amount

$ Input: coins = [10], amount = 0

› Output: 1

💡 Note: There is exactly one way to make amount 0: use no coins at all

Visualization

Tap to expand

Understanding the Visualization

Setup

Start with amount 5 and coins [1,2,5]

Find Ways

Systematically find all unique combinations

Count Total

Sum up all valid ways to make the target amount

Key Takeaway

🎯 Key Insight: Dynamic programming builds solutions systematically, processing one coin type at a time to avoid counting duplicate combinations like [1,2] and [2,1] separately.

Time & Space Complexity

Time Complexity

⏱️

O(n × amount)

We iterate through each coin (n) and for each coin through all amounts up to target

✓ Linear Growth

Space Complexity

O(amount)

Only need 1D array to store ways to make each amount from 0 to target

⚡ Linearithmic Space

Constraints

1 ≤ coins.length ≤ 300
1 ≤ coins[i] ≤ 5000
0 ≤ amount ≤ 5000
All coin values are positive integers
The answer is guaranteed to fit in a signed 32-bit integer

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses 1D Dynamic Programming with O(n×amount) time and O(amount) space. By processing coins one at a time and updating a DP array, we systematically count combinations while avoiding duplicates. The key insight is that dp[i] represents ways to make amount i, and for each coin, we update dp[amount] += dp[amount - coin] for valid amounts.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized 1D Dynamic Programming (Optimal)	O(n × amount)	O(amount)	Space-optimized DP using only 1D array, processing coins one at a time
Dynamic Programming (2D Table)	O(n × amount)	O(n × amount)	Build a 2D table where dp[i][j] represents ways to make amount j using first i coins

Optimized 1D Dynamic Programming (Optimal) — Algorithm Steps

Initialize dp array where dp[0] = 1 (one way to make amount 0)
For each coin type, iterate through all amounts from coin value to target
Update dp[amount] += dp[amount - coin] for each valid amount
Return dp[target_amount] as the final answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

dp[0] = 1, rest are 0

Process Coin 1

Update dp array considering coin value 1

Process Coin 2

Update dp array considering coin value 2

Process Coin 5

Final update with coin value 5

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int change(int amount, int* coins, int coinsSize) {
    // dp[i] = number of ways to make amount i
    int* dp = (int*)calloc(amount + 1, sizeof(int));
    dp[0] = 1; // One way to make amount 0
    
    // Process each coin type
    for (int j = 0; j < coinsSize; j++) {
        int coin = coins[j];
        // Update all amounts that can use this coin
        for (int i = coin; i <= amount; i++) {
            dp[i] += dp[i - coin];
        }
    }
    
    int result = dp[amount];
    free(dp);
    return result;
}

int main() {
    int coins[] = {1, 2, 5};
    int amount = 5;
    printf("%d\n", change(amount, coins, 3));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × amount)

We iterate through each coin (n) and for each coin through all amounts up to target

✓ Linear Growth

Space Complexity

O(amount)

Only need 1D array to store ways to make each amount from 0 to target

⚡ Linearithmic Space

Constraints

1 ≤ coins.length ≤ 300
1 ≤ coins[i] ≤ 5000
0 ≤ amount ≤ 5000
All coin values are positive integers
The answer is guaranteed to fit in a signed 32-bit integer

42.4K Views

High Frequency

~18 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Optimized 1D Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler