Maximum Number of Consecutive Values You Can Make

Maximum Number of Consecutive Values You Can Make - Problem

Imagine you're running a small coin exchange and want to know the maximum range of consecutive values you can make starting from 0 using your available coins.

You are given an integer array coins of length n representing the coins you own. The value of the i-th coin is coins[i]. You can make some value x if you can choose any subset of your coins such that their values sum up to x.

Goal: Return the maximum number of consecutive integer values that you can make with your coins starting from and including 0.

Note: You may have multiple coins of the same value, and you don't need to use all coins to make a value.

Example: If you have coins [1, 3], you can make values: 0 (no coins), 1 (coin 1), 3 (coin 3), and 4 (coins 1+3). Since you can make 0, 1 but not 2, the answer is 2.

Input & Output

example_1.py — Basic Case

$ Input: [1, 3]

› Output: 2

💡 Note: You can make 0 (no coins) and 1 (using coin 1), but you cannot make 2. The next consecutive value would be 2, so the answer is 2.

example_2.py — Multiple Small Coins

$ Input: [1, 1, 1, 4]

› Output: 8

💡 Note: You can make 0, 1, 2, 3 (using 1+1+1), 4, 5 (1+4), 6 (1+1+4), and 7 (1+1+1+4). You cannot make 8, so the answer is 8.

example_3.py — Large Gap

$ Input: [1, 4, 10, 3, 1]

› Output: 20

💡 Note: After sorting: [1,1,3,4,10]. We can make consecutive values 0 through 19. Adding 1: [0,1], adding 1: [0,1,2], adding 3: [0,1,2,3,4,5], adding 4: [0-9], adding 10: [0-19]. Cannot make 20.

Constraints

1 ≤ coins.length ≤ 4 × 10⁴
1 ≤ coins[i] ≤ 4 × 10⁴
Each coin has a positive integer value

Visualization

Tap to expand

Understanding the Visualization

Sort the Coins

Arrange coins from smallest to largest to process optimally

Track Reachable Range

Keep track of the maximum consecutive sum we can achieve so far

Extend or Stop

For each coin, either extend the range or detect a gap

Return Count

Return the total count of consecutive values we can make

Key Takeaway

🎯 Key Insight: The greedy approach works because if we can make [0...h] consecutively and have a coin ≤ h+1, we can always extend to [0...h+coin] without gaps.

Asked in

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

The optimal solution uses a greedy approach with sorting. Sort coins in ascending order, then maintain the maximum consecutive sum reachable so far. For each coin, if it's ≤ reachable + 1, extend the range by adding the coin value. This works because if we can make [0...h] and have a coin ≤ h+1, we can make [0...h+coin]. Time: O(n log n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Greedy with Sorting (Optimal)	O(n log n)	O(1)	Sort coins and greedily extend the reachable range
Brute Force (Generate All Subset Sums)	O(2^n)	O(2^n)	Generate all possible subset sums and count consecutive values from 0

Greedy with Sorting (Optimal) — Algorithm Steps

Sort the coins in ascending order
Initialize reachable range to 0 (we can always make 0)
For each coin, check if coin ≤ reachable + 1
If yes, extend reachable to reachable + coin
If no, we found a gap - return current reachable + 1

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Coins

Sort coins to process from smallest to largest

Check Extension

For each coin, check if it can extend current range

Extend Range

Add coin value to extend the reachable range

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

int getMaximumConsecutive(int* coins, int n) {
    qsort(coins, n, sizeof(int), compare);  // Sort coins in ascending order
    int reachable = 0;  // Maximum consecutive sum we can reach so far
    
    for (int i = 0; i < n; i++) {
        // If current coin is too large, we found a gap
        if (coins[i] > reachable + 1) {
            break;
        }
        // Extend our reachable range
        reachable += coins[i];
    }
    
    return reachable + 1;  // +1 because we count from 0
}

int main() {
    int coins[1000];
    int n = 0;
    char c;
    
    // Simple parsing for array input
    scanf("%c", &c); // skip '['
    while (scanf("%d%c", &coins[n], &c)) {
        n++;
        if (c == ']') break;
    }
    
    printf("%d\n", getMaximumConsecutive(coins, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting takes O(n log n), then single pass through sorted array takes O(n)

⚡ Linearithmic

Space Complexity

O(1)

Only using a few variables, not counting space for sorting (which can be in-place)

✓ Linear Space

42.5K Views

Medium-High Frequency

~22 min Avg. Time

1.3K 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

Greedy with Sorting (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler