# Covering maximum array elements with given value

Given total number of candies ‘X’, number of student ‘N’ and an array ‘arr’ which holds the value for the exact number of candies that must be given to a student to make the student happy where `arr[i]` is the exact amount of candies that make the student ‘i’ happy. The task is to distribute the candies in such a way that makes maximum students happy.

Examples:

```Input : X = 70, arr = {20, 30, 10}
Output: 2
One optimal way of distribution is (20, 40, 10)
So, the number of happy students are 2.

Input: X = 10, arr = {20, 30, 10}
Output: 1
One optimal way of distribution is (0, 0, 10)
Only 1 student can be made happy in this case
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: We can maximise the number of happy students by starting to give candies to the students who are happy with lesser candies.
So we sort the list of students in ascending based on candies. Then, we will simply go through the array and take the students until the sum is less than or equal to the total candies.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach ` `# include ` `using` `namespace` `std; ` ` `  `// Function to find value for  ` `// covering maximum array elements ` `int` `maxArrayCover(vector<``int``> a, ``int` `n, ``int` `x){ ` ` `  `    ``// sort the students in  ` `    ``// ascending based on  ` `    ``// the candies  ` `    ``sort(a.begin(), a.end()); ` `      `  `    ``// To store the number  ` `    ``// of happy students ` `    ``int` `cc = 0; ` `      `  `    ``// To store the running sum ` `    ``int` `s = 0; ` `    ``for` `(``int` `i = 0; i < n; i++){ ` `        ``s += a[i]; ` ` `  `        ``// If the current student ` `        ``// can't be made happy ` `        ``if``(s > x){ ` `           ``break``; ` `        ``} ` ` `  `        ``// increment the count  ` `        ``// if we can make the  ` `        ``// ith student happy ` `        ``cc += 1; ` `    ``} ` `      `  `    ``// If the sum = x  ` `    ``// then answer is n ` `    ``if``(accumulate(a.begin(), a.end(), 0) == x){ ` `        ``return` `n; ` `    ``} ` `    ``else``{ ` `        ``// If the count is ` `        ``// equal to n then  ` `        ``// the answer is n-1 ` `        ``if``(cc == n){ ` `            ``return` `n-1; ` `        ``} ` `        ``else``{ ` `            ``return` `cc; ` `        ``} ` `    ``} ` `} ` ` `  `// Driver function ` `int` `main(){ ` ` `  `    ``int` `n = 3; ` `    ``int` `x = 70; ` `    ``vector<``int``> a = {10, 20, 30}; ` ` `  `    ``printf``(``"%d\n"``,maxArrayCover(a, n, x)); ` ` `  `    ``return` `0; ` `} ` `// This code is contributed  ` `// by Harshit Saini  `

## Java

 `// Java implementation of the approach ` ` `  `import` `java.util.*; ` ` `  `class` `GFG{ ` ` `  `    ``// Function to find value for  ` `    ``// covering maximum array elements ` `    ``public` `static` `int` `maxArrayCover(``int``[] a, ``int` `n, ``int` `x){ ` ` `  `        ``// sort the students in  ` `        ``// ascending based on  ` `        ``// the candies  ` `        ``Arrays.sort(a); ` `          `  `        ``// To store the number  ` `        ``// of happy students ` `        ``int` `cc = ``0``; ` `          `  `        ``// To store the running sum ` `        ``int` `s = ``0``; ` `        ``for` `(``int` `i = ``0``; i < n; i++){ ` `            ``s += a[i]; ` ` `  `            ``// If the current student ` `            ``// can't be made happy ` `            ``if``(s > x){ ` `               ``break``; ` `            ``} ` ` `  `            ``// increment the count  ` `            ``// if we can make the  ` `            ``// ith student happy ` `            ``cc += ``1``; ` `        ``} ` `          `  `        ``// If the sum = x  ` `        ``// then answer is n ` `        ``if``(Arrays.stream(a).sum() == x){ ` `            ``return` `n; ` `        ``} ` `        ``else``{ ` `            ``// If the count is ` `            ``// equal to n then  ` `            ``// the answer is n-1 ` `            ``if``(cc == n){ ` `                ``return` `n-``1``; ` `            ``} ` `            ``else``{ ` `                ``return` `cc; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// Driver function ` `    ``public` `static` `void` `main(String []args){ ` ` `  `        ``int` `n   = ``3``; ` `        ``int` `x   = ``70``; ` `        ``int``[] a = ``new` `int``[]{``10``, ``20``, ``30``}; ` ` `  `        ``System.out.println(maxArrayCover(a, n, x)); ` ` `  `        ``System.exit(``0``); ` `    ``} ` `} ` ` `  `// This code is contributed  ` `// by Harshit Saini  `

