Open In App

# Minimum number of increment-other operations to make all array elements equal.

We are given an array consisting of n elements. At each operation you can select any one element and increase rest of n-1 elements by 1. You have to make all elements equal performing such operation as many times you wish. Find the minimum number of operations needed for this.

Examples:

```Input : arr[] = {1, 2, 3}
Output : Minimum Operation = 3
Explanation :
operation | increased elements | after increment
1     |    1, 2            | 2, 3, 3
2     |    1, 2            | 3, 4, 3
3     |    1, 3            | 4, 4, 4

Input : arr[] = {4, 3, 4}
Output : Minimum Operation = 2
Explanation :
operation | increased elements | after increment
1    |    1, 2           | 5, 4, 4
2    |    2, 3           | 5, 5, 5```

Brute force : A simple way to make all elements equal is that at each step find the largest elements and then increase all rest n-1 elements by 1. We should keep doing this operation till all elements become equal. Time Complexity : O(n^2)

Better Approach : If we took a closer look at each operation as well problem statement we will find that increasing all n-1 element except the largest one is similar to decreasing the largest element only. So, the smallest elements need not to decrease any more and rest of elements will got decremented upto smallest one. In this way the total number of operation required for making all elements equal will be arraySum – n * (smallestElement). Time complexity will be same as that of finding smallest elements and array sum i.e. O(n).

```// find array sum
sum = arraySum (int arr[], int n);

// find the smallest element from array
small = smallest (int arr, int n);

// calculate min operation required
minOperation = sum - (n * small);

// return result
return minOperation;```

Implementation:

## C++

 `// CPP for finding minimum operation required``#include ``using` `namespace` `std;`` ` `// function for finding array sum``int` `arraySum(``int` `arr[], ``int` `n)``{``    ``int` `sum = 0;``    ``for` `(``int` `i = 0; i < n; i++)``        ``sum += arr[i];``    ``return` `sum;``}`` ` `// function for finding smallest element``int` `smallest(``int` `arr[], ``int` `n)``{``    ``int` `small = INT_MAX;``    ``for` `(``int` `i = 0; i < n; i++)``        ``if` `(arr[i] < small)``            ``small = arr[i];``    ``return` `small;``}`` ` `// function for finding min operation``int` `minOp(``int` `arr[], ``int` `n)``{``    ``// find array sum``    ``int` `sum = arraySum(arr, n);``    ``// find the smallest element from array``    ``int` `small = smallest(arr, n);``    ``// calculate min operation required``    ``int` `minOperation = sum - (n * small);``    ``// return result``    ``return` `minOperation;``}`` ` `// driver function``int` `main()``{``    ``int` `arr[] = { 5, 6, 2, 4, 3 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);``    ``cout << ``"Minimum Operation = "` `<< minOp(arr, n);``    ``return` `0;``}`` ` `// This code is contributed by Sania Kumari Gupta`

## C++

 `// [STL] - CPP for finding minimum operation required ``#include``using` `namespace` `std;`` ` `// function for finding min operation``int` `minOp (``int` `arr[], ``int` `n)``{``    ``// find array sum``    ``int` `sum = accumulate(arr,arr+n,0);``    ``// find the smallest element from array``    ``int` `small = *min_element(arr,arr+n);``    ``// calculate min operation required``    ``int` `minOperation = sum - (n * small);``    ``// return result``    ``return` `minOperation;``}`` ` `//driver function``int` `main()``{``    ``int` `arr[] = {5, 6, 2, 4, 3};``    ``int` `n = ``sizeof``(arr)/ ``sizeof``(arr[0]);``    ``cout << ``"Minimum Operation = "` `<< minOp (arr, n);``    ``return` `0;``} `` ` `// This code is contributed by Sania Kumari Gupta`

