using System;
using System.Drawing;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Windows.Forms;
using static System.Windows.Forms.VisualStyles.VisualStyleElement;

namespace Praktika
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();

        }
        int[,] array2D;
        int[] array;
        public static int flag = 0;
        string result;
        int len;
        
        private void ButtonOne_Click(object sender, EventArgs e)
        {
            //ввод для строк
            if (arrayTextBox.Text.Length > 0 && textBoxLen.Text.Length >5 )
            {
                Vvod();
                return;
            }
            if (textBoxLen.Text == null)
            {
                MessageBox.Show("Не введена длина массива");
                return;
            }
            if (string.IsNullOrEmpty(textBoxMin.Text) || string.IsNullOrEmpty(textBoxMax.Text))
            {
                MessageBox.Show("Пожалуйста, введите все необходимые данные для создания массива.");
                return;
            }
            //выводит массив с большим размером
            len = Convert.ToInt32(textBoxLen.Text);
            array = new int[len * 2];
            Random random = new Random();
            for (int i = 0; i < len; i++)
            {
                array[i] = random.Next(Convert.ToInt32(textBoxMin.Text), Convert.ToInt32(textBoxMax.Text));
            }
            //выводит массив избавляю от 0
            string str = ""; for (int i = 0; i < len; i++)
            {
                str += array[i].ToString();
                str += " ";
            }
            arrayTextBox.Text = str;

            //выводит обычный массив
            /*len = Convert.ToInt32(textBoxLen.Text);
            array = new int[len ];
            Random random = new Random();
            for (int i = 0; i < len; i++)
            {
                array[i] = random.Next(Convert.ToInt32(textBoxMin.Text), Convert.ToInt32(textBoxMax.Text));
            }*/
            //arrayTextBox.Text = string.Join(", ", array);
        }
        private void Vvod()
        {
            string[] mas = arrayTextBox.Text.Split(' ');
            len = mas.Length;
            array = new int[len * 2];

            for (int i = 0; i < len; i++)
            {
                array[i] = Convert.ToInt32(mas[i]);
            }
        }

        private void ButtonTwo_Click(object sender, EventArgs e)
        {
            if (arrayTextBox.Text.Length > 0 && textBoxLen.Text.Length > 5)
            {
                Vvod2();
                return;
            }
            if (textBoxLen.Text == null)
            {
                MessageBox.Show("Не введена длина массива");
                return;
            }

            if (string.IsNullOrEmpty(textBoxMin.Text) || string.IsNullOrEmpty(textBoxMax.Text))
            {
                MessageBox.Show("Пожалуйста, введите все необходимые данные для создания массива.");
                return;
            }

            len = Convert.ToInt32(textBoxLen.Text);
            array2D = new int[len * 2, len * 2];
            Random random = new Random();
            for (int i = 0; i < len; i++)
            {
                for (int j = 0; j < len; j++)
                {
                    array2D[i, j] = random.Next(Convert.ToInt32(textBoxMin.Text), Convert.ToInt32(textBoxMax.Text));
                }
            }
            // Вывод двумерного массива в текстовое поле
            string str = "";
            for (int i = 0; i < len; i++)
            {
                for (int j = 0; j < len; j++)
                {
                    str += array2D[i, j].ToString();
                    str += " ";
                }
                str += "\n";
            }

            arrayTextBox.Text = str;
            /*StringBuilder sb = new StringBuilder();
            for (int i = 0; i < len; i++)
            {
                for (int j = 0; j < len; j++)
                {

                    sb.Append(array2D[i, j] + " ");
                }
                sb.AppendLine();
            }
            arrayTextBox.Text = sb.ToString();*/
        }
        private void Vvod2()
        {
            string[] mas = arrayTextBox.Text.Split(' ', '\n');
            len = Convert.ToInt32(Math.Sqrt(mas.Length));
            array2D = new int[len * 2, len * 2];

            int c = 0;
            for (int i = 0; i < len; i++)
            {
                for (int j = 0; j < len; j++)
                {
                    array2D[i, j] = Convert.ToInt32(mas[c++]);
                }
            }
        }

        private void Button1_Click(object sender, EventArgs e)
        {
            //Знак значений всех элементов серии одинаковы. минимальная серия
            int[] array = Array.ConvertAll(arrayTextBox.Text.Split(','), int.Parse);
            int minLength = 999;
            int seriesStartIndex = 0;
            int seriesLength = 0;

            int i = 1;
            int currentLength = 1;
            for (; i < array.Length; i++)
            {

                if (array[i] < 0 && array[i - 1] < 0 || array[i] >= 0 && array[i - 1] >= 0)
                {
                    currentLength++;
                }
                else
                {
                    // Если серия закончилась
                    if (currentLength < minLength && currentLength >= 2)
                    {
                        minLength = currentLength;
                        seriesStartIndex = i - currentLength;  // Начинаю с предыдущего элемента
                        seriesLength = currentLength;
                    }

                    currentLength = 1;
                }

            }
            //последняя серия
            if (currentLength < minLength && currentLength >= 2)
            {
                minLength = currentLength;
                seriesStartIndex = i - currentLength;  // Начинаю с предыдущего элемента
                seriesLength = currentLength;
            }




            MessageBox.Show($"Серия с минимальной длиной начинается с позиции {seriesStartIndex} и имеет длину {seriesLength}");
            flag = 1;
            result = "Серия с минимальной длиной начинается с позиции " + seriesStartIndex + " и имеет длину " + seriesLength;
        }

        private void Button9_Click(object sender, EventArgs e)
        {
            if (flag == 1)
            {
                richTextBox1.Text = "Дан целочисленный одномерный массив размера N. Серия – это" +
                    "последовательность элементов массива, идущих друг за другом. Знаки" +
                    "значений всех элементов серии одинаковы(все положительные или все" +
                    "отрицательные). Серия должна содержать минимум 2 элемента.Длина" +
                    "серии – количество элементов в серии. Найти серию с минимальной" +
                    "длиной.Вывести с какой позиции начинается серия и ее длину.";
            }
            else if (flag == 2)
            {
                richTextBox1.Text = "7. Дан целочисленный одномерный массив размера N. Переставить в\r\nобратном порядке элементы массива, расположенные между\r\nнаибольшим четным и наименьшим нечетным";
            }
            else if (flag == 3)
            {
                richTextBox1.Text = "8. Дан целочисленный одномерный массив размера N. Вставить 3 после\r\nкаждого нечетного элемента массива (нечетный по значению, а не по\r\nпорядковому номеру).\r\n\r\n";
            }
            else if (flag == 4)
            {
                richTextBox1.Text = "8. Дан целочисленный одномерный массив размера N. Удалить из массива\r\nвсе нечетные элементы (нечетный по значению, а не по порядковому\r\nномеру).\r\n";
            }
            else if (flag == 5)
            {
                richTextBox1.Text = "8. Дан целочисленный двумерный массив размера N*N. Добавить в массив\r\nстроку 0 после каждой строки, в которой есть хотя бы один элемент,\r\nменьший по модулю среднего арифметического элементов массива.";
            }
            else if (flag == 6)
            {
                richTextBox1.Text = "8. Дан целочисленный двумерный массив размера N*N. Упорядочить\r\nэлементы в матрице по возрастанию (справа налево, снизу-вверх)";
            }
            else
            {
                MessageBox.Show("Пожалуйста, выберите задание");
            }
        }
        /// <summary>
        /// результат
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button10_Click(object sender, EventArgs e)
        {
            richTextBox1.Text = result;
        }

        private void Button2_Click(object sender, EventArgs e)
        {
            //Переставить в обратном порядке элементы между наибольшим четным и наименьшим нечетным
            int[] array = Array.ConvertAll(arrayTextBox.Text.Split(','), int.Parse);
            int Min = int.MaxValue, minIndex = -1, Max = int.MinValue, maxIndex = -1;


            for (int i = 0; i < array.Length; i++)
            {
                if (array[i] > Max && array[i] % 2 == 0)
                {
                    Max = array[i];
                    maxIndex = i;

                }
                if (array[i] < Min && array[i] % 2 != 0)
                {
                    Min = array[i];
                    minIndex = i;

                }
            }
            if (maxIndex != -1 && minIndex != -1)
            {
                int begin = Math.Min(minIndex, maxIndex) + 1, end = Math.Max(minIndex, maxIndex) - 1;
                for (; begin < end; begin++, end--)
                {
                    int tmp = array[begin];
                    array[begin] = array[end];
                    array[end] = tmp;
                }
            }
            else
            {
                MessageBox.Show("Нет четного или нечетного элемента");
                return;
            }
            /*int begin = Math.Min(minIndex, maxIndex) + 1, end = Math.Max(minIndex, maxIndex) - 1;
            for (; begin < end; begin++, end--)
            {
                int tmp = array[begin];
                array[begin] = array[end];
                array[end] = tmp;
            }*/

            result = string.Join(", ", array);
            flag = 2;
        }

        private void Button3_Click(object sender, EventArgs e)
        {
            // Вставить 1 после каждого положительного элемента массива.
            //int[] array = Array.ConvertAll(arrayTextBox.Text.Split(','), int.Parse); // не для строк


            /*for (int i = 0; i < len; i++)
            {
                if (array[i] >= 0 )
                {
                    //Array.Resize(ref array, array.Length + 1); // Увеличиваем размер массива на 1
                    //len++;
                    for (int j = len - 1; j > i + 1; j--) // Сдвигаем все элементы после текущего на 1 позицию вправо
                    {
                        array[j] = array[j - 1];
                    }
                    array[i + 1] = 1; // Вставляем число 1 после текущего элемента
                    i++; // Пропускаем следующую итерацию цикла, чтобы не обрабатывать вставленное число 2
                }

            }*/
            //int n = array.Length;
            int count = len;
            int i = 0;
            for (; i < count; i++)
            {
                if (array[i] % 2 != 0)
                {
                    for (int j = count; j > i; j--)
                    {
                        array[j] = array[j - 1];
                    }
                    array[i + 1] = 3;
                    count++;
                    i++;
                }
            }

            string str = ""; for (i = 0; i < count; i++)
            {
                str += array[i].ToString();
                str += " ";
            }

            result = str;
            //result = string.Join(", ", array);

            /*for (int i = n - 1; i >= 0; i--)
            {
                if (array[i] > 0)
                {
                    for (int j = n - 1; j > i + 1; j--)
                    {
                        array[j] = array[j - 1];
                    }
                    array[i + 1] = 1;
                    len++;
                }
            }*/
            /*int k = 0;
            for(int i = 0; i < array.Length; i++)
            {
                if (array[i] >= 0)
                {
                    k++;
                }
            }*/ //посчитать сколько реальных элементов
                // Создаю новый массив с увеличенным размером
            /*int[] newArray = new int[array.Length ];

            // Счетчик для нового массива
            int j = 0;

            // Прохожу по исходному массиву
            for (int i = 0; i < array.Length; i++)
            {
                // Копирую элемент
                newArray[j] = array[i];
                j++;

                // Если элемент неотрицательный, вставляю 1
                if (array[i] >= 0)
                {
                    newArray[j] = 1; // Вставляю значение
                    j++;
                }
            }

            // Обновляю исходный массив
            array = newArray;*/

            //result = string.Join(", ", array);
            flag = 3;
        }

        private void Button4_Click(object sender, EventArgs e)
        {
            //Удалить из массива все положительные элементы.
            //int[] array = Array.ConvertAll(arrayTextBox.Text.Split(','), int.Parse);

            /*for (int i = 0; i < array.Length; i++)
            {
                if (array[i] > 0)
                {
                    // Увеличиваем размер массива на 1
                    for (int j = i; j < array.Length - 1; j++) // Сдвигаем все элементы после текущего на 1 позицию вправо
                    {
                        array[j] = array[j + 1];
                    }

                    Array.Resize(ref array, array.Length - 1);
                    i--;
                }

            }
            result = string.Join(", ", array);*/
            int count = len;
            int i = 0;
            for (; i < count; i++)
            {
                if (array[i] % 2 != 0)
                {
                    for (int j = i; j < count ; j++)
                    {
                        array[j] = array[j + 1];
                    }

                    count--;
                    i--;
                    if (count == 0)
                    {

                        result = "Нет элементов";
                        return;
                    }
                }
            }

            string str = " "; for (i = 0; i < count; i++)
            {
                str += array[i].ToString();
                str += " ";
            }

            result = str;

            flag = 4;
        }

        private void Button5_Click(object sender, EventArgs e)
        {
            /*int s = 0;
            float ar = 0;
            for (int j = 0; j < columns; j++)
            {
                for (int i = 0; i < rows; i++)
                {
                    if (array2D[i, j] >= 0) 
                    {
                        s += array2D[i, j];
                    }
                    
                }

            }
            ar = s / rows;
            for (int j = 0; j < columns; j++)
            {
                for (int i = 0; i < rows; i++)
                {
                    if (array2D[i,j] > ar)
                    {
                        for (int k = columns; k > j; k--)
                        {
                            for (int p = 0; p < rows; p++)
                            {
                                array2D[p, k] = 0;
                            }
                        }
                        columns++;
                        j++;
                        break;
                    }
                }
            }
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < rows; i++)
            {
                for (int j = 0; j < columns; j++)
                {

                    sb.Append(array2D[i, j] + " ");
                }
                sb.AppendLine();
            }
            richTextBox1.Text = sb.ToString();
            //richTextBox1.Text = array2D.ToString();
            //result = string.Join(" ", array2D);*/
            int s = 0;
            double ar = 0;
            int len2 = len;
            for (int j = 0; j < len2; j++)
            {
                for (int i = 0; i < len; i++)
                {
                    if (array2D[i, j] < 0 )
                    {
                        s += array2D[i, j];
                    }
                }
            }
            ar = (double)s / (len * len2);

            
            //задание 5
            for (int j = 0; j < len2; j++)
            {
                for (int i = 0; i < len; i++)
                {
                    if (Math.Abs(array2D[i, j]) > ar && array2D[i,j] != 0)
                    {
                        for (int k = len2; k > j; k--)
                        {
                            for (int p = 0; p < len; p++)
                            {
                                array2D[p, k] = array2D[p, k - 1];
                            }
                        }
                        for (int p = 0; p < len; p++)
                        {
                            array2D[p, j + 1] = 0;

                        }
                        len2++;
                        j++;
                    }
                }
            }

            // Вывод результата
            string str = "";
            for (int i = 0; i < len; i++)
            {
                for (int j = 0; j < len2; j++)
                {
                    str += array2D[i, j].ToString();
                    str += " ";
                }
                str += "\n";
            }

            result = str;
            flag = 5;

            //задание 6
            /*int s =0;
            double ar ;
            
            int len2 = len;
            for (int j = 0; j < len2; j++)
            {
                for (int i = 0; i < len; i++)
                {
                    
                        s += array2D[i, j];
                    
                }
            }
            ar = (double)s / (len * len2);
         
            for (int i = 0; i < len; i++)
            {
                for (int j = 0; j < len2; j++)
                {
                    if (Math.Abs(array2D[i, j]) < ar)
                    {
                        for (int k = len; k > i; k--)
                        {
                            for (int p = 0; p < len2; p++)
                            {
                                array2D[k, p] = array2D[k - 1, p];
                            }
                        }
                        for (int p = 0; p < len2; p++)
                        {
                            array2D[i + 1, p] = 0;
                        }
                        len++;
                        i++;
                        break;
                    }
                }
            }


            // Вывод результата
            string str = "";
            for (int i = 0; i < len; i++)
            {
                for (int j = 0; j < len2; j++)
                {
                    str += array2D[i, j].ToString();
                    str += " ";
                }
                str += "\n";
            }

            result = str;
            flag = 5;*/


            /*StringBuilder sbResult = new StringBuilder();
            for (int i = 0; i < rows; i++)
            {
                for (int j = 0; j < columns; j++)
                {
                    sbResult.Append(array2D[i, j] + " ");
                }
                sbResult.AppendLine();
            }
            richTextBox1.Text = sbResult.ToString();*/

            // Вставляем столбцы с нулями
            /*int insertCount = 0; // Счетчик вставленных столбцов
            for (int j = 0; j < len2; j++)
            {
                for (int i = 0; i < len; i++)
                {
                    if (array2D[i, j] > ar)
                    {
                        // Сдвигаем элементы массива вправо
                        for (int k = len2 - 1; k > j + insertCount; k--)
                        {
                            for (int p = 0; p < len; p++)
                            {
                                array2D[p, k] = array2D[p, k - 1];
                            }
                        }
                        // Вставляем столбец с нулями
                        for (int p = 0; p < len; p++)
                        {
                            array2D[p, j + insertCount] = 0;
                        }

                        insertCount++; // Увеличиваем счетчик вставленных столбцов
                        break;
                    }
                }
            }*/

        }

        private void Button6_Click(object sender, EventArgs e)
        {

            /*for (int i = 0; i < len; i++)
            {

                //сверху вниз

                //SortLP(array2D, i);
                //SortSN(array2D, i);
                for (int j = 0; j < len; j++)
                {
                    for (int k = 0; k < len; k++)
                    {
                        if (array2D[i, k] < array2D[i, k + 1])
                        {
                            int temp = array2D[i, k];
                            array2D[i, k] = array2D[i, k + 1];
                            array2D[i, k + 1] = temp;
                        }
                    }
                    for (int k = 0; k < len; k++)
                    {
                        if (array2D[k, 0] < array2D[k + 1, r])
                        {
                            int temp = array2D[k, r];
                            array2D[k, r] = array2D[k + 1, r];
                            array2D[k + 1, r] = temp;
                        }
                    }
                }




            }*/
            /*for (int i = 0; i < len*len; i++)
            {
                // Сортировка строки слева направо
                for (int row = 0; row < len; row++)
                {
                    for (int k = 0; k < len - 1; k++)
                    {
                        if (array2D[row, k] < array2D[row, k + 1])
                        {
                            int temp = array2D[row, k];
                            array2D[row, k] = array2D[row, k + 1];
                            array2D[row, k + 1] = temp;
                        }
                    }
                }
                // Сортировка столбца сверху вниз
                for (int col = 0; col < len ; col++)
                {
                    for (int k = 0; k < len ; k++)
                    {
                        if (array2D[k, col] < array2D[k + 1, col])
                        {
                            int temp = array2D[k, col];
                            array2D[k, col] = array2D[k + 1, col];
                            array2D[k + 1, col] = temp;
                        }
                    }
                }
            }*/
            //решение правильное
            /*for (int i = 0; i < len; i++)
            {
                for (int j = 0; j < len; j++)
                {
                    for (int x = 0; x < len; x++)
                    {
                        for (int y = 0; y < len; y++)
                        {
                            if (array2D[i, j] > array2D[x, y])
                            {
                                int zam = array2D[i, j];
                                array2D[i, j] = array2D[x, y];
                                array2D[x, y] = zam;
                            }
                        }
                    }
                }
            }*/
            //справо налево, снизу - вверх
            for (int i = len - 1; i >= 0; i--) // Идём с конца по строкам
            {
                for (int j = len - 1; j >= 0; j--) // Идём с конца по столбцам
                {
                    for (int x = len - 1; x >= 0; x--)
                    {
                        for (int y = len - 1; y >= 0; y--)
                        {
                            if (array2D[i, j] < array2D[x, y])
                            {
                                int zam = array2D[i, j];
                                array2D[i, j] = array2D[x, y];
                                array2D[x, y] = zam;
                            }
                        }
                    }
                }
            }


            /*//слева на право
                for (int k = 0; k < len; k++)
                {
                    if (array2D[0, k] < array2D[0, k + 1])
                    {
                        int temp = array2D[0, k];
                        array2D[0, k] = array2D[0, k + 1];
                        array2D[0, k + 1] = temp;
                    }
                }
            //сверху вниз
                    for (int k = 0; k < len; k++)
                    {
                        if (array2D[k, 0] < array2D[k + 1, 0])
                        {
                            int temp = array2D[k, 0];
                            array2D[k, 0] = array2D[k + 1, 0];
                            array2D[k + 1, 0] = temp;
                        }
                    }*/
            // Вывод результата
            string str = "";
            for (int i = 0; i < len; i++)
            {
                for (int j = 0; j < len; j++)
                {
                    str += array2D[i, j].ToString();
                    str += " ";
                }
                str += "\n";
            }

            result = str;
            flag = 6;

        }
        public void SortLP(int[,] arr,int r)
        {

            //слева на право
            for (int i = 0; i < len; i++)
            {
                for (int k = 0; k < len; k++)
                {
                    if (array2D[r, k] < array2D[r, k + 1])
                    {
                        int temp = array2D[r, k];
                        array2D[r, k] = array2D[r, k + 1];
                        array2D[r, k + 1] = temp;
                    }
                }
            }
            
        }
        public void SortSN(int[,] arr, int r)
        {

            //сВЕРХУ ВНИЗ
            for (int i = 0; i < len; i++)
            {
                for (int k = 0; k < len; k++)
                {
                    if (array2D[k, r] < array2D[k + 1, r])
                    {
                        int temp = array2D[k, r];
                        array2D[k, r] = array2D[k + 1, r];
                        array2D[k + 1, r] = temp;
                    }
                }
            }
        }
    }
}