Given an array **A[]** of N integers and an integer **K**, the task is to select the maximum number of elements from the array whose sum is at most **K**.

**Examples:**

Input:A[] = {1, 12, 5, 111, 200, 1000, 10}, K = 50Output:4Explanation:

Maximum number of selections will be1, 12, 5, 10 that is 1 + 12 + 5 + 10 = 28 < 50.

Input:A[] = {3, 7, 2, 9, 4}, K = 15Output:3Explanation:

Maximum number of selections will be 3, 2, 4 that is 3 + 2 + 4 =9 < 15.

**Naive Approach:** The idea is to generate all possible subsequences of the array and find the sum of elements of all the subsequences generated. Find the subsequence with maximum length and with the sum less than or equal to **K**. **Time Complexity:** O(2^{N}) **Auxiliary Space:** (1)

**Efficient Approach:** The efficient approach can be solved using the Greedy Technique. Below are the steps:

- Sort the given array.
- Iterate in the array and keep the track of the sum of elements until the
**sum is less than or equal to K**. - If the sum while iterating in the above steps exceeds
**K**then break the loop and print the value of count till that index.

Below is the implementation of the above approach:

## C++14

`// C++ program for the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to select a maximum number of` `// elements in array whose sum is at most K` `int` `maxSelections(` `int` `A[], ` `int` `n, ` `int` `k)` `{` ` ` `// Sort the array` ` ` `sort(A, A + n);` ` ` `// Calculate the sum and count while` ` ` `// iterating the sorted array` ` ` `int` `sum = 0;` ` ` `int` `count = 0;` ` ` `// Iterate for all the` ` ` `// elements in the array` ` ` `for` `(` `int` `i = 0; i < n; i++) {` ` ` `// Add the current element to sum` ` ` `sum = sum + A[i];` ` ` `if` `(sum > k) {` ` ` `break` `;` ` ` `}` ` ` `// Increment the count` ` ` `count++;` ` ` `}` ` ` `// Return the answer` ` ` `return` `count;` `}` `// Driver Code` `int` `main()` `{` ` ` `// Given array` ` ` `int` `A[] = { 3, 7, 2, 9, 4 };` ` ` `// Given sum k` ` ` `int` `k = 15;` ` ` `int` `n = ` `sizeof` `(A) / ` `sizeof` `(A[0]);` ` ` `// Function Call` ` ` `cout << maxSelections(A, n, k);` ` ` `return` `0;` `}` |

*chevron_right*

*filter_none*

## Java

`// Java program for the above approach` `import` `java.util.*;` `class` `GFG{` `// Function to select a maximum number of` `// elements in array whose sum is at most K` `static` `int` `maxSelections(` `int` `A[], ` `int` `n, ` `int` `k)` `{` ` ` ` ` `// Sort the array` ` ` `Arrays.sort(A);` ` ` `// Calculate the sum and count while` ` ` `// iterating the sorted array` ` ` `int` `sum = ` `0` `;` ` ` `int` `count = ` `0` `;` ` ` `// Iterate for all the` ` ` `// elements in the array` ` ` `for` `(` `int` `i = ` `0` `; i < n; i++)` ` ` `{` ` ` ` ` `// Add the current element to sum` ` ` `sum = sum + A[i];` ` ` `if` `(sum > k)` ` ` `{` ` ` `break` `;` ` ` `}` ` ` `// Increment the count` ` ` `count++;` ` ` `}` ` ` ` ` `// Return the answer` ` ` `return` `count;` `}` `// Driver Code` `public` `static` `void` `main(String[] args)` `{` ` ` ` ` `// Given array` ` ` `int` `A[] = { ` `3` `, ` `7` `, ` `2` `, ` `9` `, ` `4` `};` ` ` `// Given sum k` ` ` `int` `k = ` `15` `;` ` ` `int` `n = A.length;` ` ` `// Function call` ` ` `System.out.print(maxSelections(A, n, k));` `}` `}` `// This code is contributed by Rajput-Ji` |

*chevron_right*

*filter_none*

## Python3

