Maximum Number of Integers to Choose From a Range II

Maximum Number of Integers to Choose From a Range II - Problem

You are a mathematician working on a number selection puzzle! Given a range of integers from 1 to n, you need to strategically choose as many numbers as possible while following strict rules.

Your Mission:

Choose integers from the range [1, n]
Each integer can only be chosen once
Avoid all numbers in the banned array
Keep the total sum ≤ maxSum

Goal: Return the maximum count of integers you can select while respecting all constraints.

Example: If n = 7, banned = [3, 5], and maxSum = 12, you could choose [1, 2, 4] (sum = 7) or [1, 2, 6] (sum = 9), but [1, 2, 4, 6] (sum = 13) exceeds maxSum. The optimal choice is [1, 2, 4, 6] if we can fit it within the sum limit!

Input & Output

example_1.py — Basic Case

$ Input: banned = [3, 5], n = 7, maxSum = 12

› Output: 3

💡 Note: We can choose [1, 2, 4] with sum = 7. We cannot add 6 because 7 + 6 = 13 > 12. Number 7 would also exceed the limit.

example_2.py — Large Numbers Banned

$ Input: banned = [6, 7, 8], n = 10, maxSum = 15

› Output: 5

💡 Note: We can choose [1, 2, 3, 4, 5] with sum = 15. This uses exactly maxSum and gives us the maximum possible count.

example_3.py — Small maxSum

$ Input: banned = [2, 4], n = 6, maxSum = 4

› Output: 2

💡 Note: We can only choose [1, 3] with sum = 4. Adding 5 would make sum = 9 > 4, so we stop at count = 2.

Constraints

1 ≤ banned.length ≤ 10⁴
1 ≤ banned[i], n ≤ 10⁴
1 ≤ maxSum ≤ 10⁹
All elements in banned are unique

Visualization

Tap to expand

Understanding the Visualization

Identify Available Items

Create a list of items not in the banned list (out-of-stock items)

Start with Cheapest

Begin with item #1 (costs $1), then #2 (costs $2), etc.

Check Budget

For each item, verify that buying it won't exceed our maxSum budget

Stop When Needed

Once an item would exceed our budget, we've found our maximum count

Key Takeaway

🎯 Key Insight: The greedy approach works because smaller numbers leave more "budget room" for additional selections, naturally maximizing the total count we can achieve.

Asked in

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

The optimal approach uses a greedy strategy: iterate through numbers 1 to n, skip banned ones, and add valid numbers until the sum would exceed maxSum. This works because choosing smaller numbers first maximizes our total count. Time complexity: O(n + b) where b is the banned array size.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Single Pass (Optimal)	O(n + b)	O(b)	Greedily select smallest available numbers in a single pass until sum limit reached
Brute Force (Try All Combinations)	O(2^n)	O(n)	Generate all possible valid combinations and find the one with maximum count
Binary Search on Answer	O(n log n)	O(n)	Binary search on the number of integers we can choose, checking feasibility for each candidate

Greedy Single Pass (Optimal) — Algorithm Steps

Convert banned array to a hash set for O(1) lookups
Initialize count=0 and currentSum=0
Iterate through numbers from 1 to n
For each number: if not banned and adding it doesn't exceed maxSum, include it
Update count and currentSum, continue until we can't add more numbers
Return the final count

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Banned Set

Convert banned array to hash set for fast lookups

Iterate 1 to n

Check each number in ascending order

Greedy Selection

Add number if not banned and sum permits

Early Termination

Stop when next number would exceed maxSum

Code -

solution.c — C

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

int maxCount(int* banned, int bannedSize, int n, int maxSum) {
    // Create a boolean array to mark banned numbers
    bool* isBanned = (bool*)calloc(n + 1, sizeof(bool));
    
    for (int i = 0; i < bannedSize; i++) {
        if (banned[i] <= n) {
            isBanned[banned[i]] = true;
        }
    }
    
    int count = 0;
    long long currentSum = 0;
    
    for (int num = 1; num <= n; num++) {
        if (!isBanned[num]) {
            if (currentSum + num <= maxSum) {
                currentSum += num;
                count++;
            } else {
                break; // Can't add any larger numbers
            }
        }
    }
    
    free(isBanned);
    return count;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + b)

O(b) to build banned set + O(n) to iterate through range [1,n]

✓ Linear Growth

Space Complexity

O(b)

Space for banned set, where b is the size of banned array

✓ Linear Space

43.2K Views

Medium-High Frequency

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

Greedy Single Pass (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler