OOP_LR5_v1

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace OOP_LR5_v2_281016
{
    class Program
    {
        // ограничения для размера массива
        const int MIN_LENGTH = 1;
        const int MAX_LENGTH = 100;

        // ограничения для элементов массива
        const int MIN_VALUE = -100;
        const int MAX_VALUE = 100;

        // функция ввода числа с корректности ввода ()
        static int ReadIntNumber(string stringForUser, int left, int right)
        {
            bool okInput = false;
            int number = MIN_VALUE;
            do
            {
                Console.WriteLine(stringForUser);
                try
                {
                    string buf = Console.ReadLine();
                    number = Convert.ToInt32(buf); // могут возникнуть исключения FormatException, OverflowException
                    if (number >= left && number <= right) okInput = true;
                    else
                    {
                        Console.WriteLine("Некорректное значение! Повторите ввод. ");
                        okInput = false;
                    }
                }

                catch (FormatException)
                {
                    Console.WriteLine("Некорректное значение! Повторите ввод. ");
                    okInput = false;
                }

                catch (OverflowException)
                {
                    Console.WriteLine("Некорректное значение! Повторите ввод. ");
                    okInput = false;
                }

            } while (!okInput);
            return number;
        }

        static void PrintMenu()
        {
            Console.WriteLine("\nРабота с одномерными массивами");
            Console.WriteLine("[1]. Формирование одномерного массива");
            Console.WriteLine("[2]. Печать одномерного массива");
            Console.WriteLine("[3]. Удаление элементов из массива"); // удаление чисел с чётным индексом
            Console.WriteLine("\nРабота с двумерными массивами");
            Console.WriteLine("[4]. Формирование двумерного массива");
            Console.WriteLine("[5]. Печать двумерного массива");
            Console.WriteLine("[6]. Добавление столбцов"); // добавить K столбцов в конец матрицы
            Console.WriteLine("\nРабота с рваными массивами");
            Console.WriteLine("[7]. Формирование рваного массива");
            Console.WriteLine("[8]. Печать рваного массива");
            Console.WriteLine("[9]. Удалить строчку"); // Удалить первую строку, в которой встречается заданное число K
            Console.WriteLine("\n[10]. Выход ");
        }

        static void Run(int[] arr, int sizeOfArray, int[,] arr2, int strings, int columns, int stringsRv, int[] lenRv1, int[][] arr3) // вызов функций
        {
            int check = 0; // номер пункта меню
            do
            {
                PrintMenu();
                check = ReadIntNumber("", 1, 11); // 10 пунктов меню
                switch (check)
                {
                    case 1: // формирование одномерного массива
                        {
                            sizeOfArray = ReadIntNumber("Введите размер массива (не более 100 элементов): ", MIN_LENGTH, MAX_LENGTH);
                            arr = MakeArray(sizeOfArray);
                            break;
                        }

                    case 2:
                        PrintArray(arr, sizeOfArray); // печать одномерного массива
                        break;

                    case 3:
                        DeleteFromArray(ref arr, ref sizeOfArray); // удаление элементов из массива
                        break;

                    case 4: // формирование двумерного массива
                        {
                            strings = ReadIntNumber("Введите количество строк массива (не более 100 элементов): ", MIN_LENGTH, MAX_LENGTH);
                            columns = ReadIntNumber("Введите количество столбцов массива (не более 100 элементов): ", MIN_LENGTH, MAX_LENGTH);
                            arr2 = MakeArray2(strings, columns);
                            break;
                        }

                    case 5: // печать двумерного массива
                        PrintArray2(arr2, strings, columns);
                        break;

                    case 6: //добавление столбцов
                        AddColumns(ref arr2, ref strings, ref columns);
                        break;

                    case 7: //Формирований рваного массива
                        {
                            stringsRv = ReadIntNumber("Введите количество строк массива (не более 100 элементов): ", MIN_LENGTH, MAX_LENGTH);
                            lenRv1 = new int[stringsRv];
                            for (int i = 0; i < stringsRv; i++)
                            {
                                lenRv1[i] = ReadIntNumber("Введите количество элементов в строчке массива: ", MIN_LENGTH, MAX_LENGTH);
                            }
                            arr3 = MakeArrayRv(stringsRv, lenRv1);
                            break;
                        }

                    case 8: // Печать рваного массива
                        PrintArray3(arr3, stringsRv, lenRv1);
                        break;

                    case 9: // Удалить строчку
                        DeleteStrings(ref arr3, lenRv1, stringsRv);
                        break;
                }

            } while (check < 10);
        }

        /* ФУНКЦИИ ПРОВЕРКИ СУЩЕСТВОВАНИЯ МАССИВА */

        static bool ExistArray(int[] arr, ref int sizeOfArray) // проверка существования одномерного массива
        {
            if (arr == null)
            {
                if (sizeOfArray != 0) sizeOfArray = 0;
                return false;
            }

            return true;
        }

        static bool ExistArray2(int[,] arr2) // проверка существования двумерного массива
        {
            if (arr2 == null)
                return false;
            else
                return true;
        }

        static bool ExistArray3(int[][] arr3) // проверка существования рваного массива
        {
            if (arr3 == null)
                return false;
            else
                return true;
        }

        static void PrintFormMenu() // меню формирования массива
        {
            Console.WriteLine(" [1]. Формирование ДСЧ");
            Console.WriteLine(" [2]. Ввод с клавиатуры");
        }

        /* ФУНКЦИИ ФОРМИРОВАНИЯ МАССИВА */

        static int[] MakeArray(int sizeOfArray) // для формирования одномерного массива двумя способами
        {
            int[] arr = null;
            int check = 0;
            PrintFormMenu();
            check = ReadIntNumber("", 1, 3);
            switch (check)
            {
                case 1: arr = MakeRandomArray(sizeOfArray);
                    break;
                case 2: arr = ReadArray(sizeOfArray);
                    break;
            }

            Console.WriteLine(" Всё хорошо, массив сформирован ");
            return arr;
        }

        static int[,] MakeArray2(int strings, int columns) // для формирования двумерного массива двумя способами
        {
            int[,] arr2 = null;
            int check = 0;
            PrintFormMenu();
            check = ReadIntNumber("", 1, 3);
            switch (check)
            {
                case 1:
                    arr2 = MakeRandomArray2(strings, columns);
                    break;
                case 2:
                    arr2 = ReadArray2(strings, columns);
                    break;
            }

            Console.WriteLine("Всё хорошо, массив сформирован ");
            return arr2;
        }

        static int[][] MakeArrayRv(int stringsRv, int[] lenRv1) // для формирования рваного массива двумя способами
        {
            int[][] arr3 = new int[100][];
            arr3 = null;
            int check = 0;
            PrintFormMenu();
            check = ReadIntNumber("", 1, 3);
            switch (check)
            {
                case 1:
                    arr3 = MakeRandomArrayRv(stringsRv, lenRv1);
                    break;
                case 2:
                    arr3 = ReadArrayRv(stringsRv, lenRv1);
                    break;
            }

            Console.WriteLine("Всё хорошо, массив сформирован ");
            return arr3;
        }

        /* ФУНКЦИИ ВВОДА МАССИВА С КЛАВИАТУРЫ */

        static int[] ReadArray(int sizeOfArray) // для ввода элементов одномерного массива указанного размера с клавиатуры с проверкой правильности ввода
        {
            int[] arr = new int[sizeOfArray]; // выделить память под массив
            for (int i = 0; i < sizeOfArray; i++)
            {
                arr[i] = ReadIntNumber("Введите элемент массива из диапазона [-100, 100]: ", MIN_VALUE, MAX_VALUE);
            }
            return arr;
        }

        static int[,] ReadArray2(int strings, int columns) // для ввода элементов двумерного массива указанного размера с клавиатуры с проверкой правильности ввода
        {
            int[,] arr2 = new int[strings, columns];
            int i, j;
            for (i = 0; i < strings; i++)
            {
                for (j = 0; j < columns; j++)
                {
                    arr2[i, j] = ReadIntNumber("Введите элемент массива из диапазона [-100, 100]: ", MIN_VALUE, MAX_VALUE);
                }
            }
            return arr2;
        }

        static int[][] ReadArrayRv(int stringsRv, int[] lenRv1) // формирование элементов рваного массива с клавиатуры
        {
            int[][] arr3 = new int[stringsRv][];
            for (int i = 0; i < stringsRv; i++)
                arr3[i] = new int[lenRv1[i]];
            for (int i = 0; i < stringsRv; i++)
            {
                for (int j = 0; j < arr3[i].Length; j++)
                {
                    arr3[i][j] = ReadIntNumber("Введите элемент массива из диапазона [-100, 100]: ", MIN_VALUE, MAX_VALUE);
                }
            }
            return arr3;
        }

        /* ФУНКЦИИ ФОРМИРОВАНИЯ МАССИВА ДСЧ */

        static int[] MakeRandomArray(int sizeOfArray) // формирование элементов одномерного массива ДСЧ
        {
            Random rnd = new Random();
            int[] arr = new int[sizeOfArray]; // выделить память под массив
            for (int i = 0; i < sizeOfArray; i++)
            {
                arr[i] = rnd.Next(MIN_VALUE, MAX_VALUE);
            }
            return arr;
        }

        static int[,] MakeRandomArray2(int strings, int columns) // формирование элементов двумерного массива ДСЧ
        {
            Random rnd = new Random();
            int[,] arr2 = new int[strings, columns];
            int i, j;
            for (i = 0; i < strings; i++)
            {
                for (j = 0; j < columns; j++)
                {
                    arr2[i, j] = rnd.Next(MIN_VALUE, MAX_VALUE);
                }
            }
            return arr2;
        }

        static int[][] MakeRandomArrayRv(int stringsRv, int[] lenRv1) // формирование элементов рваного массива ДСЧ
        {
            Random rnd = new Random();
            int[][] arr3 = new int[stringsRv][];
            for (int i = 0; i < stringsRv; i++)
                arr3[i] = new int[lenRv1[i]];
            for (int i = 0; i < stringsRv; i++)
            {
                for (int j = 0; j < arr3[i].Length; j++)
                {
                    arr3[i][j] = rnd.Next(MIN_VALUE, MAX_VALUE);
                }
            }
            return arr3;
        }

        /* ФУНКЦИИ ПЕЧАТИ МАССИВА */

        static void PrintArray(int[] arr, int sizeOfArray) // печать одномерного массива
        {
            if (ExistArray(arr, ref sizeOfArray))
            {
                foreach (int elem in arr)
                    Console.Write(elem + " ");
                Console.WriteLine();
            }
            else Console.WriteLine(" Массив пустой! ");
        }

        static void PrintArray2(int[,] arr2, int strings, int columns) // печать двумерного массива
        {
            if (ExistArray2(arr2))
            {
                for (int i = 0; i < strings; i++)
                {
                    for (int j = 0; j < columns; j++)
                    {
                        Console.Write("{0, 5}", arr2[i, j]);
                    }
                    Console.Write("\n");
                }

            }
            else Console.WriteLine(" Массив пустой! ");
        }

        static void PrintArray3(int[][] arr3, int stringsRv, int[] lenRv) // печать рваного массива
        {
            if (ExistArray3(arr3))
            {
               // for (int i = 0; i < stringsRv; i++)
                //{
                    //for (int j = 0; j < arr3[i].Length; j++)
                    //for (int j = 0; j < lenRv[i]; j++)
                    for (int i = 0; i < arr3.Length;i++ )
                    {
                        for(int j=0; j< arr3[i].Length; j++)
                    {
                        Console.Write("{0, 5}", arr3[i][j]);
                    }
                    Console.Write("\n");
                }
            }
            else Console.WriteLine(" Массив пустой! ");
        }

        /* ФУНКЦИИ ОБРАБОТКИ МАССИВА ПО УСЛОВИЮ ЗАДАЧИ */

        static void DeleteFromArray(ref int[] arr, ref int sizeOfArray) // удаление элементов с чётным индексом
        {
            if (!ExistArray(arr, ref sizeOfArray)) // массив пустой
            {
                Console.WriteLine("Удаление невозможно, массив пустой!");
                return; // массив не меняется, заввершение функции
            }

            int howMatchElem = sizeOfArray / 2, temp_size = 0;
            temp_size = sizeOfArray - howMatchElem;

            int[] temp = new int[temp_size];
            int j = 0, i;
            for (i = 0; i < sizeOfArray; i++)
                if (i % 2 == 0)
                {
                    temp[j] = arr[i];
                    j++;
                }

            sizeOfArray = temp_size;
            j = 0;
            i = 0;
            arr = temp;
            Console.WriteLine(" Удалены все элементы с чётными индексами");
        }

        static void AddColumns(ref int[,] arr2, ref int strings, ref int columns) // добавление столбцов
        {
            if (!ExistArray2(arr2)) //массив пустой
            {
                Console.WriteLine("Добавление невозможно, так как массива нет!");
                return; //массив не меняется, можно завершить функцию
            }

            Console.WriteLine("Добавим несколько столбцов в конец двумерного массива! \n");
            int newColumns = ReadIntNumber("Введите количество столбцов (не более 100): ", MIN_LENGTH, MAX_LENGTH);

            int[,] temp2 = new int[strings, columns + newColumns];

            for (int i = 0; i < strings; i++)
            {
                for (int j = 0; j < columns; j++)
                    temp2[i, j] = arr2[i, j];
            }

            Console.WriteLine("Как заполнить добавленные столбцы? ");
            Random rnd = new Random();
            int check = 0;
            PrintFormMenu();
            check = ReadIntNumber("", 1, 3);
            switch (check)
            {
                case 1:
                    {
                        for (int i = 0; i < strings; i++)
                        {
                            for (int j = columns; j < columns + newColumns; j++)
                                temp2[i, j] = rnd.Next(MIN_VALUE, MAX_VALUE);
                        }
                    }
                    break;

                case 2:
                    {
                        for (int i = 0; i < strings; i++)
                        {
                            for (int j = columns; j < columns + newColumns; j++)
                            {
                                temp2[i, j] = ReadIntNumber("Введите элемент из диапазона [-100, 100]: ", MIN_VALUE, MAX_VALUE);
                            }
                        }
                    }
                    break;
            }

            arr2 = temp2;
            columns += newColumns;
            Console.WriteLine(" Столбцы успешно добавлены в двумерный массив");
        }

        static void DeleteStrings (ref int[][] arr3, int[] lenRv1, int stringsRv) // удаление строчки рваного массива
        {
            if (!ExistArray3(arr3)) // массив пустой
            {
                Console.WriteLine("Удаление невозможно, массив пустой!");
                return; // массив не меняется, заввершение функции
            }

            int[][] temp3 = new int[stringsRv - 1][];
            int[] lenTemp = new int[stringsRv - 1];
            int K = ReadIntNumber("Введите элемент, строчку с которым надо удалить: ", MIN_VALUE, MAX_VALUE);
            bool test = false;

            for (int i = 0; i < stringsRv; i++)
            {
                if((arr3[i][0] == K) && (!test))
                    test = true;
            }

            int t = 0;
            if(test)
            {
                for (int i = 0; i < stringsRv; i++)
                {
                    if (arr3[i][0] != K)
                    {
                        lenTemp[t] = lenRv1[i];
                        temp3[t] = new int[lenRv1[i]];
                        for (int j = 0; j < lenRv1[i]; j++)
                            temp3[t][j] = arr3[i][j];
                        t++;
                    }
                }
                arr3 = temp3;
                lenRv1 = lenTemp;
                Console.WriteLine("Строчка удалена");
                stringsRv -= 1;
            }
            else Console.WriteLine("Строчка с данным первым элементов не найдена");

        }

        /* ОСНОВНЫЕ ФУНКЦИИ */

        static void Init(out int sizeOfArray, out int[] arr, out int strings, out int columns, out int[,] arr2, out int stringsRv, out int[] lenRv1, out int[][] arr3) // инициализация
        {
            sizeOfArray = 0;
            arr = null;
            strings = 0;
            columns = 0;
            arr2 = null;
            stringsRv = 0;
            arr3 = null;
            lenRv1 = null;
        }

        static void Main(string[] args) // основная программа
        {
            int sizeOfArray;
            int[] arr;
            int[,] arr2;
            int[][] arr3;
            int strings, columns;
            int stringsRv;
            int[] lenRv1;
            Init(out sizeOfArray, out arr, out strings, out columns, out arr2, out stringsRv, out lenRv1, out arr3); // инициализация
            Run(arr, sizeOfArray, arr2, strings, columns, stringsRv, lenRv1, arr3); // выполнение функций
        }
    }
}