# Maximum removals possible from an array such that sum of its elements is greater than or equal to that of another array

• Difficulty Level : Easy
• Last Updated : 04 May, 2021

Given two arrays arr[] and brr[] of size N and M respectively, the task is to count the maximum number of elements that can be removed from the array arr[] such that the sum of elements in arr[] is greater than or equal to the sum of elements in brr[].

Examples:

Input: arr[] = { 1, 2, 4, 6 }, brr[] = { 7 }
Output:
Explanation:
Removing arr[2] modifies arr[] to { 1, 2, 6 } and sum equal to 9 (> 7)
Removing arr[1] modifies arr[] to { 1, 6 } and sum equal to 7 (&gr; 7)
Removing arr[0] modifies arr[] to { 6 } and sum equal to 6 (< 7)
Therefore, the required output is 2.

Input: arr[] = { 10, 20 }, brr[] = { 5 }
Output:
Explanation:
Removing arr[1] modifies arr[] to { 10 } and sum equal to 10 (> 5)
Removing arr[0] modifies arr[] to { } and sum equal to 0 (< 5)
Therefore, the required output is 1.

Approach: The problem can be solved using Greedy technique. Follow the steps below to solve the problem:

• Sort the array, arr[] in ascending order.
• Remove the smallest element from the array arr[] and check if the sum of elements of arr[] is greater than or equal to sum of array elements brr[] or not. If found to be true, then increment the count.
• Finally, print the count obtained.

Below is the implementation of the above approach:

## C++

 `// C++ program to implement``// the above approach``#include ``using` `namespace` `std;` `// Function to maximize the count of elements``// required to be removed from arr[] such that``// the sum of arr[] is greater than or equal``// to sum of the array brr[]``int` `maxCntRemovedfromArray(``int` `arr[], ``int` `N,``                           ``int` `brr[], ``int` `M)``{` `    ``// Sort the array arr[]``    ``sort(arr, arr + N);` `    ``// Stores index of smallest``    ``// element of arr[]``    ``int` `i = 0;` `    ``// Stores sum of elements``    ``// of the array arr[]``    ``int` `sumArr = 0;` `    ``// Traverse the array arr[]``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// Update sumArr``        ``sumArr += arr[i];``    ``}` `    ``// Stores sum of elements``    ``// of the array brr[]``    ``int` `sumBrr = 0;` `    ``// Traverse the array brr[]``    ``for` `(``int` `i = 0; i < M; i++) {` `        ``// Update sumArr``        ``sumBrr += brr[i];``    ``}` `    ``// Stores count of``    ``// removed elements``    ``int` `cntRemElem = 0;` `    ``// Repeatedly remove the smallest``    ``// element of arr[]``    ``while` `(i < N and sumArr >= sumBrr) {` `        ``// Update sumArr``        ``sumArr -= arr[i];` `        ``// Remove the smallest element``        ``i += 1;` `        ``// If the sum of remaining elements``        ``// in arr[] >= sum of brr[]``        ``if` `(sumArr >= sumBrr) {` `            ``// Update cntRemElem``            ``cntRemElem += 1;``        ``}``    ``}` `    ``return` `cntRemElem;``}` `// Driver Code``int` `main()``{` `    ``int` `arr[] = { 1, 2, 4, 6 };` `    ``int` `brr[] = { 7 };` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``int` `M = ``sizeof``(brr) / ``sizeof``(brr[0]);` `    ``cout << maxCntRemovedfromArray(arr, N, brr, M);``}`

## Java

 `// Java program to implement``// the above approach``import` `java.io.*;``import` `java.util.*;` `class` `GFG``{` `    ``// Function to maximize the count of elements``    ``// required to be removed from arr[] such that``    ``// the sum of arr[] is greater than or equal``    ``// to sum of the array brr[]``    ``static` `int` `maxCntRemovedfromArray(``int``[] arr, ``int` `N,``                                      ``int``[] brr, ``int` `M)``    ``{` `        ``// Sort the array arr[]``        ``Arrays.sort(arr);` `        ``// Stores index of smallest``        ``// element of arr[]``        ``int` `i = ``0``;` `        ``// Stores sum of elements``        ``// of the array arr[]``        ``int` `sumArr = ``0``;` `        ``// Traverse the array arr[]``        ``for` `(i = ``0``; i < N; i++)       ``        ``{` `            ``// Update sumArr``            ``sumArr += arr[i];``        ``}` `        ``// Stores sum of elements``        ``// of the array brr[]``        ``int` `sumBrr = ``0``;` `        ``// Traverse the array brr[]``        ``for` `(i = ``0``; i < M; i++)``        ``{` `            ``// Update sumArr``            ``sumBrr += brr[i];``        ``}` `        ``// Stores count of``        ``// removed elements``        ``int` `cntRemElem = ``0``;` `        ``// Repeatedly remove the smallest``        ``// element of arr[]``        ``while` `(i < N && sumArr >= sumBrr) {` `            ``// Update sumArr``            ``sumArr -= arr[i];` `            ``// Remove the smallest element``            ``i += ``1``;` `            ``// If the sum of remaining elements``            ``// in arr[] >= sum of brr[]``            ``if` `(sumArr >= sumBrr) {` `                ``// Update cntRemElem``                ``cntRemElem += ``1``;``            ``}``        ``}``        ``return` `cntRemElem;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{` `        ``int``[] arr = ``new` `int``[] { ``1``, ``2``, ``4``, ``6` `};``        ``int``[] brr = ``new` `int``[] { ``7` `};``        ``int` `N = arr.length;``        ``int` `M = brr.length;``        ``System.out.println(``            ``maxCntRemovedfromArray(arr, N, brr, M));``    ``}``}` `// This code is contributed by Dharanendra L V`

## Python3

 `# Python3 program to implement``# the above approach` `# Function to maximize the count of elements``# required to be removed from arr[] such that``# the sum of arr[] is greater than or equal``# to sum of the array brr[]``def` `maxCntRemovedfromArray(arr, N, brr, M):``    ` `    ``# Sort the array arr[]``    ``arr.sort(reverse ``=` `False``)` `    ``# Stores index of smallest``    ``# element of arr[]``    ``i ``=` `0` `    ``# Stores sum of elements``    ``# of the array arr[]``    ``sumArr ``=` `0` `    ``# Traverse the array arr[]``    ``for` `i ``in` `range``(N):``        ` `        ``# Update sumArr``        ``sumArr ``+``=` `arr[i]` `    ``# Stores sum of elements``    ``# of the array brr[]``    ``sumBrr ``=` `0` `    ``# Traverse the array brr[]``    ``for` `i ``in` `range``(M):` `        ``# Update sumArr``        ``sumBrr ``+``=` `brr[i]` `    ``# Stores count of``    ``# removed elements``    ``cntRemElem ``=` `0` `    ``# Repeatedly remove the smallest``    ``# element of arr[]``    ``while` `(i < N ``and` `sumArr >``=` `sumBrr):``        ` `        ``# Update sumArr``        ``sumArr ``-``=` `arr[i]` `        ``# Remove the smallest element``        ``i ``+``=` `1` `        ``# If the sum of remaining elements``        ``# in arr[] >= sum of brr[]``        ``if` `(sumArr >``=` `sumBrr):``            ` `            ``# Update cntRemElem``            ``cntRemElem ``+``=` `1` `    ``return` `cntRemElem` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``arr ``=` `[ ``1``, ``2``, ``4``, ``6` `]` `    ``brr ``=` `[``7``]` `    ``N ``=` `len``(arr)` `    ``M ``=` `len``(brr)` `    ``print``(maxCntRemovedfromArray(arr, N, brr, M))` `# This code is contributed by SURENDRA_GANGWAR`

## C#

 `// C# program to implement``// the above approach``using` `System;``class` `GFG``{` `    ``// Function to maximize the count of elements``    ``// required to be removed from arr[] such that``    ``// the sum of arr[] is greater than or equal``    ``// to sum of the array brr[]``    ``static` `int` `maxCntRemovedfromArray(``int``[] arr, ``int` `N,``                                      ``int``[] brr, ``int` `M)``    ``{` `        ``// Sort the array arr[]``        ``Array.Sort(arr);` `        ``// Stores index of smallest``        ``// element of arr[]``        ``int` `i = 0;` `        ``// Stores sum of elements``        ``// of the array arr[]``        ``int` `sumArr = 0;` `        ``// Traverse the array arr[]``        ``for` `(i = 0; i < N; i++)``        ``{` `            ``// Update sumArr``            ``sumArr += arr[i];``        ``}` `        ``// Stores sum of elements``        ``// of the array brr[]``        ``int` `sumBrr = 0;` `        ``// Traverse the array brr[]``        ``for` `(i = 0; i < M; i++)``        ``{` `            ``// Update sumArr``            ``sumBrr += brr[i];``        ``}` `        ``// Stores count of``        ``// removed elements``        ``int` `cntRemElem = 0;` `        ``// Repeatedly remove the smallest``        ``// element of arr[]``        ``while` `(i < N && sumArr >= sumBrr)``        ``{` `            ``// Update sumArr``            ``sumArr -= arr[i];` `            ``// Remove the smallest element``            ``i += 1;` `            ``// If the sum of remaining elements``            ``// in arr[] >= sum of brr[]``            ``if` `(sumArr >= sumBrr)``            ``{` `                ``// Update cntRemElem``                ``cntRemElem += 1;``            ``}``        ``}``        ``return` `cntRemElem;``    ``}` `    ``// Driver Code``    ``static` `public` `void` `Main()``    ``{``        ``int``[] arr = ``new` `int``[] { 1, 2, 4, 6 };``        ``int``[] brr = ``new` `int``[] { 7 };``        ``int` `N = arr.Length;``        ``int` `M = brr.Length;``        ``Console.WriteLine(``            ``maxCntRemovedfromArray(arr, N, brr, M));``    ``}``}` `// This code is contributed by Dharanendra L V`

## Javascript

 ``

Output:

`2`

Time Complexity: O(N * log(N))
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up