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++ 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 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. |
# 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# 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. |
<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>
|
67
Time Complexity: O(N * logN)
Auxiliary Space: O(1), since no extra space has been added.