using System using System Collections Generic using System Linq using

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

namespace Task_4 {
    class Program {
        static void Main(string[] args) {
            Random rnd = new Random();
            int n = 58,
                a = 29,
                b = 52,
                a1 = 11,
                b1 = 37;
            List<int> myArray = new List<int>(),
                      resultArray = new List<int>();

            for (int i = 0; i < n; ++i) {
                myArray.Add(rnd.Next(a, b));
                if (myArray[i] >= a1 && myArray[i] <= b1)
                    resultArray.Add(myArray[i]);
            }

            Console.WriteLine("-------------------------------------------------------------------------------");
            Console.WriteLine("Массив псевдослучайных чисел в диапазоне [a,b]:");
            for (int i = 0; i < n; ++i)
                Console.Write("{0} ", myArray[i]);
            Console.WriteLine("\n-------------------------------------------------------------------------------");
            resultArray.Sort();
            resultArray.Reverse();

            Console.WriteLine("Упорядосенный по убыванию массив псевдослучайных чисел в диапазоне [a1,b1]:");
            double summ = 0;
            for (int i = 0; i < resultArray.Count; ++i) {
                Console.Write("{0} ", resultArray[i]);
                summ += resultArray[i];
            }

            // вычислим ранги
            List<double> rangs = new List<double>();
            List<bool> used = new List<bool>();
            for (int i = 0; i < resultArray.Count; ++i) {
                rangs.Add(0);
                used.Add(false);
            }
            double midValue = summ / resultArray.Count;
            summ = 0;
            int rang = 1,
                count = 0;
            bool flag = true;
            
            for (int i = 0; i < resultArray.Count; ++i) {
                used[i] = true;
                count = 1;
                rang = i + 1;
                summ = rang;
                flag = false;
                for (int j = i + 1; j < resultArray.Count; ++j) {
                    if (resultArray[i] == resultArray[j] && !used[j]) {
                        rang++;
                        summ += rang;
                        used[j] = true;
                        count++;
                        flag = true;
                    }
                    else
                        break;
                }
                if (flag) {
                    for (int j = 0; j < used.Count; ++j) {
                        if (used[j] && rangs[j] == 0)
                            rangs[j] = summ / count;
                    }
                    continue;
                }
                if (rangs[i] == 0) {
                        rangs[i] = i + 1;
                }
            }

            Console.WriteLine("\nРанги:");
            for (int i = 0; i < resultArray.Count; ++i) {
                Console.Write("{0} ", rangs[i]);
            }
           
            Console.WriteLine("\nСреднее значение: {0:f2}", midValue);
            summ = 0;
            for (int i = 0; i < resultArray.Count; ++i)
                summ += (resultArray[i] - midValue) * (resultArray[i] - midValue);

            Console.WriteLine("Сумма квадратов отклонений от среднего значения: {0:f2}", summ);
            Console.WriteLine("-------------------------------------------------------------------------------");

            // группировка данных
            int k = 4,                                                            // количество групп
                omega = resultArray[0] - resultArray[resultArray.Count - 1] + 1,  // размах данных
                length = (int)(omega / k);                                        // длинна группы  

            Console.WriteLine("Количество групп: {0}\nРазмах данных: {1}\nДлина группы: {2}", k, omega, length);


            // формируем массив границ интервалов 
            List<int> begin = new List<int>(),
                      end = new List<int>();
            int leftRange = resultArray[0],
                rightRange = resultArray[resultArray.Count - 1];
            while (leftRange >= rightRange) {
                begin.Add(leftRange);
                leftRange -= length;
                end.Add(leftRange);
                leftRange -= 1;
            }

            Console.Write("Границы групп:      ");
            for (int i = 0; i < begin.Count; ++i)
                Console.Write("{0} - {1}   ", begin[i], end[i]);

            // вычисляем частоту 
            List<int> frequency = new List<int>();
            List<int> frequency2 = new List<int>();
            for (int i = 0; i < begin.Count; ++i) {
                frequency.Add(0);
                frequency2.Add(0);
            }

            for (int i = 0; i < resultArray.Count; ++i) {
                for (int j = 0; j < begin.Count; ++j) {
                    if (resultArray[i] >= end[j] && resultArray[i] <= begin[j]) {
                        frequency[j]++;
                        break;
                    }
                }
            }

            frequency2[0] = frequency[0];
            for (int i = 1; i < frequency.Count; ++i) {
                frequency2[i] = frequency[i] + frequency2[i - 1];
            }
            Console.WriteLine();
            Console.Write("Частота:            ");
            for (int i = 0; i < frequency.Count; ++i)
                Console.Write("   {0}       ", frequency[i]);
            Console.WriteLine();
            Console.Write("Накопленная частота:");
            for (int i = 0; i < frequency2.Count; ++i)
                Console.Write("   {0}       ", frequency2[i]);
            Console.WriteLine();


            // расчет медианы
            int Xn = 0,                                         // начало мединного интервала
                h = 0,                                          // ширина мединного интервала
                nMe = 0,                                        // частота мединного интервала
                SMe = 0;                                        // накомпленная частота до мединного интервала

            int ind = 0;
            for (int i = 0; i < begin.Count; ++i) {
                if (midValue <= begin[i] && midValue >= end[i]) {
                    ind = i;
                    break;
                }
            }

            Xn = end[ind];
            h = begin[ind] - end[ind];
            nMe = frequency[ind];
            SMe = (ind > 0) ? frequency2[ind - 1] : 0;

            double mean = Xn + (double)((double)resultArray.Count / 2 - SMe) / nMe * h;

            Console.WriteLine("Медиана: {0:f2}", mean);


            // расчет моды
            int X0 = 0,                                        // начало модального интервала
                n1 = 0,                                        // частота до интервала
                n2 = 0,                                        // частота интервала
                n3 = 0;                                        // частота после интервала
            h = 0;

            ind = 0;
            int maxValue = -999;
            for (int i = 0; i < frequency.Count; ++i) {
                if (frequency[i] > maxValue) {
                    maxValue = frequency[i];
                    ind = i;
                }
            }

            X0 = end[ind];
            h = begin[ind] - end[ind];
            n2 = frequency[ind];
            n1 = (ind > 0) ? frequency[ind] : 0;
            n3 = (ind + 1 < begin.Count) ? frequency[ind + 1] : 0;

            double mod = X0 + h * ((double)(n2 - n1)) / ((n2 - n1) + (n2 - n3));
            Console.WriteLine("Мода: {0:f2}", mod);

        }
    }
}