Maximum Number of Integers to Choose From a Range I

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

You're planning to select as many integers as possible from the range [1, n] while following strict rules. Think of it as a strategic number-picking game where you want to maximize your selections while staying within constraints.

The Rules:

📍 Pick only from integers 1 to n
🚫 Avoid any numbers in the banned array
📊 Each number can only be chosen once
💰 The total sum must not exceed maxSum

Your goal is to return the maximum count of integers you can select following these rules.

Example: If n = 7, banned = [3, 6], and maxSum = 12, you could pick [1, 2, 4, 5] for a sum of 12 and count of 4.

Input & Output

example_1.py — Python

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

› Output: 4

💡 Note: We can select [1, 2, 4, 5] with sum = 12. Numbers 3 and 6 are banned, and adding 7 would exceed maxSum.

example_2.py — Python

$ Input: banned = [1, 6, 7], n = 7, maxSum = 5

› Output: 2

💡 Note: We can select [2, 3] with sum = 5. Number 1 is banned, and adding 4 would make sum = 9 > 5.

example_3.py — Python

$ Input: banned = [1, 2, 3, 4, 5, 6, 7], n = 7, maxSum = 10

› Output: 0

💡 Note: All numbers from 1 to 7 are banned, so we cannot select any numbers.

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

Mark Unavailable Items

Create a quick-lookup list of banned/out-of-stock items

Shop Smart

Start with cheapest items (1, 2, 3...) to maximize quantity

Budget Check

For each item, verify it fits within remaining budget

Early Exit

Stop when next item would exceed budget (no point checking expensive items)

Key Takeaway

🎯 Key Insight: Greedy selection of smallest valid numbers maximizes count while staying within budget constraints

Asked in

a Amazon 45 ⊞ Microsoft 32 G Google 28 f Meta 19

The optimal approach uses a greedy strategy with hash set lookup. Store banned numbers in a hash set for O(1) access, then iterate from 1 to n, selecting each valid number that doesn't exceed maxSum. Since we want maximum count, choosing smaller numbers first is always better than larger ones.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Combinations)	O(2^n)	O(n)	Generate all possible combinations and find the valid one with maximum count
Greedy with Hash Set (Optimal)	O(n + m)	O(m)	Use hash set for banned numbers and greedily select from smallest to largest

Brute Force (Generate All Combinations) — Algorithm Steps

Generate all possible subsets of numbers from 1 to n
For each subset, check if it contains any banned numbers
Calculate the sum and verify it doesn't exceed maxSum
Track the maximum count among all valid subsets

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsets

Create all 2^n possible subsets using bit manipulation

Filter Invalid

Remove subsets containing banned numbers

Check Sum

Verify remaining subsets don't exceed maxSum

Find Maximum

Return the count of the largest valid subset

Code -

solution.c — C

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

int maxCount(int* banned, int bannedSize, int n, int maxSum) {
    bool bannedSet[10001] = {false};
    for (int i = 0; i < bannedSize; i++) {
        if (banned[i] <= n) {
            bannedSet[banned[i]] = true;
        }
    }
    
    int maxCount = 0;
    
    // Generate all possible subsets
    for (int mask = 0; mask < (1 << n); mask++) {
        int currentSum = 0;
        int count = 0;
        bool valid = true;
        
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                int num = i + 1;
                if (bannedSet[num]) {
                    valid = false;
                    break;
                }
                currentSum += num;
                count++;
            }
        }
        
        if (valid && currentSum <= maxSum) {
            if (count > maxCount) {
                maxCount = count;
            }
        }
    }
    
    return maxCount;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

We generate 2^n possible subsets, and for each subset we check banned numbers and calculate sum

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing current subset and banned numbers set

⚡ Linearithmic Space

28.7K Views

Medium Frequency

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Generate All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler