There are n kids with candies. You are given an integer array candies, where each candies[i] represents the number of candies the ith kid has, and an integer extraCandies, denoting the number of extra candies that you have.

Return a boolean array result of length n, where result[i] is true if, after giving the ith kid all the extraCandies, they will have the greatest number of candies among all the kids, or false otherwise.

Note that multiple kids can have the greatest number of candies.

&nbsp;
Example 1:

Input: candies = [2,3,5,1,3], extraCandies = 3
Output: [true,true,true,false,true] 
Explanation: If you give all extraCandies to:
- Kid 1, they will have 2 + 3 = 5 candies, which is the greatest among the kids.
- Kid 2, they will have 3 + 3 = 6 candies, which is the greatest among the kids.
- Kid 3, they will have 5 + 3 = 8 candies, which is the greatest among the kids.
- Kid 4, they will have 1 + 3 = 4 candies, which is not the greatest among the kids.
- Kid 5, they will have 3 + 3 = 6 candies, which is the greatest among the kids.


Example 2:

Input: candies = [4,2,1,1,2], extraCandies = 1
Output: [true,false,false,false,false] 
Explanation: There is only 1 extra candy.
Kid 1 will always have the greatest number of candies, even if a different kid is given the extra candy.


Example 3:

Input: candies = [12,1,12], extraCandies = 10
Output: [true,false,true]


&nbsp;
Constraints:


	n == candies.length
	2 &lt;= n &lt;= 100
	1 &lt;= candies[i] &lt;= 100
	1 &lt;= extraCandies &lt;= 50


class Solution:
    def kidsWithCandies(self, candy, extra):
        #create an array(res) with all values as True and it's lenght is same as candies
        res = [True]*len(candy)
        #iterate over the elements in the array candy
        for i in range(len(candy)):
            #if the no. of canides at curr position + extra is greater than or equal to the maximum of candies then continue 
            if (candy[i] + extra) >= max(candy):
                continue
            #if not 
            else:
                #change the value of that position in res as false
                res[i] = False
        #return the res list
        return res   
class Solution {
    public List<Boolean> kidsWithCandies(int[] candies, int extraCandies) {
        List<Boolean>result = new ArrayList<>(candies.length); // better practice since the length is known
        int theHighest=candies[0]; //always good practice to start from known value or to check constraints, 0 or -1
        for (int i = 1; i<candies.length; i++) {
          theHighest = Math.max(theHighest,candies[i]); //returns the greatest value for us to compare later
            }
        //Since we are comparing with greatest value, we can use math logic to subtract extraCandies the other side
        //(candies[i]+extraCandies >= theHighest) or (candies[i] >= theHighest-extraCandies)
          int mathLogic = theHighest - extraCandies;
        for (int i = 0; i<candies.length; i++) {
           //logic: 6+5>=10 or 6 >=10-5
               if (candies[i] >= mathLogic) {
                   result.add(true);
               } else {
                    result.add(false);
                    }
            }
        return result;
        }
}
class Solution {
public:
    vector<bool> kidsWithCandies(vector<int>& candies, int extraCandies) {
        vector<bool> ans;
        int i = 0, size, max = 0;
        size = candies.size();
        for(i = 0; i<size; i++){
            if(candies[i]>max) max = candies[i];
        }
        for(i = 0; i<size;i++){
            if(candies[i]+extraCandies >= max){
                ans.push_back(true);
            }
            else ans.push_back(false);
        }
        return ans;
    }
};
var kidsWithCandies = function(candies, extraCandies) {
    //First find out maximum number in array:->
    let max=0, res=[]; 
    for(let i=0; i<candies.length; i++){
        if(candies[i]>max) max=candies[i];
    }
    console.log(max)
    
    /*Now add extraCandies with every element in array and checks if
	that sum is equals to or greater than max and return true and false otherwise; */
    
    for(let i=0; i<candies.length; i++){
        let temp=candies[i]+extraCandies;
        if(temp>=max) res.push(true);
        else res.push(false);
    }
    return res;
};
Kids With the Greatest Number of Candies