Загрузить файлы ''

ret.txt

@@ -0,0 +1,216 @@
+using System;
+using System.Diagnostics;
+using System.IO;
+
+namespace ekz
+{
+    public class Program
+    {
+        static void Main(string[] args)
+        { 
+            try
+            {
+                double bestSum = Solution.getBestSum(); // Сумма для вклада с максимальным доходом
+
+                Console.WriteLine(bestSum);
+                Console.WriteLine("Годовой доход " + Solution.bestTotalCapitalization);
+
+              
+
+                using (StreamWriter streamWriter = new StreamWriter($"{Directory.GetCurrentDirectory()}/answer.txt"))
+                {
+                    streamWriter.WriteLine($"Годовой доход равен {Solution.bestTotalCapitalization} с вкладом {bestSum}");
+                }
+            }
+            catch
+            {
+                Console.WriteLine("Возникла ошибка");
+            }
+
+        }
+
+    }
+
+    /// <summary>
+    /// Решение
+    /// </summary>
+    public class Solution // Класс с методами для решения 
+    {
+
+        public static double bestTotalCapitalization; // Сумма наибольшей капитализации
+
+        /// <summary>
+        /// Метод определения процентной ставки
+        /// </summary>
+        /// <param name="N">Ставка</param>
+        /// <param name="threeMonthAdd"></param>
+        /// <param name="M">Процент</param>
+        /// <returns></returns>
+        public static double getProcent(double N, double threeMonthAdd, double M) // Метод определения процентной ставки
+        {
+            // Диапозон вкладов
+            double minValue = 0; 
+            double maxValue = 50000;
+
+            if (N < 700000) // При ставке, меньшей 700 тыс. у. е.
+            {
+                for (int i = 1; i <= (700000 / 50000); i++) // Определение процента по промежуткам
+                {
+                    if (N >= minValue && N <= maxValue - 0.01)
+                    {
+                        M = i + threeMonthAdd; // Добавление к проценту 
+
+                        if (M > 20) M = 20;
+
+                        break;
+                    }
+
+                    minValue += 50000;
+                    maxValue += 50000;
+                }
+            }
+            else if (N == 700000) // При ставке, равной 700 тыс. у. е.
+            {
+                M = 20 + threeMonthAdd;
+                if (M > 20) M = 20;
+            }
+            else if (N > 700000)  // При ставке, большей 700 тыс. у. е.
+            {
+
+                M = 20;
+                minValue = 700000;
+                maxValue = 750000.00;
+
+                for (int i = 0; i <= (700000 / 50000); i++)
+                {
+                    if (N >= minValue && N <= maxValue - 0.01)
+                    {
+                        M = M - i;
+                        M += threeMonthAdd;
+
+                        if (M < 1) M = 1;
+
+                        break;
+                    }
+                    minValue += 50000;
+                    maxValue += 50000;
+                }
+
+            }
+
+            return M;
+        }
+
+        public static double getCapitalization(double M, double N) // Метод определения месячной капитализации 
+        {
+            if (M - 8 > 5) // Если процентная ставка больше такой же в центр. банке на более чем 5 процентов
+                return ((N * (M / 100 / 12)) * 0.7);
+            else
+                return N * (M / 100 / 12);
+        }
+
+        public static double getBestSum() // Метод определения лучшего начального вложения
+        {
+            
+
+            double bestSum = 0; // Лучшее начальное вложение
+            double max = 0; // Максимальная капитализация
+            try
+            {
+                Trace.Listeners.Add(new TextWriterTraceListener("debug.txt"));
+                for (int i = 0; i < 1000000; i += 1000)
+                {
+                    double N = i;
+                    double M = 8; // Процентная ставка
+                    double capitalization;
+                    double totalCapitalization = 0;
+
+                    double threeMonthAdd = 0; // Сумма прибавки за каждый третий месяц
+
+                    int monthesCount = 12; // Кол-во месяцев
+
+                    for (int j = 1; j <= monthesCount; j++)
+                    {
+                        if (j % 3 == 0) threeMonthAdd += 0.5;
+
+                        M = getProcent(N, threeMonthAdd, M);
+
+                        capitalization = getCapitalization(M, N);
+
+                        N += capitalization;
+                        totalCapitalization += capitalization;
+
+                    }
+
+                    if (totalCapitalization > max) // Сравнение капитализаций
+                    {
+                        max = totalCapitalization;
+                        bestSum = i;
+                    }
+
+                
+                    Trace.WriteLine(i + "\nГодовой доход " + totalCapitalization);
+                   
+                }
+                Trace.Flush();
+
+
+                bestTotalCapitalization = max;
+
+                Debug.WriteLine("Подсчет суммы прошел успешно");
+                return bestSum;
+
+                
+            }
+            catch
+            {
+                Debug.WriteLine("Возникли проблемы с подсчетом");
+                return 0;
+            }
+
+           
+
+
+        }
+    }
+
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace UnitTestProject3
+{
+    [TestClass]
+    public class UnitTest1
+    {
+        [TestMethod]
+        public void TestMethod1()
+        {
+
+            double M = 10;
+            double N = 100;
+            double expected = N * (M / 100 / 12);
+
+            double actual = ekz.Solution.getCapitalization(M, N);
+
+            Assert.AreEqual(expected, actual);
+
+            
+        }
+
+        [TestMethod]
+        public void TestMethod2()
+        {
+
+            double M = 10;
+            double N = 100;
+            double expected = 102;
+
+            double actual = ekz.Solution.getCapitalization(M, N);
+
+            Assert.AreEqual(expected, actual);
+        }
+    }
+}
+
+
+    
+}

