Related Articles

# Minimize deviation of an array by given operations

• Difficulty Level : Hard
• Last Updated : 09 Jun, 2021

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 ``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);` `    ``// 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 s = ``new` `TreeSet();``    ``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;``     ` `        ``// 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);``        ``}``     ` `        ``// 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

 ``

Output:
`3`

Time Complexity : O(N * log(N))
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.  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