using System;

using System.Collections.Generic;

​

class ConveyorFIFO

{

    private readonly int conveyorInit = 0;      // Initial index of the conveyor.

    private readonly int conveyorLength = 44;     // Total conveyor length.

    private readonly int minIndex = 11;           // Leftmost allowed steel placement.

    private readonly int maxEntryIndex = 38;      // Rightmost allowed starting position.

​

    // Dictionary that maps each index to one or more steel entries.

    // Each entry is a tuple: (weight per meter, steel type).

    private Dictionary<int, List<(double weight, int type)>> conveyorBelt;

​

    public ConveyorFIFO()

    {

        conveyorBelt = new Dictionary<int, List<(double, int)>>();

        // Initialize every index with the default value (0.0, 0)

        for (int i = conveyorInit; i <= conveyorLength; i++)

        {

            conveyorBelt[i] = new List<(double, int)> { (0.0, 0) };

        }

    }

​

    // Adds steel of a given type, length, and weight-per-meter.

    public void AddSteel(int steelType, int length, float weightPerMeterFloat)

    {

        double weightPerMeter = (double)weightPerMeterFloat;

​

        if (steelType == 13)

        {

            // For type 13, search only between minIndex and maxEntryIndex for a valid starting slot.

            int startIndex = minIndex;

            while (startIndex <= maxEntryIndex)

            {

                var entry = conveyorBelt[startIndex][0];

                // Eligible if slot is default OR if it contains steel that is not already merged with type 13.

                if (entry.Equals((0.0, 0)) || !entry.type.ToString().StartsWith("13"))

                {

                    break; // Found an eligible starting slot.

                }

                startIndex++;

            }

            if (startIndex > maxEntryIndex)

            {

                Console.WriteLine("Error: No eligible starting position for type 13 steel within allowed region.");

                return;

            }

​

            // Determine the block: while the first slot is guaranteed to be within the allowed region,

            // the block may extend past maxEntryIndex (up to the end of the conveyor).

            int endIndex = Math.Min(startIndex + length - 1, conveyorLength);

​

            // Verify that every index in the block is eligible.

            for (int i = startIndex; i <= endIndex; i++)

            {

                var entry = conveyorBelt[i][0];

                if (!(entry.Equals((0.0, 0)) || !entry.type.ToString().StartsWith("13")))

                {

                    Console.WriteLine($"Error: Contiguous eligible block for merging not found at index {i} for type 13 steel.");

                    return;

                }

            }

​

            // Now add/merge type 13 steel into each slot of the block.

            for (int i = startIndex; i <= endIndex; i++)

            {

                var entry = conveyorBelt[i][0];

                if (entry.Equals((0.0, 0)))

                {

                    // Slot is empty; add type 13 steel normally.

                    conveyorBelt[i].Clear();

                    conveyorBelt[i].Add((weightPerMeter, steelType));

                }

                else

                {

                    // Slot contains another steel type; merge by summing weights and concatenating types.

                    double newWeight = entry.weight + weightPerMeter;

                    // For example, if the existing type is 8 then merging with 13 produces 138.

                    string mergedTypeStr = "13" + entry.type.ToString();

                    int mergedType = int.Parse(mergedTypeStr);

                    conveyorBelt[i].Clear();

                    conveyorBelt[i].Add((newWeight, mergedType));

                }

            }

        }

        else

        {

            // For non-13 steel, search for the first free slot between minIndex and maxEntryIndex.

            int startIndex = minIndex;

            while (startIndex <= maxEntryIndex && !conveyorBelt[startIndex][0].Equals((0.0, 0)))

            {

                startIndex++;

            }

            if (startIndex > maxEntryIndex)

            {

                Console.WriteLine("Error: No free starting slot available within allowed region.");

                return;

            }

​

            // The block may extend beyond maxEntryIndex.

            int endIndex = Math.Min(startIndex + length - 1, conveyorLength);

            for (int i = startIndex; i <= endIndex; i++)

            {

                if (conveyorBelt[i][0].Equals((0.0, 0)))

                    conveyorBelt[i].Clear();

​

                conveyorBelt[i].Add((weightPerMeter, steelType));

            }

        }

    }

​

    // Moves the conveyor left by shifting every index one position.

    // The rightmost index is cleared (FIFO removal).

    public void MoveConveyor()

    {

        // Clear the rightmost index.

        conveyorBelt[conveyorLength].Clear();

        conveyorBelt[conveyorLength].Add((0.0, 0));

​

        // Shift every entry one index to the right.

        for (int i = conveyorLength; i > conveyorInit; i--)

        {

            conveyorBelt[i] = new List<(double, int)>(conveyorBelt[i - 1]);

        }

​

        // Reset the first index.

        conveyorBelt[conveyorInit].Clear();

        conveyorBelt[conveyorInit].Add((0.0, 0));

    }

​

    // Prints the current state of the conveyor.

    public void PrintConveyor()

    {

        Console.WriteLine("Current Conveyor State:");

        for (int i = conveyorInit; i <= conveyorLength; i++)

        {

            if (conveyorBelt[i].Count > 0)

            {

                Console.Write($"Index {i}: ");

                foreach (var (weight, type) in conveyorBelt[i])

                {

                    Console.Write($"[Type {type}, {weight} kg/m] ");

                }

                Console.WriteLine();

            }

        }

        Console.WriteLine();

    }

}

​

class Program

{

    static void Main()

    {

        ConveyorFIFO conveyor = new ConveyorFIFO();

​

        // Add several non-type-13 steel pieces.

        // (Their starting slot must be between index 11 and 38.)

        conveyor.AddSteel(8, 3, 2.5f);    // Expected to fill indices 11–13.

        conveyor.AddSteel(9, 4, 2.5f);    // Expected to fill the next free block.

        conveyor.AddSteel(10, 3, 3.0f);

        conveyor.AddSteel(11, 4, 5.2f);

        conveyor.AddSteel(12, 2, 4.2f);

        conveyor.AddSteel(14, 2, 4.2f);

        conveyor.AddSteel(15, 2, 4.2f);

        conveyor.AddSteel(16, 2, 4.2f);

        conveyor.AddSteel(17, 2, 4.2f);

        conveyor.AddSteel(18, 3, 4.2f);

        conveyor.AddSteel(19, 4, 4.2f);

​

        Console.WriteLine("Before adding type 13:");

        conveyor.PrintConveyor();

​

        // Now add several type 13 steel pieces.

        // Each call searches for a starting slot between minIndex and maxEntryIndex.

        conveyor.AddSteel(13, 3, 2.5f);

        conveyor.AddSteel(13, 4, 5.0f);

​

        Console.WriteLine("After adding type 13:");

        conveyor.PrintConveyor();

        for (int i = 0; i < 7; i++)

        {

            Console.WriteLine($"Moving Conveyor Step {i + 1}...");

            conveyor.MoveConveyor();

            conveyor.PrintConveyor();

        }

    }

}

​