# Sum of Bitwise XOR of each array element with all other array elements

• Difficulty Level : Easy
• Last Updated : 09 Apr, 2021

Given an array arr[] of length N, the task for every array element is to print the sum of its Bitwise XOR with all other array elements.

Examples:

Input: arr[] = {1, 2, 3}
Output: 5 4 3
Explanation:
For arr[0]: arr[0] ^ arr[0] + arr[0] ^ arr[1] + arr[0] ^ arr[2] = 1^1 + 1^2 + 1^3 = 0 + 3 + 2 = 5
For arr[1]: arr[1] ^ arr[0] + arr[1] ^ arr[1] + arr[1] ^ arr[2] = 2^1 + 2^2 + 2^3 = 3 + 0 + 1 = 4
For arr[2]: arr[2] ^ arr[0] + arr[2] ^ arr[1] + arr[2] ^ arr[2] = 3^1 + 3^2 + 3^3 = 2 + 2 + 0 = 3

Input : arr[] = {2, 4, 8}
Output: 16 18 22
Explanation:
For arr[0]: arr[0] ^ arr[0] + arr[0] ^ arr[1] + arr[0] ^ arr[2] = 2^2 + 2^4 + 2^8 = 0 + 6 + 10 = 16.
For arr[1]: arr[1] ^ arr[0] + arr[1] ^ arr[1] + arr[1] ^ arr[2] = 4^2 + 4^4 + 4^8 = 6 + 0 + 12 = 18
For arr[2]: arr[2] ^ arr[0] + arr[2] ^ arr[1] + arr[2] ^ arr[2] = 8^2 + 8^4 + 8^8 = 10 + 12 + 0 = 22

Naive Approach: The idea is to traverse the array and for each array element, traverse the array and calculate sum of its Bitwise XOR with all other array elements.

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

