kyoo0000

rails

Sep 20th, 2020
844
328 days
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<stdbool.h>
  4. #include<string.h>
  5.  
  6. struct _arraystack {
  7.     int *elmt;
  8.     size_t size, lenght;
  9. };
  10.  
  11. typedef struct _arraystack Stack;
  12.  
  13. Stack* init_stack(int);
  14. int push(Stack*, int);
  15. int pop(Stack*);
  16. int top(Stack*);
  17. bool is_empty(Stack*);
  18. bool is_full(Stack*);
  19.  
  20. void show_stack_elements(Stack*);
  21. void show_stack_info(Stack*);
  22.  
  23. char* rails(int*, int);
  24. Stack* init_stack_sequence(int);
  25.  
  26. int main(void) {
  27.     while (true) {
  28.         int n, counter = 0, *e = NULL;
  29.         scanf("%d", &n);
  30.         if (n == 0)
  31.             break;
  32.         while (true) {
  33.             e = (int*) calloc(n, sizeof(int));
  34.             while (counter < n) {
  35.                 scanf("%d", e + counter++);
  36.                 if (*e == 0)
  37.                     break;
  38.             }
  39.             printf("%s\n", rails(e, n));
  40.             free(e);
  41.             e = NULL;
  42.             counter = 0;
  43.         }
  44.  
  45.     }
  46.     return EXIT_SUCCESS;
  47. }
  48.  
  49. Stack* init_stack(int n) {
  50.     Stack *stack = (Stack*) calloc(1, sizeof(Stack));
  51.     stack->elmt = (int*) calloc(n, sizeof(int));
  52.     stack->size = n;
  53.     stack->lenght = 0;
  54.     return stack;
  55. }
  56.  
  57. int push(Stack *stack, int e) {
  58.     if (is_full(stack))
  59.         stack->elmt = (int*) realloc(stack->elmt, (stack->size += 10) * sizeof(int));
  60.     return (stack->elmt[stack->lenght++] = e);
  61. }
  62.  
  63. int pop(Stack *stack) {
  64.     if (is_empty(stack))
  65.         return -1;
  66.      else
  67.         return stack->elmt[--stack->lenght];
  68. }
  69.  
  70. int top(Stack *stack) {
  71.     if (is_empty(stack))
  72.         return -1;
  73.     return stack->elmt[stack->lenght - 1];
  74. }
  75.  
  76. bool is_empty(Stack *stack) {
  77.     return (stack->lenght == 0);
  78. }
  79.  
  80. bool is_full(Stack *stack) {
  81.     return (stack->lenght == stack->size);
  82. }
  83.  
  84. void show_stack_elements(Stack *stack) {
  85.     for (int i = 0; i < stack->lenght; i++)
  86.         printf("%d ", stack->elmt[i]);
  87. }
  88.  
  89. void show_stack_info(Stack *s) {
  90.     printf("Stack size:\t%lu\n", s->size);
  91.     printf("Stack lenght:\t%lu\n", s->lenght);
  92.     printf("Stack elements:\t");
  93.     show_stack_elements(s);
  94.     printf("\n\n");
  95. }
  96.  
  97. char* rails(int *arr, int n) {
  98.     char *yn = (char*) calloc(4, sizeof(char));
  99.     int *aux = arr;
  100.     Stack *station = init_stack(n);
  101.     Stack *A = init_stack_sequence(n);
  102.  
  103.     while(!is_empty(A))  {
  104.         while(top(station) != *aux)
  105.             push(station, pop(A));
  106.         while(!is_empty(station)) {
  107.             if(pop(station) != *(aux++)) {
  108.                 free(aux);free(station);free(A);
  109.                 strcpy(yn, "No");
  110.                 return yn;
  111.             }
  112.         }
  113.     }
  114.  
  115.     free(station);
  116.     free(A);
  117.     strcpy(yn, "Yes");
  118.     return yn;
  119. }
  120.  
  121. Stack* init_stack_sequence(int n) {
  122.     Stack *stack = init_stack(n);
  123.     for (int i = n; i >= 1; i--)
  124.         push(stack, i);
  125.     return stack;
  126. }
  127.  
RAW Paste Data