Maximum Number of Consecutive Values You Can Make - Problem

You are given an integer array coins of length n which represents the n coins that you own. The value of the ith coin is coins[i].

You can make some value x if you can choose some of your n coins such that their values sum up to x.

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

Note that you may have multiple coins of the same value.

Input & Output

Example 1 — Basic Case

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

› Output: 3

💡 Note: You can make 0 (use no coins), 1 (use one coin), 2 (use both 1-coins), but cannot make 3. So consecutive values are [0,1,2] with count 3.

Example 2 — Single Coin

$ Input: coins = [1,3]

› Output: 2

💡 Note: You can make 0 (no coins), 1 (use coin 1), but cannot make 2. The coin 3 is too large to fill the gap. Count = 2.

Example 3 — Larger Gap

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

› Output: 8

💡 Note: With three 1's you can make [0,1,2,3]. Adding coin 4 extends to [0,1,2,3,4,5,6,7]. Count = 8.

Constraints

1 ≤ coins.length ≤ 4 × 10⁴
1 ≤ coins[i] ≤ 4 × 10⁴

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Meta 6

The key insight is to sort coins first, then greedily extend the reachable range. If we can make values [0, reach-1] and encounter a coin ≤ reach, we can extend to [0, reach+coin-1]. Best approach is Greedy with Time: O(n log n), Space: O(1).

Common Approaches

✓ Stack

⏱️ Time: N/A Space: N/A

Brute Force - Try All Subsets

⏱️ Time: O(2ⁿ × n) Space: O(2ⁿ)

Generate all possible combinations of coins, calculate their sums, then find the longest consecutive sequence starting from 0. This explores every possible way to combine coins.

Greedy Optimal Solution

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

Sort coins first, then process each coin greedily. If we can make values [0, reach-1] and encounter coin ≤ reach, we can extend to [0, reach+coin-1]. This is optimal because smaller coins are processed first.

Sort First Approach

⏱️ Time: O(n × sum) Space: O(sum)

Sort the coins first, then use dynamic programming to keep track of all achievable sums. For each coin, update the DP array to include new possible sums.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

24.5K Views

Medium Frequency

~25 min Avg. Time

847 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