Skip to content
Related Articles

Related Articles

Improve Article

Count of even set bits between XOR of two arrays

  • Last Updated : 30 Apr, 2021

Given two arrays A[] and B[] having N and M positive elements respectively. The task is to count the number of elements in array A with even number of set bits in XOR for every element of array B. 
Examples: 
 

Input: A[] = { 4, 2, 15, 9, 8, 8 }, B[] = { 3, 4, 22 } 
Output: 2 4 4 
Explanation: 
Binary representation of elements of A are : 100, 10, 1111, 1001, 1000, 1000 
Binary representation of elements of B are : 11, 101, 10110 
Now for element 3(11), 
3^4 = 11^100 = 111 
3^2 = 11^10 = 01 
3^15 = 11^1111 = 1100 
3^9 = 11^1001 = 1111 
3^8 = 11^1000 = 1011 
3^8 = 11^1000 = 1011 
Only 2 elements {15, 9} in A[] are there for element 3 such that count of set bit after XOR is even. So the count is 2. 
Similarly, Count for element 4 and 22 is 4. 
Input: A[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }, B[] = { 4 } 
Output: 5 
Explanation: 
The element in A[] such that count of set bit after XOR is even is {1, 2, 4, 7, 8}. So the count is 5.
 

 

Naive Approach: The idea is to compute the XOR for every element in the array B[] with each element in the array A[] and count the number having even set bit.
Time Complexity: O(N*M), where N and M is the length of array A[] and B[] respectively.
Efficient Approach: The idea is to use the property of XOR. For any two numbers, if the count of set bit for both the numbers are even or odd then count of the set bit after XOR of both numbers is even. 
Below are the steps based on the above property: 
 

  1. Count the number of element in the array A[] having even(say a) and odd(say b) number of set bits.
  2. For each element in the array B[]: 
    • If current element have even count of set bit, then the number element in the array A[] whose XOR with the current element has even count of set bit is a.
    • If current element have odd count of set bit, then the number element in the array A[] whose XOR with the current element has even count of set bit is b.

Below is the implementation of the above approach: 
 



CPP




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function that count the XOR of B[]
// with all the element in A[] having
// even set bit
void countEvenBit(int A[], int B[], int n, int m)
{
    int i, j, cntOdd = 0, cntEven = 0;
    for (i = 0; i < n; i++) {
 
        // Count the set bits in A[i]
        int x = __builtin_popcount(A[i]);
 
        // check for even or Odd
        if (x & 1) {
            cntEven++;
        }
        else {
            cntOdd++;
        }
    }
 
    // To store the count of element for
    // B[] such that XOR with all the
    // element in A[] having even set bit
    int CountB[m];
 
    for (i = 0; i < m; i++) {
 
        // Count set bit for B[i]
        int x = __builtin_popcount(B[i]);
 
        // check for Even or Odd
        if (x & 1) {
            CountB[i] = cntEven;
        }
        else {
            CountB[i] = cntOdd;
        }
    }
 
    for (i = 0; i < m; i++) {
        cout << CountB[i] << ' ';
    }
}
 
// Driver Code
int main()
{
    int A[] = { 4, 2, 15, 9, 8, 8 };
    int B[] = { 3, 4, 22 };
 
    countEvenBit(A, B, 6, 3);
    return 0;
}
Java



// Java program for the above approach
import java.util.*;
 
class GFG{
  
// Function that count the XOR of B[]
// with all the element in A[] having
// even set bit
static void countEvenBit(int A[], int B[], int n, int m)
{
    int i, j, cntOdd = 0, cntEven = 0;
    for (i = 0; i < n; i++) {
  
        // Count the set bits in A[i]
        int x = Integer.bitCount(A[i]);
  
        // check for even or Odd
        if (x % 2 == 1) {
            cntEven++;
        }
        else {
            cntOdd++;
        }
    }
  
    // To store the count of element for
    // B[] such that XOR with all the
    // element in A[] having even set bit
    int []CountB = new int[m];
  
    for (i = 0; i < m; i++) {
  
        // Count set bit for B[i]
        int x = Integer.bitCount(B[i]);
  
        // check for Even or Odd
        if (x%2 == 1) {
            CountB[i] = cntEven;
        }
        else {
            CountB[i] = cntOdd;
        }
    }
  
    for (i = 0; i < m; i++) {
        System.out.print(CountB[i] +" ");
    }
}
  
// Driver Code
public static void main(String[] args)
{
    int A[] = { 4, 2, 15, 9, 8, 8 };
    int B[] = { 3, 4, 22 };
  
    countEvenBit(A, B, 6, 3);
}
}
 
// This code is contributed by sapnasingh4991
Python3



# Python3 program for the above approach
 
# Function that count the XOR of B
# with all the element in A having
# even set bit
def countEvenBit(A, B, n, m):
 
    i, j, cntOdd = 0, 0, 0
    cntEven = 0
    for i in range(n):
 
        # Count the set bits in A[i]
        x = bin(A[i])[2:].count('1')
 
        # check for even or Odd
        if (x & 1):
            cntEven += 1
 
        else :
            cntOdd += 1
 
    # To store the count of element for
    # B such that XOR with all the
    # element in A having even set bit
    CountB = [0]*m
 
    for i in range(m):
 
        # Count set bit for B[i]
        x = bin(B[i])[2:].count('1')
 
        # check for Even or Odd
        if (x & 1):
            CountB[i] = cntEven
 
        else:
            CountB[i] = cntOdd
 
    for i in range(m):
        print(CountB[i], end=" ")
 
