Number of Subsequences That Satisfy the Given Sum Condition - Problem

You are given an array of integers nums and an integer target.

Return the number of non-empty subsequences of nums such that the sum of the minimum and maximum element in the subsequence is less than or equal to target.

Since the answer may be too large, return it modulo 10⁹ + 7.

Note: A subsequence is a sequence that can be derived from another sequence by deleting some or no elements without changing the order of the remaining elements.

Input & Output

Example 1 — Basic Case

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

› Output: 4

💡 Note: Valid subsequences: [3], [3,5], [3,6], [3,5,6]. Each has min + max ≤ 9. For [3]: 3+3=6≤9, [5]: 5+5=10>9 (invalid), [6]: 6+6=12>9 (invalid), [7]: 7+7=14>9 (invalid), [3,5]: 3+5=8≤9, [3,6]: 3+6=9≤9, [3,5,6]: 3+6=9≤9.

Example 2 — Smaller Target

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

› Output: 6

💡 Note: After sorting [3,3,6,8]: valid subsequences include [3], [3], [3,3], [3,6], [3,6] (different 3's), [3,3,6]. Min + max ≤ 10 for each.

Example 3 — All Valid

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

› Output: 61

💡 Note: Most subsequences are valid since target is large. Even [6,7] has 6+7=13>12, but many smaller combinations work.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁶
1 ≤ target ≤ 10⁶

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 A Amazon 8

The key insight is to sort the array first, then use two pointers to efficiently count valid subsequences. When nums[left] + nums[right] ≤ target, all 2^(right-left) subsequences containing nums[left] are valid. Best approach is Sort and Two Pointers. Time: O(n log n), Space: O(1)

Common Approaches

✓ Brute Force - Generate All Subsequences

⏱️ Time: O(n × 2^n) Space: O(n)

Generate every possible non-empty subsequence using bit manipulation, find min and max of each, and count those where min + max ≤ target.

Sort and Two Pointers

⏱️ Time: O(n log n) Space: O(1)

Sort the array to enable two-pointer technique. For each valid pair of left and right pointers where nums[left] + nums[right] ≤ target, all subsequences containing nums[left] are valid.

Brute Force - Generate All Subsequences — Algorithm Steps

Generate all 2^n - 1 non-empty subsequences
For each subsequence, find minimum and maximum elements
Count subsequences where min + max ≤ target

Visualization

Tap to expand

Step-by-Step Walkthrough

Input Array

Start with array [3,5,6,7] and target 9

Generate Subsequences

Create all 2^4-1 = 15 non-empty subsequences

Check Condition

For each subsequence, check if min + max ≤ 9

Code -

solution.c — C

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

int solution(int* nums, int numsSize, int target) {
    const int MOD = 1000000007;
    long count = 0;
    
    // Generate all non-empty subsequences using bit manipulation
    for (int mask = 1; mask < (1 << numsSize); mask++) {
        int subsequence[20];
        int subSize = 0;
        
        for (int i = 0; i < numsSize; i++) {
            if (mask & (1 << i)) {
                subsequence[subSize++] = nums[i];
            }
        }
        
        int minVal = subsequence[0];
        int maxVal = subsequence[0];
        for (int i = 1; i < subSize; i++) {
            if (subsequence[i] < minVal) minVal = subsequence[i];
            if (subsequence[i] > maxVal) maxVal = subsequence[i];
        }
        
        if (minVal + maxVal <= target) {
            count++;
        }
    }
    
    return count % MOD;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int nums[20];
    int numsSize = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != '\n') {
            nums[numsSize++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int target;
    scanf("%d", &target);
    
    int result = solution(nums, numsSize, target);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × 2^n)

Generate 2^n subsequences, each taking O(n) time to find min/max

⚡ Linearithmic

Space Complexity

O(n)

Space for current subsequence during generation

✓ Linear Space

58.0K Views

Medium Frequency

~25 min Avg. Time

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

Number of Subsequences That Satisfy the Given Sum Condition - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Generate All Subsequences — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler