Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

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[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 <bits/stdc++.h>
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




<script>
// JavaScript program for the above approach
 
     
// Function to calculate for each array
// element, sum of its Bitwise XOR with
// all other array elements
function XOR_for_every_i(A, N)
{
     
    // Declare an array of size 64
    // to store count of each bit
    let frequency_of_bits = new Uint8Array(32);
 
    // Traversing the array
    for(let i = 0; i < N; i++)
    {
        let bit_position = 0;
        let 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(let i = 0; i < N; i++)
    {
        let M = A[i];
 
        // Stores the bit position
        let value_at_that_bit = 1;
 
        // Stores the sum of Bitwise XOR
        let XOR_sum = 0;
        for(let 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]
        document.write( XOR_sum + " ");
    }
    return;
}
 
// Driver code
     
    // Given array
    let A = [ 1, 2, 3 ];
 
    // Given N
    let N = A.length;
 
    // Function Call
    XOR_for_every_i(A, N);
 
// This code is contributed by Surbhi Tyagi.
</script>
Output: 
5 4 3

 

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

 




My Personal Notes arrow_drop_up
Recommended Articles
Page :