# Driver Code
if __name__ == '__main__':
 
    A = [ 4, 2, 15, 9, 8, 8]
    B = [ 3, 4, 22 ]
 
    countEvenBit(A, B, 6, 3)
 
# This code is contributed by mohit kumar 29
C#



// C# program for the above approach
using System;
 
class GFG{
 
// Function that count the XOR of []B
// with all the element in []A having
// even set bit
static void countEvenBit(int []A, int []B, int n, int m)
{
    int i, cntOdd = 0, cntEven = 0;
    for (i = 0; i < n; i++)
    {
 
        // Count the set bits in A[i]
        int x = bitCount(A[i]);
 
        // check for even or Odd
        if (x % 2 == 1) {
            cntEven++;
        }
        else {
            cntOdd++;
        }
    }
 
    // To store the count of element for
    // []B such that XOR with all the
    // element in []A having even set bit
    int []CountB = new int[m];
 
    for (i = 0; i < m; i++) {
 
        // Count set bit for B[i]
        int x = bitCount(B[i]);
 
        // check for Even or Odd
        if (x % 2 == 1) {
            CountB[i] = cntEven;
        }
        else {
            CountB[i] = cntOdd;
        }
    }
 
    for (i = 0; i < m; i++) {
        Console.Write(CountB[i] +" ");
    }
}
static int bitCount(int x)
{
    int setBits = 0;
    while (x != 0) {
        x = x & (x - 1);
        setBits++;
    }
    return setBits;
}
 
// Driver Code
public static void Main(String[] args)
{
    int []A = { 4, 2, 15, 9, 8, 8 };
    int []B = { 3, 4, 22 };
 
    countEvenBit(A, B, 6, 3);
}
}
 
// This code is contributed by Rajput-Ji
Javascript



<script>
 
// Javascript program for the above approach
 
// Function that count the XOR of B[]
// with all the element in A[] having
// even set bit
function countEvenBit(A, B, n, m)
{
    let i, j, cntOdd = 0, cntEven = 0;
    for (i = 0; i < n; i++) {
 
        // Count the set bits in A[i]
        let x = bitCount(A[i]);
 
        // check for even or Odd
        if (x & 1) {
            cntEven++;
        }
        else {
            cntOdd++;
        }
    }
 
    // To store the count of element for
    // B[] such that XOR with all the
    // element in A[] having even set bit
    let CountB = new Array(m);
 
    for (i = 0; i < m; i++) {
 
        // Count set bit for B[i]
        let x = bitCount(B[i]);
 
        // check for Even or Odd
        if (x & 1) {
            CountB[i] = cntEven;
        }
        else {
            CountB[i] = cntOdd;
        }
    }
 
    for (i = 0; i < m; i++) {
        document.write(CountB[i] + " ");
    }
}
 
function bitCount(x)
{
    let setBits = 0;
    while (x != 0) {
        x = x & (x - 1);
        setBits++;
    }
    return setBits;
}
 
// Driver Code
    let A = [ 4, 2, 15, 9, 8, 8 ];
    let B = [ 3, 4, 22 ];
 
    countEvenBit(A, B, 6, 3);
 
</script>
Output: 
2 4 4
 
Time Complexity: O(N + M), where N and M are the length of the given two array respectively.
 
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
Previous
Bitwise XOR of a Binary array
Next

Compute the minimum or maximum of two integers without branching
Recommended Articles
Page :
Count of pairs {X, Y} from an array such that sum of count of set bits in X ⊕ Y and twice the count of set bits in X & Y is M
12, Mar 21
Count of triplets whose XOR has even set bits in range [L, R] for Q queries
17, Jun 21
Flip bits of the sum of count of set bits of two given numbers
03, Jan 21
Maximize count of pairs whose bitwise XOR is even by replacing such pairs with their Bitwise XOR
22, Feb 21
Check if bits of a number has count of consecutive set bits in increasing order
12, Jan 17
Find a number X such that (X XOR A) is minimum and the count of set bits in X and B are equal
20, Nov 19
Count set bits in Bitwise XOR of all adjacent elements upto N
11, Nov 20
Check if all bits can be made same by flipping two consecutive bits
09, Jan 20
Count set bits in the Kth number after segregating even and odd from N natural numbers
20, Nov 19
Number of ways to change the XOR of two numbers by swapping the bits
13, Sep 18
Print numbers having first and last bits as the only set bits
15, Jan 18
Count minimum bits to flip such that XOR of A and B equal to C
22, Feb 17
Count of even and odd set bit with array element after XOR with K
30, Mar 20
Count of even and odd set bit Array elements after XOR with K for Q queries
22, May 20
Count Pairs from two arrays with even sum
08, May 19
Count pairs with Even Product from two given arrays
11, Dec 20
Minimize sum of product of same-indexed elements of two arrays by reversing a subarray of one of the two arrays
31, May 21
Find XOR of two number without using XOR operator
21, Oct 15
XOR of all elements of array with set bits equal to K
19, Nov 18
Total distinct pairs from two arrays such that second number can be obtained by inverting bits of first
04, Apr 19
Maximum Sum of Products of two arrays by toggling adjacent bits
15, Nov 19
Maximize difference between odd and even indexed array elements by swapping unequal adjacent bits in their binary representations
22, Feb 21
Count of integers K in range [0, N] such that (K XOR K+1) equals (K+2 XOR K+3)
06, Jul 21
Toggle bits of a number except first and last bits
14, Jan 18
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Sanjeevkumar32
@Sanjeevkumar32
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox