Bitwise OR of All Subsequence Sums

Bitwise OR of All Subsequence Sums - Problem

Array Math Bit Manipulation Brainteaser Prefix Sum Medium

Given an integer array nums, return the value of the bitwise OR of the sum of all possible subsequences in the array.

A subsequence is a sequence that can be derived from another sequence by removing zero or more elements without changing the order of the remaining elements.

For example, given array [1, 2, 3], the subsequences are: [] (sum=0), [1] (sum=1), [2] (sum=2), [3] (sum=3), [1,2] (sum=3), [1,3] (sum=4), [2,3] (sum=5), [1,2,3] (sum=6). The bitwise OR of all these sums is 0 | 1 | 2 | 3 | 3 | 4 | 5 | 6 = 7.

Input & Output

Example 1 — Basic Case

$ Input: nums = [1, 2]

› Output: 3

💡 Note: Subsequences: [] (sum=0), [1] (sum=1), [2] (sum=2), [1,2] (sum=3). OR of sums: 0 | 1 | 2 | 3 = 3

Example 2 — Single Element

$ Input: nums = [5]

› Output: 5

💡 Note: Subsequences: [] (sum=0), [5] (sum=5). OR of sums: 0 | 5 = 5

Example 3 — Three Elements

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

› Output: 7

💡 Note: All possible sums: 0,1,2,3,4,5,6,7. OR of all sums: 0|1|2|3|4|5|6|7 = 7

Constraints

1 ≤ nums.length ≤ 20
1 ≤ nums[i] ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 15 f Meta 12 M Microsoft 8

The key insight is that we need to find all possible subsequence sums and take their bitwise OR. The dynamic programming approach efficiently builds the set of achievable sums without generating duplicate subsequences. Time: O(n × S), Space: O(S) where S is the sum of all elements.

Common Approaches

✓ Dynamic Programming with Set

⏱️ Time: O(n × S) Space: O(S)

Use a set to track all possible sums that can be achieved. For each element, update the set by adding the current element to all existing sums. This avoids generating duplicate subsequences.

Generate All Subsequences

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

Use bit manipulation to generate all possible subsequences, calculate the sum of each, and take the bitwise OR of all sums. This directly implements the problem definition.

Dynamic Programming with Set — Algorithm Steps

Start with set containing 0 (empty subsequence)
For each element, add it to all current sums
Take bitwise OR of all sums in the final set

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with {0} representing empty subsequence

Add Elements

For each element, create new sums by adding to existing ones

Final OR

Take bitwise OR of all collected sums

Code -

solution.c — C

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

int solution(int* nums, int n) {
    // Use array to track possible sums (assuming reasonable range)
    bool possibleSums[100001] = {false};
    possibleSums[0] = true;  // Empty subsequence
    int maxSum = 0;
    
    // For each element, add it to all existing sums
    for (int i = 0; i < n; i++) {
        maxSum += nums[i];
        for (int j = maxSum - nums[i]; j >= 0; j--) {
            if (possibleSums[j]) {
                possibleSums[j + nums[i]] = true;
            }
        }
    }
    
    // Calculate bitwise OR of all possible sums
    int result = 0;
    for (int i = 0; i <= maxSum; i++) {
        if (possibleSums[i]) {
            result |= i;
        }
    }
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n × S)

n elements, each sum can be at most S (sum of all elements)

✓ Linear Growth

Space Complexity

O(S)

Set stores all possible subsequence sums, at most S unique values

✓ Linear Space

23.0K Views

Medium Frequency

~25 min Avg. Time

850 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

Dynamic Programming with Set — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler