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

• Difficulty Level : Medium
• 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:
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 ` `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`

## Javascript

 ``

Output:

`22`

My Personal Notes arrow_drop_up
Recommended Articles
Page :