Bitwise OR of All Subsequence Sums - Practice Coding Problems

Bitwise OR of All Subsequence Sums - Problem

Array Math Bit Manipulation Brainteaser Prefix Sum Medium

Bitwise OR of All Subsequence Sums

You are given an integer array nums. Your task is to find the bitwise OR of the sums of all possible subsequences in the array.

A subsequence is a sequence that can be derived from the original array by removing zero or more elements without changing the order of the remaining elements. For example, from array [1, 2, 3], the subsequences include [] (empty), [1], [2], [3], [1,2], [1,3], [2,3], and [1,2,3].

Goal: Calculate the sum of each subsequence, then return the bitwise OR of all these sums.

Example: For nums = [1, 2]
• Subsequence [] → sum = 0
• Subsequence [1] → sum = 1
• Subsequence [2] → sum = 2
• Subsequence [1,2] → sum = 3
• Result: 0 | 1 | 2 | 3 = 3

Input & Output

example_1.py — Basic Case

$ Input: [1, 2]

› Output: 3

💡 Note: Subsequences and their sums: [] → 0, [1] → 1, [2] → 2, [1,2] → 3. Bitwise OR: 0 | 1 | 2 | 3 = 3

example_2.py — Single Element

$ Input: [5]

› Output: 5

💡 Note: Subsequences and their sums: [] → 0, [5] → 5. Bitwise OR: 0 | 5 = 5

example_3.py — Three Elements

$ Input: [1, 2, 4]

› Output: 7

💡 Note: All possible sums: 0, 1, 2, 3, 4, 5, 6, 7 (from 8 subsequences). Bitwise OR of all these values equals 7

Visualization

Tap to expand

Understanding the Visualization

Empty Selection

Start with selecting nothing (sum = 0)

Add First Item

Now you can choose nothing or the first item

Add Second Item

Each previous choice can now include or exclude the new item

OR All Totals

Combine all possible totals using bitwise OR

Key Takeaway

🎯 Key Insight: Instead of generating 2^n subsequences, we build possible sums incrementally. Each new element doubles our sum possibilities, but we only track unique values, making the solution much more efficient than brute force enumeration.

Time & Space Complexity

Time Complexity

⏱️

O(n × S)

n elements, S unique sums. In worst case S can be O(2^n), but often much smaller

✓ Linear Growth

Space Complexity

O(S)

Storing set of all unique possible subsequence sums

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 20
1 ≤ nums[i] ≤ 10⁴
The sum of all elements will not exceed 2 × 10⁵
Time limit: 2 seconds

Asked in

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

The optimal approach uses dynamic programming to build the set of all possible subsequence sums incrementally. Instead of generating 2^n subsequences, we maintain a set of possible sums and for each new element, we create new sums by adding it to existing ones. This reduces the problem from exponential subsequence generation to tracking unique sums, making it much more efficient for practical inputs while maintaining the same mathematical correctness.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Set (Optimal)	O(n × S)	O(S)	Build possible sums incrementally using dynamic programming approach
Generate All Subsequences	O(2^n × n)	O(1)	Generate all 2^n subsequences, calculate their sums, then OR them together

Dynamic Programming with Set (Optimal) — Algorithm Steps

Initialize a set with sum 0 (empty subsequence)
For each element in the array, create new sums by adding the element to each existing sum
Add these new sums to our set of possible sums
After processing all elements, OR all sums in the set

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with possible_sums = {0}

Process num=1

Add 1 to existing sums: {0} → {0, 1}

Process num=2

Add 2 to existing sums: {0, 1} → {0, 1, 2, 3}

Final OR

0 | 1 | 2 | 3 = 3

Code -

solution.c — C

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

#define MAX_SUM 100000

int solution(int* nums, int n) {
    // Use boolean array to represent set of possible sums
    bool possibleSums[MAX_SUM] = {false};
    possibleSums[0] = true;
    
    // For each number, we can add it to any existing sum
    for (int i = 0; i < n; i++) {
        bool newSums[MAX_SUM] = {false};
        for (int j = 0; j < MAX_SUM; j++) {
            if (possibleSums[j] && j + nums[i] < MAX_SUM) {
                newSums[j + nums[i]] = true;
            }
        }
        for (int j = 0; j < MAX_SUM; j++) {
            if (newSums[j]) {
                possibleSums[j] = true;
            }
        }
    }
    
    // OR all possible sums together
    int result = 0;
    for (int i = 0; i < MAX_SUM; i++) {
        if (possibleSums[i]) {
            result |= i;
        }
    }
    
    return result;
}

int main() {
    int nums[20];
    int n = 0;
    char c;
    
    scanf("%c", &c); // skip '['
    while (scanf("%d%c", &nums[n], &c)) {
        n++;
        if (c == ']') break;
    }
    
    printf("%d\n", solution(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × S)

n elements, S unique sums. In worst case S can be O(2^n), but often much smaller

✓ Linear Growth

Space Complexity

O(S)

Storing set of all unique possible subsequence sums

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 20
1 ≤ nums[i] ≤ 10⁴
The sum of all elements will not exceed 2 × 10⁵
Time limit: 2 seconds

23.7K Views

Medium Frequency

~25 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming with Set (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler