Number of Subsequences with Odd Sum - Practice Coding Problems

Number of Subsequences with Odd Sum - Problem

Given an array nums of integers, your task is to find the number of subsequences that have an odd sum.

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. For example, from array [1,2,3], the subsequences include [1], [2], [1,3], [1,2,3], etc.

The sum is considered odd if it's not divisible by 2. Since the answer can be very large, return it modulo 10⁹ + 7.

Example: For nums = [1,3,5], the subsequences with odd sums are: [1], [3], [5], [1,3], [1,5], [3,5], [1,3,5] → Answer: 7

Input & Output

example_1.py — Basic Case

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

› Output: 4

💡 Note: All elements are odd. Subsequences with odd sums: [1], [3], [5], [1,3,5]. Note that [1,3] has sum 4 (even), [1,5] has sum 6 (even), [3,5] has sum 8 (even).

example_2.py — Mixed Even/Odd

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

› Output: 4

💡 Note: Subsequences with odd sums: [3], [2,3], [4,3], [2,4,3]. The even numbers [2] and [4] don't contribute to odd sums alone, but can be combined with [3].

example_3.py — All Even

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

› Output: 0

💡 Note: All elements are even, so any subsequence sum will be even. No subsequences have odd sums.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
Answer fits in 32-bit integer after modulo operation

Visualization

Tap to expand

Understanding the Visualization

Start with Magic Bag

Begin with an empty bag (even sum = 0). You have 1 way to make an even sum, 0 ways for odd.

Cast Odd Spell

When you encounter an odd number, it's a 'flip spell' - all your even sums become odd, and vice versa.

Cast Even Spell

When you encounter an even number, it's a 'duplicate spell' - you can add it to any existing subsequence without changing parity.

Count Final Odd Sums

After processing all numbers, count how many ways you can create odd sums.

Key Takeaway

🎯 Key Insight: Each odd number acts as a 'parity flipper' while even numbers are 'multipliers'. By tracking even/odd counts separately, we can solve this in O(n) time without generating all subsequences!

Asked in

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

The optimal solution uses dynamic programming to track counts of subsequences with even vs odd sums. Key insight: adding an odd number flips parity while adding an even number preserves it. This achieves O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Subsequences)	O(2^n)	O(1)	Generate all possible subsequences and count those with odd sums
Dynamic Programming (Optimal)	O(n)	O(1)	Track count of even and odd subsequences using DP state transitions

Brute Force (Generate All Subsequences) — Algorithm Steps

Iterate through all numbers from 1 to 2^n - 1 (representing all non-empty subsequences)
For each number, use its binary representation to determine which elements to include
Calculate the sum of elements in the current subsequence
If the sum is odd, increment the counter
Return the final count modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with array [1,3,5] and generate all subsequences using bit masks

Generate

For each bit pattern, include elements where bit is 1

Calculate

Sum elements in each subsequence and check if odd

Count

Increment counter for each odd sum found

Code -

solution.c — C

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

int numSubseqWithOddSum(int* nums, int n) {
    const int MOD = 1000000007;
    int count = 0;
    
    // Generate all subsequences using bit manipulation
    for (int mask = 1; mask < (1 << n); mask++) {
        int subsequenceSum = 0;
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                subsequenceSum += nums[i];
            }
        }
        
        if (subsequenceSum % 2 == 1) {
            count = (count + 1) % MOD;
        }
    }
    
    return count;
}

int main() {
    int nums[1000];
    int n = 0;
    int num;
    
    while (scanf("%d", &num) == 1) {
        nums[n++] = num;
        if (getchar() == '\n') break;
    }
    
    printf("%d\n", numSubseqWithOddSum(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

We generate all 2^n subsequences and check each one

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for counters

✓ Linear Space

32.4K Views

Medium Frequency

~15 min Avg. Time

890 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