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