Sum of All Subset XOR Totals - Practice Coding Problems

Sum of All Subset XOR Totals - Problem

Array Math Backtracking Bit Manipulation Combinatorics Enumeration Easy

Sum of All Subset XOR Totals

Imagine you have an array of numbers and need to find every possible subset (including the empty set), calculate the XOR of all elements in each subset, and then sum all these XOR results together.

The XOR total of an array is the bitwise XOR of all its elements. For an empty array, the XOR total is 0.

Example: For array [2, 5, 6], the XOR total is 2 ⊕ 5 ⊕ 6 = 1

Your task is to:
1. Generate all possible subsets of the given array
2. Calculate the XOR total for each subset
3. Return the sum of all these XOR totals

Note: A subset can be obtained by deleting some (possibly zero) elements from the original array.

Input & Output

example_1.py — Basic Case

$ Input: [1, 3]

› Output: 6

💡 Note: Subsets: {} (XOR=0), {1} (XOR=1), {3} (XOR=3), {1,3} (XOR=1⊕3=2). Sum: 0+1+3+2=6

example_2.py — Single Element

$ Input: [5]

› Output: 5

💡 Note: Subsets: {} (XOR=0), {5} (XOR=5). Sum: 0+5=5

example_3.py — Three Elements

$ Input: [5, 1, 6]

› Output: 28

💡 Note: 8 subsets total: {}, {5}, {1}, {6}, {5,1}, {5,6}, {1,6}, {5,1,6} with XOR totals 0,5,1,6,4,3,7,2. Sum: 0+5+1+6+4+3+7+2=28

Visualization

Tap to expand

Understanding the Visualization

List all combinations

For stones [1,3]: {}, {1}, {3}, {1,3}

Calculate each XOR

XOR totals: 0, 1, 3, 2

Sum all totals

Total magical power: 0+1+3+2 = 6

Discover the pattern

OR(1,3) × 2^(2-1) = 3 × 2 = 6 ✨

Key Takeaway

🎯 Key Insight: Instead of generating all 2^n subsets, we use the mathematical property that each element contributes to exactly 2^(n-1) subsets. The OR of all elements combined with left-shift gives us the answer in O(n) time!

Time & Space Complexity

Time Complexity

⏱️

O(n)

We iterate through the array once to calculate OR, then do constant time operations

✓ Linear Growth

Space Complexity

O(1)

Only using a few integer variables for calculations

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 12
1 ≤ nums[i] ≤ 20
The array can have at most 2¹² = 4096 subsets

Asked in

a Amazon 35 ⊞ Microsoft 28 G Google 22 f Meta 18

The optimal solution uses bit manipulation with the key insight that each element appears in exactly 2^n-1 subsets. By calculating the OR of all elements and left-shifting by (n-1) positions, we get the answer in O(n) time instead of generating all 2ⁿ subsets.

Common Approaches

Approach	Time	Space	Notes
✓ Bit Manipulation (Optimal)	O(n)	O(1)	Use mathematical property that each element appears in exactly 2^(n-1) subsets

Bit Manipulation (Optimal) — Algorithm Steps

Calculate the OR of all elements (this gives us all bit positions that appear)
For each bit position that's set in the OR result, it contributes to exactly 2^(n-1) subsets
Multiply the OR result by 2^(n-1) to get the final answer
Return the result

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate OR

1 | 3 = 3 (binary: 11)

Apply formula

3 << (2-1) = 3 << 1 = 6

Verify result

Matches our brute force answer of 6

Code -

solution.c — C

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

int subsetXORSum(int* nums, int size) {
    // Key insight: each element appears in exactly 2^(n-1) subsets
    // The OR of all elements gives us the bit positions that matter
    int orResult = 0;
    for (int i = 0; i < size; i++) {
        orResult |= nums[i];
    }
    
    // Each bit position contributes 2^(n-1) times to the final sum
    return orResult << (size - 1);
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

We iterate through the array once to calculate OR, then do constant time operations

✓ Linear Growth

Space Complexity

O(1)

Only using a few integer variables for calculations

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 12
1 ≤ nums[i] ≤ 20
The array can have at most 2¹² = 4096 subsets

48.2K Views

Medium Frequency

~15 min Avg. Time

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

Bit Manipulation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler