Count of pairs in an Array with same number of set bits

Last Updated : 15 Jun, 2021

Given an array arr containing N integers, the task is to count the possible number of pairs of elements with the same number of set bits.

Examples:

Input: N = 8, arr[] = {1, 2, 3, 4, 5, 6, 7, 8}
Output: 9
Explanation:
Elements with 1 set bit: 1, 2, 4, 8
Elements with 2 set bits: 3, 5, 6
Elements with 3 set bits: 7
Hence, {1, 2}, {1, 4}, {1, 8}, {2, 4}, {2, 8}, {4, 8}, {3, 5}, {3, 6}, and {5, 6} are the possible such pairs.

Input: N = 12, arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}
Output: 22

Approach:

Precompute and store the set bits for all numbers up to the maximum element of the array in bitscount[]. For all powers of 2, store 1 at their respective index. After that, compute the set bits count for the remaining elements by the relation:

bitscount[i] = bitscount[previous power of 2] + bitscount[i - previous power of 2]

Store the frequency of set bits in the array elements in a Map.
Add the number of possible pairs for every set bit count. If X elements have the same number of set bits, the number of possible pairs among them is X * (X - 1) / 2.
Print the total count of such pairs.

The below code is the implementation of the above approach:

C++14

// C++ Program to count
// possible number of pairs
// of elements with same
// number of set bits.

#include <bits/stdc++.h>
using namespace std;

// Function to return the
// count of Pairs
int countPairs(int arr[], int N)
{
    // Get the maximum element
    int maxm = *max_element(arr, arr + N);

    int i, k;
    // Array to store count of bits
    // of all elements upto maxm
    int bitscount[maxm + 1] = { 0 };

    // Store the set bits
    // for powers of 2
    for (i = 1; i <= maxm; i *= 2)
        bitscount[i] = 1;
    // Compute the set bits for
    // the remaining elements
    for (i = 1; i <= maxm; i++) {
        if (bitscount[i] == 1)
            k = i;
        if (bitscount[i] == 0) {
            bitscount[i]
                = bitscount[k]
                  + bitscount[i - k];
        }
    }

    // Store the frequency
    // of respective counts
    // of set bits
    map<int, int> setbits;
    for (int i = 0; i < N; i++) {
        setbits[bitscount[arr[i]]]++;
    }

    int ans = 0;
    for (auto it : setbits) {
        ans += it.second
               * (it.second - 1) / 2;
    }

    return ans;
}

int main()
{
    int N = 12;
    int arr[] = { 1, 2, 3, 4, 5, 6, 7,
                  8, 9, 10, 11, 12 };

    cout << countPairs(arr, N);

    return 0;
}

Java

// Java program to count possible 
// number of pairs of elements 
// with same number of set bits
import java.util.*;
import java.lang.*;

class GFG{
    
// Function to return the 
// count of Pairs 
static int countPairs(int []arr, int N) 
{ 
    
    // Get the maximum element 
    int maxm = arr[0]; 
      
    for(int j = 1; j < N; j++) 
    { 
        if (maxm < arr[j]) 
        { 
            maxm = arr[j]; 
        } 
    } 
  
    int i, k = 0; 
      
    // Array to store count of bits 
    // of all elements upto maxm 
    int[] bitscount = new int[maxm + 1]; 
    Arrays.fill(bitscount, 0); 
  
    // Store the set bits 
    // for powers of 2 
    for(i = 1; i <= maxm; i *= 2) 
        bitscount[i] = 1; 
          
    // Compute the set bits for 
    // the remaining elements 
    for(i = 1; i <= maxm; i++) 
    { 
        if (bitscount[i] == 1) 
            k = i; 
        if (bitscount[i] == 0) 
        { 
            bitscount[i] = bitscount[k] +  
                           bitscount[i - k]; 
        }
    } 
  
    // Store the frequency 
    // of respective counts 
    // of set bits 
    Map<Integer, Integer> setbits = new HashMap<>(); 
      
    for(int j = 0; j < N; j++)  
    { 
        setbits.put(bitscount[arr[j]],
        setbits.getOrDefault(
            bitscount[arr[j]], 0) + 1); 
    } 
  
    int ans = 0; 
  
    for(int it : setbits.values())
    { 
        ans += it * (it - 1) / 2; 
      
    } 
    return ans; 
} 

// Driver code
public static void main(String[] args)
{
    int N = 12; 
    int []arr = { 1, 2, 3, 4, 5, 6, 7, 
                  8, 9, 10, 11, 12 }; 
    
    System.out.println(countPairs(arr, N)); 
}
}

// This code is contributed by offbeat

Python3

# Python3 program to count possible number
# of pairs of elements with same number
# of set bits.
 
