Open In App

# Minimize deviation of an array by given operations

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[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 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[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

 ``

Output:

`3`

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