Candy - Practice Coding Problems

Candy - Problem

Array Greedy Hard

Imagine you're a teacher distributing candy to n children standing in a line. Each child has been given a rating based on their performance, and you need to distribute candies fairly while minimizing the total number of candies used.

The Rules:

🍬 Every child must receive at least one candy
⭐ If a child has a higher rating than their neighbor, they must receive more candies than that neighbor
🎯 You want to use the minimum total number of candies possible

Input: An integer array ratings where ratings[i] is the rating of the i-th child.

Output: The minimum number of candies needed to satisfy all requirements.

Example: If ratings are [1,0,2], child 0 gets 2 candies, child 1 gets 1 candy, child 2 gets 2 candies, totaling 5 candies.

Input & Output

example_1.py — Basic case

$ Input: ratings = [1,0,2]

› Output: 5

💡 Note: Child 0 (rating 1) gets 2 candies (more than child 1 with rating 0). Child 1 (rating 0) gets 1 candy. Child 2 (rating 2) gets 2 candies (more than child 1). Total: 2 + 1 + 2 = 5.

example_2.py — All same ratings

$ Input: ratings = [1,2,2]

› Output: 4

💡 Note: Child 0 gets 1 candy. Child 1 (rating 2 > 1) gets 2 candies. Child 2 (rating 2, same as child 1) gets 1 candy. Total: 1 + 2 + 1 = 4.

example_3.py — Single child

$ Input: ratings = [5]

› Output: 1

💡 Note: Only one child, so they get the minimum 1 candy regardless of their rating.

Constraints

n == ratings.length
1 ≤ n ≤ 2 × 10⁴
0 ≤ ratings[i] ≤ 2 × 10⁴

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

Give every student 1 candy as the base amount

Left-to-Right Walk

Walk from first to last student, giving extra candy when a student has higher rating than their left neighbor

Right-to-Left Walk

Walk from last to first student, ensuring students with higher ratings than right neighbors have enough candy

Optimal Distribution

The two-pass approach guarantees minimum total candies while satisfying all fairness constraints

Key Takeaway

🎯 Key Insight: By making two separate passes (left-to-right, then right-to-left), we can satisfy all neighbor constraints optimally without needing complex logic or multiple iterations.

Asked in

G Google 45 a Amazon 38 f Meta 25 ⊞ Microsoft 22 Apple 18

The optimal solution uses a two-pass greedy approach. First, scan left-to-right ensuring each child has more candies than their left neighbor if their rating is higher. Then scan right-to-left, taking the maximum of current candies and required candies based on right neighbor comparison. This guarantees the minimum total candies while satisfying all constraints in O(n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Iterative Adjustment)	O(n²)	O(n)	Repeatedly scan and adjust candy counts until all constraints are satisfied
Two-Pass Greedy (Optimal)	O(n)	O(n)	Make two passes: left-to-right, then right-to-left, satisfying constraints greedily

Brute Force (Iterative Adjustment) — Algorithm Steps

Initialize all children with 1 candy
Scan left-to-right: if ratings[i] > ratings[i-1] and candies[i] <= candies[i-1], set candies[i] = candies[i-1] + 1
Scan right-to-left: if ratings[i] > ratings[i+1] and candies[i] <= candies[i+1], set candies[i] = candies[i+1] + 1
Repeat steps 2-3 until no changes are made in a complete pass
Sum all candy counts

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Give each child 1 candy initially

Left-to-right scan

Increase candy count where higher-rated child has too few

Right-to-left scan

Adjust for right neighbor comparisons

Repeat until stable

Continue passes until no changes are made

Code -

solution.c — C

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

int candy(int* ratings, int ratingsSize) {
    if (ratingsSize == 0) return 0;
    
    int* candies = (int*)malloc(ratingsSize * sizeof(int));
    for (int i = 0; i < ratingsSize; i++) {
        candies[i] = 1;
    }
    
    bool changed = true;
    while (changed) {
        changed = false;
        
        // Left to right pass
        for (int i = 1; i < ratingsSize; i++) {
            if (ratings[i] > ratings[i-1] && candies[i] <= candies[i-1]) {
                candies[i] = candies[i-1] + 1;
                changed = true;
            }
        }
        
        // Right to left pass
        for (int i = ratingsSize-2; i >= 0; i--) {
            if (ratings[i] > ratings[i+1] && candies[i] <= candies[i+1]) {
                candies[i] = candies[i+1] + 1;
                changed = true;
            }
        }
    }
    
    int total = 0;
    for (int i = 0; i < ratingsSize; i++) {
        total += candies[i];
    }
    
    free(candies);
    return total;
}

int main() {
    int ratings[1000];
    int n = 0;
    char c;
    while (scanf("%d%c", &ratings[n], &c) == 2) {
        n++;
        if (c == '\n') break;
    }
    printf("%d\n", candy(ratings, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, we need O(n) passes through the array, each taking O(n) time

⚠ Quadratic Growth

Space Complexity

O(n)

Need array to store candy count for each child

⚡ Linearithmic Space

87.5K Views

High Frequency

~25 min Avg. Time

3.2K 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Iterative Adjustment) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler