Skip to content
Related Articles

Related Articles

Minimum increments to make all array elements equal with sum same as the given array after exactly one removal
  • Last Updated : 15 Dec, 2020

Given an array arr[] of size N and an integer K, the task is to check if all array elements can be made equal by removing an array element and incrementing the value of all other array elements such that the total sum of the array elements remains the same. If found to be true, then print “YES”. Otherwise, print “NO”.

Examples :

Input: arr[] = { 2, 2, 2, 3 } 
Output: YES 
Explanation: 
Removing arr[2] ( 0-based indexing ) from the array and incrementing all other elements by 1 modifies arr[] to { 3, 3, 3 } 
Since all array elements are equal. Therefore, the required output is “YES”.

Input: arr[] = { 0, 3, 0 }, K = 3 
Output:: NO 
Removing arr[1] ( 0-based indexing ) from the array and incrementing the value arr[0] by 1 and arr[2] by 2 modifies arr[] to { 1, 2 } 
Since all array elements are not equal. Therefore, the required output is “NO”.

Approach: The problem can be solved using Greedy technique. The idea is to remove the largest array element and increment the value of other elements such that the total sum remains same. Follow the steps below to solve the problem:



Below is the implementation of above approach

C++




// C++ program to implement
// the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to check if an array of
// equal elements with sum equal to
// the given array can be obtained or not
bool CheckAllarrayEqual(int arr[], int N)
{
    // Base case
    if (N == 1) {
        return true;
    }
 
    // Stores sum of
    // array elements
    int totalSum = arr[0];
 
    // Stores second largest
    // array element
    int secMax = INT_MIN;
 
    // Stores the largest
    // array element
    int Max = arr[0];
 
    // Traverse the array
    for (int i = 1; i < N; i++) {
 
        if (arr[i] >= Max) {
 
            // Update secMax
            secMax = Max;
 
            // Update Max
            Max = arr[i];
        }
        else if (arr[i] > secMax) {
 
            // Update secMax
            secMax = arr[i];
        }
 
        // Update totalSum
        totalSum += arr[i];
    }
 
    // If totalSum is less than
    // secMax * (N - 1))
    if ((secMax * (N - 1)) > totalSum) {
 
        return false;
    }
 
    // If totalSum is not
    // divisible by (N - 1)
    if (totalSum % (N - 1)) {
 
        return false;
    }
 
    return true;
}
 
// Driver Code
int main()
{
    int arr[] = { 6, 2, 2, 2 };
    int N = sizeof(arr) / sizeof(arr[0]);
 
    if (CheckAllarrayEqual(arr, N)) {
        cout << "YES";
    }
    else {
        cout << "NO";
    }
}
Java



// Java program to implement
// the above approach
import java.util.*;
    
class GFG{
 
// Function to check if an array of
// equal elements with sum equal to
// the given array can be obtained or not
static boolean CheckAllarrayEqual(int[] arr,
                                  int N)
{
     
    // Base case
    if (N == 1)
    {
        return true;
    }
   
    // Stores sum of
    // array elements
    int totalSum = arr[0];
   
    // Stores second largest
    // array element
    int secMax = Integer.MIN_VALUE;
   
    // Stores the largest
    // array element
    int Max = arr[0];
   
    // Traverse the array
    for(int i = 1; i < N; i++)
    {
        if (arr[i] >= Max)
        {
             
            // Update secMax
            secMax = Max;
             
            // Update Max
            Max = arr[i];
        }
        else if (arr[i] > secMax)
        {
             
            // Update secMax
            secMax = arr[i];
        }
         
        // Update totalSum
        totalSum += arr[i];
    }
   
    // If totalSum is less than
    // secMax * (N - 1))
    if ((secMax * (N - 1)) > totalSum)
    {
        return false;
    }
   
    // If totalSum is not
    // divisible by (N - 1)
    if (totalSum % (N - 1) != 0)
    {
        return false;
    }
   
    return true;
}
    
// Driver Code
public static void main(String[] args)
{
    int[] arr = { 6, 2, 2, 2 };
    int N = arr.length;
   
    if (CheckAllarrayEqual(arr, N))
    {
        System.out.print("YES");
    }
    else
    {
        System.out.print("NO");
    }
}
}
 
// This code is contributed by susmitakundugoaldanga
Python3



# Python3 program to implement
# the above approach
 
# Function to check if an array of
# equal elements with sum equal to
# the given array can be obtained or not
def CheckAllarrayEqual(arr, N):
     
    # Base case
    if (N == 1):
        return True
 
    # Stores sum of
    # array elements
    totalSum = arr[0]
 
    # Stores second largest
    # array element
    secMax = -10**19
 
    # Stores the largest
    # array element
    Max = arr[0]
 
    # Traverse the array
    for i in range(1,N):
 
        if (arr[i] >= Max):
 
            # Update secMax
            secMax = Max
 
            # Update Max
            Max = arr[i]
        elif (arr[i] > secMax):
 
            # Update secMax
            secMax = arr[i]
 
        # Update totalSum
        totalSum += arr[i]
 
    # If totalSum is less than
    # secMax * (N - 1))
    if ((secMax * (N - 1)) > totalSum):
 
        return False
 
    # If totalSum is not
    # divisible by (N - 1)
    if (totalSum % (N - 1)):
        return False
    return True
 
# Driver Code
if __name__ == '__main__':
    arr=[6, 2, 2, 2]
    N = len(arr)
 
    if (CheckAllarrayEqual(arr, N)):
        print("YES")
    else:
        print("NO")
 
        # This code is contributd by mohit kumar 29
C#



// C# program to implement
// the above approach 
using System;
class GFG
{
  
// Function to check if an array of
// equal elements with sum equal to
// the given array can be obtained or not
static bool CheckAllarrayEqual(int[] arr, int N)
{
    // Base case
    if (N == 1) {
        return true;
    }
  
    // Stores sum of
    // array elements
    int totalSum = arr[0];
  
    // Stores second largest
    // array element
    int secMax = Int32.MinValue;
  
    // Stores the largest
    // array element
    int Max = arr[0];
  
    // Traverse the array
    for (int i = 1; i < N; i++) {
  
        if (arr[i] >= Max) {
  
            // Update secMax
            secMax = Max;
  
            // Update Max
            Max = arr[i];
        }
        else if (arr[i] > secMax) {
  
            // Update secMax
            secMax = arr[i];
        }
  
        // Update totalSum
        totalSum += arr[i];
    }
  
    // If totalSum is less than
    // secMax * (N - 1))
    if ((secMax * (N - 1)) > totalSum) {
  
        return false;
    }
  
    // If totalSum is not
    // divisible by (N - 1)
    if (totalSum % (N - 1) != 0) {
  
        return false;
    }
  
    return true;
}
  
// Driver Code
public static void Main()
{
    int[] arr = { 6, 2, 2, 2 };
    int N = arr.Length;
  
    if (CheckAllarrayEqual(arr, N)) {
        Console.Write("YES");
    }
    else {
        Console.Write("NO");
    }
}
}
 
// This code is contributed by sanjoy_62
Output: 
YES
 
Time complexity: O(N) 
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.
My Personal Notes
arrow_drop_up
Previous
Minimize remaining array element by removing pairs and replacing them by their absolute difference
Next

Sort a stream of integers
Recommended Articles
Page :
Minimum increments to modify array such that value of any array element can be splitted to make all remaining elements equal
25, Dec 20
Minimum increments or decrements by D required to make all array elements equal
13, Jan 21
Minimize subtraction followed by increments of adjacent elements required to make all array elements equal
22, Mar 21
Minimum prefix increments required to make all elements of an array multiples of another array
31, Jan 21
Minimum increments required to make absolute difference of all pairwise adjacent array elements even
19, Apr 21
Minimize increments required to make count of even and odd array elements equal
22, Jan 21
Minimize the maximum minimum difference after one removal from array
28, Dec 18
Minimum swaps of similar indexed elements required to make all elements of one of the two given arrays equal
02, Dec 20
Minimum increments required to make array elements alternately even and odd
19, Feb 21
Minimum increments by index value required to obtain at least two equal Array elements
17, Aug 20
Minimize increments required to make differences between all pairs of array elements even
19, Feb 21
Counting values greater than equal to x after increments
20, May 18
Count pairs of same parity indexed elements with same MSD after replacing each element by the sum of maximum digit * A and minimum digits * B
08, Mar 21
Minimize increments or decrements required to make sum and product of array elements non-zero
09, Nov 20
Check if all elements of a Circular Array can be made equal by increments of adjacent pairs
18, Aug 20
Maximum removal from array when removal time >= waiting time
24, Oct 18
Maximize sum of remaining elements after every removal of the array half with greater sum
14, Sep 20
Count pairs of equal array elements remaining after every removal
22, Dec 20
Minimum increments required to make given matrix palindromic
29, Oct 20
Length of Longest Subarray with same elements in atmost K increments
03, Feb 20
Minimize cost of increments or decrements such that same indexed elements become multiple of each other
26, Feb 21
Print indices of array elements whose removal makes the sum of odd and even-indexed elements equal
11, Dec 20
Make all array elements equal to 0 by replacing minimum subsequences consisting of equal elements
13, Jan 21
Minimum increments of Non-Decreasing Subarrays required to make Array Non-Decreasing
19, Aug 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
varuntak22
@varuntak22
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox