Minimum Number of Coins to be Added - Practice Coding Problems

Minimum Number of Coins to be Added - Problem

Problem: Imagine you're a coin collector trying to build a complete set! You have an array of coins with different values, and you want to be able to make every amount from 1 to target using combinations of these coins.

Your goal is to find the minimum number of coins you need to add (of any denomination you choose) so that you can form any integer value in the range [1, target].

Key Points:
• You can use any coin multiple times
• You can choose what value coins to add
• A subsequence means any combination of coins that sum to the desired amount

Example: If coins = [1, 3] and target = 6, you can make 1, 3, 4 (1+3), but you cannot make 2, 5, or 6. You'd need to add coins to cover all missing values.

Input & Output

example_1.py — Basic case

$ Input: coins = [1, 3], target = 6

› Output: 1

💡 Note: With coins [1, 3] we can form sums: 1, 3, 4 (1+3). We cannot form 2, 5, or 6. Adding one coin of value 2 allows us to form all values 1-6: [1], [2], [3], [1+3=4], [2+3=5], [1+2+3=6].

example_2.py — No coins needed

$ Input: coins = [1, 1, 1], target = 3

› Output: 0

💡 Note: With three coins of value 1, we can form: 1 (one coin), 2 (two coins), 3 (three coins). All values from 1 to 3 are already obtainable, so no additional coins needed.

example_3.py — Multiple gaps

$ Input: coins = [1, 5, 10], target = 20

› Output: 2

💡 Note: We can form 1, 5, 6, 10, 11, 15, 16. Missing many values like 2, 3, 4, 7, 8, 9, etc. The greedy algorithm will add coins optimally to cover all gaps with minimum additions.

Constraints

1 ≤ coins.length ≤ 10⁵
1 ≤ coins[i] ≤ 10⁴
1 ≤ target ≤ 2 × 10⁵
All coin values are positive integers

Visualization

Tap to expand

Understanding the Visualization

Sort coins by value

Process smaller coins first to build foundation

Track maximum reachable sum

Keep track of highest sum we can currently form

Extend reach with available coins

Use coins that don't create gaps in our sequence

Fill gaps strategically

Add optimal coin values when gaps are discovered

Key Takeaway

🎯 Key Insight: The greedy approach works because when we can form all amounts up to X and find a gap, adding coin value X+1 optimally extends our reach while minimizing total additions.

Asked in

G Google 42 a Amazon 38 f Meta 28 ⊞ Microsoft 25

The optimal approach uses a greedy algorithm with sorting. We maintain maxReach (the maximum sum achievable) and process coins in order. When we find a coin that fits (≤ maxReach + 1), we extend our reach. When there's a gap, we add a strategic coin of value maxReach + 1. This ensures minimum additions in O(n log n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(target² × 2^target)	O(target²)	Try adding different coin values and check all possible sums repeatedly
Greedy Approach with Sorting (Optimal)	O(n log n)	O(1)	Sort coins, track maximum reachable sum, add coins greedily when gaps are found

Brute Force (Try All Combinations) — Algorithm Steps

Start with the original coins array
Try adding coins of value 1, 2, 3, ... up to target
For each configuration, use DP to find all possible sums
Check if all values 1 to target are covered
Return the minimum number of additions needed

Visualization

Tap to expand

Step-by-Step Walkthrough

Try 0 additions

Test if original coins can form all values 1 to target

Try 1 addition

For each possible coin value to add, test if we can form all values

Try 2 additions

Test all combinations of adding 2 coins of different values

Continue until success

Keep adding more coins until we can form all required values

Code -

solution.c — C

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

bool canFormAll(int* coins, int coinCount, int target) {
    bool* possible = (bool*)calloc(target + 1, sizeof(bool));
    possible[0] = true;
    
    for (int i = 0; i < coinCount; i++) {
        bool* newPossible = (bool*)calloc(target + 1, sizeof(bool));
        for (int val = 0; val <= target; val++) {
            if (possible[val] && val + coins[i] <= target) {
                newPossible[val + coins[i]] = true;
            }
        }
        for (int val = 0; val <= target; val++) {
            if (newPossible[val]) possible[val] = true;
        }
        free(newPossible);
    }
    
    bool result = true;
    for (int i = 1; i <= target; i++) {
        if (!possible[i]) {
            result = false;
            break;
        }
    }
    
    free(possible);
    return result;
}

bool tryAdditions(int* originalCoins, int originalCount, int target, int remaining, int start, int* current, int currentSize) {
    if (remaining == 0) {
        int* allCoins = (int*)malloc((originalCount + currentSize) * sizeof(int));
        memcpy(allCoins, originalCoins, originalCount * sizeof(int));
        memcpy(allCoins + originalCount, current, currentSize * sizeof(int));
        bool result = canFormAll(allCoins, originalCount + currentSize, target);
        free(allCoins);
        return result;
    }
    
    for (int val = start; val <= target; val++) {
        current[currentSize] = val;
        if (tryAdditions(originalCoins, originalCount, target, remaining - 1, val, current, currentSize + 1)) {
            return true;
        }
    }
    return false;
}

int minimumCoins(int* coins, int coinCount, int target) {
    for (int additions = 0; additions <= target; additions++) {
        if (additions == 0) {
            if (canFormAll(coins, coinCount, target)) return 0;
        } else {
            int* current = (int*)malloc(additions * sizeof(int));
            if (tryAdditions(coins, coinCount, target, additions, 1, current, 0)) {
                free(current);
                return additions;
            }
            free(current);
        }
    }
    return target;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse coins array
    int coins[100];
    int coinCount = 0;
    
    char* token = strtok(line, "[],\n");
    while (token != NULL) {
        if (strlen(token) > 0) {
            coins[coinCount++] = atoi(token);
        }
        token = strtok(NULL, "[],\n");
    }
    
    int target;
    scanf("%d", &target);
    
    printf("%d\n", minimumCoins(coins, coinCount, target));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(target² × 2^target)

For each possible coin addition (target options), we need to check all subsets (2^target) and verify coverage (target operations)

✓ Linear Growth

Space Complexity

O(target²)

Need to store all possible sums for each configuration we try

✓ Linear Space

78.5K Views

Medium Frequency

~25 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler