# Sum of Bitwise XOR of elements of an array with all elements of another array

• Difficulty Level : Hard
• Last Updated : 28 Jun, 2021

Given an array arr[] of size N and an array Q[], the task is to calculate the sum of Bitwise XOR of all elements of the array arr[] with each element of the array q[].

Examples:

Input: arr[ ] = {5, 2, 3}, Q[ ] = {3, 8, 7}
Output: 7 34 11
Explanation:
For Q[0] ( = 3): Sum =  5 ^ 3 + 2 ^ 3 + 3 ^ 3 = 7.
For Q[1] ( = 8): Sum = 5 ^ 8 + 2 ^ 8 + 3 ^ 8 = 34.
For Q[2] ( = 7): Sum = 5 ^ 7 + 2 ^ 7 + 3 ^ 7 = 11.

Input: arr[ ] = {2, 3, 4}, Q[ ] = {1, 2}
Output: 10 7

Naive Approach: The simplest approach to solve the problem is to traverse the array Q[] and for each array element, calculate the sum of its Bitwise XOR with all elements of the array arr[]

Time Complexity: O(N2)
Auxiliary Space: O(1)

Efficient Approach: Follow the steps below to optimize the above approach:

• Initialize an array count[], of size 32. to store the count of set bits at each position of the elements of the array arr[].
• Traverse the array arr[].
• Update the array count[] accordingly. In a 32-bit binary representation, if the ith bit is set, increase the count of set bits at that position.
• Traverse the array Q[] and for each array element, perform the following operations:
• Initialize variables, say sum = 0, to store the required sum of Bitwise XOR .
• Iterate over each bit positions of the current element.
• If current bit is set, add count of elements with ith bit not set * 2i to sum.
• Otherwise, add count[i] *  2i.
• Finally, print the value of sum.

Below is the implementation of the above approach:

## C++

 `// C++ Program for the above approach` `#include ` `using` `namespace` `std;`   `// Function to calculate sum of Bitwise` `// XOR of elements of arr[] with k` `int` `xorSumOfArray(``int` `arr[], ``int` `n, ``int` `k, ``int` `count[])` `{`   `    ``// Initialize sum to be zero` `    ``int` `sum = 0;` `    ``int` `p = 1;`   `    ``// Iterate over each set bit` `    ``for` `(``int` `i = 0; i < 31; i++) {`   `        ``// Stores contribution of` `        ``// i-th bet to the sum` `        ``int` `val = 0;`   `        ``// If the i-th bit is set` `        ``if` `((k & (1 << i)) != 0) {`   `            ``// Stores count of elements` `            ``// whose i-th bit is not set` `            ``int` `not_set = n - count[i];`   `            ``// Update value` `            ``val = ((not_set)*p);` `        ``}` `        ``else` `{`   `            ``// Update value` `            ``val = (count[i] * p);` `        ``}`   `        ``// Add value to sum` `        ``sum += val;`   `        ``// Move to the next` `        ``// power of two` `        ``p = (p * 2);` `    ``}`   `    ``return` `sum;` `}`   `void` `sumOfXors(``int` `arr[], ``int` `n, ``int` `queries[], ``int` `q)` `{`   `    ``// Stores the count of elements` `    ``// whose i-th bit is set` `    ``int` `count[32];`   `    ``// Initialize count to 0` `    ``// for all positions` `    ``memset``(count, 0, ``sizeof``(count));`   `    ``// Traverse the array` `    ``for` `(``int` `i = 0; i < n; i++) {`   `        ``// Iterate over each bit` `        ``for` `(``int` `j = 0; j < 31; j++) {`   `            ``// If the i-th bit is set` `            ``if` `(arr[i] & (1 << j))`   `                ``// Increase count` `                ``count[j]++;` `        ``}` `    ``}`   `    ``for` `(``int` `i = 0; i < q; i++) {` `        ``int` `k = queries[i];` `        ``cout << xorSumOfArray(arr, n, k, count) << ``" "``;` `    ``}` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `arr[] = { 5, 2, 3 };` `    ``int` `queries[] = { 3, 8, 7 };`   `    ``int` `n = ``sizeof``(arr) / ``sizeof``(``int``);` `    ``int` `q = ``sizeof``(queries) / ``sizeof``(``int``);`   `    ``sumOfXors(arr, n, queries, q);`   `    ``return` `0;` `}`

