lab4_Ann

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

namespace ConsoleApplication5
{
    class Program
    {
        static int AskForArraySize()
        {
            bool ok;
            int size;
            Console.Write("Размерность массива:");
            do
            {
                string buf = Console.ReadLine();
                ok = int.TryParse(buf, out size) && (size > 0);
                if (!ok)
                {
                    Console.WriteLine("Размерность должна быть натуральной.");
                    Console.WriteLine("Повторите ввод: ");
                }
            } while (!ok);
            return size;
        }
        static int[] ArrayOfRandom(int size)
        {
            int[] randomArray = new int[size];
            Random rnd = new Random();
            for (int i = 0; i < size; i++)
            {
                randomArray[i] = rnd.Next(-99, 100);
            }
            return randomArray;
        }
        static int[] ArrayOfManual(int size)
        {
            bool ok;
            int n;
            int[] manualAr = new int[size];
            Console.WriteLine("Введите {0} элементов: ", size);
            for (int i = 0; i < size; i++)
            {
                Console.Write("Элемент {0}: ", i + 1);
                do
                {
                    string buf = Console.ReadLine();
                    ok = int.TryParse(buf, out n);
                    if (!ok)
                        Console.Write("Повторите ввод: ");
                } while (!ok);
                manualAr[i] = n;
            }
            return manualAr;
        }
        static int AskForCommand(int commands)
        {
            int act;
            bool ok;
            Console.Write("Команда: ");
            do
            {
                string buf = Console.ReadLine();
                ok = int.TryParse(buf, out act) && act > 0 && act <= commands;
                if (!ok)
                {
                    Console.WriteLine("Ожидалось число в пределах количества команд ({0}).", commands);
                    Console.Write("Повторите ввод: ");
                }
            } while (!ok);
            return act;
        }
        static void Print(int[] ar)
        {
            foreach (int x in ar) Console.Write(x + " ");
        }
        static void ShowInputMethods()
        {
            Console.WriteLine("1. Создать массив с помощью ДСЧ");
            Console.WriteLine("2. Ввести массив с клавиатуры");
        }
        static void ShowMenu()
        {
            string[] menuAr = new string[] {
                "1. Удалить четные элементы",
                "2. Добавить несколько элементов в массив",
                "3. Сдвинуть массив вправо",
                "4. Найти определенный элемент в массиве",
                "5. Найти элемент бинарным поиском",
                "6. Сортировать элементы простым обменом",
                "7. Выход"
            };
            for (int i = 0; i < 7; i++)
            {
                Console.WriteLine(menuAr[i]);
            }
            Console.WriteLine();
        }
        static int FindKey(int size, int[] ar, int key, out int comparisons)
        {
            comparisons = 0;
            for (int i = 0; i < size; i++)
            {
                comparisons++;
                if (ar[i] == key)
                {
                    return i;
                }

            }
            return (-1);
        }
        static int FindAverInSorted(int[] ar, double averageValue, out int comparisons)
        {
            int left = 0, right = ar.Length - 1;
            int middle;
            comparisons = 0;
            do
            {
                middle = (left + right) / 2;
                if ((double)ar[middle] < averageValue)
                {
                    left = middle + 1;
                }
                else
                {
                    right = middle;
                }
                comparisons++;
            } while (left != right);
            if ((double)ar[left] == averageValue)
            {
                return left;
            }
            return (-1);
        }

        static int[] DeleteOddElements(ref int size, int[] ar)
        {
            int i = 0, s = 0;
            foreach (int x in ar)
            {
                if (x % 2 != 0)
                {
                    s++;
                }
            }
            int[] evenItems = new int[s];
            foreach (int x in ar)
            {
                if (x % 2 != 0)
                {
                    evenItems[i++] = x;

                }
            }
            size = s;
            return evenItems;
        }

