API tools faq
paste
Advertisement
Guest User

lab3.c

a guest
Jan 12th, 2016
113
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 17.44 KB | None | 0 0
raw download clone embed print report
  1. #include"lab3.h"
  2. bool is_num(char inpt[50])
  3. {
  4.     int len=strlen(inpt)-1;
  5.     int i=0;
  6.     int flag=0;
  7.         while(i<(len-1))
  8.     {
  9.         if(!isdigit(inpt[i])&&inpt[i]!='.')
  10.         {
  11.  
  12.             printf("number must consist of numbers \n");
  13.            return false;
  14.         }
  15.                  if(inpt[i]=='.')
  16.             {
  17.                 if(flag==1)
  18.                 {
  19.                     printf("only one '.' is allowed\n");
  20.                     return false;
  21.                 }
  22.                 else
  23.                     flag++;
  24.             }
  25.         ++i;
  26.     }
  27.     return true;
  28. }
  29. void hilfe()
  30. {
  31.     printf("Input commands: \n modify \n sort \n search \n search_by_column \n add \n print \n ");
  32. }
  33. int mod_input(char function[])
  34. {
  35.     printf(function);
  36.     if(strcmp(function,"modify")==1)
  37.         return 3;
  38.     else if(strcmp(function,"sort")==1)
  39.         return 4;
  40.     else if(strcmp(function,"search")==1)
  41.         return 5;
  42.     else if(strcmp(function,"help")==1)
  43.         return 6;
  44.     else if(strcmp(function,"add")==1)
  45.         return 2;
  46.     else if(strcmp(function,"print")==1)
  47.         return 1;
  48.     else if(strcmp(function,"search_by_column")==1)
  49.             return 7;
  50.     return 404;
  51. }
  52. void print_result(struct data *database,int size)
  53. {
  54.     printf(database[0].id);
  55.     int i=0;
  56.     while(i<size)
  57.     {
  58.             printf("id- ");
  59.             printf("%s",database[i].id);
  60.             printf(" ,name- ");
  61.             printf("%s",database[i].name);
  62.              printf(" ,surname-  ");
  63.              printf("%s",database[i].surname);
  64.               printf(" ,net pension-  ");
  65.               printf("%d",database[i].net_pension);
  66.                printf(" ,taxed pension- ");
  67.                printf("%d",database[i].taxed_pension);
  68.                 printf(" ,account number-  ");
  69.                 printf("%s",database[i].account_num);
  70.                 printf("\n");
  71.                 ++i;
  72.     }
  73. }
  74. bool is_word(char input[])
  75. {
  76.     int len=strlen(input),i=0;
  77.     while(i<(len-1))
  78.     {
  79.         if(!isalpha(input[i]))
  80.         {
  81.             printf("input must consist of letters \n");
  82.            return false;
  83.         }
  84.         ++i;
  85.     }
  86.     return true;
  87. }
  88. bool is_accnum(char input[])
  89. {
  90.     int len=strlen(input),i=0;
  91.     while(i<(len-1))
  92.     {
  93.         if(!isdigit(input[i]))
  94.         {
  95.             printf("input must consist of digits \n");
  96.            return false;
  97.         }
  98.         ++i;
  99.     }
  100.     return true;
  101. }
  102. void modify_size(struct data *database,int *size)
  103. {
  104.     int len=(*size);
  105.     database=realloc(database,sizeof(struct data)*(len+1));
  106.     *size++;
  107. }
  108. void modify_element(struct data *database, int size)
  109. {
  110.     int flag=0;
  111.     int i=0;
  112.     char inpt[51];
  113.     do
  114.     {
  115.         printf("input id \n");
  116.          fgets(inpt,50,stdin);
  117.          while(i<size&&flag==0)
  118.          {
  119.              if(strcmp(database[i].id,inpt)==1)
  120.              {
  121.                  flag=1;
  122.              }
  123.              ++i;
  124.          }
  125.          if(flag==0)
  126.             printf("id not found \n");
  127.     }
  128.     while(flag==0);
  129.      int subflag=0;
  130.      int place=(i-1);
  131.         do
  132.         {
  133.             printf("Input name \n");
  134.             fgets(inpt,50,stdin);
  135.             if(is_word(inpt)==1)
  136.             {
  137.                 subflag=1;
  138.                 strcpy(database[place].name,inpt);
  139.             }
  140.         }
  141.         while(subflag==0);
  142.  
  143.     subflag=0;
  144.  
  145.         do
  146.         {
  147.             printf("Input surname \n");
  148.             fgets(inpt,50,stdin);
  149.             if(is_word(inpt)==1)
  150.             {
  151.                 subflag=1;
  152.                 strcpy(database[place].surname,inpt);
  153.             }
  154.         }
  155.         while(subflag==0);
  156.  
  157.  
  158.     subflag=0;
  159.  
  160.         do
  161.         {
  162.             printf("Input account number \n");
  163.             fgets(inpt,50,stdin);
  164.             if(is_accnum(inpt)==1)
  165.             {
  166.                 subflag=1;
  167.                 strcpy(database[place].account_num,inpt);
  168.             }
  169.         }
  170.         while(subflag==0);
  171.  
  172.     subflag=0;
  173.  
  174.         do
  175.         {
  176.             printf("Input net gain \n");
  177.             fgets(inpt,50,stdin);
  178.             if(is_num(inpt)==true)
  179.             {
  180.                 subflag=1;
  181.                 database[place].net_pension=atof(inpt);
  182.             }
  183.         }
  184.         while(subflag==0);
  185.  
  186.    subflag=0;
  187.  
  188.         do
  189.         {
  190.             printf("Input taxed gain \n");
  191.             fgets(inpt,50,stdin);
  192.             if(is_num(inpt)==true)
  193.             {
  194.                 subflag=1;
  195.                 database[place].taxed_pension=atof(inpt);
  196.             }
  197.         }
  198.         while(subflag==0);
  199. }
  200.  
  201. bool str_grt(char str1[],char str2[])
  202. {
  203.     int i=strlen(str1);
  204.     int j=strlen(str2);
  205.     int k=0;
  206.     if(i>j)
  207.     {
  208.         while(k<j)
  209.         {
  210.             if(str1[k]>str2[k])
  211.                 return false;
  212.                 ++k;
  213.         }
  214.     }
  215.     else
  216.         while(k<i)
  217.     {
  218.         if(str1[k]>str2[k])
  219.             return false;
  220.             ++k;
  221.     }
  222.     if(i<j)
  223.         return true;
  224.         else
  225.         return false;
  226. }
  227. void add_element(struct data *database,int *size)
  228. {
  229.     int subflag=0;
  230.     char inpt[50];
  231.     int place=((*size)-1);
  232.     int pass=(*size);
  233.     printf("%i",pass);
  234.     if((*size)!=1)
  235.     {
  236.         modify_element(database,(*size));
  237.     }
  238.  
  239.         do
  240.         {
  241.             printf("Input unical ID \n");
  242.             fgets(inpt,50,stdin);
  243.             if(does_exist(inpt,database,pass)==1)
  244.             {
  245.                 subflag=1;
  246.                 strncpy(database[place].id,inpt,50);
  247.             }
  248.             else
  249.             {
  250.                 printf("ID exists");
  251.             }
  252.         }
  253.         while(subflag==0);
  254.     subflag=0;
  255.         do
  256.         {
  257.             printf("Input name \n");
  258.             fgets(inpt,50,stdin);
  259.             if(is_word(inpt)==1)
  260.             {
  261.                 subflag=1;
  262.                 strcpy(database[place].name,inpt);
  263.             }
  264.         }
  265.         while(subflag==0);
  266.  
  267.     subflag=0;
  268.  
  269.         do
  270.         {
  271.             printf("Input surname \n");
  272.             fgets(inpt,50,stdin);
  273.             if(is_word(inpt)==1)
  274.             {
  275.                 subflag=1;
  276.                 strcpy(database[place].surname,inpt);
  277.             }
  278.         }
  279.         while(subflag==0);
  280.  
  281.  
  282.     subflag=0;
  283.  
  284.         do
  285.         {
  286.             printf("Input account number \n");
  287.             fgets(inpt,50,stdin);
  288.             if(is_accnum(inpt)==1)
  289.             {
  290.                 subflag=1;
  291.                 strcpy(database[place].account_num,inpt);
  292.             }
  293.         }
  294.         while(subflag==0);
  295.  
  296.     subflag=0;
  297.  
  298.         do
  299.         {
  300.             printf("Input net gain \n");
  301.             fgets(inpt,50,stdin);
  302.             if(is_num(inpt)==true)
  303.             {
  304.                 printf("%d",atof(inpt));
  305.                 subflag=1;
  306.                 database[place].net_pension=atof(inpt);
  307.             }
  308.         }
  309.         while(subflag==0);
  310.     subflag=0;
  311.         do
  312.         {
  313.             printf("Input taxed gain \n");
  314.             fgets(inpt,50,stdin);
  315.             if(is_num(inpt)==true)
  316.             {
  317.                 subflag=1;
  318.                 database[place].taxed_pension=atof(inpt);
  319.             }
  320.         }
  321.         while(subflag==0);
  322.         printf("record added \n");
  323.     if((*size)==1)
  324.         (*size)++;
  325. }
  326. void sort_by_num(struct data *database,int size,int col)
  327. {
  328.     int i;
  329.    struct data swapper;
  330.     if(col==2)
  331.     {
  332.  
  333.         for(i=1; i<size; )
  334.         {
  335.             if(atoi(database[i-1].account_num) <= atoi(database[i].account_num))
  336.                 ++i;
  337.             else
  338.             {
  339.                 swapper = database[i];
  340.                 database[i] = database[i-1];
  341.                 database[i-1] = swapper;
  342.                 --i;
  343.                 if(i == 0)
  344.                 i = 1;
  345.             }
  346.         }
  347.     }
  348.     else if(col==5)
  349.     {
  350.         for(i=1; i<size; )
  351.         {
  352.             if(database[i-1].net_pension <= database[i].net_pension)
  353.                 ++i;
  354.             else
  355.             {
  356.                 swapper = database[i];
  357.                 database[i] = database[i-1];
  358.                 database[i-1] = swapper;
  359.                 --i;
  360.                 if(i == 0)
  361.                 i = 1;
  362.             }
  363.         }
  364.     }
  365.     else
  366.     {
  367.         for(i=1; i<size; )
  368.         {
  369.             if(database[i-1].taxed_pension <= database[i].taxed_pension)
  370.                 ++i;
  371.             else
  372.             {
  373.                 swapper = database[i];
  374.                 database[i] = database[i-1];
  375.                 database[i-1] = swapper;
  376.                 --i;
  377.                 if(i == 0)
  378.                 i = 1;
  379.             }
  380.         }
  381.     }
  382. }
  383.  
  384. void sort_str(struct data *database,int size,int col)
  385. {
  386.      int i;
  387.    struct data swapper;
  388.     if(col==1)
  389.     {
  390.  
  391.         for(i=1; i<size; )
  392.         {
  393.             if(str_grt(database[i-1].id,database[i].id))
  394.                 ++i;
  395.             else
  396.             {
  397.                 swapper = database[i];
  398.                 database[i] = database[i-1];
  399.                 database[i-1] = swapper;
  400.                 --i;
  401.                 if(i == 0)
  402.                 i = 1;
  403.             }
  404.         }
  405.     }
  406.     if(col==3)
  407.     {
  408.  
  409.         for(i=1; i<size; )
  410.         {
  411.             if(str_grt(database[i-1].name,database[i].name))
  412.                 ++i;
  413.             else
  414.             {
  415.                 swapper = database[i];
  416.                 database[i] = database[i-1];
  417.                 database[i-1] = swapper;
  418.                 --i;
  419.                 if(i == 0)
  420.                 i = 1;
  421.             }
  422.         }
  423.     }
  424.     if(col==4)
  425.     {
  426.  
  427.         for(i=1; i<size; )
  428.         {
  429.             if(str_grt(database[i-1].surname,database[i].surname))
  430.                 ++i;
  431.             else
  432.             {
  433.                 swapper = database[i];
  434.                 database[i] = database[i-1];
  435.                 database[i-1] = swapper;
  436.                 --i;
  437.                 if(i == 0)
  438.                 i = 1;
  439.             }
  440.         }
  441.     }
  442. }
  443. void sort_table(struct data *database,int size)
  444. {
  445.     int pass=size;
  446.     int swtch=0;
  447.     printf("Sort by which column?");
  448.     do
  449.     {
  450.         swtch=to_col();
  451.     }
  452.     while(swtch==0);
  453.     switch(swtch)
  454.     {
  455.     case 1:
  456.         sort_str(database,pass,1);
  457.         break;
  458.     case 2:
  459.         sort_by_num(database,pass,2);
  460.         break;
  461.     case 3:
  462.         sort_str(database,pass,3);
  463.         break;
  464.     case 4:
  465.         sort_str(database,pass,4);
  466.         break;
  467.     case 5:
  468.         sort_by_num(database,pass,5);
  469.         break;
  470.     case 6:
  471.         sort_by_num(database,pass,6);
  472.         break;
  473.     }
  474.     print_result(database,pass);
  475. }
  476. int does_exist(char id[],struct data *database,int size)
  477. {
  478.     int i=0;
  479.     while(i<size)
  480.     {
  481.         if(strcmp(id,database[i].id)==1)
  482.             return false;
  483.         ++i;
  484.     }
  485.     return true;
  486. }
  487.  
  488. void search(struct data *database,int size)
  489. {
  490.     char inpt[50];
  491.     int i=0;
  492.     int l=0;
  493.     printf("Input searched value \n");
  494.     fgets(inpt,50,stdin);
  495.     while(i<size)
  496.     {
  497.         if((strcmp(inpt,database[i].name)==1) || (strcmp(inpt,database[i].surname)==1) || atof(inpt)==database[i].net_pension || atof(inpt)==database[i].taxed_pension || (strcmp(inpt,database[i].account_num)==1))
  498.         {
  499.             l++;
  500.             printf("%i",l);
  501.             printf("id- ",database[i].id);
  502.             printf(" ,name- ",database[i].name);
  503.              printf(" ,surname-  ",database[i].surname);
  504.               printf(" ,net pension-  ",database[i].net_pension);
  505.                printf(" ,taxed pension- ",database[i].taxed_pension);
  506.                 printf(" ,account number-  ",database[i].account_num);
  507.                 printf("\n");
  508.         }
  509.         ++i;
  510.     }
  511.     if(l==0)
  512.         printf("no result found");
  513. }
  514. int to_col()
  515. {
  516.     char inpt[51];
  517.     int flag=0;
  518.     printf("Avaible columns: id, name, surname, net/taxed pension,account number");
  519.     do
  520.     {
  521.         printf("Input column");
  522.         fgets(inpt,50,stdin);
  523.         if(strcmp(inpt,"id")==1)
  524.             flag=1;
  525.         else if(strcmp(inpt,"account number")==1)
  526.             flag=2;
  527.         else if(strcmp(inpt,"name")==1)
  528.             flag=3;
  529.         else if(strcmp(inpt,"surname")==1)
  530.             flag=4;
  531.         else if(strcmp(inpt,"net pension")==1)
  532.             flag=5;
  533.         else if(strcmp(inpt,"taxed pension")==1)
  534.             flag=6;
  535.     }
  536.     while(flag==0);
  537.         return flag;
  538. }
  539. void search_by_col(struct data *database,int size)
  540. {
  541.     char inpt[50];
  542.     int i=0;
  543.     int flag=0;
  544.     int l=0;
  545.     int swtch=0;
  546.     do
  547.     {
  548.         swtch=to_col();
  549.     }
  550.     while(swtch==0);
  551.     printf("Input searched value \n");
  552.     fgets(inpt,50,stdin);
  553.  
  554.     while(i<size)
  555.     {
  556.         if(swtch==1)
  557.         {
  558.             if(strcmp(inpt,database[i].id)==1)
  559.             {
  560.                             flag++;
  561.             printf("%i",flag);
  562.             printf("id- ",database[i].id);
  563.             printf(" ,name- ",database[i].name);
  564.              printf(" ,surname-  ",database[i].surname);
  565.               printf(" ,net pension-  ",database[i].net_pension);
  566.                printf(" ,taxed pension- ",database[i].taxed_pension);
  567.                 printf(" ,account number-  ",database[i].account_num);
  568.                 printf("\n");
  569.             }
  570.         }
  571.         else if(swtch==3)
  572.             {
  573.             if(strcmp(inpt,database[i].name)==1)
  574.             {
  575.                             flag++;
  576.             printf("%i",flag);
  577.             printf("id- ",database[i].id);
  578.             printf(" ,name- ",database[i].name);
  579.              printf(" ,surname-  ",database[i].surname);
  580.               printf(" ,net pension-  ",database[i].net_pension);
  581.                printf(" ,taxed pension- ",database[i].taxed_pension);
  582.                 printf(" ,account number-  ",database[i].account_num);
  583.                 printf("\n");
  584.             }
  585.         }
  586.                 else if(swtch==4)
  587.             {
  588.             if(strcmp(inpt,database[i].surname)==1)
  589.             {
  590.                             flag++;
  591.             printf("%i",flag);
  592.             printf("id- ",database[i].id);
  593.             printf(" ,name- ",database[i].name);
  594.              printf(" ,surname-  ",database[i].surname);
  595.               printf(" ,net pension-  ",database[i].net_pension);
  596.                printf(" ,taxed pension- ",database[i].taxed_pension);
  597.                 printf(" ,account number-  ",database[i].account_num);
  598.                 printf("\n");
  599.             }
  600.         }
  601.         else if(swtch==5)
  602.         {
  603.             if(atof(inpt)==database[i].net_pension)
  604.             {
  605.             flag++;
  606.             printf("%i",flag);
  607.             printf("id- ",database[i].id);
  608.             printf(" ,name- ",database[i].name);
  609.              printf(" ,surname-  ",database[i].surname);
  610.               printf(" ,net pension-  ",database[i].net_pension);
  611.                printf(" ,taxed pension- ",database[i].taxed_pension);
  612.                 printf(" ,account number-  ",database[i].account_num);
  613.                 printf("\n");
  614.             }
  615.         }
  616.     else if(swtch==6)
  617.         {
  618.             if(atof(inpt)==database[i].taxed_pension)
  619.             {
  620.                             flag++;
  621.             printf("%i",flag);
  622.             printf("id- ",database[i].id);
  623.             printf(" ,name- ",database[i].name);
  624.              printf(" ,surname-  ",database[i].surname);
  625.               printf(" ,net pension-  ",database[i].net_pension);
  626.                printf(" ,taxed pension- ",database[i].taxed_pension);
  627.                 printf(" ,account number-  ",database[i].account_num);
  628.                 printf("\n");
  629.             }
  630.         }
  631.         else if(swtch==2)
  632.         {
  633.             if(strcmp(inpt,database[i].account_num)==1)
  634.             {
  635.                             flag++;
  636.             printf("%i",flag);
  637.             printf("id- ",database[i].id);
  638.             printf(" ,name- ",database[i].name);
  639.              printf(" ,surname-  ",database[i].surname);
  640.               printf(" ,net pension-  ",database[i].net_pension);
  641.                printf(" ,taxed pension- ",database[i].taxed_pension);
  642.                 printf(" ,account number-  ",database[i].account_num);
  643.                 printf("\n");
  644.             }
  645.         }
  646.         ++i;
  647.     }
  648.     if(flag==0)
  649.     {
  650.         printf("value not found \n");
  651.     }
  652. }
  653. void menu(struct data *database)
  654. {
  655.     int current_size=1;
  656.     int input=0;
  657.     char inpt[512];
  658.     do
  659.     {
  660.         printf("Input function or input help for list of avaible commands \n");
  661.         fgets(inpt,511,stdin);
  662.         input=mod_input(inpt);
  663.         if(input==404)
  664.         {
  665.             printf("Function does not exist \n");
  666.         }
  667.         else if(input==1)
  668.         {
  669.             print_result(database,current_size);
  670.         }
  671.         else if(input==2)
  672.         {
  673.             add_element(database,&current_size);
  674.         }
  675.         else if(input==3)
  676.         {
  677.             modify_element(database,current_size);
  678.         }
  679.         else if(input==4)
  680.         {
  681.             sort_table(database, current_size);
  682.         }
  683.         else if(input==5)
  684.         {
  685.             search(database,current_size);
  686.         }
  687.         else if(input==6)
  688.         {
  689.             hilfe();
  690.         }
  691.         else if(input==7)
  692.         {
  693.             search_by_col(database,current_size);
  694.         }
  695.         input=8;
  696.     }
  697.     while(input!=0);
  698. }
  699.  
  700. int main()
  701. {
  702.     int current_size=0;
  703.     struct data *database;
  704.     database=(struct data*)malloc(1*sizeof(struct data));
  705.  
  706.     menu(database);
  707.  
  708.     return 0;
  709. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!