Kids With the Greatest Number of Candies - Practice Coding Problems

Kids With the Greatest Number of Candies - Problem

Array Easy

Imagine you're a teacher distributing extra candies to kids in your classroom! 🍭

You have n kids, each already holding some candies. You're given an integer array candies where candies[i] represents the number of candies the i-th kid currently has.

You also have extraCandies - a stash of bonus candies that you can give to any one kid. Your mission is to determine: "If I give ALL my extra candies to each kid (one at a time), would that kid end up having the most candies in the class?"

Goal: Return a boolean array result of length n, where result[i] is true if giving the i-th kid all the extraCandies makes them have the greatest number of candies among all kids.

Important: Multiple kids can be tied for having the greatest number of candies - that's perfectly fine!

Example: If kids have [2, 3, 5, 1, 3] candies and you have 3 extra candies, then giving all 3 extra candies to kid 0 gives them 2+3=5 candies, which ties for the maximum. So kid 0 would get true in the result!

Input & Output

Basic Example - Mixed Results

$ Input: candies = [2,3,5,1,3], extraCandies = 3

› Output: [true,true,true,false,true]

💡 Note: Kid 0: 2+3=5 (ties with max 5) ✓, Kid 1: 3+3=6 (exceeds max 5) ✓, Kid 2: 5+3=8 (exceeds max 5) ✓, Kid 3: 1+3=4 (less than max 5) ✗, Kid 4: 3+3=6 (exceeds max 5) ✓

All Kids Can Be Greatest

$ Input: candies = [4,2,1,1,2], extraCandies = 1

› Output: [true,false,false,false,false]

💡 Note: Current maximum is 4. Kid 0: 4+1=5 ✓, Kid 1: 2+1=3 < 4 ✗, Kid 2: 1+1=2 < 4 ✗, Kid 3: 1+1=2 < 4 ✗, Kid 4: 2+1=3 < 4 ✗

Large Extra Candies

$ Input: candies = [12,1,12], extraCandies = 10

› Output: [true,true,true]

💡 Note: With 10 extra candies, everyone can exceed or match the current maximum of 12. Kid 0: 12+10=22 ✓, Kid 1: 1+10=11 < 12 ✗... Wait, that's wrong! Kid 1: 1+10=11 < 12 ✗, but actually Kid 1: 1+10=11 < 12, so result should be [true,false,true]. Let me recalculate: Kid 0: 22≥12 ✓, Kid 1: 11≥12 ✗, Kid 2: 22≥12 ✓

Visualization

Tap to expand

Understanding the Visualization

Scout the Current Champion

Look through all kids to find who has the most candies right now

Test Each Kid's Potential

For each kid, calculate: current candies + extra candies

Compare with Champion

If their potential >= champion's candies, they can be greatest

Record Results

Build boolean array showing who can become champion

Key Takeaway

🎯 Key Insight: By finding the maximum first, we transform an O(n²) comparison problem into an elegant O(n) solution. Each kid only needs to 'compete' against the current champion, not everyone!

Time & Space Complexity

Time Complexity

⏱️

O(n)

We make two passes through the array: one to find maximum (O(n)) and one to check each kid (O(n))

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for storing the maximum value and loop variables

✓ Linear Space

Constraints

n == candies.length
2 ≤ n ≤ 100
1 ≤ candies[i] ≤ 100
1 ≤ extraCandies ≤ 50

Asked in

LC LeetCode 25 G Google 8 a Amazon 12 f Meta 6

The optimal solution uses a two-pass approach: first find the maximum candies any kid has, then check each kid to see if their total (current + extra) can reach this maximum. This reduces time complexity from O(n²) to O(n) while maintaining O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	For each kid, simulate giving them extra candies and compare with all other kids
Optimized Single Pass (Optimal)	O(n)	O(1)	Find the maximum candies first, then check each kid in one pass

Brute Force (Nested Loops) — Algorithm Steps

For each kid i, calculate their potential total: candies[i] + extraCandies
Compare this total with every other kid's current candies
If potential total >= all other kids' candies, mark result[i] as true
Otherwise, mark result[i] as false

Visualization

Tap to expand

Step-by-Step Walkthrough

Test Kid 0

Give Kid 0 all extra candies, compare with everyone

Test Kid 1

Give Kid 1 all extra candies, compare with everyone

Continue for all kids

Repeat the process for remaining kids

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

bool* kidsWithCandies(int* candies, int candiesSize, int extraCandies, int* returnSize) {
    *returnSize = candiesSize;
    bool* result = (bool*)malloc(candiesSize * sizeof(bool));
    
    for (int i = 0; i < candiesSize; i++) {
        // Calculate potential candies for kid i
        int potential = candies[i] + extraCandies;
        
        // Check if this kid can have the most candies
        bool canBeGreatest = true;
        for (int j = 0; j < candiesSize; j++) {
            if (potential < candies[j]) {
                canBeGreatest = false;
                break;
            }
        }
        
        result[i] = canBeGreatest;
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n kids, we compare with all n kids, resulting in n × n operations

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables for comparisons, no extra data structures

✓ Linear Space

Constraints

n == candies.length
2 ≤ n ≤ 100
1 ≤ candies[i] ≤ 100
1 ≤ extraCandies ≤ 50

68.0K Views

Medium Frequency

~8 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler