lab6

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

namespace lab6
{
    class Program
    {                                                                       // ввод массивов
        static Random rnd = new Random();
        static int AskForArraySize(int dimention)
        {
            bool ok;
            int size;
            string[] arrayOfDimentions = { "Количество строк: ",
                                         "Количество столбцов: ",
                                         "Количество элементов в глубину:"};
            do
            {
                Console.Write(arrayOfDimentions[dimention]);
                string buf = Console.ReadLine();
                ok = int.TryParse(buf, out size) && (size > 0);
                if (!ok)
                {
                    RedLn("Размерность должна быть натуральной.");
                }
            } while (!ok);
            Console.WriteLine();
            return size;
        }
        static int AskForJaggedArrayStringSize(int rowNumber)
        {
            bool ok;
            int length;
            do
            {
                Console.Write("Длина строки {0}: ", rowNumber + 1);
                string buf = Console.ReadLine();
                ok = int.TryParse(buf, out length) && (length > 0);
            } while (!ok);
            return length;
        }
        static double[] InputRandom(int size, int multiplier)
        {
            double[] randAr = new double[size];
            //Random rnd = new Random();
            for (int i = 0; i < size; i++)
            {
                randAr[i] = (rnd.NextDouble())*multiplier;
            }
            return randAr;
        }
        static double[] InputManual(int size)
        {
            bool ok;
            double n;
            double[] keybAr = new double[size];

            for (int i = 0; i < size; i++)
            {
                do
                {
                    Console.Write("Элемент {0}: ", i + 1);
                    string buf = Console.ReadLine();
                    ok = double.TryParse(buf, out n);
                } while (!ok);
                keybAr[i] = n;
            }
            Console.WriteLine();
            return keybAr;
        }

        static void Print(int[] vector)
        {
            if (vector.Length == 0)
            {
                Console.Write("Массив пуст.");
            }
            else
            {
                foreach (int element in vector) Console.Write("{0,4:00}", element);
            }
            Console.WriteLine();

        }// вывод
        static void Print(double[] vector)
        {
            if (vector.Length == 0)
            {
                Console.Write("Массив пуст.");
            }
            else
            {
                foreach (double element in vector) Console.Write("{0:00.000} ", element);
            }
            Console.WriteLine();
        }
        static void Print(string[] vector)
        {
            if (vector.Length == 0)
            {
                Console.Write("К сожалению, список пуст. Строки уже заказали, скоро должны привезти. Спасибо.");
            }
            else
            {
                for (int i = 0; i < vector.Length; i++)
                {
                    Console.WriteLine(i + 1 + ". " + vector[i]);
                }
            }
            Console.WriteLine();
        }
        static void Print(double[][] jagged)
        {
            if (jagged.Length == 0)
            {
                Console.WriteLine("Массив пуст");
            }
            else
            {
                for (int i = 0; i < jagged.Length; i++)
                {
                    Print(jagged[i]);
                }
            }
            Console.WriteLine();
        }
        static void Red(string str)
        {
            Console.ForegroundColor = ConsoleColor.Red;
            Console.Write(str);
            Console.ResetColor();
        }
        static void RedLn(string str)
        {
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine(str);
            Console.ResetColor();
        }
        static int AskForAction(int qtyOfActions)
        {
            int act;
            bool ok;
            do
            {
                Console.Write("Команда: ");
                string buf = Console.ReadLine();
                ok = int.TryParse(buf, out act) && act > 0 && act <= qtyOfActions;
                if (!ok)
                    RedLn("Доступны команды 1 - " + qtyOfActions + ".");
            } while (!ok);
            Console.WriteLine();
            return act;
        }

        static void ShowMenu(params string[] menu)
        {
            for (int i = 0; i < menu.Length; i++)
            {
                Console.WriteLine(i + 1 + ". " + menu[i]);
            }
            Console.WriteLine();
        }

