Coin Change - Practice Coding Problems

Coin Change - Problem

Imagine you're working as a cashier and need to make change using the fewest coins possible. You have an unlimited supply of coins with specific denominations, and you need to find the most efficient way to make exact change.

Given an integer array coins representing different coin denominations and an integer amount representing the total money you need to make, return the minimum number of coins needed to make up that exact amount.

If it's impossible to make the exact amount with the given coins, return -1.

Example: With coins [1, 3, 4] and amount 6, you could use [3, 3] (2 coins) or [1, 1, 4] (3 coins). The optimal solution uses only 2 coins.

Input & Output

example_1.py — Basic Case

$ Input: coins = [1, 3, 4], amount = 6

› Output: 2

💡 Note: The optimal solution is to use two coins of value 3: [3, 3]. This gives us exactly 6 with only 2 coins, which is better than alternatives like [1,1,4] (3 coins) or [1,1,1,3] (4 coins).

example_2.py — Impossible Case

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

› Output: -1

💡 Note: It's impossible to make amount 3 using only coins of value 2. Since 3 is odd and we only have even-valued coins, no combination can sum to 3.

example_3.py — Zero Amount

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

› Output: 0

💡 Note: To make amount 0, we need 0 coins. This is the base case - no coins are needed to make no money.

Constraints

1 ≤ coins.length ≤ 12
1 ≤ coins[i] ≤ 2³¹ - 1
0 ≤ amount ≤ 10⁴
All coin denominations are positive integers

Visualization

Tap to expand

Understanding the Visualization

Start with basics

Amount 0 needs 0 coins (obvious!)

Build up gradually

For each amount, try each coin and use the best previous result

Reuse knowledge

Each amount is calculated once and reused

Get final answer

The target amount now contains the optimal solution

Key Takeaway

🎯 Key Insight: Dynamic programming eliminates redundant work by solving each subproblem exactly once and reusing the results. The optimal substructure means we can build complex solutions from simpler ones.

Asked in

a Amazon 85 G Google 72 f Meta 58 ⊞ Microsoft 45 Apple 38

The optimal approach uses dynamic programming with time complexity O(amount × coins). We build up solutions from amount 0 to the target, storing the minimum coins needed for each value. The key insight is optimal substructure: if we know the optimal way to make amount X, we can find the optimal way to make amount X+coin by adding one more coin.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Brute Force	O(S^n)	O(S)	Try all possible combinations recursively
Dynamic Programming (Optimal)	O(S × N)	O(S)	Build up solutions from 1 to amount using memoization

Recursive Brute Force — Algorithm Steps

For each coin denomination, try using it
Recursively solve for the remaining amount
Take the minimum across all choices
Add 1 to account for the current coin used

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with amount 6

Try each coin: 1, 3, 4

Branch for each choice

Each choice creates a new subproblem

Repeat recursively

Continue until amount becomes 0 or negative

Return minimum

Take the minimum coins across all valid paths

Code -

solution.c — C

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

int helper(int* coins, int coinsSize, int remaining) {
    if (remaining == 0) return 0;
    if (remaining < 0) return INT_MAX;
    
    int minCoins = INT_MAX;
    for (int i = 0; i < coinsSize; i++) {
        int result = helper(coins, coinsSize, remaining - coins[i]);
        if (result != INT_MAX) {
            if (result + 1 < minCoins) {
                minCoins = result + 1;
            }
        }
    }
    return minCoins;
}

int coinChange(int* coins, int coinsSize, int amount) {
    int result = helper(coins, coinsSize, amount);
    return result == INT_MAX ? -1 : result;
}

int main() {
    int coins[] = {1, 3, 4};
    int amount = 6;
    printf("%d\n", coinChange(coins, 3, amount));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(S^n)

Where S is the amount and n is the number of coins. Each recursive call branches into n possibilities.

✓ Linear Growth

Space Complexity

O(S)

Recursion depth can go up to the amount in worst case

✓ Linear Space

89.2K Views

Very High Frequency

~25 min Avg. Time

2.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

Constraints

Visualization

Related Problems

Common Approaches

Recursive Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler