# 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
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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 * (smallesteElement). 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;
```
 `// 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

 `// Java program to find min operation ` `import` `java.io.*; ` `  `  `class` `minOeration ` `{ ` `    ``/* 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); ` `    ``} ` `} `

 `# Python 3 for finding minimum  ` `# operation required ` ` `  `# function for finding array sum ` `def` `arraySum (arr, n) : ` ` `  `    ``sm ``=` `0` `    ``i ``=` `0` ` `  `    ``while``(i

 `// 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; ` `         `  `        ``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. `

 ` `

Output:

```Minimum Operation = 10
```