Определить количество промежутков монотонности в массиве и переставить местами первый и последний из них

{
    class Program
    {
        static void Main(string[] args)
        {
            // Вводим N
            int N;
            do
            {
            
                Console.Write("Размер массива (N) = "); // N должна быть не менее двух
            }
 
            while ((N = Convert.ToInt32(Console.ReadLine())) < 2);
            // Заполняем массив случайными числами
            Random rnd = new Random();
            int i;
            int[] arr = new int[N];
            for (i = 0; i < N; i++)
            {
                arr[i] = rnd.Next(100);
                // Сразу же выводим массив
                Console.Write(arr[i].ToString() + ' ');
            }
            Console.WriteLine();
            // Счетчик
            int cntr = 0;
            // Флаг состояния:
            // 1 - убывание
            // 2 - возрастание
            // 0 - отсутствие изменений
            
            int flag = 0;
            for (i = 1; i < N; i++)
            {
                if (arr[i] < arr[i - 1])
                {
                    if (flag != 1) cntr++;
                    flag = 1;
                }
                else if (arr[i] > arr[i - 1])
                {
                    if (flag != 2) cntr++;
                    flag = 2;
                }
                else if (flag != 0)
                {
                    cntr++;
                    flag = 0;
                }
            }
            // Выводим результат:
            Console.WriteLine("Количество участков монотонности: " + cntr.ToString());
            Console.ReadLine();
        }
    }
}

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // Вводим N
            int N;
            do
            {
 
                Console.Write("Размер массива (N) = "); // N должна быть не менее двух
            }
 
            while ((N = Convert.ToInt32(Console.ReadLine())) < 2);
            // Заполняем массив случайными числами
            Random rnd = new Random();
            int i;
            int[] arr = new int[N];
            for (i = 0; i < arr.Length; i++)
            {
                arr[i] = rnd.Next(100);
                // Сразу же выводим массив
                Console.Write(arr[i].ToString() + ' ');
            }
            Console.WriteLine();
            var segments = new List<MonotoneSegment>();
 
            segments.Add(new MonotoneSegment(0, 1, GetMonotoneKind(arr[0], arr[1])));
            for (i = 1; i < arr.Length - 1; i++)
            {
                var s = segments.Last();
                var m = GetMonotoneKind(arr[i], arr[i + 1]);
                if (s.MonotoneKind == m)
                {
                    segments[segments.Count - 1] = new MonotoneSegment(s.Start, i + 1, s.MonotoneKind);
                }
                else
                {
                    segments.Add(new MonotoneSegment(i, i + 1, m));
                }
            }
            Console.WriteLine("Количество участков монотонности: " + segments.Count.ToString());
            segments.ForEach(seg => Console.WriteLine(seg.ToString()));
            int[] arr2 = new int[arr.Length];
            MonotoneSegment first = segments[0], last = segments.Last();
            //Обмен сегментов местами.
            Array.Copy(arr, first.End + 1, arr2, first.Start + last.Length, last.Start - first.End - 1);
            Array.Copy(arr, last.Start, arr2, first.Start, last.Length);
            Array.Copy(arr, first.Start, arr2, first.Start + last.Length + last.Start - first.End - 1, first.Length);
 
            // Выводим результат:
            Console.WriteLine(string.Join(", ", arr));
            Console.WriteLine(string.Join(", ", arr2));
 
            Console.ReadLine();
        }
        //Определение монотонности
        private static MonotoneKindEnum GetMonotoneKind(int a, int b)
        {
            if (a > b)
            {
                return MonotoneKindEnum.Descending;
            }
            return a < b ? MonotoneKindEnum.Ascending : MonotoneKindEnum.Neutral;
        }
 
        struct MonotoneSegment
        {
            /// <summary>
            /// Начало сегмента
            /// </summary>
            public int Start { get; private set; }
            /// <summary>
            /// Конец сегмента
            /// </summary>
            public int End { get; private set; }
            /// <summary>
            /// Длина сегмента
            /// </summary>
            public int Length => End - Start + 1;
            /// <summary>
            /// Тип сегмента
            /// </summary>
            public MonotoneKindEnum MonotoneKind { get; private set; }
 
            public MonotoneSegment(int start, int end, MonotoneKindEnum monotoneKind)
            {
                Start = start;
                End = end;
                MonotoneKind = monotoneKind;
            }
 
            public override string ToString()
            {
                return String.Format("Start = {0}; End={1}; MonotoneKind = {2}", Start, End, MonotoneKind);
            }
        }
    }
 
    internal enum MonotoneKindEnum
    {
        /// <summary>
        /// Отсутствие изменений
        /// </summary>
        Neutral = 0,
        /// <summary>
        /// Убывание
        /// </summary>
        Descending = 1,
        /// <summary>
        /// Возрастание
        /// </summary>
        Ascending = 2
    }
}