Candy

                                            
class Solution {
public:
    int candy(vector<int>& ratings) {
        int n = ratings.size();
        vector<int> candies(n, 1);
        
        for (int i = 1; i < n; ++i) {
            if (ratings[i] > ratings[i - 1]) {
                candies[i] = candies[i - 1] + 1;
            }
        }
        
        for (int i = n - 2; i >= 0; --i) {
            if (ratings[i] > ratings[i + 1]) {
                candies[i] = max(candies[i], candies[i + 1] + 1);
            }
        }
        
        int total = accumulate(candies.begin(), candies.end(), 0);
        
        return total;
    }
};

                                            
class Solution {
    public int candy(int[] ratings) {
        int n = ratings.length;
        int[] left = new int[n];
        int[] right = new int[n];
        
        // Initialize each child with 1 candy
        Arrays.fill(left, 1);
        Arrays.fill(right, 1);
        
        // Scan from left to right to ensure higher ratings get more candies
        for (int i = 1; i < n; i++) {
            if (ratings[i] > ratings[i - 1]) {
                left[i] = left[i - 1] + 1;
            }
        }
        
        // Scan from right to left to ensure higher ratings get more candies
        for (int i = n - 2; i >= 0; i--) {
            if (ratings[i] > ratings[i + 1]) {
                right[i] = right[i + 1] + 1;
            }
        }
        
        int total = 0;
        for (int i = 0; i < n; i++) {
            total += Math.max(left[i], right[i]);
        }
        
        return total;
    }
}

                                            
class Solution(object):
    def candy(self, ratings):
        candies = [1] * len(ratings)
        
        for i in range(1, len(ratings)):
            if ratings[i] > ratings[i-1]:
                candies[i] = candies[i-1] + 1
        
        for i in range(len(ratings) - 2, -1, -1):
            if ratings[i] > ratings[i+1]:
                candies[i] = max(candies[i], candies[i+1] + 1)
        
        return sum(candies)

                                            
int candy(int* ratings, int ratingsSize) {
    if (ratingsSize == 0) {
        return 0;
    }
    
    int candies[ratingsSize];
    memset(candies, 0, sizeof(candies));
    
    for (int i = 0; i < ratingsSize; i++) {
        candies[i] = 1;
    }
    
    for (int i = 1; i < ratingsSize; i++) {
        if (ratings[i] > ratings[i-1]) {
            candies[i] = candies[i-1] + 1;
        }
    }
    
    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;
        }
    }
    
    int sum = 0;
    for (int i = 0; i < ratingsSize; i++) {
        sum += candies[i];
    }
    
    return sum;
}

                                            
public class Solution {
    public int Candy(int[] ratings) {
        int n = ratings.Length;
        int[] leftToRight = new int[n];
        int[] rightToLeft = new int[n];

        for (int i = 0; i < n; i++) {
            leftToRight[i] = 1;
            rightToLeft[i] = 1;
        }

        for (int i = 1; i < n; i++) {
            if (ratings[i] > ratings[i - 1]) {
                leftToRight[i] = leftToRight[i - 1] + 1;
            }
        }

        for (int i = n - 2; i >= 0; i--) {
            if (ratings[i] > ratings[i + 1]) {
                rightToLeft[i] = rightToLeft[i + 1] + 1;
            }
        }

        int result = 0;
        for (int i = 0; i < n; i++) {
            result += Math.Max(leftToRight[i], rightToLeft[i]);
        }

        return result;
    }
}

                                            
/**
 * @param {number[]} ratings
 * @return {number}
 */