`# Python3 program for ` `# the above approach` `# Function to select a maximum ` `# number of elements in array ` `# whose sum is at most K` `def` `maxSelections(A, n, k):` ` ` `# Sort the array` ` ` `A.sort();` ` ` ` ` `# Calculate the sum and ` ` ` `# count while iterating ` ` ` `# the sorted array` ` ` `sum` `=` `0` `;` ` ` `count ` `=` `0` `;` ` ` `# Iterate for all the` ` ` `# elements in the array` ` ` `for` `i ` `in` `range` `(n):` ` ` `# Add the current element to sum` ` ` `sum` `=` `sum` `+` `A[i];` ` ` `if` `(` `sum` `> k):` ` ` `break` `;` ` ` `# Increment the count` ` ` `count ` `+` `=` `1` `;` ` ` `# Return the answer` ` ` `return` `count;` `# Driver Code` `if` `__name__ ` `=` `=` `'__main__'` `:` ` ` `# Given array` ` ` `A ` `=` `[` `3` `, ` `7` `, ` `2` `, ` `9` `, ` `4` `];` ` ` `# Given sum k` ` ` `k ` `=` `15` `;` ` ` `n ` `=` `len` `(A);` ` ` `# Function call` ` ` `print` `(maxSelections(A, n, k));` ` ` `# This code is contributed by gauravrajput1` |

*chevron_right*

*filter_none*

## C#

`// C# program for the above approach` `using` `System;` `class` `GFG{` `// Function to select a maximum number of` `// elements in array whose sum is at most K` `static` `int` `maxSelections(` `int` `[] A, ` `int` `n, ` `int` `k)` `{` ` ` `// Sort the array` ` ` `Array.Sort(A);` ` ` `// Calculate the sum and count while` ` ` `// iterating the sorted array` ` ` `int` `sum = 0;` ` ` `int` `count = 0;` ` ` `// Iterate for all the` ` ` `// elements in the array` ` ` `for` `(` `int` `i = 0; i < n; i++)` ` ` `{` ` ` ` ` `// Add the current element to sum` ` ` `sum = sum + A[i];` ` ` `if` `(sum > k) ` ` ` `{` ` ` `break` `;` ` ` `}` ` ` `// Increment the count` ` ` `count++;` ` ` `}` ` ` `// Return the answer` ` ` `return` `count;` `}` `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` ` ` `// Given array` ` ` `int` `[] A = { 3, 7, 2, 9, 4 };` ` ` `// Given sum k` ` ` `int` `k = 15;` ` ` `int` `n = A.Length;` ` ` `// Function call` ` ` `Console.Write(maxSelections(A, n, k));` `}` `}` `// This code is contributed by gauravrajput1` |

*chevron_right*

*filter_none*

**Output:**

3

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.

## Recommended Posts:

- Maximize Array sum by swapping at most K elements with another array
- Maximize distance between two elements of Array by at most X swaps
- Minimum possible value T such that at most D Partitions of the Array having at most sum T is possible
- Maximize length of subarray of equal elements by performing at most K increment operations
- Maximize length of subarray having equal elements by adding at most K
- Maximize the sum of X+Y elements by picking X and Y elements from 1st and 2nd array
- Maximize sum of K elements in Array by taking only corner elements
- Maximize sum of atmost K elements in array by taking only corner elements | Set 2
- Maximize the number by flipping at most K bits
- Maximize the sum of sum of the Array by removing end elements
- Maximize sum of remaining elements after every removal of the array half with greater sum
- Maximize sum of array by reducing array elements to contain no triplets (i, j, k) where a[i] < a[j] and a[i] < a[k] and j <i < k
- Rearrange Array to maximize number having Array elements as digits based on given conditions
- Maximize the sum of differences of consecutive elements after removing exactly K elements
- Maximize the profit by selling at-most M products
- Maximize length of Non-Decreasing Subsequence by reversing at most one Subarray
- Rearrange the array to maximize the number of primes in prefix sum of the array
- Maximum subarray sum by flipping signs of at most K array elements
- Maximize array sum by concatenating corresponding elements of given two arrays
- Reverse a subarray to maximize sum of even-indexed elements of given array

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.