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

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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
# include<bits/stdc++.h>
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 

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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))

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP implementation of the approach
  
// Function to find value for 
// covering maximum array elements
function maxArrayCover($a, $n, $x){
  
    // sort the students in 
    // ascending based on 
    // the candies 
    sort($a);
       
    // To store the number 
    // of happy students
    $cc = 0;
       
    // To store the running sum
    $s = 0;
    for ($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(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 
?>

chevron_right


Output:

2

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



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.