Related Articles

# Minimum number of bits of array elements required to be flipped to make all array elements equal

• Last Updated : 06 May, 2021

Given an array arr[] consisting of N positive integers, the task is to find the minimum number of bits of array elements required to be flipped to make all array elements equal.

Examples:

Input: arr[] = {3, 5}
Output: 2
Explanation:
Following are the flipping of bits of the array elements required:

• For element arr(= 3): Flipping the 3rd bit from the right modifies arr to (= 7(111)2). Now, the array becomes {7, 5}.
• For element arr(= 7): Flipping the 2nd bit from the right modifies arr to 5 (= (101)2). Now, the array becomes {5, 5}.

After performing the above operations, all the array elements are equal. Therefore, the total number of flips of bits required is 2.

Input: arr[] = {4, 6, 3, 4, 5}
Output: 5

Approach: The given problem can be solved by modifying the array element in such a way that the number of set bits and unset bits at every position between all array elements. Follow the below steps to solve the problem:

• Initialize two frequency arrays say fre0[] and fre1[] of size 32 for counting the frequency of 0 and 1 for every bit of array elements.
• Traverse the given array and for each array element, arr[i] if the jth bit of arr[i] is a set bit, then increment the frequency of fre1[j] by 1. Otherwise, increment the frequency of fre0[j] by 1.
• After completing the above steps, print the sum of the minimum of fre0[i] and fre1[i] for each bit i over the range [0, 32].

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to count minimum number``// of bits required to be flipped``// to make all array elements equal``int` `makeEqual(``int``* arr, ``int` `n)``{``    ``// Stores the count of unset bits``    ``int` `fre0 = { 0 };` `    ``// Stores the count of set bits``    ``int` `fre1 = { 0 };` `    ``// Traverse the array``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``int` `x = arr[i];` `        ``// Traverse the bit of arr[i]``        ``for` `(``int` `j = 0; j < 33; j++) {` `            ``// If current bit is set``            ``if` `(x & 1) {` `                ``// Increment fre1[j]``                ``fre1[j] += 1;``            ``}` `            ``// Otherwise``            ``else` `{` `                ``// Increment fre0[j]``                ``fre0[j] += 1;``            ``}` `            ``// Right shift x by 1``            ``x = x >> 1;``        ``}``    ``}` `    ``// Stores the count of total moves``    ``int` `ans = 0;` `    ``// Traverse the range [0, 32]``    ``for` `(``int` `i = 0; i < 33; i++) {` `        ``// Update the value of ans``        ``ans += min(fre0[i], fre1[i]);``    ``}` `    ``// Return the minimum number of``    ``// flips required``    ``return` `ans;``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 3, 5 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);``    ``cout << makeEqual(arr, N);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.io.*;``import` `java.lang.*;``import` `java.util.*;` `class` `GFG{` `// Function to count minimum number``// of bits required to be flipped``// to make all array elements equal``static` `int` `makeEqual(``int` `arr[], ``int` `n)``{``    ` `    ``// Stores the count of unset bits``    ``int` `fre0[] = ``new` `int``[``33``];` `    ``// Stores the count of set bits``    ``int` `fre1[] = ``new` `int``[``33``];` `    ``// Traverse the array``    ``for``(``int` `i = ``0``; i < n; i++)``    ``{``        ``int` `x = arr[i];` `        ``// Traverse the bit of arr[i]``        ``for``(``int` `j = ``0``; j < ``33``; j++)``        ``{` `            ``// If current bit is set``            ``if` `((x & ``1``) != ``0``)``            ``{``                ` `                ``// Increment fre1[j]``                ``fre1[j] += ``1``;``            ``}` `            ``// Otherwise``            ``else``            ``{``                ` `                ``// Increment fre0[j]``                ``fre0[j] += ``1``;``            ``}` `            ``// Right shift x by 1``            ``x = x >> ``1``;``        ``}``    ``}` `    ``// Stores the count of total moves``    ``int` `ans = ``0``;` `    ``// Traverse the range [0, 32]``    ``for``(``int` `i = ``0``; i < ``33``; i++)``    ``{``        ` `        ``// Update the value of ans``        ``ans += Math.min(fre0[i], fre1[i]);``    ``}` `    ``// Return the minimum number of``    ``// flips required``    ``return` `ans;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `arr[] = { ``3``, ``5` `};``    ``int` `N = arr.length;``    ` `    ``System.out.print(makeEqual(arr, N));``}``}` `// This code is contributed by Kingash`

