GeeksforGeeks App
Open App
Browser
Continue

# Minimum increments to modify array such that value of any array element can be splitted to make all remaining elements equal

Given an array arr[] consisting of N elements, the task is to find the minimum number of increments required to be performed on the given array such that after selecting any array element at any index and splitting its value to the other array elements makes all other N – 1 elements equal.

Examples:

Input: N = 3, arr[] = {2, 3, 7}
Output: 2
Explanation:
Incrementing arr[0] and arr[1] by 1 modifies arr[] to {3, 4, 7}.
Removing arr[0] and adding to arr[1] makes the array {7, 7}.
Removing arr[1] and adding to arr[0] makes the array {7, 7}
Removing arr[2] and adding 3 to arr[1] and 4 to arr[0] makes the array {7, 7}.
Therefore, the count of increments required is 2.

Input: N = 3, arr[] = {0, 2, 0}
Output: 2

Approach: Follow the below steps to solve the problem:

1. Find the sum of the given array elements and the maximum element present in that array and store it in variables, say sum and maxelement.
2. All remaining N – 1 elements must be equal to ceil(sum / N-1). Let this value be K.
3. As the element can only be increased by 1, set K equal to maxelement if maxelement is greater than K.
4. Now, each N – 1 value should be equal to K. Therefore, the final sum should be K * (N-1).
5. Hence, the total number of moves required is K*(N – 1) – sum.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to count minimum moves``void` `minimumMoves(``int` `arr[], ``int` `N)``{``    ``// Stores sum of given array``    ``int` `sum = 0;` `    ``// Stores maximum array element``    ``int` `maxelement = -1;` `    ``// Base Case``    ``if` `(N == 2) {` `        ``// If N is 2, the answer``        ``// will always be 0``        ``cout << 0;``    ``}` `    ``// Traverse the array``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// Calculate sum of the array``        ``sum += arr[i];` `        ``// Finding maximum element``        ``maxelement = max(maxelement, arr[i]);``    ``}` `    ``// Calculate ceil(sum/N-1)``    ``int` `K = (sum + N - 2) / (N - 1);` `    ``// If k is smaller than maxelement``    ``K = max(maxelement, K);` `    ``// Final sum - original sum``    ``int` `ans = K * (N - 1) - sum;` `    ``// Print the minimum number``    ``// of increments required``    ``cout << ans;``}` `// Driver Code``int` `main()``{``    ``// Given array``    ``int` `arr[] = { 2, 3, 7 };` `    ``// Size of given array``    ``int` `N = 3;` `    ``// Function Call``    ``minimumMoves(arr, N);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach` `import` `java.io.*;` `class` `GFG {` `    ``// Function to find the minimum moves``    ``public` `static` `void` `minimumMoves(``        ``int``[] arr, ``int` `N)``    ``{``        ``// Stores the sum of the array``        ``int` `sum = ``0``;` `        ``// Store the maximum element``        ``int` `maxelement = -``1``;` `        ``// Base Case``        ``if` `(N == ``2``) {` `            ``// If N is 2, the answer``            ``// will always be 0``            ``System.out.print(``"0"``);``            ``return``;``        ``}` `        ``// Traverse the array``        ``for` `(``int` `i = ``0``; i < N; i++) {` `            ``// Calculate sum of the array``            ``sum += arr[i];` `            ``// Finding maximum element``            ``maxelement = Math.max(``                ``maxelement, arr[i]);``        ``}` `        ``// Calculate ceil(sum/N-1)``        ``int` `k = (sum + N - ``2``) / (N - ``1``);` `        ``// If k is smaller than maxelement``        ``k = Math.max(maxelement, k);` `        ``// Final sum - original sum``        ``int` `ans = k * (N - ``1``) - sum;` `        ``// Print the minimum number``        ``// of increments required``        ``System.out.println(ans);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``// Given array``        ``int``[] arr = { ``2``, ``3``, ``7` `};` `        ``// Size of given array``        ``int` `N = arr.length;` `        ``// Function Call``        ``minimumMoves(arr, N);``    ``}``}`

## Python3

 `# Python3 program for the above approach` `# Function to count minimum moves``def` `minimumMoves(arr, N):``    ` `    ``# Stores sum of given array``    ``sum` `=` `0` `    ``# Stores maximum array element``    ``maxelement ``=` `-``1` `    ``# Base Case``    ``if` `(N ``=``=` `2``):``        ` `        ``# If N is 2, the answer``        ``# will always be 0``        ``print``(``0``, end ``=` `"")``        ` `    ``# Traverse the array``    ``for` `i ``in` `range``(N):``        ` `        ``# Calculate sum of the array``        ``sum` `+``=` `arr[i]` `        ``# Finding maximum element``        ``maxelement ``=` `max``(maxelement, arr[i])` `    ``# Calculate ceil(sum/N-1)``    ``K ``=` `(``sum` `+` `N ``-` `2``) ``/``/` `(N ``-` `1``)` `    ``# If k is smaller than maxelement``    ``K ``=` `max``(maxelement, K)` `    ``# Final sum - original sum``    ``ans ``=` `K ``*` `(N ``-` `1``) ``-` `sum` `    ``# Print the minimum number``    ``# of increments required``    ``print``(ans)``    ` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``# Given array``    ``arr ``=` `[ ``2``, ``3``, ``7` `]` `    ``# Size of given array``    ``N ``=` `3` `    ``# Function Call``    ``minimumMoves(arr, N)` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for the above approach``using` `System;``class` `GFG``{``    ` `  ``// Function to find the minimum moves``  ``static` `void` `minimumMoves(``int``[] arr, ``int` `N)``  ``{` `    ``// Stores the sum of the array``    ``int` `sum = 0;` `    ``// Store the maximum element``    ``int` `maxelement = -1;` `    ``// Base Case``    ``if` `(N == 2)``    ``{` `      ``// If N is 2, the answer``      ``// will always be 0``      ``Console.Write(``"0"``);``      ``return``;``    ``}` `    ``// Traverse the array``    ``for` `(``int` `i = 0; i < N; i++)``    ``{` `      ``// Calculate sum of the array``      ``sum += arr[i];` `      ``// Finding maximum element``      ``maxelement = Math.Max(``        ``maxelement, arr[i]);``    ``}` `    ``// Calculate ceil(sum/N-1)``    ``int` `k = (sum + N - 2) / (N - 1);` `    ``// If k is smaller than maxelement``    ``k = Math.Max(maxelement, k);` `    ``// Final sum - original sum``    ``int` `ans = k * (N - 1) - sum;` `    ``// Print the minimum number``    ``// of increments required``    ``Console.WriteLine(ans);``  ``}``  ` `  ``// Driver code``  ``static` `void` `Main()``  ``{``    ` `    ``// Given array``    ``int``[] arr = { 2, 3, 7 };` `    ``// Size of given array``    ``int` `N = arr.Length;` `    ``// Function Call``    ``minimumMoves(arr, N);``  ``}``}` `// This code is contributed by divyesh072019.`

## Javascript

 ``

Output:

`2`

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

My Personal Notes arrow_drop_up