        static double[][] ArraySortedLikeStairs(double[][] jag)
        {
            int[] arrayOfIndexes = new int[jag.Length];         // массив индексов 1..jag.Length
            for (int i = 0; i < jag.Length; i++)
            {
                arrayOfIndexes[i] = i;
            }

            int[] arrayOfLengths = new int[jag.Length];         // массив длин строк
            for (int i = 0; i < jag.Length; i++)
            {
                arrayOfLengths[i] = jag[i].Length;
            }


            for (int i = 1; i < jag.Length; i++)                // сортировка массива идексов по возрастанию длин
            {
                int el1 = arrayOfIndexes[i];
                int el2 = arrayOfLengths[i];
                int j = i - 1;
                while (j >= 0 && el2 < arrayOfLengths[j])
                {
                    arrayOfIndexes[j + 1] = arrayOfIndexes[j];
                    arrayOfLengths[j + 1] = arrayOfLengths[j];
                    j--;
                }
                arrayOfIndexes[j + 1] = el1;
                arrayOfLengths[j + 1] = el2;
            }

            double[][] newJag = new double[jag.Length][];           // создаем упорядоченный массив
            for (int i = 0; i < jag.Length; i++)                    // заполняем
            {
                newJag[i] = jag[arrayOfIndexes[i]];
            }
            return newJag;
        }

