**Physical Address**

304 North Cardinal St.

Dorchester Center, MA 02124

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*.

**Example 1:**

**Input:** ratings = [1,0,2]
**Output:** 5
**Explanation:** You can allocate to the first, second and third child with 2, 1, 2 candies respectively.

**Example 2:**

**Input:** ratings = [1,2,2]
**Output:** 4
**Explanation:** You can allocate to the first, second and third child with 1, 2, 1 candies respectively.
The third child gets 1 candy because it satisfies the above two conditions.

**Constraints:**

`n == ratings.length`

`1 <= n <= 2 * 10`

^{4}`0 <= ratings[i] <= 2 * 10`

^{4}

```
class Solution {
public:
int candy(vector<int>& ratings) {
int n = ratings.size();
int candy = n, i=1;
while(i<n){
if(ratings[i] == ratings[i-1]){
i++;
continue;
}
//For increasing slope
int peak = 0;
while(ratings[i] > ratings [i-1]){
peak++;
candy += peak;
i++;
if(i == n) return candy;
}
//For decreasing slope
int valley = 0;
while(i<n && ratings[i] < ratings[i-1]){
valley++;
candy += valley;
i++;
}
candy -= min(peak, valley); //Keep only the higher peak
}
return candy;
}
};
```

```
public int candy(int[] ratings) {
int candies[] = new int[ratings.length];
Arrays.fill(candies, 1);// Give each child 1 candy
for (int i = 1; i < candies.length; i++){// Scan from left to right, to make sure right higher rated child gets 1 more candy than left lower rated child
if (ratings[i] > ratings[i - 1]) candies[i] = (candies[i - 1] + 1);
}
for (int i = candies.length - 2; i >= 0; i--) {// Scan from right to left, to make sure left higher rated child gets 1 more candy than right lower rated child
if (ratings[i] > ratings[i + 1]) candies[i] = Math.max(candies[i], (candies[i + 1] + 1));
}
int sum = 0;
for (int candy : candies)
sum += candy;
return sum;
}
```

```
class Solution:
def candy(self, R):
n, ans = len(R), [1]*len(R)
for i in range(n-1):
if R[i] < R[i+1]:
ans[i+1] = max(1 + ans[i], ans[i+1])
for i in range(n-2, -1, -1):
if R[i+1] < R[i]:
ans[i] = max(1 + ans[i+1], ans[i])
return sum(ans)
```

In our experience, we suggest you solve this Candy LeetCode Solution and gain some new skills from Professionals completely free and we assure you will be worth it.

If you are stuck anywhere between any coding problem, just visit Queslers to get the Candy LeetCode Solution

I hope this Candy LeetCode Solution would be useful for you to learn something new from this problem. If it helped you then don’t forget to bookmark our site for more Coding Solutions.

This Problem is intended for audiences of all experiences who are interested in learning about Data Science in a business context; there are no prerequisites.

Keep Learning!

**More Coding Solutions >>**