Advertisement
ksyshshot

Untitled

Nov 5th, 2022
82
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 9.24 KB | Source Code | 0 0
  1. #include <fstream>
  2. #include <iostream>
  3. #include <string>
  4. using namespace std;
  5.  
  6. void writeTask()
  7. {
  8.     cout << "Данная программа находит седловую точку квадратной матрицы\n";
  9. }
  10.  
  11. string fileInputPath(bool isFileForRead)
  12. {
  13.     bool isNotCorrect;
  14.     string path;
  15.     fstream file;
  16.     if (isFileForRead)
  17.     {
  18.         cout << "Введите путь к файлу для чтения: ";
  19.     }
  20.     else
  21.     {
  22.         cout << "Введите путь к файлу для записи: ";
  23.     }
  24.     do
  25.     {
  26.         isNotCorrect = false;
  27.         cin >> path;
  28.         file.open(path);
  29.         if (!file.is_open())
  30.         {
  31.             cout << "Файл не найден. Повторите попытку...\n";
  32.             isNotCorrect = true;
  33.         }
  34.     } while (isNotCorrect);
  35.     file.close();
  36.     return path;
  37. }
  38.  
  39. int fileInputMatrixOrder(string path)
  40. {
  41.     fstream file;
  42.     const int MAX_ORDER = 10;
  43.     const int MIN_ORDER = 2;
  44.     bool isFileForRead = true;
  45.     bool isNotCorrect;
  46.     int matrixOrder;
  47.     do
  48.     {
  49.         isNotCorrect = false;
  50.         file.open(path);
  51.         if (!file.is_open()) {
  52.             cout << "Не удалось открыть файл. ";
  53.             isNotCorrect = true;
  54.         }
  55.         if (!isNotCorrect)
  56.         {
  57.             file >> matrixOrder;
  58.             if (file.fail())
  59.             {
  60.                 file.clear();
  61.                 while (file.get() != '\n');
  62.                 cout << "Некорректно введённый порядок матрицы. ";
  63.                 isNotCorrect = true;
  64.             }
  65.             if ((!isNotCorrect) && ((matrixOrder < MIN_ORDER) || (matrixOrder > MAX_ORDER)))
  66.             {
  67.                 cout << "Порядок матрицы неверного диапазона! ";
  68.                 isNotCorrect = true;
  69.             }
  70.             if (isNotCorrect)
  71.             {
  72.                 cout << "Повторите попытку...\n";
  73.                 path = fileInputPath(isFileForRead);
  74.                 file.close();
  75.             }
  76.         }
  77.     } while (isNotCorrect);
  78.     file.close();
  79.     return matrixOrder;
  80. }
  81.  
  82. int** fileMatrixInput(string path, int** matrix, int order)
  83. {
  84.     ifstream file;
  85.     bool isNotCorrect;
  86.     bool isFileForRead = true;
  87.     do
  88.     {
  89.         isNotCorrect = false;
  90.         file.open(path);
  91.         file.get() != '\n';
  92.         int i = 0;
  93.         while ((!isNotCorrect) && (i < order))
  94.         {
  95.             int j = 0;
  96.             while ((!isNotCorrect) && (j < order))
  97.             {
  98.                 file >> matrix[i][j];
  99.                 if (file.fail())
  100.                 {
  101.                     cout << "Ошибка! Найдено некорректное значение элемента матрицы\n";
  102.                     isNotCorrect = true;
  103.                     i--;
  104.                 }
  105.                 j++;
  106.             }
  107.             i++;
  108.         }
  109.         if (isNotCorrect)
  110.         {
  111.             cout << "Проверьте правильность введённых данных и повторите попытку...\n";
  112.             path = fileInputPath(isFileForRead);
  113.         }
  114.     } while (isNotCorrect);
  115.     file.close();
  116.     return matrix;
  117. }
  118.  
  119. int consoleInputMatrixOrder()
  120. {
  121.     const int MIN_ORDER = 2;
  122.     const int MAX_ORDER = 10;
  123.     bool isNotCorrect;
  124.     int order;
  125.     do
  126.     {
  127.         isNotCorrect = false;
  128.         cout << "Введите порядок квадратной матрицы\n";
  129.         cin >> order;
  130.         if (cin.fail())
  131.         {
  132.             cin.clear();
  133.             while (cin.get() != '\n');
  134.             cout << "Ошибка ввода! Повторите попытку...\n";
  135.             isNotCorrect = true;
  136.         }
  137.         if ((!isNotCorrect) && (cin.get() != '\n'))
  138.         {
  139.             cin.clear();
  140.             cout << "Ошибка ввода! Повторите попытку...\n";
  141.             isNotCorrect = true;
  142.         }
  143.         if ((!isNotCorrect) && ((order < MIN_ORDER) || (order > MAX_ORDER)))
  144.         {
  145.             cout << "Ошибка ввода! Проверьте, входит ли введённое значение в допустимый диапазон и повторите попытку...\n";
  146.             isNotCorrect = true;
  147.         }
  148.     } while (isNotCorrect);
  149.     return order;
  150. }
  151.  
  152. int** matrixCreation(int order)
  153. {
  154.     int** matrix = new int* [order];
  155.     for (int i = 0; i < order; i++)
  156.     {
  157.         matrix[i] = new int[order];
  158.     }
  159.     return matrix;
  160. }
  161.  
  162. int** consoleFillMatrix(int** matrix, int order)
  163. {
  164.     const int MIN_ELEMENT = -2147483648;
  165.     const int MAX_ELEMENT = 2147483647;
  166.     bool isNotCorrect;
  167.     for (int i = 0; i < order; i++)
  168.     {
  169.         for (int j = 0; j < order; j++)
  170.         {
  171.             do
  172.             {
  173.                 isNotCorrect = false;
  174.                 cout << "Введите " << j + 1 << " элемент " << i + 1 << " строки\n";
  175.                 cin >> matrix[i][j];
  176.                 if (cin.fail())
  177.                 {
  178.                     cin.clear();
  179.                     while (cin.get() != '\n');
  180.                     cout << "Ошибка ввода! Повторите попытку...";
  181.                     isNotCorrect = true;
  182.                 }
  183.                 if ((!isNotCorrect) && (cin.get() != '\n'))
  184.                 {
  185.                     cin.clear();
  186.                     cout << "Ошибка ввода! Повторите попытку...\n";
  187.                     isNotCorrect = true;
  188.                 }
  189.                 if ((!isNotCorrect) && ((order < MIN_ELEMENT) || (order > MAX_ELEMENT)))
  190.                 {
  191.                     cout << "Ошибка ввода! Введено число неверного диапазона\n";
  192.                     isNotCorrect = true;
  193.                 }
  194.             } while (isNotCorrect);
  195.         }
  196.     }
  197.     return matrix;
  198. }
  199.  
  200. void consoleMatrixOutput(int** matrix, int order)
  201. {
  202.     cout << "Исходная матрица:\n";
  203.     for (int i = 0; i < order; i++)
  204.     {
  205.         for (int j = 0; j < order; j++)
  206.         {
  207.             cout << matrix[i][j] << " ";
  208.         }
  209.         cout << endl;
  210.     }
  211. }
  212.  
  213. int* smallestElementsInLine(int** matrix, int order)
  214. {
  215.     int min;
  216.     int* minIndexes = new int[order];
  217.     for (int i = 0; i < order; i++)
  218.     {
  219.         min = matrix[i][0];
  220.         minIndexes[i] = 0;
  221.         for (int j = 0; j < order; j++)
  222.         {
  223.             if (matrix[i][j] <= min)
  224.             {
  225.                 min = matrix[i][j];
  226.                 minIndexes[i] = j;
  227.             }
  228.         }
  229.     }
  230.     return minIndexes;
  231. }
  232.  
  233. int* largestElementsInColumn(int** matrix, int order)
  234. {
  235.     int max;
  236.     int* maxIndexes = new int[order];
  237.     for (int j = 0; j < order; j++)
  238.     {
  239.         max = matrix[0][j];
  240.         maxIndexes[j] = 0;
  241.         for (int i = 0; i < order; i++)
  242.         {
  243.             if (matrix[i][j] >= max)
  244.             {
  245.                 max = matrix[i][j];
  246.                 maxIndexes[j] = i;
  247.             }
  248.         }
  249.     }
  250.     return maxIndexes;
  251. }
  252.  
  253. void findingMatrixSaddlePoints(int** matrix, bool isConsoleAnswer, int& order)
  254. {
  255.     fstream file;
  256.     string path;
  257.     int* maxElemIndexes = smallestElementsInLine(matrix, order);
  258.     int* minElemIndexes = largestElementsInColumn(matrix, order);
  259.     int saddlePoint;
  260.     bool isSaddlePoint = false;
  261.     bool isNotCorrect;
  262.     for (int i = 0; i < order; i++)
  263.     {
  264.         for (int j = 0; j < order; j++)
  265.         {
  266.             if ((minElemIndexes[i] == j) && (maxElemIndexes[j] == i))
  267.             {
  268.                 saddlePoint = matrix[i][j];
  269.                 isSaddlePoint = true;
  270.             }
  271.         }
  272.     }
  273.     if (isConsoleAnswer)
  274.     {
  275.         if (isSaddlePoint)
  276.         {
  277.             cout << "Седловая точка матрицы: " << saddlePoint;
  278.         }
  279.         else
  280.         {
  281.             cout << "Седловой точки нет";
  282.         }
  283.     }
  284.     else
  285.     {
  286.         bool isFileForRead = false;
  287.         do
  288.         {
  289.             isNotCorrect = false;
  290.             path = fileInputPath(isFileForRead);
  291.             file.open(path);
  292.             if (!file.is_open())
  293.             {
  294.                 cout << "Не удалось открыть файл. Повторите попытку...\n";
  295.                 isNotCorrect = true;
  296.             }
  297.             if (!isNotCorrect)
  298.             {
  299.                 if (isSaddlePoint)
  300.                 {
  301.                     file << "Седловая точка матрицы: " << saddlePoint;
  302.                 }
  303.                 else
  304.                 {
  305.                     file << "Седловой точки нет";
  306.                 }
  307.             }
  308.         } while (isNotCorrect);
  309.         file.close();
  310.     }
  311. }
  312.  
  313. int** fileChoice(int& order)
  314. {
  315.     bool isFileForRead = true;
  316.     string path = fileInputPath(isFileForRead);
  317.     order = fileInputMatrixOrder(path);
  318.     int** matrix = matrixCreation(order);
  319.     matrix = fileMatrixInput(path, matrix, order);
  320.     return matrix;
  321. }
  322.  
  323. int** consoleChoice(int& order)
  324. {
  325.     order = consoleInputMatrixOrder();
  326.     int** matrix = matrixCreation(order);
  327.     matrix = consoleFillMatrix(matrix, order);
  328.     consoleMatrixOutput(matrix, order);
  329.     return matrix;
  330. }
  331.  
  332. int chooseOutputMethod()
  333. {
  334.     bool isNotCorrect;
  335.     int choice;
  336.     do
  337.     {
  338.         isNotCorrect = false;
  339.         cin >> choice;
  340.         if (cin.fail())
  341.         {
  342.             cin.clear();
  343.             while (cin.get() != '\n');
  344.             cout << "Число введено некорректно. Повторите попытку...\n";
  345.             isNotCorrect = true;
  346.         }
  347.         if ((!isNotCorrect) && (cin.get() != '\n'))
  348.         {
  349.             cin.clear();
  350.             cout << "Число введено некорректно. Повторите попытку...\n";
  351.             isNotCorrect = true;
  352.         }
  353.         if ((!isNotCorrect) && (choice != 1) && (choice != 2))
  354.         {
  355.             cout << "Введите либо 1, либо 2. Ваш выбор: \n";
  356.             isNotCorrect = true;
  357.         }
  358.     } while (isNotCorrect);
  359.     return choice;
  360. }
  361.  
  362. void solution()
  363. {
  364.     int order = 0;
  365.     int** matrix = nullptr;
  366.     bool isConsoleAnswer = false;
  367.     cout << "Введите число, чтобы выбрать способ решения задания: 1 - через консоль, 2 - через файл\n";
  368.     int choice = chooseOutputMethod();
  369.     if (choice == 1)
  370.     {
  371.         isConsoleAnswer = true;
  372.         matrix = consoleChoice(order);
  373.         findingMatrixSaddlePoints(matrix, isConsoleAnswer, order);
  374.     }
  375.     else
  376.     {
  377.         matrix = fileChoice(order);
  378.         cout << "Введите число, чтобы выбрать способ вывода решения задания: 1 - через консоль, 2 - через файл\n";
  379.         choice = chooseOutputMethod();
  380.         if (choice == 1)
  381.         {
  382.             isConsoleAnswer = true;
  383.             findingMatrixSaddlePoints(matrix, isConsoleAnswer, order);
  384.         }
  385.         else
  386.         {
  387.             findingMatrixSaddlePoints(matrix, isConsoleAnswer, order);
  388.             cout << "Седловая точка матрицы успешно выведена в файл!";
  389.         }
  390.     }
  391. }
  392.  
  393. int main()
  394. {
  395.     setlocale(LC_ALL, "Rus");
  396.     writeTask();
  397.     solution();
  398. }
  399.  
  400.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement