SHARE
TWEET

Untitled

a guest Sep 19th, 2019 117 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <stdio.h>
  2. #include <ctype.h>
  3. #include <stdlib.h>
  4.  
  5. #define     MIN_YEAR    1600
  6. #define     MAX_YEAR    2399
  7. #define     YEAR_OFFSET 2000
  8.  
  9. #define     RV_NODATE   0
  10. #define     RV_VALIDDATE 1
  11. #define     RV_INVALIDDATE 2
  12. #define     RV_START 3
  13. #define     RV_MONTH_1 4
  14. #define     RV_MONTH_2 5
  15. #define     RV_DAY_0 6
  16. #define     RV_DAY_1 7
  17. #define     RV_DAY_2 8
  18. #define     RV_YEAR_0 9
  19. #define     RV_YEAR_1 10
  20. #define     RV_YEAR_2 11
  21. #define     RV_YEAR_3 12
  22. //#define     RV_YEAR_4 13
  23.  
  24. #define     MONTH_STATE 0
  25. #define     DAY_STATE 1
  26. #define     YEAR_STATE 2
  27.  
  28. /***** DFA *****/
  29.  
  30. /* The function checks if a date is present at the beginning of a line,
  31.  * and if the date is valid.
  32.  *
  33.  * Return values:
  34.  *
  35.  * 0:  Not date was found.
  36.  * 1:  Date is valid.
  37.  * 2:  Date was found, but not valid.
  38.  */
  39.  
  40.  int validate_date(int month, int day, int year) {
  41.      int output = 0;
  42.      int leapYear = 0;
  43.      
  44.      switch ((year % 400 == 0) || ((year % 4 == 0) && (year % 4 != 0))) {
  45.          case 1:
  46.             leapYear = 1;
  47.             break;
  48.          case 0:
  49.          default:
  50.             break;
  51.      }
  52.      
  53.      switch (month){
  54.          case 1:
  55.          case 3:
  56.          case 5:
  57.          case 7:
  58.          case 8:
  59.          case 10:
  60.          case 12:
  61.             switch (day <= 31) {
  62.                 case 1:
  63.                     output = 1;
  64.                     break;
  65.                 case 0:
  66.                 default:
  67.                     output = 0;
  68.                     break;
  69.                    
  70.             }
  71.             break;
  72.         case 4:
  73.         case 6:
  74.         case 9:
  75.         case 11:
  76.             switch (day <= 30) {
  77.                 case 1:
  78.                     output = 1;
  79.                     break;
  80.                 case 0:
  81.                 default:
  82.                     output = 0;
  83.                     break;
  84.             }
  85.             break;
  86.         case 2:
  87.             switch (leapYear) {
  88.                 case 1:
  89.                     switch (day <= 29) {
  90.                         case 1:
  91.                             output = 1;
  92.                             break;
  93.                         case 0:
  94.                         default:
  95.                             output = 0;
  96.                             break;
  97.                     }
  98.                     break;
  99.                 case 0:
  100.                     switch (day <= 28) {
  101.                         case 1:
  102.                             output = 1;
  103.                             break;
  104.                         case 0:
  105.                         default:
  106.                             output = 0;
  107.                             break;
  108.                     }
  109.                     break;
  110.             }
  111.             break;
  112.         default:
  113.             output = 0;
  114.             break;
  115.      }
  116.      return output;
  117.  }
  118.  
  119.  
  120. int get_date() {
  121.    
  122.     int state;
  123.     int ch;
  124.     int month = 0;
  125.     int day = 0;
  126.     int year = 0;
  127.     int expectingDash = 0;
  128.     int canAcceptDash = 0;
  129.     int dateState = 0;
  130.     int acceptChar = 0;
  131.    
  132.    
  133.     state = RV_START;
  134.     ch = getchar();
  135.    
  136.     while (ch != '\n' && ch != EOF) {
  137.         switch (isdigit(ch)) {
  138.             case 2048:
  139.                 switch (state) {
  140.                     case RV_START:
  141.                         dateState = MONTH_STATE;
  142.                         state = RV_MONTH_1;
  143.                         month += (ch - '0');
  144.                         canAcceptDash = 1;
  145.                         break;
  146.                     case RV_MONTH_1:
  147.                         state = RV_MONTH_2;
  148.                         month = (month * 10) + (ch - '0');
  149.                         switch (month > 12) {    //check if months are valid
  150.                             case 1:
  151.                                 //state = RV_INVALIDDATE;
  152.                                 break;
  153.                             default:
  154.                                 expectingDash = 1;
  155.                                 break;
  156.                         }
  157.                         break;
  158.                     case RV_DAY_0:
  159.                         dateState = DAY_STATE;
  160.                         state = RV_DAY_1;
  161.                         day += (ch - '0');
  162.                         canAcceptDash = 1;
  163.                         break;
  164.                     case RV_DAY_1:
  165.                         state = RV_DAY_2;
  166.                         day = (day * 10) + (ch - '0');
  167.                         switch (day > 31) {      //checking if days are valid
  168.                             case 1:
  169.                                 state = RV_VALIDDATE;
  170.                                 break;
  171.                             default:
  172.                                 expectingDash = 1;
  173.                                 break;
  174.                         }
  175.                         break;
  176.                     case RV_YEAR_0:
  177.                         state = RV_YEAR_1;
  178.                         dateState = YEAR_STATE;
  179.                         year += (ch - '0');
  180.                         break;
  181.                     case RV_YEAR_1:
  182.                         state = RV_YEAR_2;
  183.                         year = (year * 10) + (ch - '0');
  184.                         break;
  185.                     case RV_YEAR_2:
  186.                         state = RV_YEAR_3;
  187.                         year = (year * 10) + (ch - '0');
  188.                         break;
  189.                     case RV_YEAR_3:
  190.                         year = (year * 10) + (ch - '0');
  191.                         switch (year >= 1600 && year <= 2399) { //checking
  192.                             case 1:
  193.                                 state = RV_VALIDDATE;
  194.                                 break;
  195.                             case 0:
  196.                             default:
  197.                                 state = RV_INVALIDDATE;
  198.                                 break;
  199.                         }
  200.                         break;
  201.                     case RV_NODATE:
  202.                         break;
  203.                     case RV_VALIDDATE:
  204.                         switch (acceptChar) {
  205.                             case 1:
  206.                                 break;
  207.                             case 0:
  208.                             default:
  209.                                 state = RV_NODATE;
  210.                         }
  211.                         break;
  212.                     case RV_DAY_2:
  213.                     case RV_MONTH_2:
  214.                     case RV_INVALIDDATE:
  215.                         state = RV_NODATE;
  216.                         break;
  217.                     default:
  218.                         state = RV_INVALIDDATE;
  219.                         break;
  220.                 }
  221.                 break;
  222.             case 0:
  223.                 switch(state) {
  224.                     case RV_NODATE:
  225.                         break;
  226.                     case RV_INVALIDDATE:
  227.                         break;
  228.                     case RV_YEAR_2:
  229.                     case RV_VALIDDATE:
  230.                         switch (isblank(ch)) {
  231.                             case 1:
  232.                                 state = RV_VALIDDATE;
  233.                                 acceptChar = 1;
  234.                                 break;
  235.                             case 0:
  236.                                 switch (acceptChar) {
  237.                                     case 1:
  238.                                         break;
  239.                                     case 0:
  240.                                     default:
  241.                                         state = RV_NODATE;
  242.                                         break;
  243.                                 }
  244.                                 break;
  245.                             default:
  246.                                 state = RV_NODATE;
  247.                                 break;
  248.                         }
  249.                         break;
  250.                     default:
  251.                         switch(ch){
  252.                             case '/':
  253.                                 switch(canAcceptDash || expectingDash) {
  254.                                     case 1:
  255.                                         switch (dateState) {
  256.                                             case MONTH_STATE:
  257.                                                 state = RV_DAY_0;
  258.                                                 expectingDash = 0;
  259.                                                 canAcceptDash = 0;
  260.                                                 break;
  261.                                             case DAY_STATE:
  262.                                                 state = RV_YEAR_0;
  263.                                                 expectingDash = 0;
  264.                                                 canAcceptDash = 0;
  265.                                                 break;
  266.                                         }
  267.                                         break;
  268.                                     case 0:
  269.                                     default:
  270.                                         state = RV_NODATE;
  271.                                         break;
  272.                                 }
  273.                                 break;
  274.                             default:
  275.                                 switch (isblank(ch)) {
  276.                                     case 1:
  277.                                         state = RV_START;
  278.                                         break;
  279.                                     default:
  280.                                         state = RV_NODATE;
  281.                                         break;
  282.                                 }
  283.                                 break;
  284.                         }
  285.                         break;
  286.                 }
  287.                 break;
  288.             default:
  289.                 state = RV_NODATE;
  290.                 break;
  291.  
  292.         }
  293.         ch = getchar();
  294.     }
  295.    
  296.     switch (state) {
  297.         case RV_START:
  298.         case RV_MONTH_1:
  299.         case RV_MONTH_2:
  300.         case RV_DAY_0:
  301.         case RV_DAY_1:
  302.         case RV_DAY_2:
  303.         case RV_YEAR_0:
  304.         case RV_YEAR_1:
  305.         case RV_YEAR_3:
  306.             state = RV_NODATE;
  307.             break;
  308.         case RV_YEAR_2:
  309.             state = RV_VALIDDATE;
  310.         default:
  311.             break;
  312.     }
  313.    
  314.     switch (state) {
  315.         case RV_VALIDDATE:
  316.             switch (validate_date(month, day, year)) {
  317.                 case 1:
  318.                     state = RV_VALIDDATE;
  319.                     break;
  320.                 case 0:
  321.                 default:
  322.                     state = RV_INVALIDDATE;
  323.                     break;
  324.             }
  325.             break;
  326.         default:
  327.             break;
  328.     }
  329.    
  330.     //printf("month: %d day: %d year: %d \n", month, day, year);
  331.  
  332.     return state;
  333. }
  334.  
  335. /***** main *****/
  336. /* Do not change the main function. */
  337. int main(void)
  338. {
  339.     // run the loop until hit end of file
  340.     do  {
  341.         int rv = get_date();
  342.  
  343.         if (!feof(stdin)) {
  344.             switch (rv) {
  345.                 case RV_NODATE:
  346.                     printf("No date found.\n");
  347.                     break;
  348.                 case RV_VALIDDATE:
  349.                     printf("Valid date.\n");
  350.                     break;
  351.                 case RV_INVALIDDATE:
  352.                     printf("Invalid date.\n");
  353.                     break;
  354.                 default:
  355.                     printf("Unknown return value %d.\n", rv);
  356.                     break;
  357.             }
  358.         }
  359.     } while (! feof(stdin));
  360.  
  361.     return 0;
  362. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top