Skip to content
Related Articles
Minimize steps required to make all array elements same by adding 1, 2 or 5
• Last Updated : 29 Apr, 2021

Given an array arr[] of size N, the task is to count the minimum number of steps required to make all the array elements the same by adding 1, 2, or 5 to exactly (N – 1) elements of the array at each step.

Examples:

Input: N = 4, arr[] = {2, 2, 3, 7}
Output: 2
Explanation:
Step 1: {2, 2, 3, 7} -> {3, 3, 3, 8}
Step 2: {3, 3, 3, 8} -> {8, 8, 8, 8}

Input: N = 3, arr[] = {10, 7, 12}
Output: 3

Naive Approach: The simplest approach is to try all possible combinations recursively of adding numbers 1, 2, and 5 such that all the elements become the same and calculate the number of steps required for all such combinations. Finally, print the minimum of them as the required answer.

Time Complexity: O(MM), where M is the maximum element present in the array.
Auxiliary Space: O(1)

Efficient Approach: The above approach can be optimized by the following observations:

• Adding a number K to all indices except one (say index X) is the same as removing K from the value at index X.
• This reduces the bound to search for the final array element to lower than equal to the minimum value present in the given array.
• Let the minimum value be A, then the final value after optimal operations can either be A, A – 1, or A – 2.
• The reason A – 3 and so on are not considered in the calculation is because A + 1 takes 2 steps to reach there (-1, -2 ), A + 2 requires one step in reaching A – 3 (- 5) but can easily reach A requires in a single step(A+1 requires 1 step(-1) to reach A and A + 2 requires 1 step(-2) to reach A).
• Also, A + 3 requires 2 steps (-5, -1) to reach A – 3 and 2 steps to reach A again (-1, -2).
• Therefore, A – 3 or any lower bases are not needed to be considered.

Therefore, the idea is to find the count of operations required to reduce all the array elements to their minimum element(say minE), minE – 1, and minE – 2 by subtracting 1, 2, and 5. Print the minimum among the above three operations.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to calculate the minimum``// number of steps``int` `calculate_steps(``int` `arr[], ``int` `n,``                    ``int` `minimum)``{``    ``// count stores number of operations``    ``// required to make all elements``    ``// equal to minimum value``    ``int` `count = 0;` `    ``// Remark, the array should remain``    ``// unchanged for further calculations``    ``// with different minumum``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// Storing the current value of``        ``// arr[i] in val``        ``int` `val = arr[i];` `        ``if` `(arr[i] > minimum) {` `            ``// Finds how much extra amount``            ``// is to be removed``            ``arr[i] = arr[i] - minimum;` `            ``// Subtract the maximum number``            ``// of 5 and stores remaining``            ``count += arr[i] / 5;` `            ``arr[i] = arr[i] % 5;` `            ``// Subtract the maximum number``            ``// of 2 and stores remaining``            ``count += arr[i] / 2;` `            ``arr[i] = arr[i] % 2;` `            ``if` `(arr[i]) {``                ``count++;``            ``}``        ``}` `        ``// Restores the actual value``        ``// of arr[i]``        ``arr[i] = val;``    ``}` `    ``// Return the count``    ``return` `count;``}` `// Function to find the minimum number``// of steps to make array elements same``int` `solve(``int` `arr[], ``int` `n)``{` `    ``// Sort the array in descending order``    ``sort(arr, arr + n, greater<``int``>());` `    ``// Stores the minimum array element``    ``int` `minimum = arr[n - 1];` `    ``int` `count1 = 0, count2 = 0, count3 = 0;` `    ``// Stores the operations required``    ``// to make array elements equal to minimum``    ``count1 = calculate_steps(arr, n, minimum);` `    ``// Stores the operations required``    ``// to make array elements equal to minimum - 1``    ``count2 = calculate_steps(arr, n, minimum - 1);` `    ``// Stores the operations required``    ``// to make array elements equal to minimum - 2``    ``count3 = calculate_steps(arr, n, minimum - 2);` `    ``// Return minimum of the three counts``    ``return` `min(count1, min(count2, count3));``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 3, 6, 6 };` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);``    ``cout << solve(arr, N);``}`

