Open In App

# Check if given Array can be reduced to 0 by removing element less than K and adding it to K

Given an array, arr[] of size N and an integer K. If a value in arr[] is less than or equal to K, then that value will be removed from the array and added to K. The task is to check if all the elements in arr[] can be absorbed or not.

Examples:

Input: K = 10, arr[] = {3, 9, 19, 5, 21}
Output: true
Explanation: The array elements are absorbed in following way.
One way to absorption is {9, 19, 5, 3, 21}
value is 9 and the New k value: 10 + 9 = 19
value is 19 and the New k value: 19 + 19 = 38
value is 5 and the New k value: 38 + 5 = 43
value is 3 and the New k value: 43 + 3 = 46
value is 9 and the New k value: 46 + 21 = 6.
Hence, All values are absorbed.

Input: K = 5, arr[] = {4, 9, 23, 4}
Output: false

Approach: This problem can be solved by using the Greedy Approach. Follow the steps below to solve the given problem.

• Any element in arr[] that has the highest probability to be less than or equal to K would be the smallest element.
• So, sort the array in non-decreasing order and try to remove elements from left to right.
• Iterate from left to right while removing values of arr[].
• At any time if it is not possible to remove any element, return false.
• Else return true.

Below is the implementation of the above approach.

## C++

 `// C++ program for above approach``#include ``using` `namespace` `std;` `// Function to check if all the elements``// can be absorbed or not``bool` `absorption(``int` `K, vector<``int``>& arr)``{` `    ``// Sort the array in non-decreasing order``    ``sort(arr.begin(), arr.end());` `    ``// Long long  prevent from integer overflow``    ``long` `long` `m = K;` `    ``for` `(``int` `i = 0; i < arr.size(); i++) {``        ``int` `value = arr[i];``        ``if` `(m < value) {``            ``return` `false``;``        ``}``        ``else` `{``            ``m += arr[i];``        ``}``    ``}``    ``return` `true``;``}` `// Driver Code``int` `main()``{``    ``vector<``int``> arr{ 3, 9, 19, 5, 21 };``    ``int` `K = 10;` `    ``// Check if all the elements``    ``// can be removed or not.``    ``if` `(absorption(K, arr))``        ``cout << ``"true"``;``    ``else``        ``cout << ``"false"``;``    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.io.*;``import` `java.lang.*;``import` `java.util.*;` `class` `GFG {` `  ``// Function to check if all the elements``  ``// can be absorbed or not``  ``static`  `Boolean absorption(``int` `K, ``int` `arr[ ])``  ``{` `    ``// Sort the array in non-decreasing order``    ``Arrays.sort(arr);` `    ``// Long long  prevent from integer overflow``    ``long` `m = K;` `    ``for` `(``int` `i = ``0``; i < arr.length; i++) {``      ``int` `value = arr[i];``      ``if` `(m < value) {``        ``return` `false``;``      ``}``      ``else` `{``        ``m += arr[i];``      ``}``    ``}``    ``return` `true``;``  ``}` `  ``public` `static` `void` `main (String[] args) {``    ``int` `arr[ ] = { ``3``, ``9``, ``19``, ``5``, ``21` `};``    ``int` `K = ``10``;` `    ``// Check if all the elements``    ``// can be removed or not.``    ``if` `(absorption(K, arr))``      ``System.out.print(``"true"``);``    ``else``      ``System.out.print(``"false"``);``  ``}``}` `// This code is contributed by hrithikgarg03188.`

## Python3

 `# Python 3 program for above approach` `# Function to check if all the elements``# can be absorbed or not``def` `absorption(K, arr):` `    ``# Sort the array in non-decreasing order``    ``arr.sort()` `    ``# Long long  prevent from integer overflow``    ``m ``=` `K` `    ``for` `i ``in` `range``(``len``(arr)):``        ``value ``=` `arr[i]``        ``if` `(m < value):``            ``return` `False` `        ``else``:``            ``m ``+``=` `arr[i]` `    ``return` `True` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``arr ``=` `[``3``, ``9``, ``19``, ``5``, ``21``]``    ``K ``=` `10` `    ``# Check if all the elements``    ``# can be removed or not.``    ``if` `(absorption(K, arr)):``        ``print``(``"true"``)``    ``else``:``        ``print``(``"false"``)` `        ``# This code is contributed by ukasp.`

## C#

 `// C# program for the above approach``using` `System;``class` `GFG``{` `  ``// Function to check if all the elements``  ``// can be absorbed or not``  ``static` `bool` `absorption(``int` `K, ``int` `[]arr)``  ``{` `    ``// Sort the array in non-decreasing order``    ``Array.Sort(arr);` `    ``// Long long  prevent from integer overflow``    ``long` `m = K;` `    ``for` `(``int` `i = 0; i < arr.Length; i++) {``      ``int` `value = arr[i];``      ``if` `(m < value) {``        ``return` `false``;``      ``}``      ``else` `{``        ``m += arr[i];``      ``}``    ``}``    ``return` `true``;``  ``}` `  ``// Driver Code``  ``public` `static` `void` `Main()``  ``{``    ``int` `[]arr = { 3, 9, 19, 5, 21 };``    ``int` `K = 10;` `    ``// Check if all the elements``    ``// can be removed or not.``    ``if` `(absorption(K, arr))``      ``Console.Write(``"true"``);``    ``else``      ``Console.Write(``"false"``);``  ``}``}` `// This code is contributed by Samim Hossain Mondal.`

## Javascript

 ``

Output

`true`

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