var candy = function(ratings) {
    const n = ratings.length;
    const left = new Array(n).fill(1);
    const right = new Array(n).fill(1);
    
    for (let i = 1; i < n; i++) {
        if (ratings[i] > ratings[i - 1]) {
            left[i] = left[i - 1] + 1;
        }
    }
    
    let res = left[n - 1];
    
    for (let i = n - 2; i >= 0; i--) {
        if (ratings[i] > ratings[i + 1]) {
            right[i] = right[i + 1] + 1;
        }
        res += Math.max(left[i], right[i]);
    }
    
    return res;
};

                                            
function candy(ratings: number[]): number {
    const n = ratings.length;
    if (n === 0) return 0;
    
    const leftToRight = new Array(n).fill(1);
    const rightToLeft = new Array(n).fill(1);
    
    for (let i = 1; i < n; i++) {
        if (ratings[i] > ratings[i - 1]) {
            leftToRight[i] = leftToRight[i - 1] + 1;
        }
    }
    
    let res = leftToRight[n - 1];
    
    for (let i = n - 2; i >= 0; i--) {
        if (ratings[i] > ratings[i + 1]) {
            rightToLeft[i] = rightToLeft[i + 1] + 1;
        }
        res += Math.max(rightToLeft[i], leftToRight[i]);
    }
    
    return res;
};

                                            
class Solution {
    /**
     * @param Integer[] $ratings
     * @return Integer
     */
    function candy($ratings) {
        $n = count($ratings);
        $left = array_fill(0, $n, 1);
        $right = array_fill(0, $n, 1);
        
        for ($i = 1; $i < $n; $i++) {
            if ($ratings[$i] > $ratings[$i - 1]) {
                $left[$i] = $left[$i - 1] + 1;
            }
        }
        
        $total = $left[$n - 1];
        
        for ($i = $n - 2; $i >= 0; $i--) {
            if ($ratings[$i] > $ratings[$i + 1]) {
                $right[$i] = $right[$i + 1] + 1;
            }
            $total += max($right[$i], $left[$i]);
        }
        
        return $total;
    }
}

                                            
class Solution {
    func candy(_ ratings: [Int]) -> Int {
        let n = ratings.count
        var candies = Array(repeating: 1, count: n)
        
        for i in 1..<n {
            if ratings[i] > ratings[i-1] {
                candies[i] = candies[i-1] + 1
            }
        }
        
        for i in (0..<(n-1)).reversed() {
            if ratings[i] > ratings[i+1] {
                candies[i] = max(candies[i], candies[i+1] + 1)
            }
        }
        
        return candies.reduce(0, +)
    }
}

                                            
class Solution {
    fun candy(ratings: IntArray): Int {
        val n = ratings.size
        val left = IntArray(n) { 1 }
        val right = IntArray(n) { 1 }

        for (i in 1 until n) {
            if (ratings[i] > ratings[i - 1]) {
                left[i] = left[i - 1] + 1
            }
        }

        var result = left[n - 1]
        for (i in n - 2 downTo 0) {
            if (ratings[i] > ratings[i + 1]) {
                right[i] = right[i + 1] + 1
            }
            result += maxOf(left[i], right[i])
        }

        return result
    }
}

                                            
func candy(ratings []int) int {
    n := len(ratings)
    
    left := make([]int, n)
    right := make([]int, n)
    
    for i := 0; i < n; i++ {
        left[i] = 1
        right[i] = 1
    }
    
    for i := 1; i < n; i++ {
        if ratings[i] > ratings[i-1] {
            left[i] = left[i-1] + 1
        }
    }
    
    for i := n-2; i >= 0; i-- {
        if ratings[i] > ratings[i+1] {
            right[i] = right[i+1] + 1
        }
    }
    
    result := 0
    
    for i := 0; i < n; i++ {
        result += max(left[i], right[i])
    }
    
    return result
}

func max(a, b int) int {
    if a > b {
        return a
    }
    return b
}

                                            
# @param {Integer[]} ratings
# @return {Integer}
def candy(ratings)
    n = ratings.length
    candies = Array.new(n, 1)
    
    (1...n).each do |i|
        if ratings[i] > ratings[i-1]
            candies[i] = candies[i-1] + 1
        end
    end
    
    (n-2).downto(0).each do |i|
        if ratings[i] > ratings[i+1]
            candies[i] = [candies[i], candies[i+1] + 1].max
        end
    end
    
    return candies.sum
