Number of Subsequences with Odd Sum

Number of Subsequences with Odd Sum - Problem

Given an array nums, return the number of subsequences with an odd sum of elements.

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

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

Input & Output

Example 1 — All Odd Numbers

$ Input: nums = [1,3,5]

› Output: 4

💡 Note: The subsequences with odd sums are [1], [3], [5], [1,3,5]. Sums are 1, 3, 5, 9 respectively - all odd. Total count = 4.

Example 2 — Mixed Odd and Even

$ Input: nums = [2,4,6]

› Output: 0

💡 Note: All numbers are even, so any sum will be even. No subsequences can have odd sums. Total count = 0.

Example 3 — Single Odd Element

$ Input: nums = [1,2,4]

› Output: 4

💡 Note: Subsequences with odd sums: [1] (sum=1), [1,2] (sum=3), [1,4] (sum=5), [1,2,4] (sum=7). All contain the single odd number 1. Total count = 4.

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁹ ≤ nums[i] ≤ 10⁹
Answer is returned modulo 10⁹ + 7

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Facebook 6

The key insight is that a sum is odd if and only if it contains an odd number of odd elements. The optimal approach uses combinatorics: count odd and even elements, then apply the formula 2^(odd_count-1) × 2^even_count. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force - Generate All Subsequences

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

Use bit manipulation to generate all 2^n subsequences, calculate sum of each, and count how many have odd sums. This approach directly implements the problem definition but is exponentially slow.

Dynamic Programming - Count by Parity

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

Use DP to maintain counts of subsequences with odd and even sums. For each element, we can either include it or not, which affects the parity of existing subsequences.

Mathematical Approach - Combinatorics

⏱️ Time: O(odd_count) Space: O(1)

A sum is odd if and only if it contains an odd number of odd elements. Count odd and even elements, then use the formula: for each odd subset size, multiply by all possible even subsets.

Brute Force - Generate All Subsequences — Algorithm Steps

Generate all 2^n subsequences using bit masks
Calculate sum of each subsequence
Count subsequences with odd sums

Visualization

Tap to expand

Step-by-Step Walkthrough

Input Array

Start with the given array

Generate Subsequences

Use bit masks to generate all 2^n subsequences

Count Odd Sums

Count subsequences with odd sums

Code -

solution.c — C

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

int solution(int* nums, int n) {
    const int MOD = 1000000007;
    long long count = 0;
    
    // Generate all 2^n subsequences using bit masks
    for (int mask = 1; mask < (1 << n); mask++) {
        long long subsequenceSum = 0;
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                subsequenceSum += nums[i];
            }
        }
        
        if (subsequenceSum % 2 == 1) {
            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[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array manually
    int nums[20];
    int n = 0;
    
    char* ptr = strchr(line, '[') + 1;
    char* token = strtok(ptr, ",]");
    
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int result = solution(nums, n);
    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 calculate sum

✓ Linear Growth

Space Complexity

O(1)

Only using variables for counting, no extra data structures

✓ Linear Space

23.5K Views

Medium Frequency

~25 min Avg. Time

847 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 Subsequences — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler