Related Articles

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

• Difficulty Level : Medium
• 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)

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.

My Personal Notes arrow_drop_up