Open In App

Minimize deviation of an array by given operations

Last Updated : 09 Jun, 2021
Comments
Improve
Suggest changes
Like Article
Like
Report

Given an array A[] consisting of positive integers, the task is to calculate the minimum possible deviation of the given arrayA[] after performing the following operations any number of times:

The deviation of the array A[] is the difference between the maximum and minimum element present in the array A[].

Examples:

Input: A[] = {4, 1, 5, 20, 3}
Output: 3
Explanation: Array modifies to {4, 2, 5, 5, 3} after performing given operations. Therefore, deviation = 5 - 2 = 3.

Input: A[] = {1, 2, 3, 4}
Output: 1
Explanation: Array modifies to after two operations to {2, 2, 3, 2}. Therefore, deviation = 3 - 2 = 1.

Approach: The problem can be solved based on the following observations:

  • Even numbers can be divided multiple times until it converts to an odd number.
  • Odd numbers can be doubled only once as it converts to an even number.
  • Therefore, even numbers can never be increased.

Follow the steps below to solve the problem: 
 

Below is the implementation of above approach:

C++ 
// C++ implementation of the
// above approach

#include <bits/stdc++.h>
using namespace std;

// Function to find the minimum
// deviation of the array A[]
void minimumDeviation(int A[], int N)
{
    // Store all array elements
    // in sorted order
    set<int> s;

    for (int i = 0; i < N; i++) {

        if (A[i] % 2 == 0)
            s.insert(A[i]);

        // Odd number are transformed
        // using 2nd operation
        else
            s.insert(2 * A[i]);
    }

    // (Maximum - Minimum)
    int diff = *s.rbegin() - *s.begin();

    // Check if the size of set is > 0 and
    // the maximum element is divisible by 2
    while ((int)s.size()
           && *s.rbegin() % 2 == 0) {

        // Maximum element of the set
        int maxEl = *s.rbegin();

        // Erase the maximum element
        s.erase(maxEl);

        // Using operation 1
        s.insert(maxEl / 2);

        // (Maximum - Minimum)
        diff = min(diff, *s.rbegin() - *s.begin());
    }

    // Print the Minimum
    // Deviation Obtained
    cout << diff;
}

// Driver Code
int main()
{
    int A[] = { 4, 1, 5, 20, 3 };
    int N = sizeof(A) / sizeof(A[0]);

    // Function Call to find
    // Minimum Deviation of A[]
    minimumDeviation(A, N);

    return 0;
}
Java 
// Java program for the above approach
import java.io.*;
import java.util.*;
class GFG
{

// Function to find the minimum
// deviation of the array A[]
static void minimumDeviation(int A[], int N)
{
  
    // Store all array elements
    // in sorted order
    TreeSet<Integer> s = new TreeSet<Integer>();
    for (int i = 0; i < N; i++) 
    {

        if (A[i] % 2 == 0)
            s.add(A[i]);

        // Odd number are transformed
        // using 2nd operation
        else
            s.add(2 * A[i]);
    }

    // (Maximum - Minimum)
    int diff =  s.last() -  s.first() ;

    // Check if the size of set is > 0 and
    // the maximum element is divisible by 2
    while ((s.last() % 2 == 0)) 
    {

        // Maximum element of the set
        int maxEl = s.last();

        // Erase the maximum element
        s.remove(maxEl);

        // Using operation 1
        s.add(maxEl / 2);

        // (Maximum - Minimum)
        diff = Math.min(diff, s.last() -  s.first());
    }

    // Print the Minimum
    // Deviation Obtained
    System.out.print(diff);
}

// Driver code
public static void main(String[] args)
{
    int A[] = { 4, 1, 5, 20, 3 };
    int N = A.length;

    // Function Call to find
    // Minimum Deviation of A[]
    minimumDeviation(A, N);
}
}

// This code is contributed by susmitakundugoaldanga.
Python3 
# Python 3 implementation of the
# above approach