        static string Reverse(string originalString)
        {
            char[] reversedCharArray = new char[originalString.Length];
            int i = 0;
            int j = originalString.Length - 1;
            while (i <= j)
            {
                reversedCharArray[i] = originalString[j];
                reversedCharArray[j] = originalString[i];
                i++; j--;
            }
            return new string(reversedCharArray);
        }
        static string ReverseWords(string str)
        {
            int first = 0;
            str = str + ' ';
            string newString = "";
            for (int i = 0; i < str.Length; i++)
            {
                if (str[i] == ' ' || str[i] == ','
                    || str[i] == '.' || str[i] == '-'
                    || str[i] == ';' || str[i] == ':'
                    || str[i] == '?' || str[i] == '!')
                {
                    string partString = Reverse(str.Substring(first, i - first));
                    newString = newString + partString + str[i];
                    first = i + 1;
                }
            }
            newString = newString.Remove(newString.Length - 1);
            return newString;
        }
        /*
        static int[] ArrayOfWordsLengths(string str)
        {
            int first = 0;
            str = str + ' ';
            int[] array = new int[0];
            for (int i = 0; i < str.Length; i++)
            {
                if (str[i] == ' ' || str[i] == ','
                    || str[i] == '.' || str[i] == '-'
                    || str[i] == ';' || str[i] == ':'
                    || str[i] == '?' || str[i] == '!')
                {

                    string partString = str.Substring(first, i - first);
                    array = ElementAdded(array, i - first);
                    first = i + 1;
                }

            }
            return array;
        }
        static int[] GetArrayOfIndexes(int[] ar)
        {
            int[] createdArray = new int[ar.Length];
            for (int i = 0; i < ar.Length; i++)
            {
                createdArray[i] = i;
            }
            return createdArray;
        }
        static int[] ElementAdded(int[] ar, int value)
        {
            int i;
            int number = ar.Length;
            int[] newAr = new int[ar.Length + 1];
            for (i = 0; i < ar.Length; i++)
            {
                newAr[i] = ar[i];
            }
            newAr[i] = value;

            return newAr;
        }
        static int[] LastElementDeleted(int[] ar)
        {
            int[] newAr = new int[ar.Length - 1];
            for (int i = 0; i < ar.Length -1; i++)
            {
                newAr[i] = ar[i];
            }
            return newAr;
        }
        */
        static void Main(string[] args)
        {
            Console.Clear();

            int mainAct;
            double[][] jag = new double[0][];
            int multiplier = 99;
            int rows = 0, size = 0;
            bool firstRunArray = true;
            bool firstRunString = true;
            int[] arrayOfLengths = new int[0];
            int[] arrayOfIndexes = new int[0];
            string[] stringsArray = {
                                    "Тестовая строка номер один",
                                    "А со знаками препинания - оно как, работает?",
                                    "И ьтсуп есв у сав тедуб йээх анеракам",
                                    };
            string input = "";

            do
            {
                ShowMenu("Работа с рваным массивом",
                    "Работа со строкой",
                    "Выход из программы");
                mainAct = AskForAction(3);
                int actOfArrayInput = 0;
                int actOfStringInput = 0;

                switch (mainAct)
                {
                    case 1:
                        int arrayAct;
                        do
                        {
                            if (firstRunArray)
                            {
                                ShowMenu("Создать массив волей Божьей",                     // способ ввода
                                    "Ввести массив вручную",
                                    "В меню");
                                actOfArrayInput = AskForAction(3)+1;

                            }
                            else
                            {
                                ShowMenu("Использовать тот же массив",
                                    "Создать новый массив волей Божьей",
                                    "Ввести новый массив вручную",
                                    "В меню");
                                actOfArrayInput = AskForAction(4);
                            }

                                switch (actOfArrayInput)
                                {
                                    case 2:
                                        rows = AskForArraySize(0);
                                        jag = new double[rows][];
                                        for (int i = 0; i < rows; i++)
                                        {

                                            size = rnd.Next(1, 11);
                                            jag[i] = InputRandom(size, multiplier);

                                        }
                                        break;
                                    case 3:
                                        rows = AskForArraySize(0);
                                        jag = new double[rows][];
                                        for (int i = 0; i < rows; i++)
                                        {
                                            size = AskForJaggedArrayStringSize(i);
                                            jag[i] = InputManual(size);
                                        }
                                        break;

                                }
                                if (actOfArrayInput != 4)                               // если не нажали выход
                                {
                                    firstRunArray = false;
                                    Print(jag);

                                    do
                                    {
                                        ShowMenu("Упорядочить массив",
                                            "Вернуться к способу ввода",
                                            "Меню");
                                        arrayAct = AskForAction(3);
                                        switch (arrayAct)
                                        {
                                            case 1:
                                                for (int i = 0; i < jag.Length; i++)                // сортируем элементы
                                                {
                                                    Array.Sort(jag[i]);
                                                }

                                                jag = ArraySortedLikeStairs(jag);

                                                Console.WriteLine("Упорядоченный массив:");
                                                Print(jag);
                                                break;
                                            case 2:
                                                break;
                                            case 3:
                                                actOfArrayInput = 4;
                                                break;
                                        }
                                    } while (arrayAct != 2 && arrayAct != 3);
                                }    // end if (act != 4)
                        } while (actOfArrayInput != 4);

                        break;
                    case 2:

                        int stringAct = 0;
                        do
                        {

                            if (firstRunString)
                            {
                                ShowMenu("Ввести строку",                     // способ ввода
                                    "Выбрать строку из списка",
                                    "В меню");
                                actOfStringInput = AskForAction(3) + 1;

                            }
                            else
                            {
                                ShowMenu("Использовать ту же строку",
                                    "Ввести новую строку",
                                    "Выбрать из списка",
                                    "В меню");
                                actOfStringInput = AskForAction(4);
                            }
                            switch (actOfStringInput)
                            {
                                case 1:
                                    Red("Строка: ");
                                    Console.WriteLine(input);
                                    Console.WriteLine();
                                    break;
                                case 2:
                                    Red("Строка: ");
                                    input = Console.ReadLine();
                                    Console.WriteLine();
                                    break;
                                case 3:
                                    Print(stringsArray);
                                    int choise = AskForAction(stringsArray.Length);
                                    input = stringsArray[choise - 1];
                                    Red("Строка: ");
                                    Console.WriteLine(input);
                                    Console.WriteLine();
                                    break;

                            }


                            if (actOfStringInput != 4)
                            {
                                do
                                {
                                    firstRunString = false;

                                    ShowMenu("Перевернуть все слова в предложении",
                                                    "Вернуться к способу ввода",
                                                    "Меню");
                                    stringAct = AskForAction(3);
                                    switch(stringAct)
                                    {
                                        case 1:
                                            input = ReverseWords(input);
                                            Red("Строка: ");
                                            Console.WriteLine(input);
                                            Console.WriteLine();
                                            /*arrayOfLengths = ArrayOfWordsLengths(input);
                                            Print(arrayOfLengths);
                                            arrayOfIndexes = GetArrayOfIndexes(arrayOfLengths);
                                            Print(arrayOfIndexes);*/
                                            break;
                                        case 2:
                                            break;
                                        case 3:
                                            actOfStringInput = 4;
                                            break;
                                    }

                                } while (stringAct != 2 && stringAct != 3);

                            }

                        } while (actOfStringInput != 4);
                        break;

                }


                //Console.WriteLine(mainAct);
            } while (mainAct != 3);
        }
    }
}