# Function to return the
# count of Pairs
def countPairs(arr, N):
    
    # Get the maximum element
    maxm = max(arr)
    i = 0
    k = 0
    
    # Array to store count of bits
    # of all elements upto maxm
    bitscount = [0 for i in range(maxm + 1)]
    
    i = 1
    
    # Store the set bits
    # for powers of 2
    while i <= maxm:
        bitscount[i] = 1
        i *= 2
        
    # Compute the set bits for
    # the remaining elements
    for i in range(1, maxm + 1):
        if (bitscount[i] == 1):
            k = i
        if (bitscount[i] == 0):
            bitscount[i] = (bitscount[k] + 
                            bitscount[i - k])
 
    # Store the frequency
    # of respective counts
    # of set bits
    setbits = dict()
    
    for i in range(N):
        if bitscount[arr[i]] in setbits:
            setbits[bitscount[arr[i]]] += 1
        else:
            setbits[bitscount[arr[i]]] = 1
 
    ans = 0
    
    for it in setbits.values():
        ans += it * (it - 1) // 2
 
    return ans
 
# Driver Code
if __name__=='__main__':
    
    N = 12
    arr = [ 1, 2, 3, 4, 5, 6, 7,
            8, 9, 10, 11, 12 ]
 
    print(countPairs(arr, N))
 
# This code is contributed by pratham76

// C# program to count
// possible number of pairs
// of elements with same
// number of set bits.
using System; 
using System.Collections; 
using System.Collections.Generic; 
using System.Text; 

class GFG{
    
// Function to return the
// count of Pairs
static int countPairs(int []arr, int N)
{
    
    // Get the maximum element
    int maxm = -int.MaxValue;
    
    for(int j = 0; j < N; j++)
    {
        if (maxm < arr[j])
        {
            maxm = arr[j];
        }
    }

    int i, k = 0;
    
    // Array to store count of bits
    // of all elements upto maxm
    int []bitscount = new int[maxm + 1];
    Array.Fill(bitscount, 0);

    // Store the set bits
    // for powers of 2
    for(i = 1; i <= maxm; i *= 2)
        bitscount[i] = 1;
        
    // Compute the set bits for
    // the remaining elements
    for(i = 1; i <= maxm; i++)
    {
        if (bitscount[i] == 1)
            k = i;
        if (bitscount[i] == 0)
        {
            bitscount[i] = bitscount[k] + 
                           bitscount[i - k];
        }
    }

    // Store the frequency
    // of respective counts
    // of set bits
    Dictionary<int, 
               int> setbits = new Dictionary<int,
                                             int>();
    
    for(int j = 0; j < N; j++) 
    {
        if (setbits.ContainsKey(bitscount[arr[j]]))
        {
            setbits[bitscount[arr[j]]]++; 
        }
        else
        {
            setbits[bitscount[arr[j]]] = 1;
        }
    }

    int ans = 0;

    foreach(KeyValuePair<int, int> it in setbits) 
    {
        ans += it.Value * (it.Value - 1) / 2;
    }
    return ans;
}
    
// Driver Code
public static void Main(string[] args)
{
    int N = 12;
    int []arr = { 1, 2, 3, 4, 5, 6, 7,
                  8, 9, 10, 11, 12 };

    Console.Write(countPairs(arr, N));
}
}

// This code is contributed by rutvik_56

JavaScript

<script>

// Javascript Program to count
// possible number of pairs
// of elements with same
// number of set bits.

// Function to return the
// count of Pairs
function countPairs(arr, N)
{
    // Get the maximum element
    var maxm = arr.reduce((a,b)=>Math.max(a,b));

    var i, k;
    // Array to store count of bits
    // of all elements upto maxm
    var bitscount = Array(maxm+1).fill(0);

    // Store the set bits
    // for powers of 2
    for (i = 1; i <= maxm; i *= 2)
        bitscount[i] = 1;
    // Compute the set bits for
    // the remaining elements
    for (i = 1; i <= maxm; i++) {
        if (bitscount[i] == 1)
            k = i;
        if (bitscount[i] == 0) {
            bitscount[i]
                = bitscount[k]
                  + bitscount[i - k];
        }
    }

    // Store the frequency
    // of respective counts
    // of set bits
    var setbits = new Map();
    for (var i = 0; i < N; i++) {

        if(setbits.has(bitscount[arr[i]]))
            setbits.set(bitscount[arr[i]], 
             setbits.get(bitscount[arr[i]])+1)
        else
            setbits.set(bitscount[arr[i]], 1)
    }

    var ans = 0;

    setbits.forEach((value, key) => {
        ans += value
               * (value - 1) / 2;
    });

    return ans;
}

var N = 12;
var arr = [1, 2, 3, 4, 5, 6, 7,
              8, 9, 10, 11, 12];
document.write( countPairs(arr, N));


</script>

Output:

Number of Good Pairs - Count of index pairs with equal values in an array

noob_coder123

Improve

Article Tags :

Practice Tags :

Count of pairs in an Array with same number of set bits

Similar Reads

Thank You!

What kind of Experience do you want to share?