end

                                            
object Solution {
    def candy(ratings: Array[Int]): Int = {
        val n = ratings.length
        val leftToRight = Array.fill(n)(1)
        val rightToLeft = Array.fill(n)(1)

        for (i <- 1 until n) {
            if (ratings(i) > ratings(i - 1)) {
                leftToRight(i) = leftToRight(i - 1) + 1
            }
        }

        for (i <- n - 2 to 0 by -1) {
            if (ratings(i) > ratings(i + 1)) {
                rightToLeft(i) = rightToLeft(i + 1) + 1
            }
        }

        var result = 0
        for (i <- 0 until n) {
            result += Math.max(leftToRight(i), rightToLeft(i))
        }

        result
    }
}

                                            
impl Solution {
    pub fn candy(ratings: Vec<i32>) -> i32 {
        let n = ratings.len();
        let mut candies = vec![1; n];
        
        for i in 1..n {
            if ratings[i] > ratings[i-1] {
                candies[i] = candies[i-1] + 1;
            }
        }
        
        for i in (0..n-1).rev() {
            if ratings[i] > ratings[i+1] {
                candies[i] = candies[i].max(candies[i+1] + 1);
            }
        }
        
        candies.iter().sum()
    }
}

To solve this coding challenge, we need to distribute candies to children based on their ratings while adhering to some constraints. The goal is to ensure each child gets at least one candy and children with higher ratings get more candies than their immediately adjacent neighbors. Here’s a detailed methodology for resolving this challenge:

# Explanation

Initialization:

We initialize an array
candies

of the same length as
ratings

and fill it with 1s. This ensures that each child has at least one candy initially.

Left-to-Right Pass:

We iterate over the
ratings

array from left to right. For each child, if their rating is higher than the rating of the previous child, we increment the number of candies for the current child based on the number of candies the previous child has. This process ensures that children with higher ratings get more candies than their left-side neighbors.

Right-to-Left Pass:

We then iterate over the
ratings

array from right to left. For each child, if their rating is higher than the rating of the next child, we adjust the number of candies for the current child to ensure it's at least one more than what the next child has if needed. This process ensures the higher ratings have more candies than their right-side neighbors.

Summing Up Candies:

Finally, we sum up all the values in the
candies

array to get the minimum number of candies needed to distribute according to the problem's constraints.

Detailed Steps in Pseudocode

Step 1: Initialize Candies Array

                                            
# Initialize candies array with all elements set to 1
candies = [1 for child in range(length of ratings)]

Step 2: First Pass (Left-to-Right)

                                            
# Iterate from the second child to the last child
for i from 1 to length of ratings - 1:
    if ratings[i] > ratings[i - 1]:
        # Increase candies for the current child
        candies[i] = candies[i - 1] + 1

Step 3: Second Pass (Right-to-Left)

                                            
# Iterate from the second to last child to the first child
for i from length of ratings - 2 to 0:
    if ratings[i] > ratings[i + 1]:
        # Adjust candies to ensure correct number
        candies[i] = max(candies[i], candies[i + 1] + 1)

Step 4: Calculate Total Candies

                                            
# Return the sum of the candies array
return sum(candies)

Full Pseudocode With Comments

                                            
# Step 1: Initialize candies array to ensure each child has at least one candy

candies = [1 for child in range(length of ratings)]

# Step 2: First Pass from left to right
for i from 1 to length of ratings - 1:
    # If current child's rating is higher than the previous child's rating
    if ratings[i] > ratings[i - 1]:
        # Give one more candy than the previous child
        candies[i] = candies[i - 1] + 1

# Step 3: Second Pass from right to left
for i from length of ratings - 2 to 0:
    # If current child's rating is higher than the next child's rating
    if ratings[i] > ratings[i + 1]:
        # Adjust candies to the maximum between current candies and next child's candies + 1
        candies[i] = max(candies[i], candies[i + 1] + 1)
        
# Step 4: Calculate and return the total number of candies needed
return sum(candies)

Each part of the pseudocode addresses specific problem requirements, ensuring that we allocate candies correctly based on the given rules. The comments within the pseudocode guide the reader through the logic step-by-step, ensuring clarity and comprehensiveness in the approach.