simpl.txt

@@ -0,0 +1,322 @@
+using System;
+
+namespace Симплекс_м
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+
+            while (true)
+            {
+                int r=0, c=0;//размерности матрицы и векторов
+                while (true)//ввод количество вида сырья(размерности по стокам)
+                {
+                    try
+                    {
+                        Console.WriteLine("Введите количество вида сырья");
+                        r = Convert.ToInt32(Console.ReadLine());
+                        if (r < 2)
+                        {
+                            Console.WriteLine("Видов сырья должно быть не менее двух! Повторите ввод");
+                        }
+                        else
+                        {
+                            break;
+                        }
+                    }
+                    catch
+                    {
+                        Console.WriteLine("Введены некорректные данные!");
+                    }
+                }
+                while (true)//ввод потребителей(размерности по столбцам)
+                {
+                    try
+                    {
+                        Console.WriteLine("Введите количество видов продукции");
+                        c = Convert.ToInt32(Console.ReadLine());
+                        if (c < 2)
+                        {
+                            Console.WriteLine("Количество видов продукции должно быть не менее двух! Повторите ввод");
+                        }
+                        else
+                        {
+                            break;
+                        }
+                    }
+                    catch
+                    {
+                        Console.WriteLine("Введены некорректные данные!");
+                    }
+                }
+                int i = 0, j = 0;//переменные для циклов
+                int[,] matrxA = new int[r, c];//таблица без запасов сырья
+                Console.WriteLine("Ввод таблицы затрат на перевозку продукции:");//ввод данных в таблицу расходов ресурсов
+                for (i = 0; i < matrxA.GetLength(0); i++)
+                {
+                    for (j = 0; j < matrxA.GetLength(1); j++)
+                    {
+
+                        while (true)
+                        {
+                            try
+                            {
+                                Console.Write($"Введите расход  {i + 1} сырья  для {j + 1} единицы продукции: ");
+                                matrxA[i, j] = Convert.ToInt32(Console.ReadLine());
+                                break;
+                            }
+                            catch
+                            {
+                                Console.WriteLine("Введены некорректные данные!");
+                            }
+                        }
+
+                    }
+                    Console.WriteLine();
+                }
+
+                Console.WriteLine("Таблица расхода сырья на единицу продукции вида:");//вывод таблицы  на экран
+                for (i = 0; i < matrxA.GetLength(0); i++)
+                {
+                    for (j = 0; j < matrxA.GetLength(1); j++)
+                    {
+                        Console.Write(matrxA[i, j] + "\t");
+                    }
+                    Console.WriteLine();
+                }
+                char otv;
+                int temp;//переменная для диалога с пользователем
+                         //Изменение матрицы
+                while (true)
+                {
+                    while (true)
+                    {
+                        try
+                        {
+                            Console.Write("\nХотите изменить данные о таблице?\nДа(любая клавиша)/Нет(N)\nОтвет: ");
+                            otv = Convert.ToChar(Console.ReadLine());
+                            break;
+                        }
+                        catch
+                        {
+                            Console.WriteLine("Введены некорректные данные!");
+                        }
+                    }
+                    if (otv.Equals('n') || otv.Equals('т') || otv.Equals('N') || otv.Equals('Т'))
+                    {
+                        break;
+                    }
+                    else
+                    {
+                        Console.Write("Введите номер вида сырья, затем номер вида ресурса, который вы хотите изменить\nОтвет:\n");
+                        while (true)
+                        {
+                            i = Convert.ToInt32(Console.ReadLine());
+                            j = Convert.ToInt32(Console.ReadLine());
+                            if (i < c + 1 && j < r + 1)
+                            {
+                                while (true)
+                                {
+                                    try
+                                    {
+                                        Console.Write("Введите новое значение: ");
+                                        temp = Convert.ToInt32(Console.ReadLine());
+                                        if (temp != 0)
+                                        {
+                                            Console.WriteLine($" Была изменена {i} {j} ячейка таблицы c {matrxA[i - 1, j - 1]} на {temp}");
+                                            matrxA[i - 1, j - 1] = temp;
+                                            break;
+                                        }
+                                        else
+                                        {
+                                            Console.WriteLine("Вы ввели нулевое значение! Повторите ввод");
+                                        }
+                                    }
+                                    catch
+                                    {
+                                        Console.WriteLine("Введены некорректные данные!");
+                                    }
+                                }
+                                break;
+                            }
+                            else
+                            {
+                                Console.WriteLine("Введенная размерность не соответствует матрице! Повторите ввод");
+                            }
+                        }
+                    }
+                }
+
+                Console.Clear();
+                int[] m = new int[r];//вектор
+               
+                Console.WriteLine("Ввод данных о затратах сырья:");//ввод данных в вектор мощности поставщиков
+                for (i = 0; i < m.Length; i++)
+                {
+                    while (true)
+                    {
+                        try
+                        {
+                            Console.Write($"Введите затраты сырья {i + 1} вида: ");
+                            m[i] = Convert.ToInt32(Console.ReadLine());
+                            break;
+                        }
+                        catch
+                        {
+                            Console.WriteLine("Введены некорректные данные!");
+                        }
+                    }
+                }
+
+                Console.WriteLine("Вектор затрат сырья:");//вывод на экран
+                for (i = 0; i < m.Length; i++)
+                {
+                    Console.WriteLine($"{m[i]} ");
+                }
+
+                int[] d = new int[r];//вектор
+               
+
+
+                Console.WriteLine("Введите  доход:");
+                for (i = 0; i < c; i++)
+                {
+                    while (true)
+                    {
+                        try
+                        {
+                            Console.Write($"Введите доход продукции {i + 1} вида: ");
+                            d[i] = Convert.ToInt32(Console.ReadLine());
+                            break;
+                        }
+                        catch
+                        {
+                            Console.WriteLine("Введены некорректные данные!");
+                        }
+                    }
+                }
+
+               
+                Console.WriteLine("Вектор дохода:");//вывод на экран
+                for (i = 0; i < m.Length; i++)
+                {
+                    Console.WriteLine($"{d[i]} ");
+                }
+
+
+                Console.WriteLine("\nТаблица:");//вывод на экран матрицы и векторов
+                Console.Write("  ");
+
+                Console.WriteLine();
+                for (i = 0; i < matrxA.GetLength(0); i++)
+                {
+                    Console.Write($"{m[i]} ");
+                    for (j = 0; j < matrxA.GetLength(1); j++)
+                    {
+                        Console.Write($"{matrxA[i, j]} ");
+                    }
+                    Console.WriteLine();
+                }
+                for ( i = 0; i < d.Length; i++)
+                {
+                    Console.Write($"{d[i]} ");
+                }
+
+                double[,] simpleks = new double[r + 1, c + 1 + r];
+                for (i = 0; i < r; i++)
+                {
+                    for (j = 0; j < c; j++)
+                    {
+                        simpleks[i, j] = matrxA[i, j];
+                    }
+                }
+                for (i = 0; i < d.Length; i++)
+                {
+                    simpleks[simpleks.GetLength(0) - 1, i] = d[i];
+                }
+                for (i = 0; i < m.Length; i++)
+                {
+                    simpleks[i, simpleks.GetLength(1)-1] = m[i];
+                }
+                int l = 0;
+                for (i = c; i < c + r; i++)
+                {
+                    simpleks[l++, i] = 1;
+                }
+                Console.WriteLine("\nCимплекс таблица:");
+                for (i = 0; i < simpleks.GetLength(0); i++)
+                {
+                    for (j = 0; j < simpleks.GetLength(1); j++)
+                    {
+                        Console.Write($"{simpleks[i, j]} "); 
+                    }
+                    Console.WriteLine();
+                }
+
+                double[] b = new double[0];
+                int  temp2 = 0;
+                for ( j = 0; j < simpleks.GetLength(1) - 1; j++)
+                {
+                    temp = 0;
+                    temp2 = 0;
+                    for ( i = 0; i < simpleks.GetLength(0) - 1; i++)
+                    {
+                        if (simpleks[i, j] == 0)
+                            temp++;
+                        if (simpleks[i, j] == 1)
+                            temp2++;
+                    }
+                    if (temp == simpleks.GetLength(0) - 2 && temp2 == 1)
+                    {
+                        for ( i = 0; i < simpleks.GetLength(0) - 1; i++)
+                        {
+                            if (simpleks[i, j] == 1)
+                            {
+                                temp = i;
+                            }
+                        }
+                        Array.Resize(ref b, b.Length + 1);
+                        b[b.Length - 1] = Math.Round(simpleks[temp, simpleks.GetLength(1) - 1]);
+                    }
+                    else
+                    {
+                        Array.Resize(ref b, b.Length + 1);
+                        b[b.Length - 1] = 0;
+                    }
+                   
+                }
+                for ( i = 0; i < b.Length; i++)
+                {
+                    Console.WriteLine($"x{i + 1} = {b[i]}");
+                    
+                }
+                Array.Resize(ref b, 0);
+                int indexi = 0;
+                int indexj = 0;
+                Console.WriteLine($"F'={simpleks[simpleks.GetLength(0) - 1, simpleks.GetLength(1) - 1]}");
+                Console.WriteLine($"F ={Math.Abs(simpleks[simpleks.GetLength(0) - 1, simpleks.GetLength(1) - 1])}");
+                double max = double.MinValue;
+                for (i = 0; i < simpleks.GetLength(1); i++)
+                {
+                    if (simpleks[simpleks.GetLength(0)-1, i]>max)
+                    {
+                        max = simpleks[simpleks.GetLength(0) - 1, i];
+                        indexj = i;
+                    }
+                }
+                double min = double.MaxValue;
+                for (i = 0; i < simpleks.GetLength(0)- 1; i++)
+                {
+                    if (simpleks[i,simpleks.GetLength(1)-1]/simpleks[i, indexj] < min)
+                    {
+                        min = simpleks[i, simpleks.GetLength(1) - 1] / simpleks[i, indexj];
+                        indexi = i;
+                    }
+                }
+                Console.WriteLine($"{indexi+1}  {indexj+1}");
+
+            }
+        }
+    }
+}

