Number of Subsequences That Satisfy the Given Sum Condition

Number of Subsequences That Satisfy the Given Sum Condition - Problem

You're given an array of integers nums and an integer target. Your task is to find the number of non-empty subsequences where the sum of the minimum and maximum elements is less than or equal to the target.

A subsequence is derived from the original array by deleting some or no elements without changing the order of the remaining elements. For example, from [3,6,7,7], some valid subsequences are [3,7,7], [6], or [3,6,7].

Key insight: We only care about the min and max values in each subsequence, not the sum of all elements! This makes the problem much more manageable.

Since the answer can be very large, return the result modulo 10⁹ + 7.

Input & Output

example_1.py — Basic case

$ Input: nums = [3,5,6,7], target = 9

› Output: 4

💡 Note: There are 4 valid subsequences: [3], [3,5], [3,5,6], [3,6]. For [3]: min+max = 3+3 = 6 ≤ 9. For [3,5]: min+max = 3+5 = 8 ≤ 9. For [3,5,6]: min+max = 3+6 = 9 ≤ 9. For [3,6]: min+max = 3+6 = 9 ≤ 9.

example_2.py — Edge case

$ Input: nums = [3,3,6,8], target = 10

› Output: 6

💡 Note: Valid subsequences are [3], [3] (second occurrence), [3,3], [3,6], [3,6] (with second 3), [3,3,6]. All have min+max ≤ 10.

example_3.py — No valid subsequences

$ Input: nums = [2,3,3,4,6,7], target = 12

› Output: 61

💡 Note: Many subsequences are valid since even the largest elements sum to manageable values. The two-pointer approach efficiently counts all valid combinations.

Visualization

Tap to expand

Understanding the Visualization

Line up by skill

Sort all players by their skill level (sort the array)

Check extreme players

Look at weakest available player (left) and strongest candidate (right)

Count valid teams

If weakest + strongest ≤ budget, all teams with weakest player and anyone from left to right work

Move strategically

If valid, move to next weakest player; if not, reduce strongest candidate

Key Takeaway

🎯 Key Insight: By sorting first, we can use two pointers to efficiently count valid subsequences. When nums[left] + nums[right] ≤ target, all 2^(right-left) subsequences starting with nums[left] are valid, allowing us to count exponentially many subsequences in constant time.

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

We generate 2^n subsequences and spend O(k) time on each subsequence of length k

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth or space to store current subsequence

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁶
1 ≤ target ≤ 10⁶
Return result modulo 10⁹ + 7

Asked in

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

The optimal solution uses a two-pointer technique after sorting the array. The key insight is that if the minimum element (left pointer) plus maximum element (right pointer) in a range satisfies the condition, then all 2^(right-left) subsequences within that range are valid. This reduces the time complexity from O(2ⁿ) brute force to O(n log n).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Subsequences)	O(2^n)	O(n)	Generate all possible subsequences and check each one
Two Pointers (Optimal)	O(n log n)	O(n)	Sort array and use two pointers to efficiently count valid subsequences

Brute Force (Generate All Subsequences) — Algorithm Steps

Generate all possible subsequences using bit manipulation or recursion
For each subsequence, find minimum and maximum elements
Check if min + max ≤ target
Count valid subsequences and return modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with empty set

Begin with no elements selected

For each element

Choose to include or exclude it

Generate 2^n combinations

Each element has 2 choices, creating exponential combinations

Check each subsequence

Find min and max, check if sum ≤ target

Code -

solution.c — C

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

#define MOD 1000000007

int count_global = 0;

void backtrack(int* nums, int numsSize, int target, int index, int* subsequence, int subSize) {
    if (index == numsSize) {
        if (subSize > 0) {
            int minVal = INT_MAX, maxVal = INT_MIN;
            for (int i = 0; i < subSize; i++) {
                if (subsequence[i] < minVal) minVal = subsequence[i];
                if (subsequence[i] > maxVal) maxVal = subsequence[i];
            }
            if (minVal + maxVal <= target) {
                count_global = (count_global + 1) % MOD;
            }
        }
        return;
    }
    
    // Include current element
    subsequence[subSize] = nums[index];
    backtrack(nums, numsSize, target, index + 1, subsequence, subSize + 1);
    
    // Exclude current element
    backtrack(nums, numsSize, target, index + 1, subsequence, subSize);
}

int numSubseq(int* nums, int numsSize, int target) {
    count_global = 0;
    int* subsequence = (int*)malloc(numsSize * sizeof(int));
    backtrack(nums, numsSize, target, 0, subsequence, 0);
    free(subsequence);
    return count_global;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

We generate 2^n subsequences and spend O(k) time on each subsequence of length k

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth or space to store current subsequence

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁶
1 ≤ target ≤ 10⁶
Return result modulo 10⁹ + 7

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Generate All Subsequences) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler