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

0 0 6 minutes read

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#

// 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:

Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 zambiatek!