way.txt

@@ -0,0 +1,186 @@
+using System;
+
+namespace Indexs
+{
+    class program
+    {
+        static void Main(string[] args)
+        {
+            
+            while(true)
+            {
+                Console.Clear();
+                Console.WriteLine("Дана таблица работ для сетевого графика. Построить сетевой график и найти критический путь.");
+            
+                int[] ri = new int[] { 1, 1, 1, 2, 2, 3, 4 }; // начало пути 
+                int[] rj = new int[] { 2, 3, 5, 3, 4, 4, 5 }; // конец пути 
+                int[] dij = new int[ri.Length]; // объявление масива 
+
+            m1: int otv = 0;
+                while (true)
+                {
+                    Console.Write($"Введите номер способа заполнения продолжительностей работ\n1.Вручную\n2.Рандомно\nОтвет: ");
+                    try
+                    {
+                        otv = int.Parse(Console.ReadLine());
+                        break;
+                    }
+                    catch
+                    {
+                        Console.WriteLine("Введено некорректное значение! Повторите ввод");
+                    }
+
+                }
+
+                switch (otv) // выбор ручного или автоматического заполнения 
+                {
+                    case 1:
+                        int a = 0;
+                        for (int i = 0; i < dij.Length; i++)
+                        {
+                            while (true) // проверка введенного значения 
+                            {
+                                Console.Write($"Ввдеите продолжительность {i + 1} работы: "); // ввод продолжительности работ 
+                                a = Convert.ToInt32(Console.ReadLine());
+                                if (a > 0)
+                                {
+                                    dij[i] = a;
+                                    break;
+                                }
+                                else
+                                {
+                                    Console.WriteLine($"Введено некорректное значение! Повторите ввод.");
+                                }
+                            }
+                        }
+                        break;
+                    case 2:
+                        Random rnd = new Random();
+                        for (int i = 0; i < dij.Length; i++) // рандомное заполнение 
+                        {
+                            dij[i] = rnd.Next(1, 100);
+                        }
+                        break;
+                    default:
+                        Console.WriteLine($"Введено некорректное значение! Повторите ввод.");
+                        goto m1;
+                        break;
+                }
+
+                Console.Clear();
+
+                Console.WriteLine($"Работы и их продолжительность:");
+                for (int i = 0; i < dij.Length; i++)
+                {
+                    Console.WriteLine($"{ri[i]}-{rj[i]}({dij[i]})");  // вывод таблицы 
+                }
+
+                Console.WriteLine();
+
+                int[,] table = new int[4, 5];
+
+                int[][] pathes = new int[4][]; // массив из массивов (ступенчатый массив)
+                pathes[0] = new int[5];
+                pathes[1] = new int[6]; // пути , одна ячейка для F
+                pathes[2] = new int[5];
+                pathes[3] = new int[3];
+
+                for (int i = 0; i < ri.Length; i++)
+                {
+                    table[ri[i] - 1, rj[i] - 1] = dij[i];  // заполнение таблицы с продолжительностями в днях 
+                }
+
+                pathes[0][0] = 1;
+                pathes[0][1] = 2; // пути заполняются 
+                pathes[0][2] = 4;
+                pathes[0][3] = 5;
+
+                pathes[1][0] = 1;
+                pathes[1][1] = 2;
+                pathes[1][2] = 3;
+                pathes[1][3] = 4;
+                pathes[1][4] = 5;
+
+                pathes[2][0] = 1;
+                pathes[2][1] = 3;
+                pathes[2][2] = 4;
+                pathes[2][3] = 5;
+
+                pathes[3][0] = 1;
+                pathes[3][1] = 5;
+
+                for (int j = 0; j < pathes.Length; j++) // перебирает массивы внутри массива
+                {
+                    for (int i = 1; i < pathes[j].Length - 1; i++) // перебирает элементы конкретного массива 
+                    {
+                        pathes[j][pathes[j].Length - 1] += table[pathes[j][i - 1] - 1, pathes[j][i] - 1]; // обращаемся к последнему элементу массива и плюсуем значение пути
+                    }
+                }
+
+                for (int j = 0; j < pathes.Length; j++)// перебират массивы внутри массива 
+                {
+                    Console.Write($"Путь {j + 1}: "); // выводит путь индекс пути 
+                    for (int i = 0; i < pathes[j].Length - 1; i++) // последняя f его не выводим 
+                    {
+                        if (i == pathes[j].Length - 2)
+                        {
+                            Console.Write($"{pathes[j][i]}");
+                        }
+                        else
+                        {
+                            Console.Write($"{pathes[j][i]}-");
+                        }
+
+                    }
+                    Console.WriteLine($"; F = {pathes[j][pathes[j].Length - 1]}"); // вывод f
+                }
+
+                int MaxF = int.MinValue; /// для поиска максимального f
+                int ind = 0; // индекс максимального пути 
+
+                for (int i = 0; i < pathes.Length; i++)
+                {
+                    if (MaxF < pathes[i][pathes[i].Length - 1])
+                    {
+                        MaxF = pathes[i][pathes[i].Length - 1];
+                        ind = i;
+                    }
+                }
+
+                Console.Write($"Критический путь - Путь {ind + 1}: ");//вывод критического пути и его индекс 
+                for (int i = 0; i < pathes[ind].Length - 1; i++)
+                {
+                    if (i == pathes[ind].Length - 2)
+                    {
+                        Console.Write($"{pathes[ind][i]}");
+                    }
+                    else
+                    {
+                        Console.Write($"{pathes[ind][i]}-");
+                    }
+
+                }
+                Console.WriteLine($"; F = {pathes[ind][pathes[ind].Length - 1]}");
+                while (true)
+                {
+                    Console.Write($"Хотите повторить выполнение программы ? (0 - нет, любая цифра - да)");
+                    try
+                    {
+                        otv = int.Parse(Console.ReadLine());
+                        break;
+                    }
+                    catch
+                    {
+                        Console.WriteLine("Введено некорректное значение! Повторите ввод");
+                    }
+
+                }
+                if (otv == 0)
+                {
+                    break;
+                }
+            }
+        }
+        
+    }
+}