## Python3

 `# Python implementation of the approach ` ` `  `# Function to find value for  ` `# covering maximum array elements ` `def` `maxArrayCover(a, n, x): ` ` `  `    ``# sort the students in  ` `    ``# ascending based on  ` `    ``# the candies  ` `    ``a.sort() ` `      `  `    ``# To store the number  ` `    ``# of happy students ` `    ``cc ``=` `0` `      `  `    ``# To store the running sum ` `    ``s ``=` `0`  `    ``for` `i ``in` `range``(n): ` `         ``s``+``=` `a[i] ` `           `  `         ``# If the current student ` `         ``# can't be made happy ` `         ``if``(s > x): ` `             ``break` `      `  `         ``# increment the count  ` `         ``# if we can make the  ` `         ``# ith student happy ` `         ``cc ``+``=` `1` `      `  `    ``# If the sum = x  ` `    ``# then answer is n ` `    ``if``(``sum``(a) ``=``=` `x): ` `         ``return` `n ` `    ``else``: ` `         ``# If the count is ` `         ``# equal to n then  ` `         ``# the answer is n-1 ` `         ``if``(cc ``=``=` `n): ` `            ``return` `n``-``1` `         ``else``: ` `            ``return` `cc ` ` `  `# Driver function ` `if` `__name__ ``=``=` `'__main__'``: ` ` `  `    ``n, x ``=` `3``, ``70` `    ``a    ``=` `[``10``, ``20``, ``30``]     ` ` `  `    ``print``(maxArrayCover(a, n, x)) `

## C#

 `// C# implementation of the approach ` ` `  `using` `System; ` `using` `System.Linq; ` ` `  `class` `GFG{ ` ` `  `    ``// Function to find value for  ` `    ``// covering maximum array elements ` `    ``static` `int` `maxArrayCover(``int``[] a, ``int` `n, ``int` `x){ ` ` `  `        ``// sort the students in  ` `        ``// ascending based on  ` `        ``// the candies  ` `        ``Array.Sort(a); ` `          `  `        ``// To store the number  ` `        ``// of happy students ` `        ``int` `cc = 0; ` `          `  `        ``// To store the running sum ` `        ``int` `s = 0; ` `        ``for` `(``int` `i = 0; i < n; i++){ ` `            ``s += a[i]; ` ` `  `            ``// If the current student ` `            ``// can't be made happy ` `            ``if``(s > x){ ` `               ``break``; ` `            ``} ` ` `  `            ``// increment the count  ` `            ``// if we can make the  ` `            ``// ith student happy ` `            ``cc += 1; ` `        ``} ` `          `  `        ``// If the sum = x  ` `        ``// then answer is n ` `        ``if``(a.Sum() == x){ ` `            ``return` `n; ` `        ``} ` `        ``else``{ ` `            ``// If the count is ` `            ``// equal to n then  ` `            ``// the answer is n-1 ` `            ``if``(cc == n){ ` `                ``return` `n-1; ` `            ``} ` `            ``else``{ ` `                ``return` `cc; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// Driver function ` `    ``public` `static` `void` `Main(){ ` ` `  `        ``int` `n   = 3; ` `        ``int` `x   = 70; ` `        ``int``[] a = ``new` `int``[]{10, 20, 30}; ` ` `  `        ``Console.WriteLine(maxArrayCover(a, n, x)); ` `    ``} ` `} ` ` `  `// This code is contributed  ` `// by Harshit Saini  `

## PHP

 ` ``\$x``){ ` `           ``break``; ` `        ``} ` ` `  `        ``// increment the count  ` `        ``// if we can make the  ` `        ``// ith student happy ` `        ``\$cc` `+= 1; ` `    ``} ` `      `  `    ``// If the sum = x  ` `    ``// then answer is n ` `    ``if``(``array_sum``(``\$a``) == ``\$x``){ ` `        ``return` `\$n``; ` `    ``} ` `    ``else``{ ` `        ``// If the count is ` `        ``// equal to n then  ` `        ``// the answer is n-1 ` `        ``if``(``\$cc` `== ``\$n``){ ` `            ``return` `\$n``-1; ` `        ``} ` `        ``else``{ ` `            ``return` `\$cc``; ` `        ``} ` `    ``} ` `} ` ` `  `\$n` `= 3; ` `\$x` `= 70; ` `\$a` `= ``array``(10, 20, 30); ` ` `  `echo` `maxArrayCover(``\$a``, ``\$n``, ``\$x``); ` ` `  `// This code is contributed  ` `// by Harshit Saini  ` `?> `

Output:

```2
```

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

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.

My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

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.

Improved By : Harshit Saini

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.