Jonson/ConsoleApp2/Program.cs

namespace ConsoleApp2
{
    internal class Program
    {

        static void Main(string[] args)
        {
            int minimumOne = 0;
            int minimumTwo = 0;
            int max = 0;
            Console.WriteLine("Введите количество: ");
            int a = Convert.ToInt32(Console.ReadLine());

            List<int> columnOne = new List<int>();
            List<int> columnTwo = new List<int>();

            List<int> columnOneResult = new List<int>();
            List<int> columnTwoResult = new List<int>();

            List<int> listOfMax = new List<int>();

            for (int i = 0; i < a; i++)
            {
                columnOneResult.Add(0);
                columnTwoResult.Add(0);
            }

            for (int i = 0; i < a; i++)
            {
                Console.WriteLine("Введите: ");
                columnOne.Add(Convert.ToInt32(Console.ReadLine()));
                Console.WriteLine("Введите: ");
                columnTwo.Add(Convert.ToInt32(Console.ReadLine()));
            }

            int sumI = columnOne[0];
            int sumJ = 0;
            int count = 1;
            listOfMax.Add(sumI);

            for (int i = 1; i < a; i++)
            {
                sumI = sumI + columnOne[i];
                sumJ = sumJ + columnTwo[i - 1];
                max = sumI - sumJ;
                listOfMax.Add(max);
                max = listOfMax.Max();
            }

            Console.WriteLine("Время простоя первичном порядке равно: " + max);
            listOfMax.Clear();



            for (int i = 0; i < a; i++)
            {
                minimumOne = columnOne.Min();
                minimumTwo = columnTwo.Min();
                int minOneIndex = columnOne.IndexOf(minimumOne);
                int minTwoIndex = columnTwo.IndexOf(minimumTwo);


                for(int j = 0; j < columnOne.Count;j++)
                {
                    if (columnOne[j]==minimumOne)
                    {
                        if (columnTwo[minOneIndex] < columnTwo[j])
                        {
                            minOneIndex = j;
                        }
                        
                    }
                    if (columnTwo[j]==minimumTwo)
                    {
                        if (columnOne[minTwoIndex] < columnOne[j])
                        {
                            minTwoIndex= j;
                        }
                    }
                }


                if (minimumOne < minimumTwo || minimumOne == minimumTwo)
                {
                    columnOneResult.Insert(i,minimumOne);
                    columnTwoResult.Insert(i,columnTwo[minOneIndex]);
                    columnTwo.RemoveAt(minOneIndex);
                    columnOne.RemoveAt(minOneIndex);
                }
                else 
                {

                    columnOneResult.Insert(a-1,columnOne[minTwoIndex]);
                    columnTwoResult.Insert(a-1,minimumTwo);
                    columnTwo.RemoveAt(minTwoIndex);
                    columnOne.RemoveAt(minTwoIndex);
                    count++;
                }
            }
            columnOneResult.RemoveAll(item => item == 0);
            columnTwoResult.RemoveAll(item => item == 0);
            for (int i = 0; i < columnOneResult.Count; i++)
                {
                    Console.Write(columnOneResult[i] + " ");
                    Console.Write(columnTwoResult[i]);
                Console.WriteLine();
            }

            sumI = columnOneResult[0];
            sumJ = 0;
            count = 1;
            listOfMax.Add(sumI);

            for (int i = 1; i < a; i++)
            {
                sumI = sumI + columnOneResult[i];
                sumJ = sumJ + columnTwoResult[i - 1];
                max = sumI - sumJ;
                listOfMax.Add(max);
                max = listOfMax.Max();
            }

            Console.WriteLine("Время простоя при оптимальной перестановке равно: " + max);

        }
    }
}