Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Minimize count of divisions by 2 required to make all array elements equal

  • Last Updated : 15 Jun, 2021

Given an array arr[] consisting of N positive integers, the task is to find the minimum count of divisions(integer division) of array elements by 2 to make all array elements the same.

Examples:

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.

Input: arr[] = {3, 1, 1, 3}
Output: 2
Explanation:
Operation 1: Divide arr[0] ( = 3) by 2. The array arr[] modifies to {1, 1, 1, 3}.
Operation 2: Divide arr[3] ( = 3) by 2. The array arr[] modifies to {1, 1, 1, 1}.
Therefore, the count of division operations required is 2.



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

Approach: The idea to solve the given problem is to find the maximum number to which all the elements in the array can be reduced. Follow the steps below to solve the problem:

  • Initialize a variable, say ans, to store the minimum count of division operations required.
  • Initialize a HashMap, say M, to store the frequencies of array elements.
  • Traverse the array arr[] until any array element arr[i] is found to be greater than 0. Keep dividing arr[i] by 2 and simultaneously update the frequency of the element obtained in the Map M.
  • Traverse the HashMap and find the maximum element with frequency N. Store it in maxNumber.
  • Again, traverse the array arr[] and find the number of operations required to reduce arr[i] to maxNumber by dividing arr[i] by 2 and add the count of operations to the variable ans.
  • After completing the above steps, print the value of ans as the result.

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
// division by 2 operations required to
// make all array elements equal
void makeArrayEqual(int A[], int n)
{
    // Stores the frequencies of elements
    map<int, int> mp;
 
    // Stores the maximum number to
    // which every array element
    // can be reduced to
    int max_number = 0;
 
    // Stores the minimum number
    // of operations required
    int ans = 0;
 
    // Traverse the array and store
    // the frequencies in the map
    for (int i = 0; i < n; i++) {
 
        int b = A[i];
 
        // Iterate while b > 0
        while (b) {
            mp[b]++;
 
            // Keep dividing b by 2
            b /= 2;
        }
    }
 
    // Iterate over the map to find
    // the required maximum number
    for (auto x : mp) {
 
        // Check if the frequency
        // is equal to n
        if (x.second == n) {
 
            // If true, store it in
            // max_number
            max_number = x.first;
        }
    }
 
    // Iterate over the array, A[]
    for (int i = 0; i < n; i++) {
        int b = A[i];
 
        // Find the number of operations
        // required to reduce A[i] to
        // max_number
        while (b != max_number) {
 
            // Increment the number of
            // operations by 1
            ans++;
            b /= 2;
        }
    }
 
    // Print the answer
    cout << ans;
}
 
// Driver Code
int main()
{
    int arr[] = { 3, 1, 1, 3 };
    int N = sizeof(arr) / sizeof(arr[0]);
    makeArrayEqual(arr, N);
 
    return 0;
}
Java



/*package whatever //do not write package name here */
 
import java.io.*;
import java.util.Map;
import java.util.HashMap;
 
class GFG
{
   
  // Function to count minimum number of
  // division by 2 operations required to
  // make all array elements equal
  public static void makeArrayEqual(int A[], int n)
  {
     
    // Stores the frequencies of elements
    HashMap<Integer, Integer> map = new HashMap<>();
 
    // Stores the maximum number to
    // which every array element
    // can be reduced to
    int max_number = 0;
 
    // Stores the minimum number
    // of operations required
    int ans = 0;
 
    // Traverse the array and store
    // the frequencies in the map
    for (int i = 0; i < n; i++) {
 
      int b = A[i];
 
      // Iterate while b > 0
      while (b>0) {
        Integer k = map.get(b);
        map.put(b, (k == null) ? 1 : k + 1);
 
        // Keep dividing b by 2
        b /= 2;
      }
    }
 
    // Iterate over the map to find
    // the required maximum number
    for (Map.Entry<Integer, Integer> e :
         map.entrySet()) {
 
      // Check if the frequency
      // is equal to n
      if (e.getValue() == n) {
 
        // If true, store it in
        // max_number
        max_number = e.getKey();
      }
    }
 
    // Iterate over the array, A[]
    for (int i = 0; i < n; i++) {
      int b = A[i];
 
      // Find the number of operations
      // required to reduce A[i] to
      // max_number
      while (b != max_number) {
 
        // Increment the number of
        // operations by 1
        ans++;
        b /= 2;
      }
    }
 
    // Print the answer
    System.out.println(ans + " ");
  }
 