Efficient Approach: To` optimize the above approach, the idea is to use property of Bitwise XOR that similar bits on xor, gives 0, or 1 otherwise. Follow the below steps to solve the problem:

• Calculate the frequency of set bits at position i where 0 <= i <= 32, across all the elements of the array in a frequency array.
• For every element X, of the array, calculate the xor sum by running a loop from i=0 to 32 and check if ith bit of X is set.
• If yes, then add (N – frequency[i])*2i to the xor sum because the set bit of X at this position will make all the set bits to zero and all the unset bits to 1.
• Otherwise, add frequency[i] * 2i to the xor sum.
• Calculate the sum of all the xor sum of every element of the array and return as the answer.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to calculate for each array``// element, sum of its Bitwise XOR with``// all other array elements``void` `XOR_for_every_i(``int` `A[], ``int` `N)``{``    ``// Declare an array of size 64``    ``// to store count of each bit``    ``int` `frequency_of_bits[32]{};` `    ``// Traversing the array``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``int` `bit_position = 0;``        ``int` `M = A[i];` `        ``while` `(M) {` `            ``// Check if bit is present of not``            ``if` `(M & 1) {``                ``frequency_of_bits[bit_position] += 1;``            ``}` `            ``// Increase the bit position``            ``bit_position += 1;` `            ``// Reduce the number to half``            ``M >>= 1;``        ``}``    ``}` `    ``// Traverse the array``    ``for` `(``int` `i = 0; i < N; i++) {``        ``int` `M = A[i];` `        ``// Stores the bit position``        ``int` `value_at_that_bit = 1;` `        ``// Stores the sum of Bitwise XOR``        ``int` `XOR_sum = 0;` `        ``for` `(``int` `bit_position = 0;``             ``bit_position < 32;``             ``bit_position++) {` `            ``// Check if bit is present of not``            ``if` `(M & 1) {``                ``XOR_sum``                    ``+= (N``                        ``- frequency_of_bits[bit_position])``                       ``* value_at_that_bit;``            ``}``            ``else` `{``                ``XOR_sum``                    ``+= (frequency_of_bits[bit_position])``                       ``* value_at_that_bit;``            ``}` `            ``// Reduce the number to its half``            ``M >>= 1;` `            ``value_at_that_bit <<= 1;``        ``}` `        ``// Print the sum for A[i]``        ``cout << XOR_sum << ``' '``;``    ``}` `    ``return``;``}` `// Driver Code``int` `main()``{` `    ``// Given array``    ``int` `A[] = { 1, 2, 3 };` `    ``// Given N``    ``int` `N = ``sizeof``(A) / ``sizeof``(A[0]);` `    ``// Function Call``    ``XOR_for_every_i(A, N);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;`` ` `class` `GFG{``     ` `// Function to calculate for each array``// element, sum of its Bitwise XOR with``// all other array elements``static` `void` `XOR_for_every_i(``int` `A[], ``int` `N)``{``    ` `    ``// Declare an array of size 64``    ``// to store count of each bit``    ``int` `frequency_of_bits[] = ``new` `int``[``32``];`` ` `    ``// Traversing the array``    ``for``(``int` `i = ``0``; i < N; i++)``    ``{``        ``int` `bit_position = ``0``;``        ``int` `M = A[i];`` ` `        ``while` `(M != ``0``)``        ``{``            ` `            ``// Check if bit is present of not``            ``if` `((M & ``1``) != ``0``)``            ``{``                ``frequency_of_bits[bit_position] += ``1``;``            ``}`` ` `            ``// Increase the bit position``            ``bit_position += ``1``;`` ` `            ``// Reduce the number to half``            ``M >>= ``1``;``        ``}``    ``}`` ` `    ``// Traverse the array``    ``for``(``int` `i = ``0``; i < N; i++)``    ``{``        ``int` `M = A[i];`` ` `        ``// Stores the bit position``        ``int` `value_at_that_bit = ``1``;`` ` `        ``// Stores the sum of Bitwise XOR``        ``int` `XOR_sum = ``0``;`` ` `        ``for``(``int` `bit_position = ``0``;``                ``bit_position < ``32``;``                ``bit_position++)``        ``{``            ` `            ``// Check if bit is present of not``            ``if` `((M & ``1``) != ``0``)``            ``{``                ``XOR_sum += (N -``                            ``frequency_of_bits[bit_position]) *``                            ``value_at_that_bit;``            ``}``            ``else``            ``{``                ``XOR_sum += (frequency_of_bits[bit_position]) *``                            ``value_at_that_bit;``            ``}`` ` `            ``// Reduce the number to its half``            ``M >>= ``1``;`` ` `            ``value_at_that_bit <<= ``1``;``        ``}`` ` `        ``// Print the sum for A[i]``        ``System.out.print( XOR_sum + ``" "``);``    ``}``    ``return``;``}`` ` `// Driver code``public` `static` `void` `main(String[] args)``{``    ` `    ``// Given array``    ``int` `A[] = { ``1``, ``2``, ``3` `};`` ` `    ``// Given N``    ``int` `N = A.length;`` ` `    ``// Function Call``    ``XOR_for_every_i(A, N);``}``}` `// This code is contributed by susmitakundugoaldanga`

