fork download
copy 
  1. #include <assert.h>
  2. #include <ctype.h>
  3. #include <limits.h>
  4. #include <math.h>
  5. #include <stdbool.h>
  6. #include <stddef.h>
  7. #include <stdint.h>
  8. #include <stdio.h>
  9. #include <stdlib.h>
  10. #include <string.h>
  11.  
  12. char* readline();
  13. char* ltrim(char*);
  14. char* rtrim(char*);
  15. char** split_string(char*);
  16.  
  17.  
  18.  
  19. // Complete the find_largest_in_row_smallest_in_column_element_in_matrix function below.
  20. int find_largest_in_row_smallest_in_column_element_in_matrix(int R, int C, int** matrix) {
  21.     int i,j;
  22.     int a1[1005],a2[1005],a3[1005],a4[1005];
  23.     for(j=0;j<C;j++)
  24.     {
  25.         int minn=1000000009,x,y;
  26.         for(i=0;j<R;i++)
  27.         {
  28.             if(minn>matrix[j][i])
  29.                 {
  30.                     x=i;
  31.                     y=j;
  32.                     minn=matrix[j][i];
  33.                 }
  34.         }
  35.         a1[j]=x;
  36.         a2[j]=y;
  37.     }
  38.     for(i=0;i<R;i++)
  39.     {
  40.         int maxx=0,x,y;
  41.         for(j=0;j<C;j++)
  42.         {
  43.             if(maxx<matrix[i][j])
  44.             {
  45.                 maxx=matrix[i][j];
  46.                 x=i;y=j;
  47.             }
  48.         }
  49.         a3[i]=x;
  50.         a4[i]=y;
  51.     }
  52.     printf("here");
  53.     int ans=-1;
  54.     for(int i=0;i<C;i++)
  55.     {
  56.         int a=a1[i],b=a2[i];
  57.         for(int j=0;j<R;j++)
  58.         {
  59.             if(a3[j]==a && a4[j]==b)
  60.             ans=matrix[a][b];
  61.         }
  62.     }
  63.     return ans;
  64.  
  65. }
  66.  
  67. int main()
  68. {
  69.     FILE* fptr = fopen(getenv("OUTPUT_PATH"), "w");
  70.  
  71.     char* matrix_rows_endptr;
  72.     char* matrix_rows_str = ltrim(rtrim(readline()));
  73.     int matrix_rows = strtol(matrix_rows_str, &matrix_rows_endptr, 10);
  74.  
  75.     if (matrix_rows_endptr == matrix_rows_str || *matrix_rows_endptr != '\0') { exit(EXIT_FAILURE); }
  76.  
  77.     char* matrix_columns_endptr;
  78.     char* matrix_columns_str = ltrim(rtrim(readline()));
  79.     int matrix_columns = strtol(matrix_columns_str, &matrix_columns_endptr, 10);
  80.  
  81.     if (matrix_columns_endptr == matrix_columns_str || *matrix_columns_endptr != '\0') { exit(EXIT_FAILURE); }
  82.  
  83.     int** matrix = malloc(matrix_rows * sizeof(int*));
  84.  
  85.     for (int i = 0; i < matrix_rows; i++) {
  86.         *(matrix + i) = malloc(matrix_columns * (sizeof(int)));
  87.  
  88.         char** matrix_item_temp = split_string(rtrim(readline()));
  89.  
  90.         for (int j = 0; j < matrix_columns; j++) {
  91.             char* matrix_item_endptr;
  92.             char* matrix_item_str = *(matrix_item_temp + j);
  93.             int matrix_item = strtol(matrix_item_str, &matrix_item_endptr, 10);
  94.  
  95.             if (matrix_item_endptr == matrix_item_str || *matrix_item_endptr != '\0') { exit(EXIT_FAILURE); }
  96.  
  97.             *(*(matrix + i) + j) = matrix_item;
  98.         }
  99.     }
  100.  
  101.     int res = find_largest_in_row_smallest_in_column_element_in_matrix(matrix_rows, matrix_columns, matrix);
  102.  
  103.     fprintf(fptr, "%d\n", res);
  104.  
  105.     fclose(fptr);
  106.  
  107.     return 0;
  108. }
  109.  
  110. char* readline() {
  111.     size_t alloc_length = 1024;
  112.     size_t data_length = 0;
  113.     char* data = malloc(alloc_length);
  114.  
  115.     while (true) {
  116.         char* cursor = data + data_length;
  117.         char* line = fgets(cursor, alloc_length - data_length, stdin);
  118.  
  119.         if (!line) {
  120.             break;
  121.         }
  122.  
  123.         data_length += strlen(cursor);
  124.  
  125.         if (data_length < alloc_length - 1 || data[data_length - 1] == '\n') {
  126.             break;
  127.         }
  128.  
  129.         alloc_length <<= 1;
  130.  
  131.         data = realloc(data, alloc_length);
  132.  
  133.         if (!data) {
  134.             data = '\0';
  135.  
  136.             break;
  137.         }
  138.     }
  139.  
  140.     if (data[data_length - 1] == '\n') {
  141.         data[data_length - 1] = '\0';
  142.  
  143.         data = realloc(data, data_length);
  144.  
  145.         if (!data) {
  146.             data = '\0';
  147.         }
  148.     } else {
  149.         data = realloc(data, data_length + 1);
  150.  
  151.         if (!data) {
  152.             data = '\0';
  153.         } else {
  154.             data[data_length] = '\0';
  155.         }
  156.     }
  157.  
  158.     return data;
  159. }
  160.  
  161. char* ltrim(char* str) {
  162.     if (!str) {
  163.         return '\0';
  164.     }
  165.  
  166.     if (!*str) {
  167.         return str;
  168.     }
  169.  
  170.     while (*str != '\0' && isspace(*str)) {
  171.         str++;
  172.     }
  173.  
  174.     return str;
  175. }
  176.  
  177. char* rtrim(char* str) {
  178.     if (!str) {
  179.         return '\0';
  180.     }
  181.  
  182.     if (!*str) {
  183.         return str;
  184.     }
  185.  
  186.     char* end = str + strlen(str) - 1;
  187.  
  188.     while (end >= str && isspace(*end)) {
  189.         end--;
  190.     }
  191.  
  192.     *(end + 1) = '\0';
  193.  
  194.     return str;
  195. }
  196.  
  197. char** split_string(char* str) {
  198.     char** splits = NULL;
  199.     char* token = strtok(str, " ");
  200.  
  201.     int spaces = 0;
  202.  
  203.     while (token) {
  204.         splits = realloc(splits, sizeof(char*) * ++spaces);
  205.  
  206.         if (!splits) {
  207.             return splits;
  208.         }
  209.  
  210.         splits[spaces - 1] = token;
  211.  
  212.         token = strtok(NULL, " ");
  213.     }
  214.  
  215.     return splits;
  216. }
  217.  
Time limit exceeded #stdin #stdout 5s 9424KB
comments (?)
stdin
copy 
3 
3
1 2 3 
4 5 6 
7 8 9
stdout
copy 
Standard output is empty
https://ideone.com/sMZOUY
language:
C (gcc 8.3)
created:
4 years 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!