  // Driver Code
  public static void main(String[] args)
  {
    int arr[] = { 3, 1, 1, 3 };
    int N = arr.length;
    makeArrayEqual(arr, N);
  }
}
 
// This code is contributed by aditya7409.
Python3



# Python 3 program for the above approach
 
# Function to count minimum number of
# division by 2 operations required to
# make all array elements equal
def makeArrayEqual(A, n):
   
  # Stores the frequencies of elements
  mp = dict()
 
  # Stores the maximum number to
  # which every array element
  # can be reduced to
  max_number = 0
 
  # Stores the minimum number
  # of operations required
  ans = 0
 
  # Traverse the array and store
  # the frequencies in the map
  for i in range(n):
    b = A[i]
 
      # Iterate while b > 0
    while (b>0):
      if (b in mp):
        mp[b] += 1
      else:
        mp[b] = mp.get(b,0)+1
 
      # Keep dividing b by 2
      b //= 2
 
  # Iterate over the map to find
  # the required maximum number
  for key,value in mp.items():
     
    # Check if the frequency
    # is equal to n
    if (value == n):
       
      # If true, store it in
      # max_number
      max_number = key
 
  # Iterate over the array, A[]
  for i in range(n):
    b = A[i]
 
      # Find the number of operations
      # required to reduce A[i] to
      # max_number
    while (b != max_number):
       
      # Increment the number of
      # operations by 1
      ans += 1
      b //= 2
 
  # Print the answer
  print(ans)
 
# Driver Code
if __name__ == '__main__':
  arr = [3, 1, 1, 3]
  N = len(arr)
  makeArrayEqual(arr, N)
 
  # This code is contributed by bgangwar59.
C#



using System;
using System.Collections.Generic;
 
class GFG
{
   
  // Function to count minimum number of
  // division by 2 operations required to
  // make all array elements equal
  public static void makeArrayEqual(int[] A, int n)
  {
     
    // Stores the frequencies of elements
    Dictionary<int, int> map = new Dictionary<int, int>();
 
    // Stores the maximum number to
    // which every array element
    // can be reduced to
    int max_number = 0;
 
    // Stores the minimum number
    // of operations required
    int ans = 0;
 
    // Traverse the array and store
    // the frequencies in the map
    for (int i = 0; i < n; i++) {
 
      int b = A[i];
 
      // Iterate while b > 0
      while (b > 0)
      {
        if (map.ContainsKey(b))
            map[b] ++;
        else
            map[b]=  1;
 
        // Keep dividing b by 2
        b /= 2;
      }
    }
 
    // Iterate over the map to find
    // the required maximum number
    foreach(KeyValuePair<int, int> e in map)
    {
 
      // Check if the frequency
      // is equal to n
      if (e.Value == n) {
 
        // If true, store it in
        // max_number
        max_number = e.Key;
      }
    }
 
    // Iterate over the array, A[]
    for (int i = 0; i < n; i++) {
      int b = A[i];
 
      // Find the number of operations
      // required to reduce A[i] to
      // max_number
      while (b != max_number) {
 
        // Increment the number of
        // operations by 1
        ans++;
        b /= 2;
      }
    }
 
    // Print the answer
    Console.Write(ans + " ");
  }
 
  // Driver Code
  public static void Main(String[] args)
  {
    int[] arr = { 3, 1, 1, 3 };
    int N = arr.Length;
    makeArrayEqual(arr, N);
  }
}
 
// This code is contributed by shubhamsingh10.
Javascript



<script>
 
// Javascript program for the above approach
 
