Problem

You are given an integer array banned and two integers n and maxSum. You are choosing some number of integers following the below rules:

  • The chosen integers have to be in the range [1, n].
  • Each integer can be chosen at most once.
  • The chosen integers should not be in the array banned.
  • The sum of the chosen integers should not exceed maxSum.

Return the maximum number of integers you can choose following the mentioned rules.

Examples

Example 1

1
2
3
4

Input: banned = [1,6,5], n = 5, maxSum = 6
Output: 2
Explanation: You can choose the integers 2 and 4.
2 and 4 are from the range [1, 5], both did not appear in banned, and their sum is 6, which did not exceed maxSum.

Example 2

1
2
3

Input: banned = [1,2,3,4,5,6,7], n = 8, maxSum = 1
Output: 0
Explanation: You cannot choose any integer while following the mentioned conditions.

Example 3

1
2
3
4

Input: banned = [11], n = 7, maxSum = 50
Output: 7
Explanation: You can choose the integers 1, 2, 3, 4, 5, 6, and 7.
They are from the range [1, 7], all did not appear in banned, and their sum is 28, which did not exceed maxSum.

Constraints

  • 1 <= banned.length <= 10^4
  • 1 <= banned[i], n <= 10^4
  • 1 <= maxSum <= 10^9

Solution

Method 1 - Using the set

Here is the approach:

  1. Convert the Banned Array to a Set: This allows for O(1) average-time complexity checks to quickly identify whether a number is banned.
  2. Initialize Variables: Start with a sum accumulator set to zero and a counter for the chosen numbers.
  3. Iterate and Select Numbers: Iterate from 1 to n, and for each number:
    • Check if the number is in the banned set.
    • Check if adding this number will exceed the maxSum.
    • If both checks pass, add this number to the sum and increase the count.
  4. Return the Count: The count will represent the maximum number of integers that can be chosen following the rules.

Video explanation

Here is the video explaining this method in detail. Please check it out:

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

class Solution {
    public int maxCount(int[] banned, int n, int maxSum) {
        Set<Integer> bannedSet = new HashSet<>();
        for (int num : banned) {
            bannedSet.add(num);
        }
        
        int currSum = 0;
        int ans = 0;
        
        for (int i = 1; i <= n; i++) {
            if (bannedSet.contains(i)) {
	            continue;
	        }
            if (currSum + i > maxSum) {
	            break;
	        }
            currSum += i;
            ans++;
        }
        
        return ans;
    }
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

class Solution:
    def maxCount(self, banned: List[int], n: int, maxSum: int) -> int:
        banned_set: Set[int] = set(banned)
        curr_sum: int = 0
        ans: int = 0
        
        for i in range(1, n + 1):
            if i in banned_set:
                continue
            if curr_sum + i > maxSum:
                break
            curr_sum += i
            ans += 1
        
        return ans

Complexity

  • ⏰ Time complexity: O(n + m), where n is the range up to n and m is the size of the banned array. Converting the banned array to a set takes O(m), and iterating through the range is O(n).
  • 🧺 Space complexity:  O(m) for the set used to store banned elements.