### LeetCode Challenge #1431. Kids With the Greatest Number of Candies

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.

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]
```

Constraints:

• `n == candies.length`
• `2 <= n <= 100`
• `1 <= candies[i] <= 100`
• `1 <= extraCandies <= 50`
##### Video Solution
###### C++ Solution
```				```
class Solution {
public:
vector<bool> kidsWithCandies(vector<int>& candies, int extraCandies) {

vector<bool> result(candies.size(),0);

int maxm=INT_MIN;

for(int i=0; i<candies.size(); i++)
{
maxm=max(maxm,candies[i]);
}

for(int i=0; i<candies.size(); i++)
{
if((candies[i]+extraCandies)>=maxm) result[i]=true;
}

return result;
}
};

```
```
###### Code Explanation

The purpose of this function is to determine, which children can have the greatest number of candies when provided with some ‘extraCandies’. Every element of ‘candies’ represents the number of candies ‘ i th’ kid have.

We have to return an array in a boolean function  ( ‘True’ or ‘false’ )

1. Declare two arguments: a vector int ‘candies’  which represents the the number of candies each child has, and an integer ‘extraCandies’ which represents the extra candies given to each child.
2. Starting by determining the array of boolean function  ‘vector<bool>’ and a boolean vector ‘result’ . All the elements of ‘result’ are initialised to false with the size same as the size of ‘candies.size ’
1. We need to iterate the ‘candies’ vector. In this loop, we first need to find out the ‘max’ number of candies a child can have i.e., finding the maximum element from the array.

For this purpose, initialise an integer variable ‘maxm’ with a very small value, ‘INT_MIN’

1. After finding the maximum number of candies, we’ll use another loop to determine which children can have the most candies when provided with ‘extraCandies’. With ‘maxm’
2. If the sum of the current child’s candies and ‘extraCandies’ is greater than or equal to ‘maxm’ , it means the child can have the maximum number of candies , and result[ i ] is ‘true’ for this child.
1. Finally, if the corresponding child is having the maximum number of candies when given extra candies, the ‘result’ returns ‘True ‘ and ‘False’ otherwise. In this way, we can determine which children can have the most candies after receiving extra candies.