##### Welcome to Subscribe On Youtube

Formatted question description: https://leetcode.ca/all/1863.html

# 1863. Sum of All Subset XOR Totals

Easy

## Description

The XOR total of an array is defined as the bitwise XOR of all its elements, or 0 if the array is empty.

• For example, the XOR total of the array [2,5,6] is 2 XOR 5 XOR 6 = 1.

Given an array nums, return the sum of all XOR totals for every subset of nums.

Note: Subsets with the same elements should be counted multiple times.

An array a is a subset of an array b if a can be obtained from b by deleting some (possibly zero) elements of b.

Example 1:

Input: nums = [1,3]

Output: 6

Explanation: The 4 subsets of [1,3] are:

• The empty subset has an XOR total of 0.
• [1] has an XOR total of 1.
• [3] has an XOR total of 3.
• [1,3] has an XOR total of 1 XOR 3 = 2.

0 + 1 + 3 + 2 = 6

Example 2:

Input: nums = [5,1,6]

Output: 28

Explanation: The 8 subsets of [5,1,6] are:

• The empty subset has an XOR total of 0.
• [5] has an XOR total of 5.
• [1] has an XOR total of 1.
• [6] has an XOR total of 6.
• [5,1] has an XOR total of 5 XOR 1 = 4.
• [5,6] has an XOR total of 5 XOR 6 = 3.
• [1,6] has an XOR total of 1 XOR 6 = 7.
• [5,1,6] has an XOR total of 5 XOR 1 XOR 6 = 2.

0 + 5 + 1 + 6 + 4 + 3 + 7 + 2 = 28

Example 3:

Input: nums = [3,4,5,6,7,8]

Output: 480

Explanation: The sum of all XOR totals for every subset is 480.

Constraints:

• 1 <= nums.length <= 12
• 1 <= nums[i] <= 20

## Solution

Enumerate all subsets of nums. For each subset, calculate the XOR total. Finally, calculate the sum of all subsets’ XOR totals and return.

• class Solution {
public int subsetXORSum(int[] nums) {
int sum = 0;
int length = nums.length;
int count = 1 << length;
for (int i = 0; i < count; i++) {
int xor = getXor(nums, i);
sum += xor;
}
return sum;
}

public int getXor(int[] nums, int curNum) {
int xor = 0;
int index = 0;
while (curNum > 0) {
int remainder = curNum % 2;
if (remainder == 1)
xor ^= nums[index];
curNum >>= 1;
index++;
}
return xor;
}
}

############

class Solution {
private int res;

public int subsetXORSum(int[] nums) {
dfs(nums, 0, 0);
return res;
}

private void dfs(int[] nums, int depth, int prev) {
res += prev;
for (int i = depth; i < nums.length; ++i) {
prev ^= nums[i];
dfs(nums, ++depth, prev);
prev ^= nums[i];
}
}
}

• // OJ: https://leetcode.com/problems/sum-of-all-subset-xor-totals/
// Time: O(2^N)
// Space: O(N)
class Solution {
int ans = 0;
void dfs(vector<int> &A, int start, int val) {
if (start == A.size()) {
ans += val;
return;
}
dfs(A, start + 1, val ^ A[start]);
dfs(A, start + 1, val);
}
public:
int subsetXORSum(vector<int>& A) {
dfs(A, 0, 0);
return ans;
}
};

• class Solution:
def subsetXORSum(self, nums: List[int]) -> int:
def dfs(nums, depth, prev):
self.res += prev
for num in nums[depth:]:
prev ^= num
depth += 1
dfs(nums, depth, prev)
prev ^= num

self.res = 0
dfs(nums, 0, 0)
return self.res

############

# 1863. Sum of All Subset XOR Totals
# https://leetcode.com/problems/sum-of-all-subset-xor-totals/

class Solution:
def subsetXORSum(self, nums: List[int]) -> int:
n = len(nums)
res = 0

for i in range(1 << n):
t = 0
for j in range(n):
if i >> j & 1:
t ^= nums[j]

res += t

return res


• /**
* @param {number[]} nums
* @return {number}
*/
var subsetXORSum = function (nums) {
let res = [];
let prev = 0;
dfs(nums, 0, prev, res);
return res.reduce((a, c) => a + c, 0);
};

function dfs(nums, depth, prev, res) {
res.push(prev);
for (let i = depth; i < nums.length; i++) {
prev ^= nums[i];
depth++;
dfs(nums, depth, prev, res);
// bracktrack
prev ^= nums[i];
}
}


• func subsetXORSum(nums []int) (ans int) {
n := len(nums)
var dfs func(int, int)
dfs = func(i, s int) {
if i >= n {
ans += s
return
}
dfs(i+1, s)
dfs(i+1, s^nums[i])
}
dfs(0, 0)
return
}

• function subsetXORSum(nums: number[]): number {
let ans = 0;
const n = nums.length;
const dfs = (i: number, s: number) => {
if (i >= n) {
ans += s;
return;
}
dfs(i + 1, s);
dfs(i + 1, s ^ nums[i]);
};
dfs(0, 0);
return ans;
}