Longest Subsequence With Limited Sum - Practice Coding Problems

Longest Subsequence With Limited Sum - Problem

Array Binary Search Greedy Sorting Prefix Sum Easy

Find the Maximum Subsequence Size Within Budget Constraints

You're given an integer array nums of length n and an array of queries of length m. For each query value, you need to determine the maximum number of elements you can select from nums such that their sum doesn't exceed the query limit.

Key Points:
• You can pick any elements from nums (order doesn't matter)
• The sum of selected elements must be ≤ query value
• You want to maximize the count of elements, not their sum
• Return an array where answer[i] is the maximum subsequence size for queries[i]

Example: If nums = [4,5,2,1] and queries = [3,10,21], then:
• Query 3: Can pick [2,1] → answer is 2
• Query 10: Can pick [4,5,1] or [2,1,4,5] but [2,1,4] gives us 3 elements → answer is 3
• Query 21: Can pick all [4,5,2,1] → answer is 4

Input & Output

example_1.py — Basic Case

$ Input: nums = [4,5,2,1], queries = [3,10,21]

› Output: [2,3,4]

💡 Note: For query 3: Best is [2,1] with sum=3, giving 2 elements. For query 10: Best is [1,2,4] with sum=7, giving 3 elements. For query 21: Can take all [1,2,4,5] with sum=12, giving 4 elements.

example_2.py — Single Element

$ Input: nums = [2,3,4,5], queries = [1]

› Output: [0]

💡 Note: Query 1 is less than the smallest element (2), so we cannot take any elements. Answer is 0.

example_3.py — Large Budget

$ Input: nums = [1,2,3], queries = [100]

› Output: [3]

💡 Note: Query 100 is much larger than the sum of all elements (1+2+3=6), so we can take all 3 elements.

Constraints

1 ≤ nums.length, queries.length ≤ 10³
1 ≤ nums[i], queries[i] ≤ 10⁶
Goal: Maximize the count of elements, not their sum

Visualization

Tap to expand

Understanding the Visualization

Sort by Price

Arrange all items from cheapest to most expensive

Running Totals

Keep track of cumulative costs as you add cheaper items

Find Budget Limit

For each budget, binary search to find how many cheapest items you can afford

Key Takeaway

🎯 Key Insight: Greedy approach works perfectly here - always choose the smallest elements first to maximize count within budget constraints.

Asked in

a Amazon 15 G Google 12 ⊞ Microsoft 8 f Meta 5

The optimal solution uses a greedy approach with binary search. Key insight: to maximize element count with limited sum, always pick the smallest elements first. We sort the array, build prefix sums, then use binary search to find how many smallest elements fit within each query budget. Time complexity: O(n log n + m log n).

Common Approaches

Approach	Time	Space	Notes
✓ Sorting + Binary Search (Optimal)	O(n log n + m log n)	O(n)	Sort array, build prefix sums, then binary search for each query
Brute Force (Try All Subsequences)	O(2^n × m)	O(1)	Generate all possible subsequences and find the longest valid one for each query

Sorting + Binary Search (Optimal) — Algorithm Steps

Sort the nums array in ascending order
Compute prefix sums array where prefixSum[i] = sum of first i+1 elements
For each query, use binary search on prefix sums to find the largest index where prefixSum[index] ≤ query
The answer is index + 1 (number of elements we can take)

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Array

Sort nums to enable greedy selection of smallest elements

Build Prefix Sums

Create cumulative sums for quick range sum queries

Binary Search

For each query, find the rightmost valid prefix sum

Code -

solution.c — C

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

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

int* answerQueries(int* nums, int numsSize, int* queries, int queriesSize, int* returnSize) {
    *returnSize = queriesSize;
    
    // Sort array
    qsort(nums, numsSize, sizeof(int), compare);
    
    // Build prefix sums
    int* prefixSums = (int*)malloc(numsSize * sizeof(int));
    prefixSums[0] = nums[0];
    for (int i = 1; i < numsSize; i++) {
        prefixSums[i] = prefixSums[i-1] + nums[i];
    }
    
    int* result = (int*)malloc(queriesSize * sizeof(int));
    for (int i = 0; i < queriesSize; i++) {
        int query = queries[i];
        // Binary search
        int left = 0, right = numsSize - 1;
        int answer = 0;
        
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (prefixSums[mid] <= query) {
                answer = mid + 1;
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        
        result[i] = answer;
    }
    
    free(prefixSums);
    return result;
}

int main() {
    int n, m;
    scanf("%d", &n);
    int* nums = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        scanf("%d", &nums[i]);
    }
    
    scanf("%d", &m);
    int* queries = (int*)malloc(m * sizeof(int));
    for (int i = 0; i < m; i++) {
        scanf("%d", &queries[i]);
    }
    
    int returnSize;
    int* result = answerQueries(nums, n, queries, m, &returnSize);
    
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(" ");
    }
    printf("\n");
    
    free(nums);
    free(queries);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n + m log n)

O(n log n) for sorting, O(n) for prefix sums, O(m log n) for m binary searches

⚡ Linearithmic

Space Complexity

O(n)

O(n) for prefix sums array (sorting can be done in-place)

⚡ Linearithmic Space

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

Sorting + Binary Search (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler