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 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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <bits/stdc++.h>
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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of the approach
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);
    }
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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)

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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);
    }
}

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP implementation of the approach
  
// Function to find the count of required pairs
function 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 = 0; $i < $n; $i++) {
  
        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;
  
    echo("cntXOR = $total_XOR_pairs\n");
    echo("cntAND = $total_AND_pairs\n");
    echo("cntOR = $total_OR_pairs\n");
}
  
// Driver code
$a = array(1, 3, 4, 2);
$n = count($a);
  
// Print the count
CalculatePairs($a, $n);
?>

chevron_right


Output:

cntXOR = 4
cntAND = 1
cntOR = 5

Time Complexity: O(N)



My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.