Candy

Candy - Problem

Array Greedy Hard

There are n children standing in a line. Each child is assigned a rating value given in the integer array ratings.

You are giving candies to these children subjected to the following requirements:

Each child must have at least one candy.
Children with a higher rating get more candies than their neighbors.

Return the minimum number of candies you need to have to distribute the candies to the children.

Input & Output

Example 1 — Basic Case

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

› Output: 5

💡 Note: Child 0: rating=1, gets 2 candies (higher than right neighbor). Child 1: rating=0, gets 1 candy. Child 2: rating=2, gets 2 candies (higher than left neighbor). Total: 2+1+2=5

Example 2 — All Same Rating

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

› Output: 4

💡 Note: Child 0: rating=1, gets 1 candy. Child 1: rating=2, gets 2 candies (higher than left). Child 2: rating=2, gets 1 candy (same as left, no constraint). Total: 1+2+1=4

Example 3 — Decreasing Sequence

$ Input: ratings = [5,4,3,2,1]

› Output: 15

💡 Note: Decreasing sequence requires candies [5,4,3,2,1] to satisfy neighbor constraints. Each child must have more candies than the right neighbor. Total: 5+4+3+2+1=15

Constraints

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

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 f Facebook 32 🍎 Apple 28

The key insight is to handle neighbor constraints with two passes: left-to-right for increasing sequences, right-to-left for decreasing sequences. The optimal two-pass greedy approach ensures minimum candies while satisfying all constraints. Time: O(n), Space: O(n)

Common Approaches

✓ Stack

⏱️ Time: N/A Space: N/A

Brute Force - Iterative Adjustment

⏱️ Time: O(n²) Space: O(n)

Start with 1 candy per child, then keep scanning and adjusting whenever a child with higher rating has less or equal candies than a neighbor. Continue until no more adjustments needed.

One Pass Greedy with Peak/Valley Detection

⏱️ Time: O(n) Space: O(1)

Identify increasing sequences, decreasing sequences, and peaks. For each segment, calculate the minimum candies needed and handle overlaps at peaks optimally. This avoids storing the entire candy array.

Two Pass Greedy

⏱️ Time: O(n) Space: O(n)

Make two passes through the array. First pass (left-to-right) ensures children with higher rating than left neighbor get more candies. Second pass (right-to-left) ensures children with higher rating than right neighbor get more candies.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚡ Linearithmic Space

285.0K Views

Medium Frequency

~35 min Avg. Time

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