fork download
copy 
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <ctype.h>
  5. #define BUFSIZE 2048
  6. struct _Range{
  7.     int min;
  8.     int max;
  9.     struct _Range *next;
  10. };
  11. typedef struct _Range Range;
  12. Range *new(void){
  13.     Range *ptr = (Range *)malloc(sizeof(Range));
  14.     if(ptr == NULL){
  15.         perror("malloc");
  16.         exit(EXIT_FAILURE);
  17.     }
  18.     return(ptr);
  19. }
  20. void del(Range *head){
  21.     Range *cur, *tmp;
  22.     cur = head;
  23.     while(cur){
  24.         tmp = cur->next;
  25.         free(cur);
  26.         cur = tmp;
  27.     }
  28. }
  29. void print(Range *r){
  30.     if(r != NULL){
  31.         printf("[%d,%d]", r->min, r->max);
  32.         while((r = r->next) != NULL){
  33.             printf(",[%d,%d]", r->min, r->max);
  34.         }
  35.         puts("");
  36.     }
  37. }
  38. int is_within(Range *a, Range *b){
  39.     if(a == NULL || b == NULL){
  40.         return(0);
  41.     }else{
  42.         int ret = 0;
  43.         ret |= (a->min-1 <= b->min) & (b->min <= a->max+1);
  44.         ret |= (a->min-1 <= b->max) & (b->max <= a->max+1);
  45.         ret |= (b->min-1 <= a->min) & (a->min <= b->max+1);
  46.         ret |= (b->min-1 <= a->max) & (a->max <= b->max+1);
  47.         return(ret);
  48.     }
  49. }
  50. int min(int a, int b){
  51.     return(a < b ? a : b);
  52. }
  53. int max(int a, int b){
  54.     return(a > b ? a : b);
  55. }
  56. Range *regist(Range *head, int mn, int mx){
  57.     Range *tmp = new();
  58.     *tmp = (Range){mn, mx, NULL};
  59.     if(head == NULL){
  60.         head = tmp;
  61.         return(head);
  62.     }    
  63.     Range *cur, *prev;
  64.     cur = prev = head;
  65.     if((tmp->min) < (cur->min)){
  66.         head = tmp;
  67.         head->next = cur;
  68.         cur = prev = head;
  69.     }else{
  70.         cur = cur->next;
  71.         while(cur != NULL){
  72.             if((tmp->min) < (cur->min)){
  73.                 prev->next = tmp;
  74.                 tmp->next = cur;
  75.                 break;
  76.             }
  77.             prev = prev->next;
  78.             cur = cur->next;
  79.         }
  80.         if(cur == NULL){
  81.             prev->next = tmp;
  82.         }
  83.     }
  84.     cur = prev->next;
  85.     while(cur != NULL){
  86.         if(is_within(prev, cur)){
  87.             prev->min = min(prev->min, cur->min);
  88.             prev->max = max(prev->max, cur->max);
  89.             prev->next = cur->next;
  90.             free(cur);
  91.             cur = prev->next;
  92.             continue;
  93.         }
  94.         prev = prev->next;
  95.         cur = cur->next;
  96.     }
  97.     return(head);
  98. }
  99. void del_space(char *s){
  100.     int i,j;
  101.     j = 0;
  102.     for(i = 0; i < BUFSIZE; i++){
  103.         if(isgraph(s[i])){
  104.             s[j] = s[i];
  105.             j++;
  106.         }
  107.     }
  108.     memset(s+j, 0, BUFSIZE-j);
  109. }
  110. void odai(const char *s){
  111.     Range *r = NULL;
  112.     int mn, mx;
  113.     char *p, *ep;
  114.     int flg_err = 1;
  115.     p = (char *)s;
  116.     while(1){
  117.         if(*p != '[')
  118.             break;
  119.         p++;
  120.         mn = strtol(p, &ep, 10);
  121.         if(p == ep || *ep != ',')
  122.             break;
  123.         p = ep+1;
  124.         mx = strtol(p, &ep, 10);
  125.         if(p == ep || *ep != ']')
  126.             break;
  127.         p = ep+1;
  128.         r = regist(r,mn,mx);
  129.         if(*p == '\0'){
  130.             flg_err = 0;
  131.             break;
  132.         }else if(*p != ',')
  133.             break;
  134.         p++;
  135.     }
  136.     if(flg_err){
  137.         puts("Input error.");
  138.         del(r);
  139.         return;
  140.     }        
  141.     print(r);
  142.     del(r);
  143. }
  144. int main(void){
  145.     char buf[BUFSIZE];
  146.     while(fgets((char *)memset(buf, 0, BUFSIZE), BUFSIZE, stdin)){
  147.         del_space(buf);
  148.         odai(buf);
  149.     }   
  150.     return(0);
  151. }
Success #stdin #stdout 0s 4372KB
comments (?)
stdin
copy 
[1, 5], [2, 6], [-1, 10]
[2, 3], [3, 4], [7, 10]
stdout
copy 
[-1,10]
[2,4],[7,10]
https://ideone.com/2oXq06
17_131
language:
C (gcc 8.3)
created:
3 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!