Skip to content
Related Articles
Get the best out of our app
GFG App
Open App
geeksforgeeks
Browser
Continue

Related Articles

Maximize sum of chosen Array elements with value at most M

Improve Article
Save Article
Like Article
Improve Article
Save Article
Like Article

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 <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)
Auxiliary Space: O(1), since no extra space has been added.

 


My Personal Notes arrow_drop_up
Last Updated : 13 Jul, 2022
Like Article
Save Article
Similar Reads
Related Tutorials