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

• Difficulty Level : Basic
• 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. Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Examples:

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

Input : arr[] = {2, 4, 8}
Output: 16 18 22
Explanation:
For arr: arr ^ arr + arr ^ arr + arr ^ arr = 2^2 + 2^4 + 2^8 = 0 + 6 + 10 = 16.
For arr: arr ^ arr + arr ^ arr + arr ^ arr = 4^2 + 4^4 + 4^8 = 6 + 0 + 12 = 18
For arr: arr ^ arr + arr ^ arr + arr ^ arr = 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{};` `    ``// 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);` `    ``// 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``;``  ` `    ``// 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