Skip to content
Related Articles

Related Articles

Improve Article

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[0](= 3): Flipping the 3rd bit from the right modifies arr[0] to (= 7(111)2). Now, the array becomes {7, 5}.
  • For element arr[0](= 7): Flipping the 2nd bit from the right modifies arr[0] 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 <bits/stdc++.h>
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[33] = { 0 };
 
    // Stores the count of set bits
    int fre1[33] = { 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[0]);
    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[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()
    {
        int[] arr = { 3, 5 };
        int N = arr.Length;
 
        Console.WriteLine(makeEqual(arr, N));
    }
}
 
// This code is contributed by ukasp.

Javascript




<script>
// javascript program for the above approach
    // Function to count minimum number
    // of bits required to be flipped
    // to make all array elements equal
    function makeEqual(arr , n)
    {
 
        // Stores the count of unset bits
        var fre0 = Array(33).fill(0);
 
        // Stores the count of set bits
        var fre1 = Array(33).fill(0);
 
        // Traverse the array
        for (i = 0; i < n; i++) {
            var x = arr[i];
 
            // Traverse the bit of arr[i]
            for (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
        var ans = 0;
 
        // Traverse the range [0, 32]
        for (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
        var arr = [ 3, 5 ];
        var N = arr.length;
 
        document.write(makeEqual(arr, N));
 
// This code is contributed by aashish1995
</script>
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
Recommended Articles
Page :