        static int[] ElementInserted(ref int size, int[] ar, int number, int value)
        {
            int i;
            int[] newAr = new int[size + 1];
            for (i = 0; i < number - 1; i++)
            {
                newAr[i] = ar[i];
            }
            newAr[i++] = value;
            for (; i <= size; i++)
            {
                newAr[i] = ar[i - 1];
            }
            size++;
            return newAr;

        }
        static int[] ElementsInserted(ref int size, int[] ar, int number, int[] values, int valuesLength)
        {
            int i;
            int[] newAr = new int[size + valuesLength];
            for (i = 0; i < number - 1; i++)
            {
                newAr[i] = ar[i];
            }
            int pos = i;
            for (int j = 0; j < valuesLength; j++)
            {
                newAr[i++] = values[j];

            }
            for (; i < size+valuesLength; i++)
            {
                newAr[i] = ar[pos++];
            }
            size += valuesLength;
            return newAr;
        }
        static int[] MoveRight(int size, int[] ar, int k)
        {
            k %= size;
            k = size - k;
            for (int j = 0; j < k; j++)
            {
                int temp = ar[0];
                for (int i = 0; i < size - 1; i++)
                {
                    ar[i] = ar[i + 1];
                }
                ar[size - 1] = temp;
            }
            return ar;
        }
        static int[] ChangeSort(int size, int[] ar)
        {
            int min, nMin;
            for (int i = 0; i < size-1; i++)
            {
                min = ar[i];
                nMin = i;
                for (int j = i + 1; j < size; j++)
                {
                    if (ar[j] < min)
                    {
                        min = ar[j];
                        nMin = j;

                        ar[nMin] = ar[i];
                        ar[i] = min;
                    }
                }
            }
            return ar;
        }
        static void Main(string[] args)
        {
            bool ok;
            int act;
            int[] ar = new int[0];

            ShowInputMethods();
            act = AskForCommand(2);
            Console.WriteLine();

            int size = AskForArraySize();
            Console.WriteLine();

            switch (act)
            {
                case 1:
                    ar = ArrayOfRandom(size);
                    Print(ar);
                    Console.WriteLine();
                    Console.WriteLine();
                    break;
                case 2:
                    ar = ArrayOfManual(size);
                    Print(ar);
                    Console.WriteLine();
                    Console.WriteLine();
                    break;
            }
            do
            {

                ShowMenu();
                act = AskForCommand(7);

                switch (act)
                {
                    case 1:
                        int[] shortAr = DeleteOddElements(ref size, ar);
                        if (shortAr != null)
                        {
                            ar = shortAr;
                        }
                        else Console.WriteLine("В массиве из одного элемента нет элементов с четными индексами. ");
                        Console.WriteLine();
                        Print(ar);
                        Console.WriteLine();
                        break;
                    case 2:
                        int number, n;
                        Console.Write("Сколько элементов вставлять: ");
                        do
                        {
                            string buf = Console.ReadLine();
                            ok = int.TryParse(buf, out n) && n > 0;
                            if (!ok)
                            {
                                Console.WriteLine("Ожидалось натуральное число.");
                                Console.Write("Повторите ввод:");
                            };
                        } while (!ok);

                        Console.Write("Вставить элементы начиная с ячейки: ");
                        do
                        {
                            string buf = Console.ReadLine();
                            ok = int.TryParse(buf, out number) && number > 0 && number <= size + 1;
                            if (!ok)
                            {
                                Console.Write("Ожидалось натуральное число в пределах 1-");
                                Console.WriteLine((size + 1).ToString() + ".");
                                Console.Write("Повторите ввод:");
                            };
                        } while (!ok);
                        int[] insertAr = ArrayOfManual(n);


                        ar = ElementsInserted(ref size, ar, number, insertAr, n);
                        Console.WriteLine();
                        Print(ar);
                        Console.WriteLine();
                        break;
                    case 3:
                        int k;

                        do
                        {
                            Console.Write("На сколько элементов сдвигаем: ");
                            string buf = Console.ReadLine();
                            ok = int.TryParse(buf, out k) && (k >= 0);
                            if (!ok)
                                Console.WriteLine("Ожидалось натуральное число.");
                        } while (!ok);

                        Console.Write("\nИсходный:   ");
                        Print(ar);
                        Console.Write("\nПолученный: ");
                        ar = MoveRight(size, ar, k);
                        Print(ar);
                        Console.WriteLine();
                        break;
                    case 4:
                        int comparisons;
                         Console.Write("Какой элемент искать: ");
                        do
                        {
                            string buf = Console.ReadLine();
                            ok = int.TryParse(buf, out n);
                            if (!ok)
                            {
                                Console.WriteLine("Ожидалось целое число.");
                                Console.Write("Повторите ввод:");
                            };
                        } while (!ok);
                        int res = FindKey(size, ar, n, out comparisons);
                        if (res >= 0) Console.WriteLine("Элемент " + n + " находится в ячейке " + (res + 1));
                        else Console.WriteLine("В массиве нет заданного элемента.");
                        Console.WriteLine("Сравнений: {0}", comparisons);
                        break;
                    case 5:
                        comparisons = 0;
                        Console.Write("Какой элемент искать: ");
                        do
                        {
                            string buf = Console.ReadLine();
                            ok = int.TryParse(buf, out n);
                            if (!ok)
                            {
                                Console.WriteLine("Ожидалось целое число.");
                                Console.Write("Повторите ввод:");
                            };
                        } while (!ok);
                        ar = ChangeSort(size, ar);
                        res = FindAverInSorted(ar, n, out comparisons);
                        Console.WriteLine("Массив был отсортирован: ");
                        Print(ar);
                        Console.WriteLine();
                        if (res >= 0) Console.WriteLine("Среднее арифметическое " + n + " находится в ячейке " + (res + 1));
                        else Console.WriteLine("В массиве нет элемента, равного среднему арифметическому его элементов.");
                        Console.WriteLine("Сравнений в процессе поиска: {0}", comparisons);
                        Console.WriteLine();
                        Print(ar);
                        Console.WriteLine();
                        break;
                    case 6:
                        Console.Write("Исходный:   ");
                        Print(ar);
                        Console.WriteLine();
                        Console.Write("Полученный: ");
                        ar = ChangeSort(ar: ar, size: size); // Тестовое использование именнованных параметров
                        Print(ar);
                        Console.WriteLine();
                        break;
                }
                Console.WriteLine();
            } while (act != 7);

        }
    }
}