## Java

 `// Java program for the above approach``import` `java.util.*;``class` `GFG{` `// Function to calculate the minimum``// number of steps``static` `int` `calculate_steps(Integer arr[],``                           ``int` `n, ``int` `minimum)``{``    ``// count stores number of operations``    ``// required to make all elements``    ``// equal to minimum value``    ``int` `count = ``0``;` `    ``// Remark, the array should remain``    ``// unchanged for further calculations``    ``// with different minumum``    ``for` `(``int` `i = ``0``; i < n; i++)``    ``{``        ``// Storing the current value of``        ``// arr[i] in val``        ``int` `val = arr[i];` `        ``if` `(arr[i] > minimum)``        ``{``            ``// Finds how much extra amount``            ``// is to be removed``            ``arr[i] = arr[i] - minimum;` `            ``// Subtract the maximum number``            ``// of 5 and stores remaining``            ``count += arr[i] / ``5``;` `            ``arr[i] = arr[i] % ``5``;` `            ``// Subtract the maximum number``            ``// of 2 and stores remaining``            ``count += arr[i] / ``2``;` `            ``arr[i] = arr[i] % ``2``;` `            ``if` `(arr[i] > ``0``)``            ``{``                ``count++;``            ``}``        ``}` `        ``// Restores the actual value``        ``// of arr[i]``        ``arr[i] = val;``    ``}` `    ``// Return the count``    ``return` `count;``}` `// Function to find the minimum number``// of steps to make array elements same``static` `int` `solve(Integer arr[], ``int` `n)``{` `    ``// Sort the array in descending order``     ``Arrays.sort(arr, Collections.reverseOrder());` `    ``// Stores the minimum array element``    ``int` `minimum = arr[n - ``1``];` `    ``int` `count1 = ``0``, count2 = ``0``, count3 = ``0``;` `    ``// Stores the operations required``    ``// to make array elements equal``    ``// to minimum``    ``count1 = calculate_steps(arr, n,``                             ``minimum);` `    ``// Stores the operations required``    ``// to make array elements equal to``    ``// minimum - 1``    ``count2 = calculate_steps(arr, n,``                             ``minimum - ``1``);` `    ``// Stores the operations required``    ``// to make array elements equal to``    ``// minimum - 2``    ``count3 = calculate_steps(arr, n,``                             ``minimum - ``2``);` `    ``// Return minimum of the three counts``    ``return` `Math.min(count1, Math.min(count2,``                                     ``count3));``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``Integer arr[] = {``3``, ``6``, ``6``};``    ``int` `N = arr.length;``    ``System.out.print(solve(arr, N));``}``}``// This code is contributed by Rajput-Ji`