// Function to count minimum number of
// division by 2 operations required to
// make all array elements equal
function makeArrayEqual(A, n)
{
     
    // Stores the frequencies of elements
    let mp = new Map();
 
    // Stores the maximum number to
    // which every array element
    // can be reduced to
    let max_number = 0;
 
    // Stores the minimum number
    // of operations required
    let ans = 0;
 
    // Traverse the array and store
    // the frequencies in the map
    for(let i = 0; i < n; i++)
    {
        let b = A[i];
 
        // Iterate while b > 0
        while (b)
        {
            if (mp.has(b))
            {
                mp.set(b, mp.get(b) + 1)
            }
            else
            {
                mp.set(b, 1)
            }
 
            // Keep dividing b by 2
            b = Math.floor(b / 2);
        }
    }
 
    // Iterate over the map to find
    // the required maximum number
    for(let x of mp)
    {
         
        // Check if the frequency
        // is equal to n
        if (x[1] == n)
        {
             
            // If true, store it in
            // max_number
            max_number = x[0];
        }
    }
 
    // Iterate over the array, A[]
    for(let i = 0; i < n; i++)
    {
        let b = A[i];
 
        // Find the number of operations
        // required to reduce A[i] to
        // max_number
        while (b != max_number)
        {
             
            // Increment the number of
            // operations by 1
            ans++;
            b = Math.floor(b / 2);
        }
    }
     
    // Print the answer
    document.write(ans);
}
 
// Driver Code
let arr = [ 3, 1, 1, 3 ];
let N = arr.length
 
makeArrayEqual(arr, N);
 
// This code is contributed by gfgking
 
</script>
Output: 
2
 
Time Complexity: O(N*log N)
Auxiliary Space: O(N)



My Personal Notes
arrow_drop_up
Previous
Minimize difference between two sequences obtained by splitting first N powers of 2
Next

Minimize cost to reach end of an array by two forward jumps or one backward jump in each move
Recommended Articles
Page :
Minimize count of divisions by D to obtain at least K equal array elements
17, Jul 20
Minimize subtraction followed by increments of adjacent elements required to make all array elements equal
22, Mar 21
Minimize count of given operations required to be performed to make all array elements equal to 1
13, Jan 21
Minimize replacements of leftmost largest array element required to make all array elements equal
28, Jun 21
Minimize cost of insertions and deletions required to make all array elements equal
19, Jan 21
Minimize flips on K-length subarrays required to make all array elements equal to 1
09, Mar 21
Minimize cost required to make all array elements greater than or equal to zero
20, Feb 21
Minimize increments required to make count of even and odd array elements equal
22, Jan 21
Minimize moves required to make array elements equal by incrementing and decrementing pairs | Set 2
20, Jul 21
Minimize count of flips required to make sum of the given array equal to 0
31, Jan 21
Minimum number of bits of array elements required to be flipped to make all array elements equal
19, Apr 21
Minimize steps required to make all array elements same by adding 1, 2 or 5
01, Sep 20
Minimize increments required to make differences between all pairs of array elements even
19, Feb 21
Minimize insertions required to make ratio of maximum and minimum of all pairs of adjacent array elements at most K
03, Mar 21
Minimize swaps required to make the first and last elements the largest and smallest elements in the array respectively
23, Mar 21
Minimize count of swaps of adjacent elements required to make an array increasing
02, Mar 21
Minimum increment and decrement by K of each pair elements required to make all array elements equal
31, Jan 21
Count decrements to nearest smaller element required to make all array elements equal
03, Nov 20
Minimize operations required to make each element of Array equal to it's index value
03, Jul 20
Minimize Bitwise XOR of array elements with 1 required to make sum of array at least K
21, Apr 21
Minimize adding odd and subtracting even numbers to make all array elements equal to K
28, Oct 20
Minimize swaps required to make all prime-indexed elements as prime
01, Oct 21
Make all array elements equal to 0 by replacing minimum subsequences consisting of equal elements
13, Jan 21
Minimum swaps of similar indexed elements required to make all elements of one of the two given arrays equal
02, Dec 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
vandanakillari54935
@vandanakillari54935
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!