Skip to content
Related Articles

Related Articles

Make all array elements equal by reducing array elements to half minimum number of times
  • Last Updated : 08 Feb, 2021

Given an array arr[] consisting of N integers, the task is to minimize the number of operations required to make all array elements equal by converting Ai to Ai / 2. in each operation

Examples:

Input: arr[] = {3, 1, 1, 3}
Output: 2
Explanation: 
Reducing A0 to A0 / 2 modifies arr[] to {1, 1, 1, 3}. 
Reducing A3 to A3 / 2 modifies arr[] to {1, 1, 1, 1}. 
Therefore, all array elements are equal, Hence, the minimum operations required is 2.

Input: arr[] = {2, 2, 2}
Output: 0

 

Approach: The idea to solve this problem is to use Greedy Approach. Below are the steps:



  • Initialize an auxiliary Map, say mp.
  • Traverse the array and for each array element, divide the element by 2 until it reduces to 1 and store the resulting number in the Map.
  • Traverse the map and find the maximum element having frequency equal to N, say mx.
  • Again, traverse the array and for each element, divide the element by 2 until it becomes equal to mx and increment count.
  • Print count as the minimum number of required operations.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find minimum number of operations
int minOperations(int arr[], int N)
{
    // Initialize map
    map<int, int> mp;
 
    // Traverse the array
    for (int i = 0; i < N; i++) {
        int res = arr[i];
 
        // Divide current array
        // element until it reduces to 1
        while (res) {
 
            mp[res]++;
            res /= 2;
        }
    }
 
    int mx = 1;
    // Traverse the map
    for (auto it : mp) {
        // Find the maximum element
        // having frequency equal to N
        if (it.second == N) {
            mx = it.first;
        }
    }
 
    // Stores the minimum number
    // of operations required
    int ans = 0;
 
    for (int i = 0; i < N; i++) {
        int res = arr[i];
 
        // Count operations required to
        // convert current element to mx
        while (res != mx) {
 
            ans++;
 
            res /= 2;
        }
    }
 
    // Print the answer
    cout << ans;
}
 
// Driver Code
int main()
{
    // Given array
    int arr[] = { 3, 1, 1, 3 };
 
    // Size of the array
    int N = sizeof(arr) / sizeof(arr[0]);
 
    minOperations(arr, N);
}


Java




// Java program to implement
// the above approach
import java.io.*;
import java.util.*;
 
class GFG{
 
  // Function to find minimum number of operations
  static void minOperations(int[] arr, int N)
  {
    // Initialize map
    HashMap<Integer,
    Integer> mp = new HashMap<Integer,
    Integer>();
 
    // Traverse the array
    for (int i = 0; i < N; i++) {
      int res = arr[i];
 
      // Divide current array
      // element until it reduces to 1
      if (mp.containsKey(res))
        mp.put(res, mp.get(res) + 1);
      else
        mp.put(res, 1);
 
      res /= 2;
    }   
    int mx = 1;
 
    for(Map.Entry<Integer, Integer> it : mp.entrySet())
    {
 
      // Find the maximum element
      // having frequency equal to N
      if (it.getValue() == N)
      {
        mx = it.getKey();
      }
    }
 
    // Stores the minimum number
    // of operations required
    int ans = 0;
 
    for (int i = 0; i < N; i++)
    {
      int res = arr[i];
 
      // Count operations required to
      // convert current element to mx
      while (res != mx)
      {
        ans++;
        res /= 2;
      }
    }
 
    // Print the answer
    System.out.println(ans);
  }      
 
  // Driver Code
  public static void main(String[] args)
  {
    // Given array
    int arr[] = { 3, 1, 1, 3 };
 
    // Size of the array
    int N = arr.length;
    minOperations(arr, N);
  }
}
 
// This code is contributed by code_hunt.


Python3




# Python program for the above approach
# Function to find minimum number of operations
def minOperations(arr, N):
   
  # Initialize map
  mp = {}
   
  # Traverse the array
  for i in range(N):
    res = arr[i]
     
    # Divide current array
    # element until it reduces to 1
    while (res):
      if res in mp:
        mp[res] += 1
      else:
        mp[res] = 1
      res //= 2
  mx = 1
   
  # Traverse the map
  for it in mp:
     
    # Find the maximum element
    # having frequency equal to N
    if (mp[it] == N):
      mx = it
       
  # Stores the minimum number
  # of operations required
  ans = 0
  for i in range(N):
    res = arr[i]
     
    # Count operations required to
    # convert current element to mx
    while (res != mx):
      ans += 1
      res //= 2
       
  # Print the answer
  print(ans)
 
# Driver Code
# Given array
arr = [ 3, 1, 1, 3 ]
 
# Size of the array
N = len(arr)
minOperations(arr, N)
 
# This code is contributed by rohitsingh07052.


C#




// C# program for the above approach
using System;
using System.Collections.Generic;
class GFG {
     
    // Function to find minimum number of operations
    static void minOperations(int[] arr, int N)
    {
        // Initialize map
        Dictionary<int, int> mp = new Dictionary<int, int>();
      
        // Traverse the array
        for (int i = 0; i < N; i++) {
            int res = arr[i];
      
            // Divide current array
            // element until it reduces to 1
            while (res > 0) {
                if(mp.ContainsKey(res))
                {
                    mp[res]++;
                }
                else{
                    mp[res] = 1;
                }
                res /= 2;
            }
        }   
        int mx = 1;
        
        foreach(KeyValuePair<int, int> it in mp)
        {
           
            // Find the maximum element
            // having frequency equal to N
            if (it.Value == N)
            {
                mx = it.Key;
            }
        }
      
        // Stores the minimum number
        // of operations required
        int ans = 0;
      
        for (int i = 0; i < N; i++)
        {
            int res = arr[i];
      
            // Count operations required to
            // convert current element to mx
            while (res != mx)
            {
                ans++;
                res /= 2;
            }
        }
      
        // Print the answer
        Console.Write(ans);
    }
 
  // Driver code
  static void Main()
  {
     
    // Given array
    int[] arr = { 3, 1, 1, 3 };
  
    // Size of the array
    int N = arr.Length;
  
    minOperations(arr, N);
  }
}
 
// This code is contributed by divyesh072019.


 
 

Output: 

2

 

Time Complexity: O(N * log(max(arr[i]))
Auxiliary Space: O(N)

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.




My Personal Notes arrow_drop_up
Recommended Articles
Page :