Get the best out of our app
GeeksforGeeks App
Open App
Browser
Continue

# Total pairs in an array such that the bitwise AND, bitwise OR and bitwise XOR of LSB is 1

Given an array arr[] of size N. The task is to find the number of pairs (arr[i], arr[j]) as cntAND, cntOR, and cntXOR such that:

1. cntAND: Count of pairs where bitwise AND of least significant bits is 1.
2. cntOR: Count of pairs where bitwise OR of least significant bits is 1.
3. cntXOR: Count of pairs where bitwise XOR of least significant bits is 1.

Examples:

Input: arr[] = {1, 2, 3}
Output:
cntXOR = 2
cntAND = 1
cntOR = 3
Array elements in binary are {01, 10, 11}
Total XOR pairs: 2 i.e., (1, 2) and (2, 3)
Total AND pairs: 1 i.e., (1, 3)
Total OR pairs: 3 i.e., (1, 2), (2, 3) and (1, 3)

Input: arr[] = {1, 3, 4, 2}
Output:
cntXOR = 4
cntAND = 1
cntOR = 5

Approach:

1. To get the LSB of the elements of the array, first, we calculate the total even and odd elements. Even elements have LSB as 0 and odd elements have LSB as 1.
2. In order for
• XOR to be 1, LSB of both the elements have to be different.
• AND to be 1, LSB of both the elements have to be 1.
• OR to be 1, at least one of the elements should have it’s LSB as 1.
3. Therefore, total number of required pairs
• For XOR: cntXOR = cntOdd * cntEven
• For AND: cntAND = cntOdd * (cntOdd – 1) / 2
• For OR: cntOR = (cntOdd * cntEven) + cntOdd * (cntOdd – 1) / 2

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Function to find the count of required pairs``void` `CalculatePairs(``int` `a[], ``int` `n)``{` `    ``// To store the count of elements which``    ``// give remainder 0 i.e. even values``    ``int` `cnt_zero = 0;` `    ``// To store the count of elements which``    ``// give remainder 1 i.e. odd values``    ``int` `cnt_one = 0;` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``if` `(a[i] % 2 == 0)``            ``cnt_zero += 1;``        ``else``            ``cnt_one += 1;``    ``}` `    ``long` `int` `total_XOR_pairs = cnt_zero * cnt_one;``    ``long` `int` `total_AND_pairs = (cnt_one) * (cnt_one - 1) / 2;``    ``long` `int` `total_OR_pairs = cnt_zero * cnt_one``                              ``+ (cnt_one) * (cnt_one - 1) / 2;` `    ``cout << ``"cntXOR = "` `<< total_XOR_pairs << endl;``    ``cout << ``"cntAND = "` `<< total_AND_pairs << endl;``    ``cout << ``"cntOR = "` `<< total_OR_pairs << endl;``}` `// Driver code``int` `main()``{``    ``int` `a[] = { 1, 3, 4, 2 };``    ``int` `n = ``sizeof``(a) / ``sizeof``(a[0]);` `    ``CalculatePairs(a, n);` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.io.*;``public` `class` `GFG {` `    ``// Function to find the count of required pairs``    ``static` `void` `CalculatePairs(``int` `a[], ``int` `n)``    ``{` `        ``// To store the count of elements which``        ``// give remainder 0 i.e. even values``        ``int` `cnt_zero = ``0``;` `        ``// To store the count of elements which``        ``// give remainder 1 i.e. odd values``        ``int` `cnt_one = ``0``;` `        ``for` `(``int` `i = ``0``; i < n; i++) {` `            ``if` `(a[i] % ``2` `== ``0``)``                ``cnt_zero += ``1``;``            ``else``                ``cnt_one += ``1``;``        ``}` `        ``int` `total_XOR_pairs = cnt_zero * cnt_one;``        ``int` `total_AND_pairs = (cnt_one) * (cnt_one - ``1``) / ``2``;``        ``int` `total_OR_pairs = cnt_zero * cnt_one``                             ``+ (cnt_one) * (cnt_one - ``1``) / ``2``;` `        ``System.out.println(``"cntXOR = "` `+ total_XOR_pairs);``        ``System.out.println(``"cntAND = "` `+ total_AND_pairs);``        ``System.out.println(``"cntOR = "` `+ total_OR_pairs);``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `a[] = { ``1``, ``3``, ``4``, ``2` `};``        ``int` `n = a.length;` `        ``CalculatePairs(a, n);``    ``}``}`

## Python3

 `# Python3 program to find number of pairs` `# Function to find the count of required pairs``def` `CalculatePairs(a, n):` `    ``# To store the count of elements which``    ``# give remainder 0 i.e. even values``    ``cnt_zero ``=` `0` `    ``# To store the count of elements which``    ``# give remainder 1 i.e. odd values``    ``cnt_one ``=` `0` `    ``for` `i ``in` `range``(``0``, n):``        ``if` `(a[i] ``%` `2` `=``=` `0``):``            ``cnt_zero ``+``=` `1``        ``else``:``            ``cnt_one ``+``=` `1``    ` `    ``total_XOR_pairs ``=` `cnt_zero ``*` `cnt_one``    ``total_AND_pairs ``=` `(cnt_one) ``*` `(cnt_one ``-` `1``) ``/` `2``    ``total_OR_pairs ``=` `cnt_zero ``*` `cnt_one ``+` `(cnt_one) ``*` `(cnt_one ``-` `1``) ``/` `2` `    ``print``(``"cntXOR = "``, ``int``(total_XOR_pairs))``    ``print``(``"cntAND = "``, ``int``(total_AND_pairs))``    ``print``(``"cntOR = "``, ``int``(total_OR_pairs))``    `  `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``a ``=` `[``1``, ``3``, ``4``, ``2``]``    ``n ``=` `len``(a)``    ` `    ``# Print the count``    ``CalculatePairs(a, n)`

## C#

 `// C# implementation of the approach``using` `System;` `class` `GFG {` `    ``// Function to find the count of required pairs``    ``static` `void` `CalculatePairs(``int``[] a, ``int` `n)``    ``{` `        ``// To store the count of elements which``        ``// give remainder 0 i.e. even values``        ``int` `cnt_zero = 0;` `        ``// To store the count of elements which``        ``// give remainder 1 i.e. odd values``        ``int` `cnt_one = 0;` `        ``for` `(``int` `i = 0; i < n; i++) {` `            ``if` `(a[i] % 2 == 0)``                ``cnt_zero += 1;``            ``else``                ``cnt_one += 1;``        ``}` `        ``int` `total_XOR_pairs = cnt_zero * cnt_one;``        ``int` `total_AND_pairs = (cnt_one) * (cnt_one - 1) / 2;``        ``int` `total_OR_pairs = cnt_zero * cnt_one``                             ``+ (cnt_one) * (cnt_one - 1) / 2;` `        ``Console.WriteLine(``"cntXOR = "` `+ total_XOR_pairs);``        ``Console.WriteLine(``"cntAND = "` `+ total_AND_pairs);``        ``Console.WriteLine(``"cntOR = "` `+ total_OR_pairs);``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{``        ``int``[] a = { 1, 3, 4, 2 };``        ``int` `n = a.Length;` `        ``// Print the count``        ``CalculatePairs(a, n);``    ``}``}`

## PHP

 ``

## Javascript

 ``

Output

```cntXOR = 4
cntAND = 1
cntOR = 5```

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

My Personal Notes arrow_drop_up