fork download
copy 
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. int main() {
  5.     int operation;
  6.     int rows1, cols1, rows2, cols2;
  7.     int **matrix1, **matrix2, **result;
  8.     int i, j, k;
  9.  
  10.     if (scanf("%d", &operation) != 1) {
  11.         printf("n/a\\n");
  12.         return 0;
  13.     }
  14.  
  15.     if (operation < 1 || operation > 3) {
  16.         printf("n/a\\n");
  17.         return 0;
  18.     }
  19.  
  20.     // Ввод размеров первой матрицы
  21.     if (scanf("%d %d", &rows1, &cols1) != 2) {
  22.         printf("n/a\\n");
  23.         return 0;
  24.     }
  25.  
  26.     if (rows1 <= 0 || cols1 <= 0) {
  27.         printf("n/a\\n");
  28.         return 0;
  29.     }
  30.  
  31.     // Выделение памяти для первой матрицы
  32.     matrix1 = (int **)malloc(rows1 * sizeof(int *));
  33.     if (matrix1 == NULL) {
  34.         printf("n/a\\n");
  35.         return 0;
  36.     }
  37.     for (i = 0; i < rows1; i++) {
  38.         matrix1[i] = (int *)malloc(cols1 * sizeof(int));
  39.         if (matrix1[i] == NULL) {
  40.             printf("n/a\\n");
  41.             // Освобождение памяти, если выделение не удалось
  42.             for (j = 0; j < i; j++) {
  43.                 free(matrix1[j]);
  44.             }
  45.             free(matrix1);
  46.             return 0;
  47.         }
  48.     }
  49.  
  50.     // Ввод первой матрицы
  51.     for (i = 0; i < rows1; i++) {
  52.         for (j = 0; j < cols1; j++) {
  53.             if (scanf("%d", &matrix1[i][j]) != 1) {
  54.                 printf("n/a\\n");
  55.                 // Освобождение памяти
  56.                 for (int row = 0; row < rows1; row++) {
  57.                     free(matrix1[row]);
  58.                 }
  59.                 free(matrix1);
  60.                 return 0;
  61.             }
  62.         }
  63.     }
  64.  
  65.     if (operation == 1 || operation == 2) { // Сложение и умножение требуют второй матрицы
  66.         // Ввод размеров второй матрицы
  67.         if (scanf("%d %d", &rows2, &cols2) != 2) {
  68.             printf("n/a\\n");
  69.             // Освобождение памяти
  70.             for (i = 0; i < rows1; i++) {
  71.                 free(matrix1[i]);
  72.             }
  73.             free(matrix1);
  74.             return 0;
  75.         }
  76.  
  77.         if (rows2 <= 0 || cols2 <= 0) {
  78.             printf("n/a\\n");
  79.             // Освобождение памяти
  80.              for (i = 0; i < rows1; i++) {
  81.                 free(matrix1[i]);
  82.             }
  83.             free(matrix1);
  84.             return 0;
  85.         }
  86.  
  87.         // Выделение памяти для второй матрицы
  88.         matrix2 = (int **)malloc(rows2 * sizeof(int *));
  89.         if (matrix2 == NULL) {
  90.             printf("n/a\\n");
  91.             // Освобождение памяти
  92.             for (i = 0; i < rows1; i++) {
  93.                 free(matrix1[i]);
  94.             }
  95.             free(matrix1);
  96.             return 0;
  97.         }
  98.         for (i = 0; i < rows2; i++) {
  99.             matrix2[i] = (int *)malloc(cols2 * sizeof(int));
  100.             if (matrix2[i] == NULL) {
  101.                 printf("n/a\\n");
  102.                  // Освобождение памяти
  103.                 for (int row = 0; row < rows1; row++) {
  104.                     free(matrix1[row]);
  105.                 }
  106.                 free(matrix1);
  107.  
  108.                 for (j = 0; j < i; j++) {
  109.                     free(matrix2[j]);
  110.                 }
  111.                 free(matrix2);
  112.                 return 0;
  113.             }
  114.         }
  115.  
  116.         // Ввод второй матрицы
  117.         for (i = 0; i < rows2; i++) {
  118.             for (j = 0; j < cols2; j++) {
  119.                 if (scanf("%d", &matrix2[i][j]) != 1) {
  120.                     printf("n/a\\n");
  121.                     // Освобождение памяти
  122.                     for (int row = 0; row < rows1; row++) {
  123.                         free(matrix1[row]);
  124.                     }
  125.                     free(matrix1);
  126.                     for (int row = 0; row < rows2; row++) {
  127.                         free(matrix2[row]);
  128.                     }
  129.                     free(matrix2);
  130.                     return 0;
  131.                 }
  132.             }
  133.         }
  134.     }
  135.  
  136.     // Выполнение операции
  137.     if (operation == 1) { // Сложение
  138.         if (rows1 != rows2 || cols1 != cols2) {
  139.             printf("n/a\\n");
  140.              // Освобождение памяти
  141.             for (i = 0; i < rows1; i++) {
  142.                 free(matrix1[i]);
  143.             }
  144.             free(matrix1);
  145.             for (i = 0; i < rows2; i++) {
  146.                 free(matrix2[i]);
  147.             }
  148.             free(matrix2);
  149.             return 0;
  150.         }
  151.  
  152.         // Выделение памяти для результата
  153.         result = (int **)malloc(rows1 * sizeof(int *));
  154.         if (result == NULL) {
  155.             printf("n/a\\n");
  156.              // Освобождение памяти
  157.             for (i = 0; i < rows1; i++) {
  158.                 free(matrix1[i]);
  159.             }
  160.             free(matrix1);
  161.             for (i = 0; i < rows2; i++) {
  162.                 free(matrix2[i]);
  163.             }
  164.             free(matrix2);
  165.             return 0;
  166.         }
  167.         for (i = 0; i < rows1; i++) {
  168.             result[i] = (int *)malloc(cols1 * sizeof(int));
  169.             if (result[i] == NULL) {
  170.                 printf("n/a\\n");
  171.                  // Освобождение памяти
  172.                 for (int row = 0; row < rows1; row++) {
  173.                     free(matrix1[row]);
  174.                 }
  175.                 free(matrix1);
  176.                 for (int row = 0; row < rows2; row++) {
  177.                     free(matrix2[row]);
  178.                 }
  179.                 free(matrix2);
  180.                 for (j = 0; j < i; j++) {
  181.                     free(result[j]);
  182.                 }
  183.                 free(result);
  184.                 return 0;
  185.             }
  186.         }
  187.  
  188.         // Выполнение сложения
  189.         for (i = 0; i < rows1; i++) {
  190.             for (j = 0; j < cols1; j++) {
  191.                 result[i][j] = matrix1[i][j] + matrix2[i][j];
  192.             }
  193.         }
  194.  
  195.         // Вывод результата
  196.         for (i = 0; i < rows1; i++) {
  197.             for (j = 0; j < cols1; j++) {
  198.                 printf("%d", result[i][j]);
  199.                 if (j < cols1 - 1) {
  200.                     printf(" ");
  201.                 }
  202.             }
  203.             printf("\n");
  204.         }
  205.  
  206.         // Освобождение памяти
  207.         for (i = 0; i < rows1; i++) {
  208.             free(matrix1[i]);
  209.         }
  210.         free(matrix1);
  211.         for (i = 0; i < rows2; i++) {
  212.             free(matrix2[i]);
  213.         }
  214.         free(matrix2);
  215.         for (i = 0; i < rows1; i++) {
  216.             free(result[i]);
  217.         }
  218.         free(result);
  219.  
  220.     } else if (operation == 2) { // Умножение
  221.         if (cols1 != rows2) {
  222.             printf("n/a\\n");
  223.              // Освобождение памяти
  224.             for (i = 0; i < rows1; i++) {
  225.                 free(matrix1[i]);
  226.             }
  227.             free(matrix1);
  228.             for (i = 0; i < rows2; i++) {
  229.                 free(matrix2[i]);
  230.             }
  231.             free(matrix2);
  232.             return 0;
  233.         }
  234.  
  235.         // Выделение памяти для результата
  236.         result = (int **)malloc(rows1 * sizeof(int *));
  237.         if (result == NULL) {
  238.             printf("n/a\\n");
  239.             // Освобождение памяти
  240.             for (i = 0; i < rows1; i++) {
  241.                 free(matrix1[i]);
  242.             }
  243.             free(matrix1);
  244.             for (i = 0; i < rows2; i++) {
  245.                 free(matrix2[i]);
  246.             }
  247.             free(matrix2);
  248.             return 0;
  249.         }
  250.         for (i = 0; i < rows1; i++) {
  251.             result[i] = (int *)malloc(cols2 * sizeof(int));
  252.             if (result[i] == NULL) {
  253.                 printf("n/a\\n");
  254.                  // Освобождение памяти
  255.                 for (int row = 0; row < rows1; row++) {
  256.                     free(matrix1[row]);
  257.                 }
  258.                 free(matrix1);
  259.                 for (int row = 0; row < rows2; row++) {
  260.                     free(matrix2[row]);
  261.                 }
  262.                 free(matrix2);
  263.                 for (j = 0; j < i; j++) {
  264.                     free(result[j]);
  265.                 }
  266.                 free(result);
  267.                 return 0;
  268.             }
  269.         }
  270.  
  271.         // Выполнение умножения
  272.         for (i = 0; i < rows1; i++) {
  273.             for (j = 0; j < cols2; j++) {
  274.                 result[i][j] = 0;
  275.                 for (k = 0; k < cols1; k++) {
  276.                     result[i][j] += matrix1[i][k] * matrix2[k][j];
  277.                 }
  278.             }
  279.         }
  280.  
  281.         // Вывод результата
  282.         for (i = 0; i < rows1; i++) {
  283.             for (j = 0; j < cols2; j++) {
  284.                 printf("%d", result[i][j]);
  285.                 if (j < cols2 - 1) {
  286.                     printf(" ");
  287.                 }
  288.             }
  289.             printf("\n");
  290.         }
  291.  
  292.         // Освобождение памяти
  293.         for (i = 0; i < rows1; i++) {
  294.             free(matrix1[i]);
  295.         }
  296.         free(matrix1);
  297.         for (i = 0; i < rows2; i++) {
  298.             free(matrix2[i]);
  299.         }
  300.         free(matrix2);
  301.         for (i = 0; i < rows1; i++) {
  302.             free(result[i]);
  303.         }
  304.         free(result);
  305.  
  306.     } else { // Транспонирование
  307.         // Выделение памяти для результата
  308.         result = (int **)malloc(cols1 * sizeof(int *));
  309.         if (result == NULL) {
  310.             printf("n/a\\n");
  311.               // Освобождение памяти
  312.             for (i = 0; i < rows1; i++) {
  313.                 free(matrix1[i]);
  314.             }
  315.             free(matrix1);
  316.             return 0;
  317.         }
  318.         for (i = 0; i < cols1; i++) {
  319.             result[i] = (int *)malloc(rows1 * sizeof(int));
  320.             if (result[i] == NULL) {
  321.                 printf("n/a\\n");
  322.                  // Освобождение памяти
  323.                  for (i = 0; i < rows1; i++) {
  324.                     free(matrix1[i]);
  325.                 }
  326.                 free(matrix1);
  327.  
  328.                 for (j = 0; j < i; j++) {
  329.                     free(result[j]);
  330.                 }
  331.                 free(result);
  332.                 return 0;
  333.             }
  334.         }
  335.  
  336.         // Выполнение транспонирования
  337.         for (i = 0; i < rows1; i++) {
  338.             for (j = 0; j < cols1; j++) {
  339.                 result[j][i] = matrix1[i][j];
  340.             }
  341.         }
  342.  
  343.         // Вывод результата
  344.         for (i = 0; i < cols1; i++) {
  345.             for (j = 0; j < rows1; j++) {
  346.                 printf("%d", result[i][j]);
  347.                 if (j < rows1 - 1) {
  348.                     printf(" ");
  349.                 }
  350.             }
  351.             printf("\n");
  352.         }
  353.  
  354.         // Освобождение памяти
  355.         for (i = 0; i < rows1; i++) {
  356.             free(matrix1[i]);
  357.         }
  358.         free(matrix1);
  359.         for (i = 0; i < cols1; i++) {
  360.             free(result[i]);
  361.         }
  362.         free(result);
  363.     }
  364.  
  365.     return 0;
  366. }
Success #stdin #stdout 0s 5284KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
n/a\n
https://ideone.com/Yhhx8o
language:
C (clang 8.0)
created:
10 days ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!