## Python3

 `# Python3 program for the above approach`` ` `# Function to calculate for each array``# element, sum of its Bitwise XOR with``# all other array elements``def` `XOR_for_every_i(A, N):``    ` `    ``# Declare an array of size 64``    ``# to store count of each bit``    ``frequency_of_bits ``=` `[``0``] ``*` `32`` ` `    ``# Traversing the array``    ``for` `i ``in` `range``(N):``        ``bit_position ``=` `0``        ``M ``=` `A[i]`` ` `        ``while` `(M):``            ` `            ``# Check if bit is present of not``            ``if` `(M & ``1` `!``=` `0``):``                ``frequency_of_bits[bit_position] ``+``=` `1`` ` `            ``# Increase the bit position``            ``bit_position ``+``=` `1`` ` `            ``# Reduce the number to half``            ``M >>``=` `1``    ` `    ``# Traverse the array``    ``for` `i ``in` `range``(N):``        ``M ``=` `A[i]`` ` `        ``# Stores the bit position``        ``value_at_that_bit ``=` `1`` ` `        ``# Stores the sum of Bitwise XOR``        ``XOR_sum ``=` `0`` ` `        ``for` `bit_position ``in` `range``(``32``):`` ` `            ``# Check if bit is present of not``            ``if` `(M & ``1` `!``=` `0``):``                ``XOR_sum ``+``=` `((N ``-` `frequency_of_bits[bit_position]) ``*``                            ``value_at_that_bit)``            ` `            ``else``:``                ``XOR_sum ``+``=` `((frequency_of_bits[bit_position]) ``*``                            ``value_at_that_bit)``            ` `            ``# Reduce the number to its half``            ``M >>``=` `1`` ` `            ``value_at_that_bit <<``=` `1`` ` `        ``# Print the sum for A[i]``        ``print``(XOR_sum, end ``=` `" "``)``    ` `    ``return` `# Driver Code` `# Given arr1[]``A ``=` `[ ``1``, ``2``, ``3` `]` `# Size of N``N ``=` `len``(A)`` ` `# Function Call``XOR_for_every_i(A, N)` `# This code is contributed by code_hunt`

## C#

 `// C# program for the above approach``using` `System;``class` `GFG``{``     ` `// Function to calculate for each array``// element, sum of its Bitwise XOR with``// all other array elements``static` `void` `XOR_for_every_i(``int``[] A, ``int` `N)``{``     ` `    ``// Declare an array of size 64``    ``// to store count of each bit``    ``int``[] frequency_of_bits = ``new` `int``[32];``  ` `    ``// Traversing the array``    ``for``(``int` `i = 0; i < N; i++)``    ``{``        ``int` `bit_position = 0;``        ``int` `M = A[i];``  ` `        ``while` `(M != 0)``        ``{``             ` `            ``// Check if bit is present of not``            ``if` `((M & 1) != 0)``            ``{``                ``frequency_of_bits[bit_position] += 1;``            ``}``  ` `            ``// Increase the bit position``            ``bit_position += 1;``  ` `            ``// Reduce the number to half``            ``M >>= 1;``        ``}``    ``}``  ` `    ``// Traverse the array``    ``for``(``int` `i = 0; i < N; i++)``    ``{``        ``int` `M = A[i];``  ` `        ``// Stores the bit position``        ``int` `value_at_that_bit = 1;``  ` `        ``// Stores the sum of Bitwise XOR``        ``int` `XOR_sum = 0;``  ` `        ``for``(``int` `bit_position = 0;``                ``bit_position < 32;``                ``bit_position++)``        ``{``             ` `            ``// Check if bit is present of not``            ``if` `((M & 1) != 0)``            ``{``                ``XOR_sum += (N -``                            ``frequency_of_bits[bit_position]) *``                            ``value_at_that_bit;``            ``}``            ``else``            ``{``                ``XOR_sum += (frequency_of_bits[bit_position]) *``                            ``value_at_that_bit;``            ``}``  ` `            ``// Reduce the number to its half``            ``M >>= 1; ``            ``value_at_that_bit <<= 1;``        ``}``  ` `        ``// Print the sum for A[i]``        ``Console.Write( XOR_sum + ``" "``);``    ``}``    ``return``;``}`` ` `// Driver Code``public` `static` `void` `Main()``{``  ` `    ``// Given array``    ``int``[] A = { 1, 2, 3 };``  ` `    ``// Given N``    ``int` `N = A.Length;``  ` `    ``// Function Call``    ``XOR_for_every_i(A, N);``}``}` `// This code is contributed by sanjoy_62`

## Javascript

 ``

Output:

`5 4 3`

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

My Personal Notes arrow_drop_up