如何比较数组 c# 中的下一个值

Question

process involves adding toppings to individual pudding that have varying sizes that roll out on a conveyor belt.

1. At least 1g of toppings needs to be added to each pudding.
2. If two adjacent puddings are of different sizes, the larger piece needs to have at least 1g more than the smaller one.
3. If two adjacent pieces are of the same size, then the amount of toppings relative to each other does not matter.

XXXXXXX

public class Program
{

    static void Main(string[] args)
    {
        //topping t1 = new topping();
        //t1.CalTopping();

        topping t1 = new topping();
        t1.CalTopping();
    }

    public class topping
    {
     

        public void CalTopping()
        {
            int[] cupcakes = { 1, 2, 2, 6, 2, 1 };
            int tot = 0;
            int topping = 0;
            //int i=0;



            for (int i = 0; i < cupcakes.Length; i++)
            {
                
                if (i + 1 < cupcakes.Length)
                {
                    topping = 1;
                    if (cupcakes[i] == cupcakes[0])
                    {
                        topping = 1;
                    }

                    else if (cupcakes[i] > cupcakes[i - 1])
                    {

                        topping = topping + 1;
                    }
                    else
                        topping = 1;
                }

                tot = tot + topping;
                Console.WriteLine(cupcakes[i] + " = " + topping + "g");
            }
            Console.WriteLine("total toppings Amount:-" + tot + "g");

        }

    }
}

}

Answer 1

You can use the following algorithm to fulfill the requirements:

1. The first cupcake gets 1g of topping
2. If the current cupcake is larger than the previous, it get 1g more topping of the previous, otherwise it gets 1g of topping.
3. Repeat step 2 for all cupcakes.

Processing sequential pairs can be done with a loop like

for (int i = 1; i < cupcakes.Length; i++) { 
    var current = cupcakes[i];
    var previous = cupcakes[i-1];
    ...

Now, the question specified adjacent and not subsequent . To handle this we also need to do a loop in the reverse order using the same logic, but in this pass we need to take the maximum of the currently assigned topping amount and the new amount.

For example, Cupcakes of size 1, 2, 2, 6, 3, 2, 1 would get toppings of size

1. forward pass: 1, 2, 1, 2, 1, 1, 1
2. reverse pass: 1, 1, 1, 4, 3, 2, 1 ,
3. maximum of both: 1, 2, 1, 4, 3, 2, 1 .

This would not fit very well in the conveyor belt analogy since it would require the belt to go backwards and forwards, and require all cupcakes to be placed on the belt. But there are real world applications for algorithms like this.