Skip to content
Related Articles
Count of pairs in an Array with same number of set bits
• Difficulty Level : Medium
• Last Updated : 15 Dec, 2020

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:
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 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 same number of set bits, the number of possible pairs among them is X * (X – 1) / 2.
• Print the total count of such pairs.

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 ``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 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`
Output:
`22`

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 industry experts, please refer Geeks Classes Live

My Personal Notes arrow_drop_up