Minimum Number of Coins to be Added - Problem

You are given a 0-indexed integer array coins, representing the values of the coins available, and an integer target.

An integer x is obtainable if there exists a subsequence of coins that sums to x.

Return the minimum number of coins of any value that need to be added to the array so that every integer in the range [1, target] is obtainable.

A subsequence of an array is a new non-empty array that is formed from the original array by deleting some (possibly none) of the elements without disturbing the relative positions of the remaining elements.

Input & Output

Example 1 — Basic Case

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

› Output: 1

💡 Note: We can make sums 1, 3, 4 initially. Missing: 2, 5, 6. Add coin 2 to make all sums 1-6 possible: 1, 2, 3, 4(1+3), 5(2+3), 6(1+2+3).

Example 2 — Already Complete

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

› Output: 1

💡 Note: With coins 1,2,3 we can make sums 1,2,3,4(1+3),5(2+3),6(1+2+3). To make 7, we need to add one more coin of value 4, giving us 7(3+4). So 1 addition is needed.

Example 3 — Large Gap

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

› Output: 2

💡 Note: Can make 1, 5, 6, 10, 11, 15, 16. Missing many sums. Need to add coins 2 and 4 to fill gaps efficiently.

Constraints

1 ≤ coins.length ≤ 10⁵
1 ≤ coins[i] ≤ 10⁴
1 ≤ target ≤ 10⁴

Visualization

Tap to expand

Asked in

G Google 12 a Amazon 8 M Microsoft 6

The key insight is that if we can make all sums from 1 to k, then adding a coin of value k+1 allows us to make all sums from 1 to 2k+1. The greedy approach sorts coins and tracks the maximum achievable sum, adding coins only when gaps are found. Time: O(n log n), Space: O(1)

Common Approaches

✓ Brute Force - Check All Combinations

⏱️ Time: O(2^n × target) Space: O(target)

Generate all possible subsequences of coins and check which sums are achievable. For missing sums, add coins one by one until all amounts 1 to target are covered.

Greedy - Sort and Fill Gaps

⏱️ Time: O(n log n) Space: O(1)

Sort coins first, then iterate through them while maintaining the maximum sum we can achieve. When we find a gap (coin > maxAchievable + 1), we add the missing coin to fill the gap.

Brute Force - Check All Combinations — Algorithm Steps

Generate all possible coin combinations
Track which sums 1 to target are achievable
Add coins for missing sums

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Create all possible coin subsequences

Check Coverage

See which sums 1 to target are achievable

Add Missing

Add coins for first missing sum

Code -

solution.c — C

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

int solution(int* coins, int coinsSize, int target) {
    int* currentCoins = malloc(1000 * sizeof(int));
    int currentSize = coinsSize;
    
    for (int i = 0; i < coinsSize; i++) {
        currentCoins[i] = coins[i];
    }
    
    int added = 0;
    
    while (true) {
        bool* achievable = calloc(target + 1, sizeof(bool));
        achievable[0] = true;
        
        for (int i = 0; i < currentSize; i++) {
            for (int s = target; s >= currentCoins[i]; s--) {
                if (achievable[s - currentCoins[i]]) {
                    achievable[s] = true;
                }
            }
        }
        
        int missing = -1;
        for (int i = 1; i <= target; i++) {
            if (!achievable[i]) {
                missing = i;
                break;
            }
        }
        
        free(achievable);
        
        if (missing == -1) break;
        
        currentCoins[currentSize++] = missing;
        added++;
    }
    
    free(currentCoins);
    return added;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int coins[1000];
    int coinsSize = 0;
    
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        coins[coinsSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int target;
    scanf("%d", &target);
    
    int result = solution(coins, coinsSize, target);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n × target)

2^n combinations to check, each taking O(target) time to verify coverage

⚠ Quadratic Growth

Space Complexity

O(target)

Set to store achievable sums up to target

✓ Linear Space

28.4K Views

Medium Frequency

~25 min Avg. Time

892 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

Minimum Number of Coins to be Added - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Check All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler