 GFG App
Open App Browser
Continue

# Maximize sum of chosen Array elements with value at most M

Given an array arr[] of N positive numbers and an integer M. The task is to maximize the value of M by adding array elements when arr[i] ≤ M

Note: Any array element can be added at most once.

Examples:

Input: arr[] = {3, 9, 19, 5, 21}, M = 10
Output: 67
Explanation: One way to getthe value is
M > 3; 3 is added to M and it becomes 10+3 = 13
M > 9; 9 is added to M and it becomes 13+9 = 22
M > 19; 19 is added to M and it becomes 22+19 = 41
M > 5; 5 is added to M and it becomes 41+5 = 46
M > 21; 21 is added to M and it becomes 46+21 = 67
Thus, M = 67 at the end.

Input: arr[] = {2, 13, 4, 19}, M = 6
Output: 12
Explanation: One way to get the value is
M > 4; 4 is added to M and it becomes 6+4 = 10
M > 2; 2 is added to M and it becomes 10+2 = 12
No other value in the array is smaller or equal to M.
Thus, M is 12 at the end.

Approach: The solution is based on the concept of sorting. Follow the steps mentioned below:

• First, sort the array in increasing order.
• For every index i, from 0 to N-1, do the following:
• If M ≥ arr[i], add arr[i] with M.
• If M< arr[i], stop iteration.
• Return the final value of M as the answer.

Below is the implementation of the above approach.

## C++

 `// C++ code to implement the approach` `#include ` `using` `namespace` `std;`   `// Function to calculate` `// the maximum value of M` `// that can be obtained` `int` `IsArrayHungry(``int` `M, vector<``int``>& arr)` `{` `    ``// Sort the array in increasing order.` `    ``sort(arr.begin(), arr.end());` `    ``long` `long` `sum = M;` `    ``int` `N = arr.size();`   `    ``for` `(``int` `i = 0; i < N; i++) {` `        ``if` `(sum >= arr[i])` `            ``sum += arr[i];` `        ``else` `            ``break``;` `    ``}` `    ``return` `sum;` `}`   `// Driver code` `int` `main()` `{` `    ``vector<``int``> arr{ 3, 9, 19, 5, 21 };` `    ``int` `M = 10;` `    ``int` `res = IsArrayHungry(M, arr);` `    ``cout << res;` `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `import` `java.io.*;` `import` `java.lang.*;` `import` `java.util.*;`   `class` `GFG` `{`   `  ``// Function to calculate` `  ``// the maximum value of M` `  ``// that can be obtained` `  ``static` `int` `IsArrayHungry(``int` `M, ``int` `arr[ ])` `  ``{`   `    ``// Sort the array in increasing order.` `    ``Arrays.sort(arr);` `    ``int` `sum = M;` `    ``int` `N = arr.length;`   `    ``for` `(``int` `i = ``0``; i < N; i++) {` `      ``if` `(sum >= arr[i])` `        ``sum += arr[i];` `      ``else` `        ``break``;` `    ``}` `    ``return` `sum;` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `main (String[] args)` `  ``{` `    ``int` `arr[ ] = { ``3``, ``9``, ``19``, ``5``, ``21` `};` `    ``int` `M = ``10``;` `    ``int` `res = IsArrayHungry(M, arr);` `    ``System.out.print(res);` `  ``}` `}`   `// This code is contributed by hrithikgarg03188.`

## Python3

 `# Python 3 code to implement the approach`   `# Function to calculate` `# the maximum value of M` `# that can be obtained` `def` `IsArrayHungry(M,  arr):`   `    ``# Sort the array in increasing order.` `    ``arr.sort()` `    ``sum` `=` `M` `    ``N ``=` `len``(arr)`   `    ``for` `i ``in` `range``(N):` `        ``if` `(``sum` `>``=` `arr[i]):` `            ``sum` `+``=` `arr[i]`   `        ``else``:` `            ``break`   `    ``return` `sum`   `# Driver code` `if` `__name__ ``=``=` `"__main__"``:`   `    ``arr ``=` `[``3``, ``9``, ``19``, ``5``, ``21``]` `    ``M ``=` `10` `    ``res ``=` `IsArrayHungry(M, arr)` `    ``print``(res)`   `    ``# This code is contributed by ukasp.`

## C#

 `// C# code to implement above approach` `using` `System;` `class` `GFG` `{`   `  ``// Function to calculate` `  ``// the maximum value of M` `  ``// that can be obtained` `  ``static` `int` `IsArrayHungry(``int` `M, ``int` `[]arr)` `  ``{`   `    ``// Sort the array in increasing order.` `    ``Array.Sort(arr);` `    ``int` `sum = M;` `    ``int` `N = arr.Length;`   `    ``for` `(``int` `i = 0; i < N; i++) {` `      ``if` `(sum >= arr[i])` `        ``sum += arr[i];` `      ``else` `        ``break``;` `    ``}` `    ``return` `sum;` `  ``}`   `  ``// Driver Code:` `  ``public` `static` `void` `Main()` `  ``{` `    ``int` `[]arr = { 3, 9, 19, 5, 21 };` `    ``int` `M = 10;` `    ``int` `res = IsArrayHungry(M, arr);` `    ``Console.WriteLine(res);` `  ``}` `}`   `// This code is contributed by Samim Hossain Mondal.`

## Javascript

 ``

Output

`67`

Time Complexity: O(N * logN)
Auxiliary Space: O(1), since no extra space has been added.

My Personal Notes arrow_drop_up