# Function to find the minimum
# deviation of the array A[]
def minimumDeviation(A, N):

    # Store all array elements
    # in sorted order
    s = set([])

    for i in range(N):
        if (A[i] % 2 == 0):
            s.add(A[i])

        # Odd number are transformed
        # using 2nd operation
        else:
            s.add(2 * A[i])

    # (Maximum - Minimum)

    s = list(s)
    diff = s[-1] - s[0]

    # Check if the size of set is > 0 and
    # the maximum element is divisible by 2
    while (len(s) and s[-1] % 2 == 0):

        # Maximum element of the set
        maxEl = s[-1]

        # Erase the maximum element
        s.remove(maxEl)

        # Using operation 1
        s.append(maxEl // 2)

        # (Maximum - Minimum)
        diff = min(diff, s[-1] - s[0])

    # Print the Minimum
    # Deviation Obtained
    print(diff)

# Driver Code
if __name__ == "__main__":
    A = [4, 1, 5, 20, 3]
    N = len(A)

    # Function Call to find
    # Minimum Deviation of A[]
    minimumDeviation(A, N)

    # This code is contributed by chitranayal.
C# 
// C# implementation of the
// above approach
using System;
using System.Collections.Generic;
using System.Linq;
class GFG 
{
    
    // Function to find the minimum
    // deviation of the array A[]
    static void minimumDeviation(int[] A, int N)
    {
      
        // Store all array elements
        // in sorted order
        HashSet<int> s = new HashSet<int>();
        for (int i = 0; i < N; i++) 
        {
            if (A[i] % 2 == 0)
                s.Add(A[i]);
     
            // Odd number are transformed
            // using 2nd operation
            else
                s.Add(2 * A[i]);
        }
        List<int> S = s.ToList();
        S.Sort();
     
        // (Maximum - Minimum)
        int diff = S[S.Count - 1] - S[0];
     
        // Check if the size of set is > 0 and
        // the maximum element is divisible by 2
        while ((int)S.Count != 0 && S[S.Count - 1] % 2 == 0) {
     
            // Maximum element of the set
            int maxEl = S[S.Count - 1];
     
            // Erase the maximum element
            S.RemoveAt(S.Count - 1);
     
            // Using operation 1
            S.Add(maxEl / 2);
            
            S.Sort();
     
            // (Maximum - Minimum)
            diff = Math.Min(diff, S[S.Count - 1] - S[0]);
        }
     
        // Print the Minimum
        // Deviation Obtained
        Console.Write(diff);
    }

  // Driver code
  static void Main() 
  {
    int[] A = { 4, 1, 5, 20, 3 };
    int N = A.Length;
 
    // Function Call to find
    // Minimum Deviation of A[]
    minimumDeviation(A, N);
  }
}

// This code is contributed by divyeshrabadiya07.
JavaScript 
<script>


// JavaScript implementation of the
// above approach

// Function to find the minimum
// deviation of the array A[]
function minimumDeviation(A, N)
{
    // Store all array elements
    // in sorted order
    var s = new Set();

    for (var i = 0; i < N; i++) {

        if (A[i] % 2 == 0)
            s.add(A[i]);

        // Odd number are transformed
        // using 2nd operation
        else
            s.add(2 * A[i]);
    }

    var tmp = [...s].sort((a,b)=>a-b);
    // (Maximum - Minimum)
    var diff = tmp[tmp.length-1] - tmp[0];

    // Check if the size of set is > 0 and
    // the maximum element is divisible by 2
    while (s.size
           && tmp[tmp.length-1] % 2 == 0) {

        // Maximum element of the set
        var maxEl = tmp[tmp.length-1];

        // Erase the maximum element
        s.delete(maxEl);

        // Using operation 1
        s.add(parseInt(maxEl / 2));
        tmp = [...s].sort((a,b)=>a-b);
        // (Maximum - Minimum)
        diff = Math.min(diff, tmp[tmp.length-1] - tmp[0]);
    }

    // Print the Minimum
    // Deviation Obtained
    document.write( diff);
}

// Driver Code

var A = [4, 1, 5, 20, 3];
var N = A.length;

// Function Call to find
// Minimum Deviation of A[]
minimumDeviation(A, N);


</script>

 
 


Output: 
3

 

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


Next Article
Minimize deviation of an array by given operations
author
saikumarkudikala
Improve
Article Tags :
Practice Tags :

Similar Reads

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