LeetCode //C - 1431. Kids With the Greatest Number of Candies

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

From: LeetCode
Link: 1431. Kids With the Greatest Number of Candies

---

Solution:

Ideas：

1. Create a function kidsWithCandies that takes four parameters: candies (an array of integers), candiesSize (the size of the candies array), extraCandies (an integer), and returnSize (a pointer to an integer).
2. Inside the function, first find the maximum number of candies any kid currently has. This will help us to determine if adding extraCandies to any kid’s candies makes them have the greatest number of candies.
3. Allocate memory for a boolean array result of size candiesSize to store the output. The malloc function is used for memory allocation.
4. Iterate through the candies array, for each kid, add extraCandies to their current number of candies and compare it with the maximum number of candies. If the sum is greater than or equal to the maximum, set the corresponding element in result to true; otherwise, set it to false.
5. Set *returnSize to candiesSize to indicate the size of the returned array.
6. Return the result array.

Code:

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
bool* kidsWithCandies(int* candies, int candiesSize, int extraCandies, int* returnSize) {
    int maxCandies = 0;
    for (int i = 0; i < candiesSize; ++i) {
        if (candies[i] > maxCandies) {
            maxCandies = candies[i];
        }
    }

    bool* result = (bool*)malloc(candiesSize * sizeof(bool));
    for (int i = 0; i < candiesSize; ++i) {
        result[i] = (candies[i] + extraCandies >= maxCandies);
    }

    *returnSize = candiesSize;
    return result;
}