## Java

 `// Java Program for the above approach` `import` `java.util.Arrays;`   `class` `GFG{`   `// Function to calculate sum of Bitwise` `// XOR of elements of arr[] with k` `static` `int` `xorSumOfArray(``int` `arr[], ``int` `n, ` `                         ``int` `k, ``int` `count[])` `{` `    `  `    ``// Initialize sum to be zero` `    ``int` `sum = ``0``;` `    ``int` `p = ``1``;`   `    ``// Iterate over each set bit` `    ``for``(``int` `i = ``0``; i < ``31``; i++) ` `    ``{` `        `  `        ``// Stores contribution of` `        ``// i-th bet to the sum` `        ``int` `val = ``0``;`   `        ``// If the i-th bit is set` `        ``if` `((k & (``1` `<< i)) != ``0``) ` `        ``{` `            `  `            ``// Stores count of elements` `            ``// whose i-th bit is not set` `            ``int` `not_set = n - count[i];`   `            ``// Update value` `            ``val = ((not_set)*p);` `        ``}` `        ``else` `        ``{` `            `  `            ``// Update value` `            ``val = (count[i] * p);` `        ``}`   `        ``// Add value to sum` `        ``sum += val;`   `        ``// Move to the next` `        ``// power of two` `        ``p = (p * ``2``);` `    ``}` `    ``return` `sum;` `}`   `static` `void` `sumOfXors(``int` `arr[], ``int` `n, ` `                      ``int` `queries[], ``int` `q)` `{` `    `  `    ``// Stores the count of elements` `    ``// whose i-th bit is set` `    ``int` `[]count = ``new` `int``[``32``];`   `    ``// Initialize count to 0` `    ``// for all positions` `    ``Arrays.fill(count,``0``);`   `    ``// Traverse the array` `    ``for``(``int` `i = ``0``; i < n; i++) ` `    ``{` `        `  `        ``// Iterate over each bit` `        ``for``(``int` `j = ``0``; j < ``31``; j++) ` `        ``{` `            `  `            ``// If the i-th bit is set` `            ``if`  `((arr[i] & (``1` `<< j)) != ``0``)`   `                ``// Increase count` `                ``count[j]++;` `        ``}` `    ``}`   `    ``for``(``int` `i = ``0``; i < q; i++)` `    ``{` `        ``int` `k = queries[i];` `        ``System.out.print(` `            ``xorSumOfArray(arr, n, k, count) + ``" "``);` `    ``}` `}`   `// Driver Code` `public` `static` `void` `main(String args[])` `{` `    ``int` `arr[] = { ``5``, ``2``, ``3` `};` `    ``int` `queries[] = { ``3``, ``8``, ``7` `};` `    ``int` `n = arr.length;` `    ``int` `q = queries.length;`   `    ``sumOfXors(arr, n, queries, q);` `}` `}`   `// This code is contributed by SoumikMondal`

