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