## C

 `// C for finding minimum operation required``#include ``#include `` ` `// function for finding array sum``int` `arraySum(``int` `arr[], ``int` `n)``{``    ``int` `sum = 0;``    ``for` `(``int` `i = 0; i < n; i++)``        ``sum += arr[i];``    ``return` `sum;``}`` ` `// function for finding smallest element``int` `smallest(``int` `arr[], ``int` `n)``{``    ``int` `small = INT_MAX;``    ``for` `(``int` `i = 0; i < n; i++)``        ``if` `(arr[i] < small)``            ``small = arr[i];``    ``return` `small;``}`` ` `// function for finding min operation``int` `minOp(``int` `arr[], ``int` `n)``{``    ``// find array sum``    ``int` `sum = arraySum(arr, n);``    ``// find the smallest element from array``    ``int` `small = smallest(arr, n);``    ``// calculate min operation required``    ``int` `minOperation = sum - (n * small);``    ``// return result``    ``return` `minOperation;``}`` ` `// driver function``int` `main()``{``    ``int` `arr[] = { 5, 6, 2, 4, 3 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);``    ``printf``(``"Minimum Operation = %d"``, minOp(arr, n));``    ``return` `0;``}`` ` `// This code is contributed by Sania Kumari Gupta`

## Java

 `// Java program to find min operation``import` `java.io.*;`` ` `class` `minOperation {``    ``// Function to print minimum operation required to make``    ``// all elements of an array equal``    ``static` `void` `printMinOp(``int` `arr[])``    ``{``        ``int` `arraySum, smallest, arr_size = arr.length;``        ``arraySum = ``0``;``        ``smallest = arr[``0``];``        ``for` `(``int` `i = ``0``; i < arr_size; i++) {``            ``// If current element is smaller than update smallest``            ``if` `(arr[i] < smallest)``                ``smallest = arr[i];`` ` `            ``// find array sum``            ``arraySum += arr[i];``        ``}`` ` `        ``int` `minOperation = arraySum - arr_size * smallest;`` ` `        ``// Print min operation required``        ``System.out.println(``"Minimum Operation = "` `+ minOperation);``    ``}`` ` `    ``// Driver program to test above functions``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `arr[] = { ``5``, ``6``, ``2``, ``4``, ``3` `};``        ``printMinOp(arr);``    ``}``}`` ` `// This code is contributed by Sania Kumari Gupta`

## Python3

 `# Python 3 for finding minimum ``# operation required`` ` `# function for finding min``# operation``def` `minOp (arr, n) :``     ` `    ``# find array sum``    ``sm ``=` `sum``(arr)`` ` `    ``# find the smallest element from ``    ``# array``    ``small ``=` `min``(arr)`` ` `    ``# calculate min operation required``    ``minOperation ``=` `sm ``-` `(n ``*` `small)`` ` `    ``# return result``    ``return` `minOperation``     ` `# Driver function``arr ``=` `[``5``, ``6``, ``2``, ``4``, ``3``]``n ``=` `len``(arr)``print``( ``"Minimum Operation = "``, minOp (arr, n))`` ` `# This code is contributed by Shubham Singh`

## C#

 `// C# program to find min operation``using` `System;`` ` `class` `GFG {``     ` `    ``/* Function to print minimum ``    ``operation required to make all``    ``elements of an array equal */``    ``static` `void` `printMinOp(``int` `[]arr)``    ``{``        ``int` `arraySum, smallest, ``        ``arr_size = arr.Length;``        ``arraySum = 0;``        ``smallest = arr[0];``         ` `        ``for` `(``int` `i = 0; i < arr_size ; i ++)``        ``{``            ``/* If current element is ``            ``smaller than update smallest */``            ``if` `(arr[i] < smallest)         ``                ``smallest = arr[i];         `` ` `            ``/*find array sum */``            ``arraySum += arr[i];``        ``}`` ` `        ``int` `minOperation = arraySum -  ``                        ``arr_size * smallest;`` ` `        ``/* Print min operation required */``        ``Console.Write(``"Minimum Operation = "` `+``                            ``minOperation);``    ``}`` ` `    ``/* Driver program to test above``    ``functions */``    ``public` `static` `void` `Main ()``    ``{``        ``int` `[]arr = {5, 6, 2, 4, 3};``         ` `        ``printMinOp(arr);``    ``}``}`` ` `// This code is contributed by nitin mittal.`

## PHP

 ``

## Javascript

 ``

Output

`Minimum Operation = 10`

Time Complexity: O(N), where N represents the size of the given array.
Auxiliary Space: O(1), no extra space is required, so it is a constant.