## Python3

 `# Python3 Program for the above approach`   `# Function to calculate sum of Bitwise` `# XOR of elements of arr[] with k` `def` `xorSumOfArray(arr, n, k, count):` `    `  `    ``# Initialize sum to be zero` `    ``sum` `=` `0` `    ``p ``=` `1`   `    ``# Iterate over each set bit` `    ``for` `i ``in` `range``(``31``):` `        `  `        ``# Stores contribution of` `        ``# i-th bet to the sum` `        ``val ``=` `0`   `        ``# If the i-th bit is set` `        ``if` `((k & (``1` `<< i)) !``=` `0``):` `            `  `            ``# Stores count of elements` `            ``# whose i-th bit is not set` `            ``not_set ``=` `n ``-` `count[i]`   `            ``# Update value` `            ``val ``=` `((not_set)``*``p)`   `        ``else``:` `            `  `            ``# Update value` `            ``val ``=` `(count[i] ``*` `p)`   `        ``# Add value to sum` `        ``sum` `+``=` `val`   `        ``# Move to the next` `        ``# power of two` `        ``p ``=` `(p ``*` `2``)`   `    ``return` `sum`   `def` `sumOfXors(arr, n, queries, q):` `    `  `    ``# Stores the count of elements` `    ``# whose i-th bit is set` `    ``count ``=` `[``0` `for` `i ``in` `range``(``32``)]`   `    ``# Traverse the array` `    ``for` `i ``in` `range``(n):` `        `  `        ``# Iterate over each bit` `        ``for` `j ``in` `range``(``31``):` `            `  `            ``# If the i-th bit is set` `            ``if` `(arr[i] & (``1` `<< j)):` `                `  `                ``# Increase count` `                ``count[j] ``+``=` `1`   `    ``for` `i ``in` `range``(q):` `        ``k ``=` `queries[i]` `        `  `        ``print``(xorSumOfArray(arr, n, k, count), end ``=` `" "``)`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    `  `    ``arr ``=` `[ ``5``, ``2``, ``3` `]` `    ``queries ``=` `[ ``3``, ``8``, ``7` `]` `    ``n ``=` `len``(arr)` `    ``q ``=` `len``(queries)` `    `  `    ``sumOfXors(arr, n, queries, q)`   `# This code is contributed by SURENDRA_GANGWAR`

## C#

 `// C# Program for the above approach` `using` `System;`   `public` `class` `GFG{` `    `  `// Function to calculate sum of Bitwise` `// XOR of elements of arr[] with k` `static` `int` `xorSumOfArray(``int` `[]arr, ``int` `n, ``int` `k, ``int` `[]count)` `{`   `    ``// Initialize sum to be zero` `    ``int` `sum = 0;` `    ``int` `p = 1;`   `    ``// Iterate over each set bit` `    ``for` `(``int` `i = 0; i < 31; i++) {`   `        ``// Stores contribution of` `        ``// i-th bet to the sum` `        ``int` `val = 0;`   `        ``// If the i-th bit is set` `        ``if` `((k & (1 << i)) != 0) {`   `            ``// Stores count of elements` `            ``// whose i-th bit is not set` `            ``int` `not_set = n - count[i];`   `            ``// Update value` `            ``val = ((not_set)*p);` `        ``}` `        ``else` `{`   `            ``// Update value` `            ``val = (count[i] * p);` `        ``}`   `        ``// Add value to sum` `        ``sum += val;`   `        ``// Move to the next` `        ``// power of two` `        ``p = (p * 2);` `    ``}`   `    ``return` `sum;` `}`   `static` `void` `sumOfXors(``int` `[]arr, ``int` `n, ``int` `[]queries, ``int` `q)` `{`   `    ``// Stores the count of elements` `    ``// whose i-th bit is set` `    ``int` `[]count = ``new` `int``[32];`   `    ``// Initialize count to 0` `    ``// for all positions` `    `  `    ``for``(``int` `i = 0; i < 32; i++)` `        ``count[i] = 0;` `        `  `    ``// Traverse the array` `    ``for` `(``int` `i = 0; i < n; i++) {`   `        ``// Iterate over each bit` `        ``for` `(``int` `j = 0; j < 31; j++) {`   `            ``// If the i-th bit is set` `            ``if` `((arr[i] & (1 << j)) != 0)`   `                ``// Increase count` `                ``count[j]++;` `        ``}` `    ``}`   `    ``for` `(``int` `i = 0; i < q; i++) {` `        ``int` `k = queries[i];` `        ``Console.Write(xorSumOfArray(arr, n, k, count) + ``" "``);` `    ``}` `}`   `// Driver Code` `static` `public` `void` `Main ()` `{` `    ``int` `[]arr = { 5, 2, 3 };` `    ``int` `[]queries = { 3, 8, 7 };`   `    ``int` `n = arr.Length;` `    ``int` `q = queries.Length;`   `    ``sumOfXors(arr, n, queries, q);` `}` `}`   `// This code is contributed by AnkThon`

## Javascript

 ``

Output:

`7 34 11`

Time Complexity: O(N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up
Recommended Articles
Page :