## Python3

 `# Python3 program for the above approach` `# Function to count minimum number``# of bits required to be flipped``# to make all array elements equal``def` `makeEqual(arr, n):``  ` `    ``# Stores the count of unset bits``    ``fre0 ``=` `[``0``]``*``33` `    ``# Stores the count of set bits``    ``fre1 ``=` `[``0``]``*``33``    ` `    ``# Traverse the array``    ``for` `i ``in` `range``(n):` `        ``x ``=` `arr[i]` `        ``# Traverse the bit of arr[i]``        ``for` `j ``in` `range``(``33``):` `            ``# If current bit is set``            ``if` `(x & ``1``):``                ``# Increment fre1[j]``                ``fre1[j] ``+``=` `1``            ``# Otherwise``            ``else``:``                ``# Increment fre0[j]``                ``fre0[j] ``+``=` `1``            ``# Right shift x by 1``            ``x ``=` `x >> ``1` `    ``# Stores the count of total moves``    ``ans ``=` `0` `    ``# Traverse the range [0, 32]``    ``for` `i ``in` `range``(``33``):``      ` `        ``# Update the value of ans``        ``ans ``+``=` `min``(fre0[i], fre1[i])` `    ``# Return the minimum number of``    ``# flips required``    ``return` `ans` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``arr``=` `[``3``, ``5``]``    ``N ``=` `len``(arr)``    ``print``(makeEqual(arr, N))` `# This code is contributed by mohit kumar 29.`

## C#

 `// C# program for the above approach``using` `System;``class` `GFG {` `    ``// Function to count minimum number``    ``// of bits required to be flipped``    ``// to make all array elements equal``    ``static` `int` `makeEqual(``int``[] arr, ``int` `n)``    ``{` `        ``// Stores the count of unset bits``        ``int``[] fre0 = ``new` `int``;` `        ``// Stores the count of set bits``        ``int``[] fre1 = ``new` `int``;` `        ``// Traverse the array``        ``for` `(``int` `i = 0; i < n; i++) {``            ``int` `x = arr[i];` `            ``// Traverse the bit of arr[i]``            ``for` `(``int` `j = 0; j < 33; j++) {` `                ``// If current bit is set``                ``if` `((x & 1) != 0) {` `                    ``// Increment fre1[j]``                    ``fre1[j] += 1;``                ``}` `                ``// Otherwise``                ``else` `{` `                    ``// Increment fre0[j]``                    ``fre0[j] += 1;``                ``}` `                ``// Right shift x by 1``                ``x = x >> 1;``            ``}``        ``}` `        ``// Stores the count of total moves``        ``int` `ans = 0;` `        ``// Traverse the range [0, 32]``        ``for` `(``int` `i = 0; i < 33; i++) {` `            ``// Update the value of ans``            ``ans += Math.Min(fre0[i], fre1[i]);``        ``}` `        ``// Return the minimum number of``        ``// flips required``        ``return` `ans;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main()``    ``{``        ``int``[] arr = { 3, 5 };``        ``int` `N = arr.Length;` `        ``Console.WriteLine(makeEqual(arr, N));``    ``}``}` `// This code is contributed by ukasp.`

## Javascript

 ``
Output:
`2`

Time Complexity: O(N * log N)
Auxiliary Space: O(1)

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 experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up