# 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 = 10Output:67Explanation: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 = 6Output:12Explanation: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.

- If
- 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 <bits/stdc++.h>` `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

`<script>` ` ` `// JavaScript code for the above approach` ` ` `// Function to calculate` ` ` `// the maximum value of M` ` ` `// that can be obtained` ` ` `function` `IsArrayHungry(M, arr)` ` ` `{` ` ` ` ` `// Sort the array in increasing order.` ` ` `arr.sort(` `function` `(a, b) { ` `return` `a - b })` ` ` `let sum = M;` ` ` `let N = arr.length;` ` ` `for` `(let i = 0; i < N; i++) {` ` ` `if` `(sum >= arr[i])` ` ` `sum += arr[i];` ` ` `else` ` ` `break` `;` ` ` `}` ` ` `return` `sum;` ` ` `}` ` ` `// Driver code` ` ` `let arr = [3, 9, 19, 5, 21];` ` ` `let M = 10;` ` ` `let res = IsArrayHungry(M, arr);` ` ` `document.write(res);` ` ` `// This code is contributed by Potta Lokesh` ` ` `</script>` |

**Output**

67

* Time Complexity:* O(N * logN)

*O(1), since no extra space has been added.*

**Auxiliary Space:**