## Python3

 `# Python3 program for the above approach` `# Function to calculate the minimum``# number of steps``def` `calculate_steps(arr, n, minimum):` `    ``# count stores number of operations``    ``# required to make all elements``    ``# equal to minimum value``    ``count ``=` `0` `    ``# Remark, the array should remain``    ``# unchanged for further calculations``    ``# with different minumum``    ``for` `i ``in` `range``(n):` `        ``# Storing the current value of``        ``# arr[i] in val``        ``val ``=` `arr[i]` `        ``if` `(arr[i] > minimum):` `            ``# Finds how much extra amount``            ``# is to be removed``            ``arr[i] ``=` `arr[i] ``-` `minimum` `            ``# Subtract the maximum number``            ``# of 5 and stores remaining``            ``count ``+``=` `arr[i] ``/``/` `5` `            ``arr[i] ``=` `arr[i] ``%` `5` `            ``# Subtract the maximum number``            ``# of 2 and stores remaining``            ``count ``+``=` `arr[i] ``/``/` `2` `            ``arr[i] ``=` `arr[i] ``%` `2` `            ``if` `(arr[i]):``                ``count ``+``=` `1` `        ``# Restores the actual value``        ``# of arr[i]``        ``arr[i] ``=` `val` `    ``# Return the count``    ``return` `count` `# Function to find the minimum number``# of steps to make array elements same``def` `solve(arr, n):` `    ``# Sort the array in descending order``    ``arr ``=` `sorted``(arr)``    ``arr ``=` `arr[::``-``1``]` `    ``# Stores the minimum array element``    ``minimum ``=` `arr[n ``-` `1``]` `    ``count1 ``=` `0``    ``count2 ``=` `0``    ``count3 ``=` `0` `    ``# Stores the operations required``    ``# to make array elements equal to minimum``    ``count1 ``=` `calculate_steps(arr, n, minimum)` `    ``# Stores the operations required``    ``# to make array elements equal to minimum - 1``    ``count2 ``=` `calculate_steps(arr, n, minimum ``-` `1``)` `    ``# Stores the operations required``    ``# to make array elements equal to minimum - 2``    ``count3 ``=` `calculate_steps(arr, n, minimum ``-` `2``)` `    ``# Return minimum of the three counts``    ``return` `min``(count1, ``min``(count2, count3))` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``arr ``=` `[ ``3``, ``6``, ``6` `]``    ``N ``=` `len``(arr)``    ` `    ``print``(solve(arr, N))` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for the above approach` `using` `System;` `public` `class` `GFG{` `// Function to calculate the minimum``// number of steps``static` `int` `calculate_steps(``int` `[]arr, ``int` `n,``                    ``int` `minimum)``{``    ``// count stores number of operations``    ``// required to make all elements``    ``// equal to minimum value``    ``int` `count = 0;` `    ``// Remark, the array should remain``    ``// unchanged for further calculations``    ``// with different minumum``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// Storing the current value of``        ``// arr[i] in val``        ``int` `val = arr[i];` `        ``if` `(arr[i] > minimum) {` `            ``// Finds how much extra amount``            ``// is to be removed``            ``arr[i] = arr[i] - minimum;` `            ``// Subtract the maximum number``            ``// of 5 and stores remaining``            ``count += arr[i] / 5;` `            ``arr[i] = arr[i] % 5;` `            ``// Subtract the maximum number``            ``// of 2 and stores remaining``            ``count += arr[i] / 2;` `            ``arr[i] = arr[i] % 2;` `            ``if` `(arr[i]>0) {``                ``count++;``            ``}``        ``}` `        ``// Restores the actual value``        ``// of arr[i]``        ``arr[i] = val;``    ``}` `    ``// Return the count``    ``return` `count;``}` `// Function to find the minimum number``// of steps to make array elements same``static` `int` `solve(``int` `[]arr, ``int` `n)``{` `    ``// Sort the array in descending order``    ``Array.Sort(arr);``    ``Array.Reverse(arr);``    ``// Stores the minimum array element``    ``int` `minimum = arr[n - 1];` `    ``int` `count1 = 0, count2 = 0, count3 = 0;` `    ``// Stores the operations required``    ``// to make array elements equal to minimum``    ``count1 = calculate_steps(arr, n, minimum);` `    ``// Stores the operations required``    ``// to make array elements equal to minimum - 1``    ``count2 = calculate_steps(arr, n, minimum - 1);` `    ``// Stores the operations required``    ``// to make array elements equal to minimum - 2``    ``count3 = calculate_steps(arr, n, minimum - 2);` `    ``// Return minimum of the three counts``    ``return` `Math.Min(count1, Math.Min(count2, count3));``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int` `[]arr = { 3, 6, 6 };` `    ``int` `N = arr.Length;``    ``Console.Write(solve(arr, N));``}``}`` `  `// This code contributed by Rajput-Ji`

## Javascript

 ``
Output:
`3`

Time Complexity: O(N), where N is the size of the given array.
Auxiliary Space: O(1)

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 industry experts, please refer Geeks Classes Live

My Personal Notes arrow_drop_up