Adooo6735

skuska ccko

Jan 29th, 2019
727
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. SUBOR SKUSKA:
  2. #include <stdio.h>
  3.  
  4. int all_positives(const int size, const int array[]){
  5.     int pocitadlo = 0;
  6.    
  7.     if(array == NULL)
  8.         return -1;
  9.    
  10.     for(int i = 0; i < size; i++){
  11.         if( array[i] <= 0)
  12.             pocitadlo++;
  13.     }
  14.    
  15.     if(pocitadlo == 0)
  16.         return 1;
  17.     else
  18.         return 0;
  19.    
  20. }
  21.  
  22. int main()
  23. {
  24.     const int array1[] = {1, 2, 0, 3, 5, 0};
  25.     const int array2[] = {1, 2, 5, 3, 5, 9};
  26.     const int array3[] = {1, -2, 9, 3, 5, 8};
  27.     printf("%d %d %d \n", all_positives(6, array1), all_positives(6, array2), all_positives(6, array3));
  28.     return 0;
  29. }
  30.  
  31. -------------------------------------------------------------------------------------------
  32.  
  33. #include <stdio.h>
  34.  
  35. int count_leap_years(const int size, const int array[]){
  36.    
  37.     if(array == NULL)
  38.         return -1;
  39.    
  40.     int pocitadlo;
  41.    
  42.     for(int i = 0; i < size; i++){
  43.        
  44.         if (array[i] % 4 == 0){
  45.            
  46.             if( array[i] % 100 == 0){
  47.                 if (array[i] % 400 == 0)
  48.                     pocitadlo++;
  49.  
  50.             }
  51.            
  52.             else
  53.                 pocitadlo++;
  54.         }
  55.     }
  56.    
  57.     return pocitadlo;
  58. }
  59.  
  60. int main()
  61. {
  62.     int array[3] = {1000, 400, 3004};
  63.     printf("%d \n", count_leap_years(3, array));
  64.     return 0;
  65. }
  66.  
  67. ------------------------------------------------------------------------------------
  68.  
  69. #include <stdio.h>
  70.  
  71. int even(const int num){
  72.     if(num % 2 > 0)
  73.         return 0;
  74.     else
  75.         return 1;
  76. }
  77.  
  78. int main(int argc, char **argv)
  79. {
  80.     printf("%d %d %d %d \n", even(-4), even(0), even(4), even(3));
  81.     return 0;
  82. }
  83.  
  84. ---------------------------------------------------------------------------------
  85.  
  86. #include <stdio.h>
  87. #include <math.h>
  88.  
  89. int is_prime(const int num){
  90.     int odmocnina = sqrt(num);
  91.     int pocitadlo = 0;
  92.    
  93.     for(int i = 2; i <= odmocnina; i++){
  94.         if(num % i == 0)
  95.             pocitadlo++;
  96.     }
  97.    
  98.     if(pocitadlo > 0)
  99.         return 0;
  100.     else
  101.         return 1;
  102. }
  103.  
  104. int main()
  105. {
  106.     printf("%d %d %d \n", is_prime(293), is_prime(24), is_prime(29));
  107.     return 0;
  108. }
  109.  
  110. --------------------------------------------------------------------------------
  111.  
  112. #include <stdio.h>
  113.  
  114. int is_white(const char c){
  115.    
  116.     if(c == ' ' || c == '\n' || c == '\t')
  117.         return 1;
  118.     else
  119.         return 0;
  120. }
  121.  
  122. int main()
  123. {
  124.     printf("%d \n", is_white(' '));
  125.     return 0;
  126. }
  127.  
  128. -----------------------------------------------------------------------------
  129.  
  130. #include <stdio.h>
  131.  
  132. char ul(const char c){
  133.     int ascii_value = (int)c;
  134.     int new_value;
  135.    
  136.     if(ascii_value >= 97 && ascii_value <= 122)
  137.         new_value = ascii_value - 32;
  138.    
  139.     else
  140.         new_value = ascii_value + 32;
  141.    
  142.     char vysledok = new_value;
  143.    
  144.     return vysledok;
  145. }
  146.  
  147. int main()
  148. {
  149.     printf("%c \n", ul('z'));
  150.     return 0;
  151. }
  152.  
  153. -------------------------------------------------------------------------------
  154.  
  155. #include <stdio.h>
  156.  
  157. int min_2d(const int size, int array[][size]){
  158.     if(array == NULL)
  159.         return -1;
  160.    
  161.     int vacsi, max;
  162.    
  163.     for(int i = 0; i < size; i++){
  164.        
  165.         for(int j = 0; j < size; j++){
  166.             if(vacsi > array[i][j])
  167.                 vacsi = array[i][j];
  168.         }
  169.        
  170.         if(max > vacsi)
  171.             max = vacsi;
  172.     }
  173.    
  174.     return max;
  175. }
  176.  
  177. int main()
  178. {
  179.     int array[2][2] = { {33, -10}, {22, -5} };
  180.     printf("%d \n", min_2d(2, array));
  181.     return 0;
  182. }
  183.  
  184. ---------------------------------------------------------------------------------
  185.  
  186. #include <stdio.h>
  187.  
  188. int sum_greater(const int a, const int b, const int c){
  189.  
  190.     int result;
  191.     if(a > b){
  192.         if(b > c)
  193.             result = a + b;
  194.         else
  195.             result = a + c;
  196.     }
  197.    
  198.     else{
  199.         if(a > c)
  200.             result = b + a;
  201.         else
  202.             result = b + c;
  203.     }
  204.  
  205.     return result;
  206. }
  207.  
  208. int main()
  209. {
  210.     printf("%d\n", sum_greater(5, 4, 6));
  211.     return 0;
  212. }
  213.  
  214. -------------------------------------------------------------------------------
  215.  
  216. #include <stdio.h>
  217. #include <string.h>
  218.  
  219. int vowels_count(const char string[]){
  220.     if(string == NULL)
  221.         return -1;
  222.    
  223.     int sum = 0;
  224.     for(int i = 0; i < strlen(string); i++){
  225.         if(string[i] == 'a' || string[i] == 'e' || string[i] == 'i' || string[i] == 'o' || string[i] == 'u' || string[i] == 'y' || string[i] == 'ä')
  226.             sum++;
  227.     }
  228.    
  229.     return sum;
  230. }
  231.  
  232. int main(int argc, char **argv)
  233. {
  234.     printf("%d %d %d \n", vowels_count("Hello, how are you?"), vowels_count("ahoj"), vowels_count("pssst!"));
  235.    
  236.     return 0;
  237. }
  238.  
  239. --------------------------------------------------------------------------------------------
  240. SUBOR FUNKCIE: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  241.  
  242. #include <stdio.h>
  243.  
  244. int count_positives(const int size, const int array[]){
  245.     int result = 0;
  246.    
  247.     if  (array == NULL)
  248.         return -1;
  249.  
  250.     for(int idx = 0; idx < size; idx++){
  251.         if(array[idx] > 0)
  252.             result++;
  253.     }
  254.  
  255.     return result;
  256. }
  257.  
  258. -----------------------------------------------------------------------
  259.  
  260. #include <stdio.h>
  261.  
  262. int is_white(const char c){
  263.     if(c == ' ' || c == '\t' || c == '\n')
  264.         return 1;
  265.  
  266.     return 0;
  267. }
  268.  
  269. -------------------------------------------------------------------------
  270.  
  271. #include <stdio.h>
  272.  
  273. int max_2d(const int size, int array[][size] ){
  274.     int result;
  275.  
  276.     if(array == NULL)
  277.         return -1;
  278.  
  279.     result = array[0][0];
  280.     for(int index = 0; index < size; index++){
  281.         for(int idx = 0; idx < size; idx++){
  282.             if(array[index][idx] > result)
  283.                 result = array[index][idx];
  284.         }
  285.     }
  286.  
  287.     return result;
  288. }
  289.  
  290. -------------------------------------------------------------------------
  291.  
  292.  
  293. #include<stdio.h>
  294.  
  295. int sum_greater(const int a, const int b, const int c){
  296.     int result;
  297.    
  298.     if(a < b){
  299.         if(a < c)
  300.             result = b+c;
  301.         else
  302.             result = a + b;
  303.     }
  304.     else{
  305.         if(b < c)
  306.             result = a + c;
  307.         else
  308.             result = a + b;
  309.     }
  310.  
  311.     return result;
  312. }
  313.  
  314. ----------------------------------------------------------------------------
  315.  
  316. #include <stdio.h>
  317. #include <string.h>
  318.  
  319. void change_whiters(char string[]){
  320.     if(string == NULL)
  321.         return;
  322.  
  323.     for(int idx = 0; idx < strlen(string); idx++){
  324.         if(string[idx] == ' ' || string[idx] == '\n')
  325.             string[idx] = '.';
  326.     }
  327. }
  328.  
  329. -----------------------------------------------------------------------------
  330.  
  331. #include <stdio.h>
  332.  
  333. int sum_digits(const int n){
  334.     if(n <= 0)
  335.         return 0;
  336.  
  337.     int result = 0, counter = 0;
  338.     int array[n];
  339.  
  340.     array[0] = 1;
  341.     for(int idx = 1; idx < n; idx++){
  342.         result = 0;
  343.         for(int i = 0; i <= counter; i++){     
  344.             int tmp = array[i];
  345.             while(1){
  346.                 int reminder = tmp % 10;
  347.                 tmp /= 10;
  348.                 result += reminder;
  349.                 if(tmp <= 0)
  350.                     break;
  351.             }
  352.         }
  353.         counter++;
  354.         array[counter] = result;
  355.     }  
  356.  
  357.     return result;
  358. }
  359.  
  360. XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  361. DALSIE SKOPCENE PICOVINY:
  362. ALL POSITIVES
  363. xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  364.  
  365. #include<stdio.h>
  366.  
  367. int pole[10]={1,2,3,4,33,5,6,10,8,50};
  368.  
  369. int main(void)
  370.  
  371. {
  372.         int count=0;
  373. for(int i=0;i<sizeof(pole) / sizeof(pole[0]);i++)
  374.  
  375. {
  376.         if(pole[i]<1)
  377.         {
  378.                 count++;
  379.         }
  380.  
  381.  
  382. }
  383.  
  384.         if(count==0)
  385.         {printf("vsetky cisla v poli su kladne\n");
  386.         }
  387.         else
  388.         {printf("v poli sa nachadzaju aj zaporne cisla\n");
  389.         }
  390.  
  391. return 0;
  392. }
  393.  
  394.  
  395. xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  396. EVEN
  397. xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  398.  
  399. #include<stdio.h>
  400.  
  401. int cislo;
  402.  
  403. int main(void)
  404.  
  405.  
  406.  
  407. {
  408.         printf("zadaj cislo\n");
  409.         scanf("%d",&cislo);
  410.  
  411.         if(cislo%2==0)
  412.         {
  413.                 printf("cislo ktore si zadal je parne\n");
  414.         }
  415.  
  416.         else
  417.         {printf("cislo ktore si zadal nieje parne\n");
  418.         }
  419.  
  420.  
  421. return 0;
  422. }
  423.  
  424. xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  425. IS PRIME
  426. xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  427.  
  428. #include<stdio.h>
  429.  
  430.  
  431. int num;
  432. int delitele=0;
  433. int main(void)
  434.  
  435.  
  436. {
  437.         printf("zadaj cislo\n");
  438.         scanf("%d",&num);
  439.  
  440.         printf("zadal si cislo %d\n" ,num );
  441.  
  442.         if(num==1)
  443.         {printf("cislo nieje prvocislo");
  444.         }
  445.  
  446.         else{
  447.                 for (int i=2;i<num;i++)
  448.                 {
  449.                         if((num%i)==0 )
  450.                         {
  451.                                  if(i==num)
  452.                                  {delitele--;
  453.                                  }
  454.                                  else{
  455.                                          delitele++;}
  456.  
  457.                         }
  458.  
  459.                 }
  460.  
  461.  
  462.         }
  463.          if(delitele>0)
  464.          {printf("cislo nieje prvocislo");
  465.          }
  466.           else
  467.           {printf("cislo je prvocislo");
  468.           }
  469.  
  470.           return 0;
  471. }
  472.  
  473. xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  474. IS WHITE
  475. xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  476. #include<stdio.h>
  477.  
  478. char znak;
  479.  
  480. int main(void)
  481.  
  482. {
  483.  
  484.         printf("zadaj znak z klavesnice\n");
  485.         znak=getchar();
  486.  
  487.  
  488.         if((znak==32)||(znak==44)||(znak==9)||(znak==13))
  489.         {
  490.         printf("zadany znak je nahovno\n");
  491.         }
  492.  
  493.         else
  494.         {
  495.                 printf("zadany znak je v pohode\n");
  496.         }
  497.  
  498.  
  499. return 0;
  500. }
  501. xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  502. LEAP YEARS
  503. xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  504. #include<stdio.h>
  505.  
  506. int rok[10]={2014,2015,2013,2018,2019,2020,1979,1998,2272,2448};
  507. //v skuske je velkost pola const int size
  508. int main (void)
  509. {
  510.  
  511.         int pocitadlo=0;
  512.  
  513.                 for (int i=0;i < 10;i++)     //for (int i=0;i<size;i++)
  514.  
  515.  
  516.  {
  517.       if ((rok[i]%400) == 0)
  518.       { pocitadlo++;}
  519.         else if ((rok[i]%100) == 0)
  520.               {}
  521.  
  522.                 else if ((rok[i]%4) == 0)
  523.                      {   pocitadlo++;}
  524.                         else
  525.                                 { }
  526.  }
  527.  
  528.  
  529.             printf("%d",pocitadlo);   //return pocitadlo;
  530.  
  531.  
  532.  
  533.  
  534.  
  535. return 0;
  536.  
  537.  
  538.  }
  539. xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  540. MIN2D
  541. xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  542. #include <stdio.h>
  543.  
  544. int min_2d(const int size, int array[][size]){
  545.                 if(array == NULL)
  546.                                         return -1;
  547.  
  548.                         int vacsi, max;
  549.  
  550.                                 for(int i = 0; i < size; i++){
  551.  
  552.                                                         for(int j = 0; j < size; j++){
  553.                                                                                         if(vacsi > array[i][j])
  554.                                                                                                                                 vacsi = array[i][j];
  555.                                                                                                         }
  556.  
  557.                                                                         if(max > vacsi)
  558.                                                                                                         max = vacsi;
  559.                                                                                 }
  560.  
  561.                                         return max;
  562. }
  563. xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  564. VOWELS in string
  565. xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  566. #include <stdio.h>
  567.  
  568. int main()
  569.  
  570. {
  571.         int c = 0, pocet = 0;
  572.         char s[1000];
  573.  
  574.         printf("zadaj string\n");
  575.         scanf("%[^\n]", s);
  576.  
  577.  
  578.  
  579.         while (s[c] != '\0') {
  580.                  if (s[c] == 'a' || s[c] == 'A' || s[c] == 'e' || s[c] == 'E' || s[c] == 'i' || s[c] == 'I' || s[c] =='o' || s[c]=='O' || s[c] == 'u' || s[c] == 'U')
  581.                          pocet++;
  582.  
  583.                  printf("%c",s[c]);
  584.  
  585.                   c++;
  586.         }
  587.  
  588. printf("pocet samohlasok v stringu: %d", pocet);
  589.  
  590. return 0;
  591. }
  592. xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  593. SEC2HUMAN
  594. xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  595. #include<stdio.h>
  596.  
  597. long int vstup;
  598. long int year;
  599. long int months;
  600. long int days;
  601. long int hours;
  602. long int minutes;
  603. long int seconds;
  604.  
  605. long int zvysok=0;
  606.  
  607.  
  608.  
  609. int main(void)
  610.  
  611. {
  612.         printf("zadaj cas v sekundach");
  613.         scanf("%ld",&vstup);
  614.  
  615.         year = vstup / 31104000;
  616.         zvysok = vstup % 31104000;
  617.  
  618.         months = zvysok/2592000;
  619.         zvysok = zvysok%2592000;
  620.  
  621.         days = zvysok / 86400;
  622.         zvysok = zvysok % 86400;
  623.  
  624.         hours = zvysok / 3600;
  625.         zvysok = zvysok % 3600;
  626.  
  627.         minutes = zvysok / 60;
  628.         zvysok = zvysok % 60;
  629.  
  630.         seconds = zvysok;
  631.  
  632.         printf ("%ld years %ld months %ld days %ld hours %ld minutes %ld seconds",year,months,days,hours,minutes,seconds);
  633.  
  634.  
  635.  
  636.  
  637.  
  638.         return 0;
  639. }
  640. xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  641. SUM GREATER
  642. xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  643. #include<stdio.h>
  644.  
  645. int a=3;
  646. int b=6;
  647. int c=1;
  648.  
  649. int main(void)
  650.  
  651.  
  652. {
  653. int sucet=0;
  654.  
  655. if((a>b) && (c>b)  )
  656. {
  657. sucet=a+c;
  658. }
  659.  
  660.  
  661. else if((b>c) && (a>c)  )
  662. {
  663.         sucet=a+b;
  664. }
  665.  
  666. else
  667. {
  668.         sucet=c+b;
  669. }
  670.  
  671. printf("sucet najvacsich cisel je %d\n",sucet);
  672.  
  673. return 0;
  674. }
  675. xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  676. UL
  677. xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  678. #include <stdio.h>
  679.  
  680. char ul(const char c)
  681.  
  682.  
  683. {
  684.                 int ascii_value = (int)c;
  685.                         int new_value;
  686.  
  687.                                 if(ascii_value >= 97 && ascii_value <= 122)
  688.                                                         new_value = ascii_value - 32;
  689.  
  690.                                         else
  691.                                                                 new_value = ascii_value + 32;
  692.  
  693.                                                 char vysledok = new_value;
  694.  
  695.                                                         return vysledok;
  696. }
  697. xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  698. VOWELS between letters
  699. xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  700. #include<stdio.h>
  701.  
  702. int pismenoa;
  703. int pismenob;
  704.  
  705. int main(void)
  706.  
  707. {
  708.  
  709.         int samohlasky [10] = {97,101,105,111,117,65,69,73,79,85};
  710.         int pocet = 0;
  711.         void test_samohlasky(char *c);
  712.  
  713.         printf("zadaj prve pismeno: \n" );
  714.         pismenoa = getchar();
  715.         getchar();
  716.         printf("zadaj druhe pismeno: \n");
  717.         pismenob = getchar();
  718.  
  719.  
  720.         if ((pismenoa==pismenob) && ((pismenoa>=65) &&( pismenoa <= 90 )) && ((pismenob>=65) && (pismenob<=90))                                          )
  721.         { printf("1\n"); //return 1;
  722.         }
  723.  
  724.  
  725.         else if ((pismenoa==pismenob) && ((pismenoa>=97) &&( pismenoa <= 122 )) && ((pismenob>=97) && (pismenob<=122))                                          )
  726.         { printf("1\n"); //return 1;
  727.         }
  728.  
  729.         else if (pismenoa==pismenob)
  730.         {printf("zadane symboly niesu pismena \n");
  731.         }
  732.  
  733.         else if (((pismenoa>=65) &&( pismenoa <= 90 )) && ((pismenob>=97) && (pismenob<=122)))
  734.                         {
  735.                                         printf("pismena niesu rovnako velke"); //return 0;
  736.                                                 }
  737.  
  738.         else if (((pismenob>=65) &&( pismenob <= 90 )) && ((pismenoa>=97) && (pismenoa<=122)))
  739.                         {
  740.                                         printf("pismena niesu rovnako velke"); //return 0;
  741.                                                 }
  742.   else if (((pismenob>=65) &&( pismenob <= 90 )) && ((pismenoa>=97) && (pismenoa<=122)))
  743.                         {
  744.                                         printf("pismena niesu rovnako velke"); //return 0;
  745.                                                 }
  746.         else if(((pismenoa<65) || (pismenoa>90)) && ((pismenoa<97) || (pismenoa>122))                                         )
  747.                         {printf("jeden zo zadanych symoblov nieje pismeno\n"); //return 0;
  748.                                         }
  749.         else if(((pismenob<65) || (pismenob>90)) && ((pismenob<97) || (pismenob>122))                                         )
  750.                                 {printf("jeden zo zadanych symoblov nieje pismeno\n"); //return 0;
  751.                                                 }
  752.  
  753.                                         else {
  754.          int min = 0, max=0;
  755. if(pismenoa<pismenob)
  756. {
  757. min = pismenoa;
  758. max = pismenob;
  759. } else {
  760.          min = pismenob;
  761.          max = pismenoa;
  762. }
  763.  
  764. for(int i=min;i<=max;i++)
  765.  
  766. {
  767.          //printf("%d ",i);
  768.           for(int j=0;j<=sizeof(samohlasky) / sizeof(samohlasky[0])  ;j++)
  769.           {
  770.            if (i == samohlasky[j]  )
  771.            {
  772.             //printf("%d\n",samohlasky[j]);
  773.              pocet++;
  774.              }
  775.              }
  776.              }
  777.  
  778.              printf("%d", pocet); //return pocet;
  779.                      }
  780.  
  781.                      return 0;
  782.                      }
  783. xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  784. WORKER
  785. xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  786. #include<stdio.h>
  787.  
  788. int num1;
  789. int num2;
  790. int j=0;
  791. int h=0;
  792.  
  793. int cislo[10000];
  794.  
  795. int main(void)
  796. {
  797.  
  798.  
  799.  
  800.  
  801.  
  802.  
  803.  
  804.         printf("zadaj 1. cislo");
  805.         scanf("%d",&num1);
  806.         printf("zadaj 2. cislo");
  807.         scanf("%d",&num2);
  808.  
  809.  
  810.         for(int i=num1;i<=num2;i++)
  811.         {
  812.                 if(((i%7)==2) || ((i%7)==3) )
  813.  
  814.                 {
  815.                         cislo[j]=i;j++;
  816.                 }
  817.         }
  818.  
  819.  
  820.         for(int h=0;h<j;h++ )
  821.         {printf("%d\n",cislo[h]);
  822.         }
  823.  
  824.  
  825.  
  826.         return 0;
  827. }
  828. amen
  829. XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  830. PROGRAM IS PRIME
  831. xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  832.  
  833. #include<stdio.h>
  834.  
  835.  
  836. int num;
  837. int delitele=0;
  838. int main(void)
  839.  
  840.  
  841. {
  842.     printf("zadaj cislo\n");
  843.         scanf("%d",&num);
  844.  
  845.         printf("zadal si cislo %d\n" ,num );
  846.  
  847.         if(num==1)
  848.         {printf("cislo nieje prvocislo");
  849.         }
  850.  
  851.         else{
  852.                 for (int i=2;i<num;i++)
  853.                 {
  854.                         if((num%i)==0 )
  855.                         {
  856.                                  if(i==num)
  857.                                  {delitele--;
  858.                                  }
  859.                                  else{
  860.                                          delitele++;}
  861.  
  862.                         }
  863.  
  864.                 }
  865.  
  866.  
  867.         }
  868.          if(delitele>0)
  869.          {printf("cislo nieje prvocislo");
  870.          }
  871.           else
  872.           {printf("cislo je prvocislo");
  873.           }
  874.  
  875.           return 0;
  876. }
  877.  
  878. xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  879.  
  880. PROGRAM LEAP YEARS
  881. xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  882.  
  883. #include<stdio.h>
  884.  
  885. int rok[10]={2014,2015,2013,2018,2019,2020,1979,1998,2272,2448};
  886. //v skuske je velkost pola const int size
  887. int main (void)
  888. {
  889.  
  890.         int pocitadlo=0;
  891.  
  892.                 for (int i=0;i < 10;i++)     //for (int i=0;i<size;i++)
  893.  
  894.  
  895.  {
  896.       if ((rok[i]%400) == 0)
  897.       { pocitadlo++;}
  898.         else if ((rok[i]%100) == 0)
  899.               {}
  900.  
  901.                 else if ((rok[i]%4) == 0)
  902.                      {   pocitadlo++;}
  903.                         else
  904.                                 { }
  905.  }
  906.  
  907.  
  908.             printf("%d",pocitadlo);   //return pocitadlo;
  909.  
  910.  
  911.  
  912.  
  913.  
  914. return 0;
  915.  
  916.  
  917.  }
  918.  
  919. xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  920. SAMOHLASKY V ZADANOM SLOVE
  921. xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  922. #include <stdio.h>
  923.  
  924. int main()
  925.  
  926. {
  927.         int c = 0, pocet = 0;
  928.         char s[1000];
  929.  
  930.         printf("zadaj string\n");
  931.         scanf("%[^\n]", s);
  932.  
  933.  
  934.  
  935.         while (s[c] != '\0') {
  936.                  if (s[c] == 'a' || s[c] == 'A' || s[c] == 'e' || s[c] == 'E' || s[c] == 'i' || s[c] == 'I' || s[c] =='o' || s[c]=='O' || s[c] == 'u' || s[c] == 'U')
  937.                          pocet++;
  938.  
  939.                  printf("%c",s[c]);
  940.  
  941.                   c++;
  942.         }
  943.  
  944. printf("pocet samohlasok v stringu: %d", pocet);
  945.  
  946. return 0;
  947. }
  948.  
  949. xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  950. PROGRAM SEC2HUMAN
  951. xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  952. #include<stdio.h>
  953.  
  954. long int vstup;
  955. long int year;
  956. long int months;
  957. long int days;
  958. long int hours;
  959. long int minutes;
  960. long int seconds;
  961.  
  962. long int zvysok=0;
  963.  
  964.  
  965.  
  966. int main(void)
  967.  
  968. {
  969.         printf("zadaj cas v sekundach");
  970.         scanf("%ld",&vstup);
  971.  
  972.         year = vstup / 31104000;
  973.         zvysok = vstup % 31104000;
  974.  
  975.         months = zvysok/2592000;
  976.         zvysok = zvysok%2592000;
  977.  
  978.         days = zvysok / 86400;
  979.         zvysok = zvysok % 86400;
  980.  
  981.         hours = zvysok / 3600;
  982.         zvysok = zvysok % 3600;
  983.  
  984.         minutes = zvysok / 60;
  985.         zvysok = zvysok % 60;
  986.  
  987.         seconds = zvysok;
  988.  
  989.         printf ("%ld years %ld months %ld days %ld hours %ld minutes %ld seconds",year,months,days,hours,minutes,seconds);
  990.  
  991.  
  992.  
  993.  
  994.  
  995.         return 0;
  996. }
  997.  
  998. xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  999. SAMOHLASKY MEDZI ZADANYMI PISMENAMI
  1000. xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  1001.  
  1002. #include<stdio.h>
  1003.  
  1004. int pismenoa;
  1005. int pismenob;
  1006.  
  1007. int main(void)
  1008.  
  1009. {
  1010.  
  1011.         int samohlasky [10] = {97,101,105,111,117,65,69,73,79,85};
  1012.         int pocet = 0;
  1013.         void test_samohlasky(char *c);
  1014.  
  1015.         printf("zadaj prve pismeno: \n" );
  1016.         pismenoa = getchar();
  1017.         getchar();
  1018.         printf("zadaj druhe pismeno: \n");
  1019.         pismenob = getchar();
  1020.  
  1021.  
  1022.         if ((pismenoa==pismenob) && ((pismenoa>=65) &&( pismenoa <= 90 )) && ((pismenob>=65) && (pismenob<=90))                                          )
  1023.         { printf("1\n"); //return 1;
  1024.         }
  1025.  
  1026.  
  1027.         else if ((pismenoa==pismenob) && ((pismenoa>=97) &&( pismenoa <= 122 )) && ((pismenob>=97) && (pismenob<=122))                                          )
  1028.         { printf("1\n"); //return 1;
  1029.         }
  1030.  
  1031.         else if (pismenoa==pismenob)
  1032.         {printf("zadane symboly niesu pismena \n");
  1033.         }
  1034.  
  1035.         else if (((pismenoa>=65) &&( pismenoa <= 90 )) && ((pismenob>=97) && (pismenob<=122)))
  1036.                         {
  1037.                                         printf("pismena niesu rovnako velke"); //return 0;
  1038.                                                 }
  1039.  
  1040.         else if (((pismenob>=65) &&( pismenob <= 90 )) && ((pismenoa>=97) && (pismenoa<=122)))
  1041.                         {
  1042.                                         printf("pismena niesu rovnako velke"); //return 0;
  1043.                                                 }
  1044.   else if (((pismenob>=65) &&( pismenob <= 90 )) && ((pismenoa>=97) && (pismenoa<=122)))
  1045.                         {
  1046.                                         printf("pismena niesu rovnako velke"); //return 0;
  1047.                                                 }
  1048.         else if(((pismenoa<65) || (pismenoa>90)) && ((pismenoa<97) || (pismenoa>122))                                         )
  1049.                         {printf("jeden zo zadanych symoblov nieje pismeno\n"); //return 0;
  1050.                                         }
  1051.         else if(((pismenob<65) || (pismenob>90)) && ((pismenob<97) || (pismenob>122))                                         )
  1052.                                 {printf("jeden zo zadanych symoblov nieje pismeno\n"); //return 0;
  1053.                                                 }
  1054.  
  1055.                                         else {
  1056.          int min = 0, max=0;
  1057. if(pismenoa<pismenob)
  1058. {
  1059. min = pismenoa;
  1060. max = pismenob;
  1061. } else {
  1062.          min = pismenob;
  1063.          max = pismenoa;
  1064. }
  1065.  
  1066. for(int i=min;i<=max;i++)
  1067.  
  1068. {
  1069.          //printf("%d ",i);
  1070.           for(int j=0;j<=sizeof(samohlasky) / sizeof(samohlasky[0])  ;j++)
  1071.           {
  1072.            if (i == samohlasky[j]  )
  1073.            {
  1074.             //printf("%d\n",samohlasky[j]);
  1075.              pocet++;
  1076.              }
  1077.              }
  1078.              }
  1079.  
  1080.              printf("%d", pocet); //return pocet;
  1081.                      }
  1082.  
  1083.                      return 0;
  1084.                      }
  1085.  
  1086. xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  1087. WORKER
  1088. xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  1089.  
  1090. #include<stdio.h>
  1091.  
  1092. int num1;
  1093. int num2;
  1094. int j=0;
  1095. int h=0;
  1096.  
  1097. int cislo[10000];
  1098.  
  1099. int main(void)
  1100. {
  1101.         printf("zadaj 1. cislo");
  1102.         scanf("%d",&num1);
  1103.         printf("zadaj 2. cislo");
  1104.         scanf("%d",&num2);
  1105.  
  1106.  
  1107.         for(int i=num1;i<=num2;i++)
  1108.         {
  1109.                 if(((i%7)==2) || ((i%7)==3) )
  1110.  
  1111.                 {
  1112.                         cislo[j]=i;j++;
  1113.                 }
  1114.         }
  1115.  
  1116.  
  1117.         for(int h=0;h<j;h++ )
  1118.         {printf("%d\n",cislo[h]);
  1119.         }
  1120.  
  1121.  
  1122.  
  1123.         return 0;
  1124. }
  1125. XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  1126.  
  1127. PRACA SO SUBOROM: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  1128.  
  1129. #include <stdio.h>
  1130.  
  1131. #include <ctype.h> // pouzitie makier isalpha() a toupper()
  1132.  
  1133.  
  1134.  
  1135. #define POCET   ('Z' - 'A' + 1) // rozsah vsetkych velkych pismen (bez diakritiky) + 1
  1136.  
  1137.  
  1138.  
  1139. int main(void) {
  1140.  
  1141.     FILE *fr;
  1142.  
  1143.     int c, i;
  1144.  
  1145.     int pole[POCET]; // pole na mnoztvo opakovani jednotlivych pismen
  1146.  
  1147.  
  1148.  
  1149.     for (i = 0; i < POCET; i++)
  1150.  
  1151.         pole[i] = 0;            // nulovanie pola - naplnenie pola nulami
  1152.  
  1153.  
  1154.  
  1155.     fr = fopen("TEXT.TXT", "r"); // otvorenie suboru
  1156.  
  1157.  
  1158.  
  1159.     while ((c = getc(fr)) != EOF) { // citanie jednostlivych znakov suboru
  1160.  
  1161.         if (isalpha( c )) // ak je znak pismeno
  1162.  
  1163.         pole[toupper( c ) - 'A']++; // v cykle zvacsuje o jedna prvok pola s indexom
  1164.  
  1165.                                  // velke pismeno ( c ) - 'A', teda ak napr. c = 'A',
  1166.  
  1167.                                  // 'A' - 'A' = 0, teda obsah pole[0] sa zvacsi o jedna
  1168.  
  1169.     }
  1170.  
  1171.     printf("V subore bol tento pocet jednotlivych pismen:\n");
  1172.  
  1173.     for (i = 0; i < POCET; i++)
  1174.  
  1175.         printf("%c - %d \n", i + 'A', pole[i]); // v cykle vypisuje jednotlive velke pismena
  1176.  
  1177.                                                 // a k nim hodnoty z prislusnych prvkov pola
  1178.  
  1179.  
  1180.  
  1181.     fclose(fr);
  1182.  
  1183.     return 0;
  1184.  
  1185. }
  1186. -------------------------------------------------------------------------------
  1187. FREKVENCIA PISMEN (ZNAKOV) : XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  1188. A:
  1189. #include <stdio.h>
  1190. #include <string.h>
  1191.  
  1192. int main()
  1193. {
  1194.    char string[100];
  1195.    int c = 0, count[26] = {0}, x;
  1196.  
  1197.    printf("Enter a string\n");
  1198.    gets(string);
  1199.  
  1200.    while (string[c] != '\0') {
  1201.    /** Considering characters from 'a' to 'z' only and ignoring others. */
  1202.  
  1203.       if (string[c] >= 'a' && string[c] <= 'z') {
  1204.          x = string[c] - 'a';
  1205.          count[x]++;
  1206.       }
  1207.  
  1208.       c++;
  1209.    }
  1210.  
  1211.    for (c = 0; c < 26; c++)
  1212.          printf("%c occurs %d times in the string.\n", c + 'a', count[c]);
  1213.  
  1214.    return 0;
  1215. }
  1216. Explanation of "count[string[c]-'a']++", suppose input string begins with 'a' so c is 0 initially and string[0] = 'a' and string[0] - 'a' = 0 and we increment count[0] i.e. 'a' has occurred one time and repeat this till the complete string is scanned.
  1217.  
  1218.  
  1219. B : XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  1220.  
  1221. #include <stdio.h>
  1222. #include <string.h>
  1223.  
  1224. void find_frequency(char [], int []);
  1225.  
  1226. int main()
  1227. {
  1228.    char string[100];
  1229.    int c, count[26] = {0};
  1230.  
  1231.    printf("Input a string\n");
  1232.    gets(string);
  1233.  
  1234.    find_frequency(string, count);
  1235.    
  1236.    printf("Character Count\n");
  1237.    
  1238.    for (c = 0 ; c < 26 ; c++)
  1239.       printf("%c \t  %d\n", c + 'a', count[c]);
  1240.  
  1241.    return 0;
  1242. }
  1243.  
  1244. void find_frequency(char s[], int count[]) {
  1245.    int c = 0;
  1246.    
  1247.    while (s[c] != '\0') {
  1248.       if (s[c] >= 'a' && s[c] <= 'z' )
  1249.          count[s[c]-'a']++;
  1250.       c++;
  1251.    }
  1252. }
  1253.  
  1254. C : XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  1255. #include <stdio.h>
  1256. int main()
  1257. {
  1258.     char c;
  1259.     printf("Enter a character: ");
  1260.     scanf("%c",&c);
  1261.  
  1262.     if( (c>='a' && c<='z') || (c>='A' && c<='Z'))
  1263.         printf("%c is an alphabet.",c);
  1264.     else
  1265.         printf("%c is not an alphabet.",c);
  1266.  
  1267.     return 0;
  1268. }
  1269. EVEN OR ODD: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  1270. #include <stdio.h>
  1271. int main()
  1272. {
  1273.     int number;
  1274.  
  1275.     printf("Enter an integer: ");
  1276.     scanf("%d", &number);
  1277.  
  1278.     // True if the number is perfectly divisible by 2
  1279.     if(number % 2 == 0)
  1280.         printf("%d is even.", number);
  1281.     else
  1282.         printf("%d is odd.", number);
  1283.  
  1284.     return 0;
  1285. }
  1286. PRIME OR NOT: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  1287. #include <stdio.h>
  1288. int main()
  1289. {
  1290.     int n, i, flag = 0;
  1291.  
  1292.     printf("Enter a positive integer: ");
  1293.     scanf("%d", &n);
  1294.  
  1295.     for(i = 2; i <= n/2; ++i)
  1296.     {
  1297.         // condition for nonprime number
  1298.         if(n%i == 0)
  1299.         {
  1300.             flag = 1;
  1301.             break;
  1302.         }
  1303.     }
  1304.  
  1305.     if (n == 1)
  1306.     {
  1307.       printf("1 is neither a prime nor a composite number.");
  1308.     }
  1309.     else
  1310.     {
  1311.         if (flag == 0)
  1312.           printf("%d is a prime number.", n);
  1313.         else
  1314.           printf("%d is not a prime number.", n);
  1315.     }
  1316.    
  1317.     return 0;
  1318. }
  1319. ARMSTRONG/PRIME/POSITIVE: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  1320. #include <stdio.h>
  1321. #include <math.h>
  1322.  
  1323. int checkPrimeNumber(int n);
  1324. int checkArmstrongNumber(int n);
  1325.  
  1326. int main()
  1327. {
  1328.     int n, flag;
  1329.  
  1330.     printf("Enter a positive integer: ");
  1331.     scanf("%d", &n);
  1332.  
  1333.     // Check prime number
  1334.     flag = checkPrimeNumber(n);
  1335.     if (flag == 1)
  1336.         printf("%d is a prime number.\n", n);
  1337.     else
  1338.         printf("%d is not a prime number.\n", n);
  1339.  
  1340.     // Check Armstrong number
  1341.     flag = checkArmstrongNumber(n);
  1342.     if (flag == 1)
  1343.         printf("%d is an Armstrong number.", n);
  1344.     else
  1345.         printf("%d is not an Armstrong number.",n);
  1346.     return 0;
  1347. }
  1348.  
  1349. int checkPrimeNumber(int n)
  1350. {
  1351.     int i, flag = 1;
  1352.  
  1353.     for(i=2; i<=n/2; ++i)
  1354.     {
  1355.  
  1356.     // condition for non-prime number
  1357.         if(n%i == 0)
  1358.         {
  1359.             flag = 0;
  1360.             break;
  1361.         }
  1362.     }
  1363.     return flag;
  1364. }
  1365.  
  1366. int checkArmstrongNumber(int number)
  1367. {
  1368.     int originalNumber, remainder, result = 0, n = 0, flag;
  1369.  
  1370.     originalNumber = number;
  1371.  
  1372.     while (originalNumber != 0)
  1373.     {
  1374.         originalNumber /= 10;
  1375.         ++n;
  1376.     }
  1377.  
  1378.     originalNumber = number;
  1379.  
  1380.     while (originalNumber != 0)
  1381.     {
  1382.         remainder = originalNumber%10;
  1383.         result += pow(remainder, n);
  1384.         originalNumber /= 10;
  1385.     }
  1386.  
  1387.     // condition for Armstrong number
  1388.     if(result == number)
  1389.         flag = 1;
  1390.     else
  1391.         flag = 0;
  1392.  
  1393.     return flag;
  1394. }
  1395. DELITELNOST: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  1396. A: //vypise kterymi cisly je dane cislo delitelne beze zbytku XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  1397. #include<stdio.h>
  1398. #include<stdlib.h>
  1399.  
  1400. main(){
  1401.  
  1402. int delenec, delitel;
  1403.  
  1404. scanf("%d", &delenec);
  1405.  
  1406. for(delitel = 1; delitel <= delenec; delitel++)
  1407. {
  1408.     if(delenec % delitel == 0)
  1409.     {
  1410.         printf("%d\n", delitel);
  1411.     }
  1412. }
  1413.  
  1414. system("pause > nul");
  1415. }
  1416. B : XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  1417. #include <stdio.h>
  1418.  
  1419. int main(void)
  1420. {
  1421.  
  1422.     int i,j,k;
  1423.     int cislo;
  1424.  
  1425.     printf("Zadej i pro delitelna 7, j pro delitelna 9, k pro delitelna 13\n");
  1426.     scanf("%d");
  1427.  
  1428.     {
  1429.     for(i = 0; i <=1000; i++)
  1430.     if(i % 7 == 0 )
  1431.     printf("%d\n", i);
  1432.     }
  1433.     {
  1434.  
  1435.  
  1436.     for(j = 0; j <=1000; j++)
  1437.     if(j % 9 == 0 )
  1438.     printf("%d\n", j);
  1439.     }
  1440.     {
  1441.  
  1442.     for(k = 0; k <=1000; k++)
  1443.     if(k % 13 == 0 )
  1444.     printf("%d\n", k);
  1445.     }
  1446. }
  1447. FIBONACCI: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  1448. A: #include<stdio.h>
  1449. int main()
  1450. {
  1451.     int count, first_term = 0, second_term = 1, next_term, i;
  1452.  
  1453.     //Ask user to input number of terms
  1454.     printf("Enter the number of terms:\n");
  1455.     scanf("%d",&count);
  1456.  
  1457.     printf("First %d terms of Fibonacci series:\n",count);
  1458.     for ( i = 0 ; i < count ; i++ )
  1459.     {
  1460.        if ( i <= 1 )
  1461.           next_term = i;
  1462.        else
  1463.        {
  1464.           next_term = first_term + second_term;
  1465.           first_term = second_term;
  1466.           second_term = next_term;
  1467.        }
  1468.        printf("%d\n",next_term);
  1469.     }
  1470.  
  1471.     return 0;
  1472. }
  1473. POSITION IN ARRAY : XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  1474. int largestPos(int array[], int size, int index) {
  1475.  
  1476. int k, maxVal = 0;
  1477.  
  1478. printf("Enter a starting index: ");
  1479. scanf("%d", &index);
  1480.  
  1481. for (k = index; k < size; k++){
  1482.     if (maxVal < array[k]){
  1483.         maxVal = array[k];
  1484.     }
  1485. }
  1486. printf("The maximum value is %d at position %d \n", maxVal, array[maxVal]);
  1487.  
  1488. return 0;
  1489. }
  1490. LENGTH OF STRING : XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  1491. #include <stdio.h>
  1492. int main()
  1493. {
  1494.     char s[1000];
  1495.     int i;
  1496.  
  1497.     printf("Enter a string: ");
  1498.     scanf("%s", s);
  1499.  
  1500.     for(i = 0; s[i] != '\0'; ++i);
  1501.  
  1502.     printf("Length of string: %d", i);
  1503.     return 0;
  1504. }
  1505. Output
  1506.  
  1507. Enter a string: Programiz
  1508. Length of string: 9
  1509.  
  1510. MAXIMUM NUMBER + ITS ARRAY: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  1511. #include <stdio.h>
  1512.  
  1513. int main()
  1514. {
  1515.   int array[100], maximum, size, c, location = 1;
  1516.  
  1517.   printf("Enter the number of elements in array\n");
  1518.   scanf("%d", &size);
  1519.  
  1520.   printf("Enter %d integers\n", size);
  1521.  
  1522.   for (c = 0; c < size; c++)
  1523.     scanf("%d", &array[c]);
  1524.  
  1525.   maximum = array[0];
  1526.  
  1527.   for (c = 1; c < size; c++)
  1528.   {
  1529.     if (array[c] > maximum)
  1530.     {
  1531.        maximum  = array[c];
  1532.        location = c+1;
  1533.     }
  1534.   }
  1535.  
  1536.   printf("Maximum element is present at location %d and it's value is %d.\n", location, maximum);
  1537.   return 0;
  1538. }
  1539. If the maximum element occurs, two or more times in array then index at which it occurs first is printed or maximum value at the smallest index. You can easily modify this code this code to print the largest index at which maximum occurs. You can also store all indices at which maximum occur in an array.
  1540.  
  1541. ARRAY SORTING : XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  1542. #include <stdio.h>              //including stdio.h for printf and other functions
  1543.  
  1544.  
  1545. int main()                        //default function for call
  1546. {
  1547.     int a[100],n,i,j;
  1548.     printf("Array size: ");
  1549.         scanf("%d",&n);
  1550.         printf("Elements: ");
  1551.        
  1552.       for(i=0;i<n;i++)
  1553.     {
  1554.         scanf("%d",&a[i]);
  1555.     }
  1556.     for (int i = 0; i < n; i++)                     //Loop for ascending ordering
  1557.     {
  1558.         for (int j = 0; j < n; j++)             //Loop for comparing other values
  1559.         {
  1560.             if (a[j] > a[i])                //Comparing other array elements
  1561.             {
  1562.                 int tmp = a[i];         //Using temporary variable for storing last value
  1563.                 a[i] = a[j];            //replacing value
  1564.                 a[j] = tmp;             //storing last value
  1565.             }  
  1566.         }
  1567.     }
  1568.     printf("\n\nAscending : ");                     //Printing message
  1569.     for (int i = 0; i < n; i++)                     //Loop for printing array data after sorting
  1570.     {
  1571.         printf(" %d ", a[i]);
  1572.     }
  1573.     for (int i = 0; i < n; i++)                     //Loop for descending ordering
  1574.     {
  1575.         for (int j = 0; j < n; j++)             //Loop for comparing other values
  1576.         {
  1577.             if (a[j] < a[i])                //Comparing other array elements
  1578.             {
  1579.                 int tmp = a[i];         //Using temporary variable for storing last value
  1580.                 a[i] = a[j];            //replacing value
  1581.                 a[j] = tmp;             //storing last value
  1582.             }
  1583.         }
  1584.     }
  1585.     printf("\n\nDescending : ");                    //Printing message
  1586.     for (int i = 0; i < n; i++)                     //Loop for printing array data after sorting
  1587.     {
  1588.         printf(" %d ", a[i]);                   //Printing data
  1589.     }
  1590.  
  1591.     return 0;                                       //returning 0 status to system
  1592. }
  1593.  
  1594. //Ouput
  1595. /*
  1596.  
  1597. Array size: 10
  1598.  
  1599. Elements :  3  4  7  6  5  1  2  8  10  9
  1600.  
  1601. Ascending :  1  2  3  4  5  6  7  8  9  10
  1602.  
  1603. Descending :  10  9  8  7  6  5  4  3  2  1
  1604. */
  1605. CHECKNE CI JE TROJUHOLNIK: #include<stdio.h>
  1606. int main()
  1607. {
  1608. int a,b,c,x,y,z;
  1609. printf("Enter the three numbers:");
  1610. scanf("%d%d%d",&a,&b,&c);
  1611. x=a+b;
  1612. y=b+c;
  1613. z=a+c;
  1614. if(x>c)
  1615. {
  1616. if(y>a)
  1617. {
  1618. if(z>b)
  1619. {
  1620. printf(" You've got a valid triangle !!!");
  1621. }
  1622. else
  1623. printf("Not a valid triangle...");
  1624. }
  1625. else
  1626. printf("Not a valid triangle...");
  1627. }
  1628. else
  1629. printf("Not a valid triangle...");
  1630. return 0;
  1631. }
  1632. POSITION OF ARRAY: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  1633. #include <stdio.h>
  1634.  
  1635. int main()
  1636. {
  1637.    int array[100], position, c, n, value;
  1638.  
  1639.    printf("Enter number of elements in array\n");
  1640.    scanf("%d", &n);
  1641.  
  1642.    printf("Enter %d elements\n", n);
  1643.  
  1644.    for (c = 0; c < n; c++)
  1645.       scanf("%d", &array[c]);
  1646.  
  1647.    printf("Enter the location where you wish to insert an element\n");
  1648.    scanf("%d", &position);
  1649.  
  1650.    printf("Enter the value to insert\n");
  1651.    scanf("%d", &value);
  1652.  
  1653.    for (c = n - 1; c >= position - 1; c--)
  1654.       array[c+1] = array[c];
  1655.  
  1656.    array[position-1] = value;
  1657.  
  1658.    printf("Resultant array is\n");
  1659.  
  1660.    for (c = 0; c <= n; c++)
  1661.       printf("%d\n", array[c]);
  1662.  
  1663.    return 0;
  1664. }
  1665. NUMBER OF DIGITS: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  1666. #include <stdio.h>
  1667. int main()
  1668. {
  1669.     long long n;
  1670.     int count = 0;
  1671.  
  1672.     printf("Enter an integer: ");
  1673.     scanf("%lld", &n);
  1674.  
  1675.     while(n != 0)
  1676.     {
  1677.         // n = n/10
  1678.         n /= 10;
  1679.         ++count;
  1680.     }
  1681.  
  1682.     printf("Number of digits: %d", count);
  1683. }
  1684. NASOBKY: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  1685. #include <stdio.h>
  1686. int main()
  1687. {
  1688.     int number, i;
  1689.  
  1690.     printf("Enter a positive integer: ");
  1691.     scanf("%d",&number);
  1692.  
  1693.     printf("Factors of %d are: ", number);
  1694.     for(i=1; i <= number; ++i)
  1695.     {
  1696.         if (number%i == 0)
  1697.         {
  1698.             printf("%d ",i);
  1699.         }
  1700.     }
  1701.  
  1702.     return 0;
  1703. }
  1704. COUNTING SYMBOLS: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  1705. #include <stdio.h>
  1706.  
  1707. int main()
  1708. {
  1709.     char line[150];
  1710.     int i, vowels, consonants, digits, spaces;
  1711.  
  1712.     vowels =  consonants = digits = spaces = 0;
  1713.  
  1714.     printf("Enter a line of string: ");
  1715.     scanf("%[^\n]", line);
  1716.  
  1717.     for(i=0; line[i]!='\0'; ++i)
  1718.     {
  1719.         if(line[i]=='a' || line[i]=='e' || line[i]=='i' ||
  1720.            line[i]=='o' || line[i]=='u' || line[i]=='A' ||
  1721.            line[i]=='E' || line[i]=='I' || line[i]=='O' ||
  1722.            line[i]=='U')
  1723.         {
  1724.             ++vowels;
  1725.         }
  1726.         else if((line[i]>='a'&& line[i]<='z') || (line[i]>='A'&& line[i]<='Z'))
  1727.         {
  1728.             ++consonants;
  1729.         }
  1730.         else if(line[i]>='0' && line[i]<='9')
  1731.         {
  1732.             ++digits;
  1733.         }
  1734.         else if (line[i]==' ')
  1735.         {
  1736.             ++spaces;
  1737.         }
  1738.     }
  1739.  
  1740.     printf("Vowels: %d",vowels);
  1741.     printf("\nConsonants: %d",consonants);
  1742.     printf("\nDigits: %d",digits);
  1743.     printf("\nWhite spaces: %d", spaces);
  1744.  
  1745.     return 0;
  1746. }
  1747. MIDDLE OF ARRAY: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  1748. #include <stdio.h>
  1749.  
  1750. #define SIZE(x) (sizeof x / sizeof x[0])
  1751.  
  1752. int main(void) {
  1753.     int array1[] = {2,5,7,23,1,8,3,8,2};
  1754.     int array2[] = {2,6,9,231,62,3};
  1755.  
  1756.     printf("First midpoint = %d\n", array1[SIZE(array1)/2]);
  1757.     printf("Second midpoint = %d\n", array2[SIZE(array2)/2]);
  1758.  
  1759.     return 0;
  1760. }
  1761. CIFERNY SUCET: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  1762. #include <stdio.h>
  1763.  
  1764. int main()
  1765. {
  1766.    int n, t, sum = 0, remainder;
  1767.  
  1768.    printf("Enter an integer\n");
  1769.    scanf("%d", &n);
  1770.  
  1771.    t = n;
  1772.  
  1773.    while (t != 0)
  1774.    {
  1775.       remainder = t % 10;
  1776.       sum       = sum + remainder;
  1777.       t         = t / 10;
  1778.    }
  1779.  
  1780.    printf("Sum of digits of %d = %d\n", n, sum);
  1781.  
  1782.    return 0;
  1783. }
  1784. B: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  1785. # include<stdio.h>
  1786.  
  1787. /* Function to get sum of digits */
  1788. int getSum(int n)
  1789. {  
  1790.    int sum = 0;
  1791.    while (n != 0)
  1792.    {
  1793.        sum = sum + n % 10;
  1794.        n = n/10;
  1795.    }
  1796.    return sum;
  1797. }
  1798.  
  1799. int main()
  1800. {
  1801.   int n = 687;
  1802.   printf(" %d ", getSum(n));
  1803.   return 0;
  1804. }
  1805.  
  1806. PS1 : XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  1807. A: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  1808. #include <karel.h>
  1809. void jumpOver();
  1810. void turnRight();
  1811. void jumpBack();
  1812.  
  1813.     int main()
  1814.     {
  1815.     setStepDelay(200)
  1816.         turnOn("task_1.kw");
  1817.         putBeeper();
  1818.  
  1819.     if(frontIsClear())
  1820.     {
  1821.         movek();
  1822.     }
  1823.     else
  1824.     {
  1825.         turnLeft();
  1826.         movek();
  1827.         turnRight();
  1828.     }
  1829.     while(noBeepersPresent())
  1830.     {
  1831.         while(frontIsClear())
  1832.         {
  1833.             movek();
  1834.         }
  1835.         if(frontIsBlocked()&& noBeepersPresent() )
  1836.         {
  1837.          jumpOver();
  1838.         }
  1839.     }
  1840.     pickBeeper();
  1841.     turnLeft();
  1842.     turnLeft();
  1843.    
  1844.     while(noBeepersPresent())
  1845.     {
  1846.         while(frontIsClear())
  1847.         {
  1848.             if(beepersPresent())
  1849.             {
  1850.            
  1851.                 break;
  1852.             }
  1853.             movek();
  1854.         }
  1855.         if(beepersPresent())
  1856.         {
  1857.             break;
  1858.         }
  1859.         if(frontIsBlocked())
  1860.         {
  1861.             jumpBack();
  1862.         }
  1863.     }
  1864.     pickBeeper();
  1865.     turnOff();
  1866.         }
  1867.  
  1868.     void turnRight()
  1869.     {
  1870.         loop(3)
  1871.     {
  1872.         turnLeft();
  1873.     }
  1874.     }
  1875.         void jumpOver()
  1876.     {
  1877.     turnLeft();
  1878.     while(rightIsBlocked())
  1879.     {
  1880.         movek();
  1881.     }
  1882.     turnRight();
  1883.     movek();
  1884.     while(rightIsBlocked())
  1885.     {
  1886.         movek();
  1887.     }
  1888.     turnRight();
  1889.     while(frontIsClear())
  1890.     {
  1891.         movek();
  1892.     }
  1893.     turnLeft();
  1894.     }  
  1895.     void jumpBack()
  1896.     {
  1897.     turnRight();
  1898.     while(leftIsBlocked())
  1899.     {
  1900.     movek();
  1901.     }
  1902.     turnLeft();
  1903.     movek();
  1904.     while(leftIsBlocked())
  1905.     {
  1906.     movek();
  1907.     }
  1908.     turnLeft();
  1909.     while(frontIsClear())
  1910.     {
  1911.     movek();
  1912.     }
  1913.     turnRight();
  1914.  
  1915.     }
  1916.  
  1917. B: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  1918.  
  1919. #include <karel.h>
  1920. //ahojee
  1921.     void turnRight();  
  1922.     void turnAround();
  1923.     void faceWest();
  1924.     void faceEast();
  1925.     void findStart();
  1926.         void buildRoof();
  1927.     void skopiruj();
  1928.         void skopiruj1();
  1929.  
  1930.     int main()
  1931.         {
  1932.     setStepDelay(5);
  1933.         turnOn("task_2.kw");
  1934.     findStart();
  1935.  
  1936.     putBeeper();
  1937.    
  1938.        while(frontIsClear())
  1939.     {
  1940.     movek();   
  1941.     }  
  1942.     if(frontIsBlocked())
  1943.     {
  1944.         putBeeper();
  1945.     }
  1946.  
  1947.     buildRoof();
  1948.     setStepDelay(5);
  1949.       if(facingWest())
  1950.       {
  1951.     turnRight();
  1952.     movek();
  1953.     turnRight();
  1954.     movek();
  1955.     putBeeper();
  1956.     turnRight();
  1957.     movek();
  1958.     turnRight();
  1959.     movek();
  1960.     turnAround();  
  1961.       }
  1962.       else if (facingEast())
  1963.       {
  1964.           turnLeft();
  1965.           movek();
  1966.           turnLeft();
  1967.           movek();
  1968.         putBeeper();
  1969.     turnLeft();
  1970.     movek();
  1971.     turnRight();
  1972.     movek();
  1973.     turnAround();  
  1974.  
  1975.       }  
  1976.       if(rightIsClear())
  1977.       {
  1978.          
  1979.      
  1980.         skopiruj();
  1981.         movek();
  1982.     movek();
  1983.     turnAround();
  1984.     skopiruj1();
  1985.       }
  1986.         faceEast();
  1987.     setStepDelay(10);
  1988.         movek();
  1989.     if(frontIsBlocked())
  1990.     {
  1991.         faceWest();
  1992.         while(frontIsClear())
  1993.         {setStepDelay(5);
  1994.             movek();}
  1995.             if(frontIsBlocked())
  1996.             {
  1997.             turnRight();   
  1998.             }
  1999.         while(frontIsClear())
  2000.         {
  2001.         setStepDelay(5);   
  2002.         movek();   
  2003.        
  2004.         if(frontIsBlocked() )
  2005.         {
  2006.         turnRight();
  2007.         turnOff();
  2008.            
  2009.         }  
  2010.         }
  2011.        
  2012.     }
  2013.     else
  2014.  
  2015.     movek();
  2016.     if(noBeepersPresent())
  2017.         {
  2018.         setStepDelay(10);
  2019.         turnAround();
  2020.         movek();
  2021.         turnLeft();
  2022.         movek();
  2023.         faceWest();
  2024.         }
  2025.     while(frontIsClear())
  2026.     {
  2027.         while(facingWest())
  2028.         {
  2029.         setStepDelay(10);  
  2030.         turnLeft();
  2031.         skopiruj();
  2032.         turnRight();
  2033.         movek();
  2034.         movek();
  2035.         turnLeft();
  2036.         skopiruj1();
  2037.         faceWest();
  2038.        
  2039.         movek();
  2040.         if(frontIsBlocked())
  2041.             break;
  2042.         movek();
  2043.         if(noBeepersPresent())
  2044.         {
  2045.         turnAround();
  2046.         movek();
  2047.         turnRight();
  2048.         movek();
  2049.         faceEast();
  2050.         break
  2051.         }
  2052.         else
  2053.         {
  2054.         turnAround();
  2055.         loop(2)
  2056.         {
  2057.         movek();
  2058.         }
  2059.         turnAround();
  2060.         }
  2061.        
  2062.         }
  2063.         while(facingEast())
  2064.         {
  2065.         //  setStepDelay(1000);
  2066.         turnRight();
  2067.         skopiruj1();
  2068.         turnLeft();
  2069.         movek();
  2070.         movek();
  2071.         turnRight();
  2072.         skopiruj();
  2073.         faceEast();
  2074.        
  2075.        
  2076.             movek();
  2077.             if(frontIsBlocked())
  2078.             {
  2079.             //  setStepDelay(1000);
  2080.             break
  2081.             }
  2082.                 movek();
  2083.         if(noBeepersPresent())
  2084.         {
  2085.         turnAround();
  2086.         movek();
  2087.         turnLeft();
  2088.         movek();
  2089.         faceWest();
  2090.         break
  2091.         }
  2092.         else
  2093.         {
  2094.         turnAround();
  2095.         loop(2)
  2096.         {
  2097.         movek();   
  2098.         }  
  2099.         turnAround();
  2100.         }  
  2101.         }
  2102.  
  2103.     }  
  2104.  
  2105. /*  while(facingEast())
  2106.     {
  2107.         if(noBeepersPresent())
  2108.         {
  2109.         turnAround();
  2110.         movek();
  2111.         turnLeft();
  2112.         movek();
  2113.         skopiruj();
  2114.         turnRight();
  2115.         movek();
  2116.         movek();
  2117.         turnLeft();
  2118.         skopiruj1();
  2119.         faceEast();
  2120.         }
  2121.  
  2122.     else
  2123.  
  2124.     {
  2125.  
  2126.     break;
  2127.  
  2128.     }
  2129.  
  2130.  
  2131.     }
  2132. */
  2133.  
  2134.     faceWest();
  2135.      
  2136.     while(frontIsClear())
  2137.     {
  2138.     movek();}
  2139.     if(frontIsBlocked())
  2140.     {
  2141.     turnRight();   
  2142.     }  
  2143.     while(frontIsClear())
  2144.     {
  2145.     movek();
  2146.     if(frontIsBlocked())
  2147.     {
  2148.     turnRight();
  2149.     break
  2150.     }  
  2151.     }
  2152.        
  2153.     turnOff();
  2154.         }
  2155.     void turnRight()
  2156.     {
  2157.         loop(3)
  2158.         {
  2159. //  setStepDelay(10);
  2160.         turnLeft();
  2161.         }
  2162.     }
  2163.     void turnAround()
  2164.     {
  2165.         loop(2)
  2166.         {
  2167.         turnLeft();
  2168.         }  
  2169.     }
  2170.     void faceWest()
  2171.     {
  2172.     if(facingNorth())
  2173.     {
  2174.         turnLeft();
  2175.     }  
  2176.     else if(facingEast())
  2177.     {
  2178.     turnAround();
  2179.     }
  2180.     else if(facingSouth())
  2181.     {
  2182.         turnRight();
  2183.     }
  2184.     }
  2185.     void faceEast()
  2186.     {
  2187.         if(facingNorth())
  2188.         {
  2189.         turnLeft();
  2190.         }  
  2191.         else if(facingWest())
  2192.         {
  2193.         turnAround();  
  2194.         }  
  2195.         else if(facingSouth())
  2196.         {
  2197.         turnLeft();
  2198.         }
  2199.     }
  2200.    
  2201.     void findStart()
  2202.     {
  2203.     faceWest();
  2204.     while(frontIsClear())
  2205.     {
  2206.     movek();   
  2207.     }
  2208.     if(frontIsBlocked())
  2209.     {
  2210.     turnLeft();
  2211.     }
  2212.     while(rightIsBlocked()&& frontIsClear() )
  2213.     {
  2214.     movek();   
  2215.     }
  2216.     turnLeft();
  2217.     }
  2218.    
  2219.     void buildRoof()
  2220.     {
  2221.     while(1)
  2222.     {  
  2223.     if(facingEast())
  2224.     {  
  2225.     turnLeft();
  2226.     movek();
  2227.     turnLeft();
  2228.     movek();
  2229.         turnAround();
  2230.     movek();
  2231.     turnRight();
  2232.     movek();
  2233.     turnRight();
  2234.     loop(2)
  2235.     {
  2236.         movek();
  2237.     }
  2238.     if(beepersPresent())
  2239.     {
  2240.     break
  2241.     }
  2242.     else
  2243.     {
  2244.     turnAround();
  2245.     movek();
  2246.     movek();
  2247.     turnLeft();
  2248.     movek();
  2249.     turnLeft();
  2250.     movek();
  2251.     if(noBeepersPresent())
  2252.     {
  2253.     putBeeper();   
  2254.     }  
  2255.     }
  2256.     while(frontIsClear())
  2257.     {
  2258.     movek();
  2259.     turnLeft();
  2260.     movek();
  2261.     if(beepersPresent())
  2262.     {
  2263.    
  2264.     turnAround();
  2265.     movek();
  2266.     turnRight();
  2267.     movek();
  2268.     putBeeper();
  2269.     turnAround();
  2270.         break;     
  2271.     }
  2272.     else
  2273.     {
  2274.     turnAround();
  2275.     movek();
  2276.     turnLeft();
  2277.     }  
  2278.     }
  2279.  
  2280.         }
  2281.     if (facingWest())
  2282.     {
  2283. //  setStepDelay(10);
  2284.     turnRight();
  2285.     movek();
  2286.     turnRight();
  2287.     movek();
  2288.     turnAround();
  2289.     movek();
  2290.     turnLeft();
  2291.     movek();
  2292.     turnLeft();
  2293.     loop(2)
  2294.     {
  2295.     movek();   
  2296.     }
  2297.     if(beepersPresent())
  2298.     {
  2299.         break;
  2300.     }
  2301.     else
  2302.     {
  2303.     turnAround();
  2304.     movek();
  2305.     movek();
  2306.     turnRight();
  2307.     movek();
  2308.     turnRight();
  2309.     movek();
  2310.     if(noBeepersPresent())
  2311.     {
  2312.         putBeeper();
  2313.     }
  2314.     }  
  2315.     while(frontIsClear())
  2316.     {
  2317.     movek();
  2318.     turnRight();
  2319.     movek();
  2320.     if(beepersPresent())
  2321.     {
  2322.     turnAround();
  2323.     movek();
  2324.     turnLeft();
  2325.     movek();
  2326.     putBeeper();
  2327.     turnAround();
  2328.     break;
  2329.     }
  2330.     else
  2331.     {
  2332.     turnAround();
  2333.     movek();
  2334.     turnRight();   
  2335.     }  
  2336.     }
  2337.         }
  2338.     }  
  2339.         }
  2340.    
  2341.     void skopiruj()
  2342.     {
  2343.     if(beepersPresent())
  2344.     {
  2345.     pickBeeper();
  2346.     skopiruj();
  2347.     movek();
  2348.     turnRight();
  2349.     movek();
  2350.     putBeeper();
  2351.     turnAround();
  2352.     movek();
  2353.     turnLeft();
  2354.     movek();
  2355.     putBeeper();
  2356.     turnAround();  
  2357.     }
  2358.        
  2359.     }
  2360.     void skopiruj1()
  2361.     {
  2362.     if(beepersPresent())
  2363.     {
  2364.     pickBeeper();
  2365.     skopiruj1();
  2366.     movek();
  2367.     turnLeft();
  2368.     movek();
  2369.     putBeeper();
  2370.     turnAround();
  2371.     movek();
  2372.     turnRight();
  2373.     movek();
  2374.     putBeeper();
  2375.     turnAround();
  2376.        
  2377.     }  
  2378.     }
  2379.  
  2380. PS2: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  2381.  
  2382. #include <karel.h>
  2383.     void faceWest();
  2384.     void faceEast();
  2385.     void faceSouth();
  2386.     void turnRight();
  2387.     void turnAround();
  2388.     void findStart();
  2389.     void collect();
  2390.         void najdi();
  2391.     void faceNorth();
  2392. //pespes
  2393.     int main()
  2394.     {
  2395.     turnOn("ps2.kw");
  2396.     setStepDelay(0);
  2397.     faceWest();
  2398.     findStart();
  2399.     collect();
  2400.     faceEast();
  2401.     najdi();   
  2402.    
  2403.        
  2404.  
  2405.     turnOff()
  2406.     }  
  2407.     void turnRight()
  2408.     {  
  2409.     loop(3)
  2410.     {
  2411.     turnLeft();
  2412.     }  
  2413.     }
  2414.     void faceNorth()
  2415.     {
  2416.     if (facingSouth())
  2417.     {
  2418.     turnAround();  
  2419.     }  
  2420.     else if(facingWest())
  2421.     {
  2422.     turnRight();   
  2423.     }
  2424.     else if(facingEast())
  2425.     {
  2426.     turnLeft();
  2427.     }  
  2428.  
  2429.     }
  2430.     void faceEast()
  2431.     {
  2432.     if(facingNorth())
  2433.     {
  2434.     turnRight();   
  2435.     }
  2436.     else if(facingWest())
  2437.     {
  2438.     turnAround();  
  2439.     }
  2440.     else if (facingSouth())
  2441.     {
  2442.     turnLeft();
  2443.     }  
  2444.     }
  2445.     void faceWest()
  2446.     {
  2447.     if(facingSouth())
  2448.     {
  2449.     turnRight();   
  2450.     }  
  2451.     else if (facingNorth())
  2452.     {
  2453.     turnLeft();
  2454.     }
  2455.     else if(facingEast())
  2456.     {
  2457.     turnAround();  
  2458.     }  
  2459.     }
  2460.     void turnAround()
  2461.     {
  2462.     loop(2)
  2463.     {
  2464.     turnLeft();
  2465.     }  
  2466.     }
  2467.     void faceSouth()
  2468.     {
  2469.     if(facingNorth())
  2470.     turnAround();
  2471.     else if(facingEast())
  2472.     turnRight();
  2473.     else if(facingWest())
  2474.     turnLeft();
  2475.     }
  2476.     void findStart()
  2477.     {  
  2478.         setStepDelay(1);
  2479.     while(noBeepersPresent())
  2480.     {  
  2481.     while(frontIsClear())
  2482.     {
  2483.         movek();
  2484.         if(beepersPresent())
  2485.         {
  2486.             if(facingWest())
  2487.             {
  2488.             faceNorth();   
  2489.             }
  2490.             else if (facingEast())
  2491.             {
  2492.             faceSouth();   
  2493.             }
  2494.             else if (facingNorth() )
  2495.             {
  2496.             faceWest();
  2497.             }
  2498.             else if (facingSouth())
  2499.             {
  2500.             faceWest();
  2501.             }  
  2502.             break;
  2503.  
  2504.         }
  2505.         while(frontIsBlocked())
  2506.         {
  2507.             turnRight();
  2508.         }
  2509.         if(leftIsClear())
  2510.         {
  2511.             setStepDelay(100);
  2512.             turnLeft();
  2513.             movek();
  2514.            
  2515.             if(beepersPresent())
  2516.             {
  2517.                 if(frontIsClear())
  2518.                 {   movek();
  2519.                 if(frontIsBlocked())
  2520.                 {
  2521.                     faceWest();
  2522.                     while(frontIsClear())
  2523.                     {
  2524.                         movek();
  2525.                         if(frontIsBlocked()&&facingWest()&&rightIsBlocked() )
  2526.                         {
  2527.                             loop(45)
  2528.                             {
  2529.                             putBeeper();
  2530.                             }
  2531.                             faceNorth();
  2532.                             break;
  2533.                         }
  2534.  
  2535.                     }
  2536.                 }  
  2537.                 }
  2538.             else if(facingWest())
  2539.             {
  2540.             faceNorth();   
  2541.             }
  2542.             else if (facingEast())
  2543.             {
  2544.             faceSouth();   
  2545.             }
  2546.             else if (facingNorth() )
  2547.             {
  2548.             faceWest();
  2549.             }
  2550.             else if (facingSouth())
  2551.             {
  2552.             faceWest();
  2553.             }  
  2554.             break;
  2555.             }
  2556.             else
  2557.             {
  2558.             turnAround();
  2559.             movek();
  2560.             turnLeft();
  2561.             }  
  2562.  
  2563.         }
  2564.        
  2565.     }  
  2566.     }
  2567.     while(frontIsClear())
  2568.     {
  2569.    
  2570.     setStepDelay(10);
  2571.         movek();
  2572.         if(frontIsBlocked()&&facingWest()&&rightIsBlocked())
  2573.         {
  2574.             faceNorth();
  2575.         }
  2576.        
  2577.          if(beepersPresent()&&frontIsClear())
  2578.         {
  2579.             movek();
  2580.         }
  2581.         if(frontIsBlocked()&&leftIsBlocked()&&facingNorth() )
  2582.         {
  2583.             loop(45)
  2584.             {
  2585.                 putBeeper();
  2586.             }
  2587.             faceEast();
  2588.             break;
  2589.         }
  2590.         else if (frontIsBlocked()&&rightIsBlocked()&&facingWest())
  2591.         {
  2592.             loop(45)
  2593.             {
  2594.                 putBeeper();
  2595.             }
  2596.             faceEast();
  2597.             break;
  2598.         }
  2599.         else if(frontIsBlocked())
  2600.         {
  2601.             turnRight();
  2602.         }
  2603.     }      
  2604.     }  
  2605.     void collect()
  2606.     {  
  2607.     while(1)
  2608.     {
  2609.         faceEast();
  2610.         setStepDelay(1);
  2611.         if(frontIsClear())
  2612.         {
  2613.             setStepDelay(1);
  2614.             movek();
  2615.             if(beepersPresent())
  2616.             {
  2617.                 pickBeeper();
  2618.                         if(noBeepersPresent())
  2619.                         {
  2620.                         putBeeper();
  2621.                         turnRight();
  2622.                         movek();
  2623.                         putBeeper();
  2624.                         turnAround();
  2625.                         movek();
  2626.                         turnRight();
  2627.                         }
  2628.             }
  2629.             if(rightIsClear()&&noBeepersPresent()&&facingEast())
  2630.             {
  2631.                 turnRight();
  2632.                 while(frontIsClear())
  2633.                 {
  2634.                 movek();
  2635.                 }
  2636.  
  2637.                 if(beepersPresent())
  2638.                 {
  2639.                     pickBeeper();  
  2640.                 }
  2641.                 else
  2642.                 {
  2643.                 turnLeft();
  2644.                 }
  2645.                 while(frontIsClear())
  2646.                 {
  2647.                     movek();
  2648.                     if(beepersPresent())
  2649.                     {
  2650.                         pickBeeper();
  2651.                         if(noBeepersPresent())
  2652.                         {
  2653.                         putBeeper();
  2654.                         turnRight();
  2655.                         movek();
  2656.                         putBeeper();
  2657.                         turnAround();
  2658.                         movek();
  2659.                         turnRight();
  2660.                         }
  2661.                     }
  2662.                 }
  2663.                 while(frontIsBlocked())
  2664.                 {
  2665.                     turnLeft();
  2666.                 }
  2667.                 while(frontIsClear())
  2668.                 {
  2669.                     movek();
  2670.                     if(frontIsBlocked())
  2671.                     {
  2672.                         turnRight();
  2673.                         break;
  2674.                     }
  2675.                 }              
  2676.             }
  2677.            
  2678.         }
  2679.        
  2680.     while(frontIsClear())
  2681.     {
  2682.         setStepDelay(1);
  2683.     movek();
  2684.  
  2685.     if(beepersPresent()&&facingSouth()&&leftIsClear()&&rightIsBlocked() )
  2686.     {
  2687.     pickBeeper();
  2688.     if(noBeepersPresent())
  2689.     {
  2690.     putBeeper();
  2691.     movek();
  2692.     putBeeper();
  2693.     turnAround();
  2694.     movek();
  2695.         turnRight();
  2696.     }
  2697.     else
  2698.     turnLeft();
  2699.     }  
  2700.     if(frontIsClear()&&rightIsClear()&&facingNorth() )
  2701.         {
  2702.         while(frontIsClear()&&noBeepersPresent())
  2703.                 {
  2704.                     setStepDelay(1);
  2705.                 movek();
  2706.                 if(frontIsBlocked()&&beepersPresent() )
  2707.                 {
  2708.                 pickBeeper();
  2709.                 if(noBeepersPresent()&&frontIsBlocked())
  2710.                 {
  2711.                     faceNorth();
  2712.                     break;
  2713.                    
  2714.                 }
  2715.                 else
  2716.                 {  
  2717.                 //  turnAround();
  2718.             //  movek();
  2719.             //  turnAround();
  2720.                 faceEast();
  2721.                 break;
  2722.                 }
  2723.                 }
  2724.                 }
  2725.         if(frontIsBlocked()&&leftIsBlocked()&&facingNorth()&&noBeepersPresent() )
  2726.         {
  2727.             break;
  2728.         }
  2729.         }
  2730.     if(rightIsClear())
  2731.     {
  2732.     if(beepersPresent()&&frontIsClear() )
  2733.     {
  2734.         pickBeeper();
  2735.         if(noBeepersPresent())
  2736.         {
  2737.             putBeeper();
  2738.             turnRight();
  2739.             movek();
  2740.             putBeeper();
  2741.             turnAround();
  2742.             movek();
  2743.             turnRight();
  2744.         }
  2745.     }
  2746.     else if (noBeepersPresent() )
  2747.     {
  2748.         turnRight();
  2749.     }  
  2750.     }
  2751.    
  2752.  
  2753.     while(frontIsBlocked())
  2754.     {
  2755.         if(frontIsBlocked()&&leftIsBlocked()&&facingNorth()&&beepersPresent() )
  2756.         {
  2757.             pickBeeper();
  2758.             break;
  2759.         }
  2760.         else
  2761.         turnLeft();
  2762.     }
  2763.     }  
  2764.     if(frontIsBlocked()&&leftIsBlocked()&&facingNorth()&&noBeepersPresent())
  2765.     {
  2766.        
  2767.         break;
  2768.     }
  2769.     }
  2770.  
  2771.     }
  2772.     void najdi()
  2773.     {
  2774.         while(1)
  2775.     {
  2776.         setStepDelay(1);
  2777.         if(frontIsClear())
  2778.         {
  2779.             movek();
  2780.  
  2781.             if(rightIsClear()&&noBeepersPresent()&&facingEast())
  2782.             {
  2783.                 turnRight();
  2784.                 while(frontIsClear())
  2785.                 {
  2786.                 movek();
  2787.                 }
  2788.                 if(beepersPresent())
  2789.                 {
  2790.                     turnRight();
  2791.                     movek();
  2792.                     pickBeeper();
  2793.                     if(noBeepersPresent())
  2794.                     {
  2795.                         turnAround();
  2796.                         break;
  2797.                     }
  2798.                     turnAround();
  2799.                     movek();
  2800.                     turnRight();   
  2801.                 }
  2802.                 else
  2803.                 {
  2804.                 turnLeft();
  2805.                 }
  2806.                 while(frontIsClear())
  2807.                 {
  2808.                     movek();
  2809.                 }
  2810.                 if(frontIsBlocked())
  2811.                 {
  2812.                     turnLeft();
  2813.                 }
  2814.                 while(frontIsClear())
  2815.                 {
  2816.                     movek();
  2817.                     if(frontIsBlocked())
  2818.                     {
  2819.                         turnRight();
  2820.                         break;
  2821.                     }
  2822.                 }              
  2823.             }
  2824.            
  2825.         }
  2826.        
  2827.     while(frontIsClear())
  2828.     {
  2829.         setStepDelay(1);
  2830.     movek();
  2831.    
  2832.  
  2833.         if(beepersPresent()&&facingSouth()&&leftIsClear()&&rightIsBlocked() )
  2834.     {
  2835.     movek();
  2836.     pickBeeper();
  2837.     if(noBeepersPresent())
  2838.     {
  2839.     turnAround();
  2840.     break;
  2841.     }
  2842.     else
  2843.     {
  2844.     turnAround();
  2845.     movek();
  2846.     turnRight();
  2847.     }
  2848.     }
  2849.  
  2850.  
  2851.  
  2852.    
  2853.     if(rightIsClear())
  2854.     {
  2855.         if(beepersPresent()&&leftIsClear()&&facingNorth())
  2856.         {
  2857.            
  2858.         }
  2859.         else if(beepersPresent())
  2860.     {
  2861.         setStepDelay(1);
  2862.         turnRight();
  2863.         movek();
  2864.         pickBeeper();
  2865.         if(noBeepersPresent())
  2866.         {
  2867.             setStepDelay(1);
  2868.             turnAround();
  2869.             break;
  2870.         }
  2871.         else
  2872.         {
  2873.         turnAround();
  2874.         movek();
  2875.         turnRight();
  2876.         }
  2877.     }
  2878.     else if (noBeepersPresent() )
  2879.     {
  2880.         turnRight();
  2881.     }  
  2882.     }
  2883.  
  2884.     while(frontIsBlocked())
  2885.     {
  2886.  
  2887.         turnLeft();
  2888.     }
  2889.     }
  2890.     break
  2891.     }  
  2892.     }
  2893.    
  2894. PS3: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  2895.  
  2896. #include <karel.h>
  2897.    
  2898.     void turnRight();
  2899.     void faceWest();
  2900.     void turnAround();
  2901.     void findCorner();
  2902.     void goandput();
  2903.     void faceEast();
  2904.     void prehladaj();
  2905.     int pocetbeep();
  2906.     void faceNorth();
  2907.     void faceSouth();
  2908.  
  2909. int main()
  2910.     {
  2911.             turnOn("ps3.kw");
  2912.         setStepDelay(1);
  2913.         findCorner();
  2914.         goandput();
  2915.         if(frontIsBlocked()&&facingSouth() )
  2916.         {
  2917.             turnLeft();
  2918.             while(frontIsClear())
  2919.             {
  2920.             movek();
  2921.             if(frontIsBlocked()&&rightIsBlocked())
  2922.             {
  2923.                 turnOff();
  2924.             }
  2925.             }      
  2926.         }
  2927.         else
  2928.         turnOff();
  2929.        
  2930.            
  2931.         //caubuci
  2932.     }  
  2933.     void turnAround()
  2934.     {
  2935.         loop(2)
  2936.         {
  2937.             turnLeft();
  2938.         }
  2939.     }
  2940.     void turnRight()
  2941.     {
  2942.         loop(3)
  2943.         {
  2944.             turnLeft();
  2945.         }  
  2946.     }
  2947.     void faceEast()
  2948.     {
  2949.         if(facingNorth())
  2950.         {
  2951.             turnRight();   
  2952.         }
  2953.         else if(facingWest())
  2954.         {
  2955.             turnAround();
  2956.         }
  2957.         else if (facingSouth())
  2958.         {
  2959.             turnLeft();
  2960.         }  
  2961.     }
  2962.  
  2963.     void faceWest()
  2964.     {
  2965.         if(facingSouth())
  2966.         {
  2967.             turnRight();
  2968.         }
  2969.         else if (facingNorth())
  2970.         {
  2971.             turnLeft();
  2972.         }
  2973.         else if (facingEast())
  2974.         {
  2975.             turnAround();  
  2976.         }  
  2977.     }
  2978.     void faceNorth()
  2979.     {
  2980.         if(facingSouth())
  2981.         {
  2982.             turnAround();
  2983.         }
  2984.         else if(facingEast())
  2985.         {
  2986.             turnLeft();
  2987.         }
  2988.         else if (facingWest())
  2989.         {
  2990.             turnRight();
  2991.         }
  2992.     }
  2993.     void faceSouth()
  2994.     {
  2995.         if(facingNorth())
  2996.         {
  2997.             turnAround();
  2998.         }
  2999.         else if (facingEast())
  3000.         {
  3001.             turnRight();
  3002.         }
  3003.         else if (facingWest())
  3004.         {
  3005.             turnLeft();
  3006.         }  
  3007.     }
  3008.  
  3009.     void findCorner()
  3010.     {
  3011.         faceWest();
  3012.         if(frontIsBlocked())
  3013.         {
  3014.             turnRight();
  3015.         }
  3016.         while(frontIsClear())
  3017.         {
  3018.         movek();
  3019.  
  3020.         if(frontIsBlocked()&&leftIsBlocked()&&facingNorth())
  3021.         {
  3022.             break;
  3023.         }
  3024.             else if(frontIsBlocked()&&rightIsBlocked()&&facingWest() )
  3025.         {
  3026.             break;
  3027.         }
  3028.         else if(frontIsBlocked())
  3029.         {
  3030.             turnRight();
  3031.         }
  3032.         }
  3033.     }
  3034.  
  3035.     int pocetbeep()
  3036.     {
  3037.             int a=0;
  3038.             while(beepersPresent()&&frontIsClear() )
  3039.             {
  3040.                
  3041.             pickBeeper();
  3042.             a++;
  3043.  
  3044.             }  
  3045.             while(noBeepersPresent()&&frontIsClear())
  3046.             {
  3047.             loop(a)
  3048.             {
  3049.                 putBeeper();
  3050.             }
  3051.             if( a==3&&facingSouth())
  3052.             {
  3053.                 faceSouth();
  3054.             //  setStepDelay(100);
  3055.                 while(frontIsClear())
  3056.                 {
  3057.                     movek();
  3058.                     if(frontIsBlocked()&&rightIsClear() )
  3059.                     {
  3060.                         turnLeft();
  3061.                     }
  3062.                     else if (frontIsBlocked()&&rightIsBlocked())
  3063.                     {
  3064.                         break;
  3065.                     }  
  3066.                 }
  3067.                
  3068.  
  3069.                 turnOff();
  3070.             }  
  3071.             }
  3072.             return a;
  3073.     }
  3074.     void goandput()
  3075.     {
  3076.    
  3077.     int a=0;
  3078.     int riadok=8;
  3079.     faceEast();
  3080.     while(frontIsClear())
  3081.     {
  3082.  
  3083.                
  3084.             if(riadok==8 || riadok==6 || riadok==4 || riadok==2 )
  3085.         {
  3086.             faceEast();
  3087.         }
  3088.         else if (riadok==7 || riadok==5 || riadok==3 || riadok==1 )
  3089.         {
  3090.             faceWest();
  3091.         }  
  3092.         movek();
  3093.         if(beepersPresent() )
  3094.         {
  3095.         while(beepersPresent())
  3096.         {
  3097.             pickBeeper();
  3098.             a++;
  3099.         }
  3100.             while(noBeepersPresent())
  3101.             {
  3102.             loop(a)
  3103.             {
  3104.                 putBeeper();
  3105.             }
  3106.             if(a==2&&leftIsClear())
  3107.             {
  3108.                 prehladaj();   
  3109.             a=0;
  3110.             break;
  3111.             }
  3112.  
  3113.             }
  3114.          a=0;
  3115.         }
  3116.         if(frontIsBlocked()&&facingEast()&&rightIsClear() )
  3117.         {
  3118.             turnRight();
  3119.             movek();
  3120.             faceWest();
  3121.             riadok--;
  3122.         }
  3123.         else if(frontIsBlocked()&&facingWest() )
  3124.         {
  3125.             while(frontIsBlocked())
  3126.             {
  3127.             turnLeft();
  3128.             }
  3129.             movek();
  3130.             faceEast();
  3131.             riadok--;
  3132.         }
  3133.         else if(frontIsBlocked()&&rightIsBlocked())
  3134.         {
  3135.             faceEast();
  3136.             turnOff();
  3137.         }
  3138.            
  3139.     }
  3140.     }
  3141.     void prehladaj()
  3142.     {
  3143.         setStepDelay(1);
  3144.         int i=1;
  3145.         faceEast();
  3146.         if(frontIsClear())
  3147.         {
  3148.         movek();
  3149.         }
  3150.         while(beepersPresent())
  3151.         {
  3152.             if(pocetbeep()==2)
  3153.                 {
  3154.                 if(frontIsClear())
  3155.                 {  
  3156.                 movek();
  3157.                 i++;
  3158.                 }
  3159.                 else if(frontIsBlocked())
  3160.                 {
  3161.                 turnAround();
  3162.                 loop(i)
  3163.                 {
  3164.                     movek();
  3165.                 }  
  3166.                 break;
  3167.                 }  
  3168.                 }
  3169.            
  3170.             else if(pocetbeep()==1)
  3171.                 {
  3172.                 turnAround();
  3173.                     loop(i)
  3174.                     {
  3175.                     movek();
  3176.                     }
  3177.                     if(frontIsClear())
  3178.                     {
  3179.                     movek();
  3180.                     }
  3181.                     if(frontIsBlocked())
  3182.                     {
  3183.                     faceNorth();
  3184.                     break;
  3185.                     }  
  3186.                
  3187.                    
  3188.                    
  3189.                    
  3190.  
  3191.                 i=1;
  3192.     while(beepersPresent())
  3193.         {
  3194.             if (pocetbeep()==3)
  3195.             {  
  3196.                 turnAround();
  3197.                 loop(i)
  3198.                 {
  3199.                     movek();
  3200.                 }
  3201.                 break;
  3202.                    
  3203.             }
  3204.             else if(pocetbeep()==2)
  3205.                 {
  3206.                 if(frontIsClear())
  3207.                 {  
  3208.                 movek();
  3209.                 i++;
  3210.                 }
  3211.                 else if(frontIsBlocked())
  3212.                 {
  3213.  
  3214.                     turnAround();
  3215.                     loop(i)
  3216.                     {
  3217.                         movek();
  3218.                     }
  3219.                 break;
  3220.  
  3221.                 }
  3222.  
  3223.                
  3224.  
  3225.                 }
  3226.         //  else if(pocetbeep()==3)
  3227.         //  {
  3228.         //      turnAround();
  3229.         //      loop(i)
  3230.         //      {
  3231.         //          movek();
  3232.         //      }
  3233.         //  }
  3234.             else if(pocetbeep()==1)
  3235.                 {
  3236.                 //  setStepDelay(1000);
  3237.                 turnAround();
  3238.                     loop(i)
  3239.                     {
  3240.                     movek();
  3241.                     }
  3242.                 break
  3243.                 }
  3244.         }
  3245.                     if(noBeepersPresent())
  3246.                     {
  3247.                         loop(3)
  3248.                         {
  3249.                             putBeeper();
  3250.                         }
  3251.                         turnAround();
  3252.                         loop(i)
  3253.                         {
  3254.                             movek();
  3255.                         }
  3256.                     }
  3257.                     break;
  3258.                 }
  3259.             else if (pocetbeep()==3)
  3260.             {
  3261.                 turnAround();
  3262.                 loop(i)
  3263.                 {
  3264.                     movek();
  3265.                 }
  3266.  
  3267.                 break;
  3268.             }
  3269.        
  3270.        
  3271.         }
  3272.         if(noBeepersPresent())
  3273.         {
  3274.         //  i=0;
  3275.             turnAround();
  3276.             loop(i)
  3277.             {
  3278.             movek();
  3279.             }
  3280.             i=0;
  3281.             while(beepersPresent())
  3282.             {
  3283.                 movek();
  3284.                 i++;
  3285.                 if(noBeepersPresent()|| pocetbeep()==3)
  3286.                 {
  3287.                     turnAround();
  3288.                     loop(i)
  3289.                     {
  3290.                         movek();
  3291.                     }
  3292.                     break;
  3293.                 }
  3294.                 else if (pocetbeep()==1)
  3295.                 {
  3296.                     turnAround();
  3297.                     loop(i)
  3298.                     {
  3299.                         movek();
  3300.                     }
  3301.                     while(beepersPresent())
  3302.                     {
  3303.                         movek();
  3304.                     }  
  3305.                     loop(3)
  3306.                     {
  3307.                         putBeeper();
  3308.                     }
  3309.                     turnAround();
  3310.            
  3311.                     loop(i)
  3312.                     {
  3313.                         movek();
  3314.                     }
  3315.                     break;
  3316.                 }
  3317.                
  3318.             }
  3319.         }
  3320.             setStepDelay(1);
  3321.         faceNorth();
  3322.        
  3323.         if(frontIsClear())
  3324.         {  
  3325.         movek();
  3326.         }
  3327.  
  3328.         i=1;
  3329.         while(beepersPresent())
  3330.         {
  3331.         //  setStepDelay(2);
  3332.             if(pocetbeep()==2)
  3333.                 {
  3334.                    
  3335.                 if(frontIsClear()){
  3336.                 movek();
  3337.                 i++;
  3338.                 }
  3339.                 if(frontIsBlocked())
  3340.                 {
  3341.                     break;
  3342.                 }
  3343.                
  3344.                 }
  3345.         //  else if(noBeepersPresent() )
  3346.         //  {
  3347.         //      loop(3)
  3348.         //      {
  3349.         //          putBeeper();
  3350.         //      }  
  3351.         //      turnAround();
  3352.         //      movek();
  3353.         //      faceEast();
  3354.         //  }
  3355.             else if(pocetbeep()==1)
  3356.                 {
  3357.                 turnAround();
  3358.                     loop(i)
  3359.                     {
  3360.                     movek();
  3361.                     }
  3362.                 movek();
  3363.                 i=1;
  3364.                     while(beepersPresent())
  3365.         {
  3366.             if(pocetbeep()==2)
  3367.                 {
  3368.                 if(frontIsClear())
  3369.                 {  
  3370.                 movek();
  3371.                 i++;
  3372.                 }
  3373.                 }
  3374.             else if(pocetbeep()==1)
  3375.                 {
  3376.                 turnAround();
  3377.                     loop(i)
  3378.                     {
  3379.                     movek();
  3380.                     }
  3381.                 break
  3382.                 }
  3383.         }
  3384.                     if(noBeepersPresent())
  3385.                     {
  3386.                         loop(3)
  3387.                         {
  3388.                             putBeeper();
  3389.                         }
  3390.                         if(frontIsBlocked()&&facingSouth())
  3391.                         {
  3392.                             turnRight();
  3393.                             movek();
  3394.                             loop(3)
  3395.                             {
  3396.                             putBeeper();
  3397.                             }
  3398.                             faceEast();
  3399.                             while(frontIsClear())
  3400.                             {
  3401.                                 movek();
  3402.                                 if(frontIsBlocked())
  3403.                                 {
  3404.                                     turnOff();
  3405.                                 }
  3406.                             }
  3407.                         }
  3408.                         turnAround();
  3409.                         loop(i)
  3410.                         {
  3411.                             movek();
  3412.                         }
  3413.                     }
  3414.                     faceEast();
  3415.                     break;
  3416.                 }
  3417.             else if (pocetbeep()==3||noBeepersPresent())
  3418.             {
  3419.                 turnAround();
  3420.                 loop(i)
  3421.                 {
  3422.                     movek();
  3423.                 }
  3424.                 faceEast();
  3425.                 break;
  3426.             }
  3427.        
  3428.        
  3429.         }
  3430.         if(noBeepersPresent())
  3431.         {
  3432.            
  3433.             turnAround();
  3434.             loop(i)
  3435.             {
  3436.             movek();
  3437.             }
  3438.             i=0;
  3439.             while(beepersPresent())
  3440.             {
  3441.                 movek();
  3442.                 i++;
  3443.                 if(noBeepersPresent()|| pocetbeep()==3)
  3444.                 {
  3445.                     turnAround();
  3446.                     loop(i)
  3447.                     {
  3448.                         movek();
  3449.                     }
  3450.                     break;
  3451.                 }
  3452.                 else if (pocetbeep()==1)
  3453.                 {
  3454.                     turnAround();
  3455.                     loop(i)
  3456.                     {
  3457.                         movek();
  3458.                     }
  3459.                     while(beepersPresent())
  3460.                     {
  3461.                         movek();
  3462.                     }  
  3463.                     loop(3)
  3464.                     {
  3465.                         putBeeper();
  3466.                     }
  3467.                     turnAround();
  3468.                     movek();
  3469.                     break;
  3470.                 }
  3471.            
  3472.             }
  3473.  
  3474.  
  3475.        
  3476.         }
  3477.  
  3478.         if(leftIsClear())
  3479.         {
  3480.         setStepDelay(1);   
  3481.      faceNorth();
  3482.      if(frontIsClear()&&leftIsClear() )
  3483.      {
  3484.      movek();
  3485.      turnLeft();
  3486.      movek();
  3487.      }
  3488.      i=1;
  3489.      while(beepersPresent() )
  3490.      {
  3491.          if(pocetbeep()==2)
  3492.          {
  3493.              if(frontIsClear())
  3494.              {
  3495.              movek();
  3496.              turnRight();
  3497.              movek();
  3498.              faceWest();
  3499.              i++;
  3500.              }
  3501.              else if(frontIsBlocked())
  3502.              {
  3503.                  break;
  3504.              }
  3505.              
  3506.          }
  3507.          else if(pocetbeep()==1)
  3508.          {
  3509.             turnAround();
  3510.             loop(i)
  3511.             {
  3512.                 movek();
  3513.                 turnRight();
  3514.                 movek();
  3515.                 faceEast();
  3516.             }
  3517.             movek();
  3518.             turnRight();
  3519.             movek();
  3520.             faceEast();
  3521.             i=1;
  3522.             while(beepersPresent())
  3523.             {
  3524.                 if(pocetbeep()==2)
  3525.                 {
  3526.                     if(frontIsClear())
  3527.                     {
  3528.                     movek();
  3529.                     turnRight();
  3530.                     movek();
  3531.                     faceEast();
  3532.                     i++;
  3533.                     }
  3534.                     else
  3535.                         break;
  3536.                 }
  3537.                 else if(pocetbeep()==1 || pocetbeep()==3  )
  3538.                 {
  3539.                     turnAround();
  3540.                     loop(i)
  3541.                     {
  3542.                         movek();
  3543.                         turnRight();
  3544.                         movek();
  3545.                         faceWest();
  3546.                     }
  3547.                 break
  3548.                 }
  3549.                    
  3550.             }
  3551.         if(noBeepersPresent())
  3552.         {
  3553.             loop(3)
  3554.             {
  3555.                 putBeeper();
  3556.             }
  3557.             turnAround();
  3558.             loop(i)
  3559.             {
  3560.                 movek();
  3561.                 turnRight();
  3562.                 movek();
  3563.                 faceWest();
  3564.             }  
  3565.         }  
  3566.         break;
  3567.        
  3568.     }
  3569.          else if (pocetbeep()==3)
  3570.          {
  3571.              turnAround();
  3572.              loop(i)
  3573.              {
  3574.                  movek();
  3575.                  turnRight();
  3576.                  movek();
  3577.                  faceEast();
  3578.                 }
  3579.              faceEast();
  3580.              break;
  3581.          }
  3582.      }   
  3583.         if(noBeepersPresent())
  3584.         {
  3585.         //  i=0;
  3586.             turnAround();
  3587.             loop(i)
  3588.             {  
  3589.             movek();
  3590.             turnRight();
  3591.             movek();
  3592.             faceEast();
  3593.             }
  3594.             i=0;
  3595.             while(beepersPresent())
  3596.             {
  3597.                 if(frontIsClear())
  3598.                 {
  3599.                 movek();
  3600.                 turnRight();
  3601.                 movek();
  3602.                 faceEast();
  3603.                 i++;
  3604.                 }
  3605.                 else
  3606.                 {
  3607.                     turnAround();
  3608.                     loop(i)
  3609.                     {  
  3610.                     movek();
  3611.                     turnRight();
  3612.                     movek();
  3613.                     faceWest();
  3614.                     }
  3615.                     faceEast();
  3616.                     break;
  3617.  
  3618.                 }  
  3619.                 if(noBeepersPresent()||pocetbeep()==3)
  3620.                 {
  3621.                     turnAround();
  3622.                     loop(i)
  3623.                     {  
  3624.                     movek();
  3625.                     turnRight();
  3626.                     movek();
  3627.                     faceWest();
  3628.                     }
  3629.                     faceEast();
  3630.                     break;
  3631.                 }
  3632.                 else if(pocetbeep()==1)
  3633.                 {
  3634.                     turnAround();
  3635.                     loop(i)
  3636.                     {
  3637.                         movek();
  3638.                         turnRight();
  3639.                         movek();
  3640.                         faceWest();
  3641.                     }
  3642.                 while(beepersPresent())
  3643.                 {
  3644.                     movek();
  3645.                     turnRight();
  3646.                     movek();
  3647.                     faceWest();
  3648.  
  3649.                 }
  3650.                 loop(3)
  3651.                 {
  3652.                     putBeeper();
  3653.                 }
  3654.                 turnAround();
  3655.                 movek();
  3656.                 turnRight();
  3657.                 movek();
  3658.                 break
  3659.                 }
  3660.            
  3661.             }
  3662.         }
  3663.         }
  3664.        
  3665.             setStepDelay(1);
  3666.             faceNorth();
  3667.        
  3668.         if(frontIsClear() )
  3669.         {
  3670.         faceNorth();
  3671.         movek();
  3672.         turnRight();
  3673.         movek();
  3674.         }
  3675.         i=1;
  3676.             while(beepersPresent() )
  3677.             {
  3678.                 if(pocetbeep()==2)
  3679.                 {
  3680.                     faceNorth();
  3681.                     if(frontIsClear())
  3682.                     {
  3683.                     movek();
  3684.                     turnRight();
  3685.                     movek();
  3686.                     faceEast();
  3687.                     i++;
  3688.                     }
  3689.                     else
  3690.                     {
  3691.                     //  turnAround();
  3692.                         loop(i)
  3693.                         {
  3694.                             faceSouth();
  3695.                             movek();
  3696.                             turnRight();
  3697.                             movek();
  3698.                         }
  3699.                         break;
  3700.                     }  
  3701.                 }
  3702.                 else if(pocetbeep()==1)
  3703.                 {
  3704.                     turnAround();
  3705.                     loop(i)
  3706.                     {
  3707.                         movek();
  3708.                         turnLeft();
  3709.                         movek();
  3710.                         faceWest();
  3711.                     }
  3712.                     movek();
  3713.                     turnLeft();
  3714.                     movek();
  3715.                     faceWest();
  3716.                     i=1;
  3717.                 while(beepersPresent())
  3718.                 {
  3719.                     if(pocetbeep()==2)
  3720.                     {
  3721.                         if(frontIsClear())
  3722.                         {
  3723.                         movek();
  3724.                         turnLeft();
  3725.                         movek();
  3726.                         faceWest();
  3727.                         }
  3728.                     }
  3729.                     else if(pocetbeep()==1)
  3730.                     {
  3731.                         turnAround();
  3732.                         loop(i)
  3733.                         {
  3734.                             movek();
  3735.                             turnLeft();
  3736.                             movek();
  3737.                             faceWest();
  3738.                         }
  3739.                     break
  3740.                     }
  3741.                     else if (pocetbeep()==3)
  3742.                     {
  3743.                         turnAround();
  3744.                         loop(i)
  3745.                         {
  3746.                             movek();
  3747.                             turnLeft();
  3748.                             movek();
  3749.                             faceWest();
  3750.                         }
  3751.                         break;
  3752.                     }
  3753.                 }
  3754.             if(noBeepersPresent())
  3755.             {
  3756.                 loop(3)
  3757.                 {
  3758.                     putBeeper();
  3759.                 }
  3760.                     turnAround();
  3761.                 loop(i)
  3762.                 {
  3763.                     movek();
  3764.                     turnLeft();
  3765.                     movek();
  3766.                     faceEast();
  3767.                 }
  3768.             }  
  3769.             break;
  3770.                 }
  3771.                 else if(pocetbeep()==3)
  3772.                 {
  3773.                     turnAround();
  3774.                     loop(i)
  3775.                     {
  3776.                         movek();
  3777.                         turnLeft();
  3778.                         movek();
  3779.                     }
  3780.                     //  faceWest();
  3781.                     break;
  3782.                 }  
  3783.  
  3784.             }
  3785.  
  3786.             if(noBeepersPresent())
  3787.             {
  3788.                 setStepDelay(1);
  3789.                 turnAround();
  3790.                 //  faceWest();
  3791.                 loop(i)
  3792.                 {
  3793.                     movek();
  3794.                     turnLeft();
  3795.                     movek();
  3796.                     faceWest();
  3797.                 }
  3798.                 i=0;
  3799.                 while(beepersPresent())
  3800.                 {
  3801.                     if(frontIsClear())
  3802.                     {
  3803.                     movek();
  3804.                     turnLeft();
  3805.                     movek();
  3806.                     faceWest();
  3807.                     i++;
  3808.                     }
  3809.                     if(frontIsBlocked())
  3810.                     {
  3811.                         setStepDelay(1);
  3812.                         int ojeb=0;
  3813.                         turnRight();
  3814.                         while(frontIsClear())
  3815.                         {
  3816.                             movek();
  3817.                             ojeb++;
  3818.                             if(frontIsBlocked())
  3819.                             {
  3820.                             turnAround();
  3821.                             loop(ojeb)
  3822.                             {
  3823.                                 movek();
  3824.                             }
  3825.                             break;
  3826.                             }
  3827.                         }
  3828.  
  3829.                         if(ojeb==4)
  3830.                         {
  3831.                         faceNorth();
  3832.                         movek();
  3833.                         loop(3)
  3834.                         {
  3835.                             putBeeper();
  3836.                         }
  3837.                         faceSouth();
  3838.                         movek();
  3839.                         faceEast();
  3840.                         loop(4)
  3841.                         {
  3842.                             movek();
  3843.                         }
  3844.                         faceSouth();
  3845.                         movek();
  3846.                         loop(3)
  3847.                         {
  3848.                             putBeeper();
  3849.                         }
  3850.                         faceNorth();
  3851.                         movek();
  3852.                         faceEast();
  3853.                         movek();
  3854.                         loop(3)
  3855.                         {
  3856.                             putBeeper();
  3857.                         }
  3858.                         while(frontIsClear())
  3859.                         {
  3860.                             setStepDelay(1);
  3861.                             movek();
  3862.                             if(frontIsBlocked()&&facingEast() )
  3863.                             {
  3864.                                 turnRight();
  3865.                                
  3866.                             }
  3867.                             if(frontIsBlocked()&&facingSouth())
  3868.                             {
  3869.                                 faceEast();
  3870.                                 break;
  3871.                             }
  3872.                            
  3873.                         }
  3874.                         }
  3875.                         else if (ojeb==3)
  3876.                         {
  3877.                             faceNorth();
  3878.                             movek();   
  3879.                             movek();
  3880.                             turnRight();
  3881.                             movek();
  3882.                             loop(3)
  3883.                             {
  3884.                                 putBeeper();
  3885.                             }
  3886.                             movek();
  3887.                             loop(3)
  3888.                             {
  3889.                                 putBeeper();
  3890.                             }
  3891.                             movek();
  3892.                             loop(3)
  3893.                             {
  3894.                                 putBeeper();
  3895.                             }
  3896.                             movek();
  3897.                             faceEast();
  3898.                             break;
  3899.                            
  3900.                         }
  3901.                     }  
  3902.                    
  3903.                     if(noBeepersPresent()||pocetbeep()==3 )
  3904.                     {
  3905.                         if(noBeepersPresent()&&frontIsBlocked()&&facingEast())
  3906.                         {
  3907.                             turnOff();
  3908.                         }
  3909.                         turnAround();
  3910.                         loop(i)
  3911.                         {
  3912.                             movek();
  3913.                             turnLeft();
  3914.                             movek();
  3915.                             faceEast();
  3916.                         }
  3917.                        
  3918.                            
  3919.                     //      faceWest(); //pokus (faceEast)
  3920.                         break;
  3921.                         }
  3922.                     else if(pocetbeep()==1)
  3923.                     {
  3924.                         turnAround();
  3925.                         loop(i)
  3926.                         {
  3927.                             movek();
  3928.                             turnLeft();
  3929.                             movek();
  3930.                             faceEast();
  3931.                         }
  3932.                     while(beepersPresent())
  3933.                     {
  3934.                         movek();
  3935.                         turnLeft();
  3936.                         movek();
  3937.                         faceEast();
  3938.                     }
  3939.                     loop(3)
  3940.                     {
  3941.                         putBeeper();
  3942.                     }
  3943.                     turnAround();
  3944.                     movek();
  3945.                     turnLeft();
  3946.                     movek();
  3947.                     break;
  3948.                     }
  3949.                 }
  3950.             }          
  3951.         if(rightIsBlocked()&&frontIsBlocked())
  3952.         {
  3953.             faceEast();
  3954.             turnOff();
  3955.         }
  3956. //      faceEast();
  3957.          }
  3958.  
  3959. PS5:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  3960. SUBOR A:
  3961.  
  3962. #include <math.h>
  3963. #include <stdio.h>
  3964. #include <stdlib.h>
  3965.  
  3966. short int gcd(const short int a, const short int b);
  3967. long int lcm(const int a, const int b);
  3968.  
  3969.  
  3970. int main(){
  3971.     return 0;
  3972.       }
  3973.  
  3974.     short int gcd(const short int a, const short int b)
  3975.     {
  3976.         short int cislo1,cislo2;
  3977.         short int gcd;
  3978.        
  3979.         cislo1=a;
  3980.         cislo2=b;
  3981.  
  3982.         if(a==0||b==0)
  3983.         {
  3984.         return -1;
  3985.         }
  3986.         if ((a>1000||a<-1000)||(b>1000||b<-1000))
  3987.         {
  3988.         return -1;
  3989.         }
  3990.         else
  3991.         {
  3992.         cislo1 = ( cislo1 > 0) ? cislo1 : -cislo1;
  3993.         cislo2 = ( cislo2 > 0) ? cislo2 : -cislo2;
  3994.         while(cislo1!=cislo2)
  3995.         {
  3996.             if(cislo1 > cislo2)
  3997.             {cislo1 -= cislo2;}
  3998.             else
  3999.             cislo2 -= cislo1;
  4000.         }  
  4001.         }
  4002.     gcd=cislo1;
  4003.     return gcd;
  4004.  
  4005.     }
  4006.  
  4007. long int lcm(const int a, const int b){
  4008.     long int lcm;
  4009.     int cislo1=a;
  4010.         int cislo2=b;
  4011.     long int sucin=cislo1*cislo2;  
  4012.  
  4013.     if(a<=0 || b<=0)
  4014.     {
  4015.     return -1;
  4016.     }
  4017.     else if(a>10000 || b>10000)
  4018.     {
  4019.     return -1;
  4020.     }
  4021.    
  4022.     cislo1 = ( cislo1 > 0) ? cislo1 : -cislo1;
  4023.         cislo2 = ( cislo2 > 0) ? cislo2 : -cislo2;
  4024.         while(cislo1!=cislo2)
  4025.         {
  4026.             if(cislo1 > cislo2)
  4027.             {cislo1 -= cislo2;}
  4028.             else
  4029.             cislo2 -= cislo1;
  4030.         }  
  4031.        
  4032.     int gcd=cislo1;
  4033.  
  4034.  
  4035.     lcm=(sucin)/gcd;
  4036.        
  4037.         if(lcm>0)
  4038.         {
  4039.         return lcm;
  4040.         }  
  4041.         else
  4042.         {  
  4043.         return -1;
  4044.         }
  4045.        
  4046.  
  4047. }
  4048.  
  4049.  
  4050. SUBOR B: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  4051.  
  4052. #include <stdio.h>
  4053. #include <math.h>
  4054.  
  4055. int main(){
  4056.  
  4057.   double vallue;
  4058.  
  4059. printf("Enter value of your bill: ");
  4060.    scanf("%lf", &vallue);
  4061.     if(vallue > 10000 || vallue < 0) {
  4062.     printf("Wrong input!\n");
  4063.     return 1;
  4064.   }
  4065.  
  4066.   double cashh[]={0.01,0.02,0.05,0.10,0.20,0.50,1,2,5,10,20,50,100};
  4067.   double payment[200];
  4068.  
  4069. for (int i=0; i<200; i++){
  4070. payment[i]=0;
  4071. }
  4072.  
  4073. printf("Insert money for payment: ");
  4074.  
  4075. for (int i=0; i<200; i++) {
  4076. scanf("%lf", &payment[i]);
  4077. if(payment[i]==0){
  4078. break;
  4079. }
  4080. if(getchar()==EOF)
  4081. {
  4082.     break;
  4083. }
  4084. }
  4085.  
  4086. int t=0;
  4087. for (int i=0; i<200; i++){
  4088.   for (int j=0; j<13; j++){
  4089.   if((payment[i] != cashh[j]) && (payment[i]!=0)){
  4090.   t++;
  4091.     if(t==13)
  4092.     {
  4093.   if(payment[i] - (int)payment[i] == 0){
  4094.   printf("%.0f is invalid!\n", payment[i]);
  4095.   return 1;
  4096.   }
  4097.   else{
  4098.   printf("%.2f is invalid!\n", payment[i]);
  4099.   return 1;
  4100.   }
  4101.   }
  4102.  
  4103.   }
  4104.   else
  4105.   {
  4106.   t=0;   
  4107.   break;
  4108.   }
  4109.   }
  4110.  
  4111.   /* if(t==13){
  4112.   if(payment[i] - (int)payment[i] == 0){
  4113.   printf("%.0f is invalid!\n", payment[i]);
  4114.   return 1;
  4115.   }
  4116.   else{
  4117.   printf("%.2f is invalid!\n", payment[i]);
  4118.   return 1;
  4119.   }
  4120.   }
  4121.  */
  4122. }
  4123.  
  4124.  
  4125. double back;
  4126. double parment;
  4127. double sumofall=0;
  4128.  
  4129. int parmentP,vallue1=vallue*100,sumofall1=sumofall*100;
  4130. for (int i=0; i<200; i++){
  4131.   sumofall += payment[i];
  4132. }
  4133. if(sumofall - (int)sumofall == 0){
  4134. printf("You have inserted: %.0f\n", sumofall);
  4135. }
  4136. else{
  4137. printf("You have inserted: %.2f\n", sumofall);
  4138. }
  4139. if((round(sumofall * 100) / 100) < vallue) {
  4140. printf("Not enough money!\n");
  4141. return 0;
  4142. }
  4143.  
  4144. else {
  4145. back = sumofall - vallue;
  4146. parmentP = sumofall1 - vallue1;
  4147. if(parmentP == 0){
  4148. printf("To return: 0\n");
  4149. return 0;
  4150. }
  4151.  
  4152. if(back - (int)back == 0){
  4153. printf("To return: %.0f\n", back);
  4154. return 0;
  4155. }
  4156. else{
  4157.     if(back<=0.01)
  4158.     {
  4159.         back=0;
  4160.     printf("To return: %.0f\n", back);
  4161.     return 0;
  4162.     }
  4163. printf("To return: %.2f\n", back);
  4164. }
  4165. }
  4166.  
  4167. float backa[200];
  4168. int c=0;
  4169.     parment = back*100;
  4170.  
  4171. do {
  4172.    if(roundf(parment) >= 10000){
  4173.        backa[c] = 100 ;
  4174.        parment = parment - 10000;
  4175.        }
  4176.    else if(roundf(parment) >= 5000){
  4177.        backa[c] = 50 ;
  4178.        parment = parment - 5000;
  4179.        }
  4180.    else if(roundf(parment) >= 2000){
  4181.        backa[c] = 20;
  4182.        parment = parment - 2000;
  4183.        }
  4184.    else if(roundf(parment) >= 1000){
  4185.        backa[c] = 10 ;
  4186.        parment = parment - 1000;
  4187.        }
  4188.    else if(roundf(parment) >= 500){
  4189.        backa[c] = 5 ;
  4190.        parment = parment - 500;
  4191.        }
  4192.    else if(roundf(parment) >= 200){
  4193.        backa[c] = 2;
  4194.        parment = parment - 200;
  4195.        }
  4196.    else if(roundf(parment) >= 100){
  4197.        backa[c] = 1;
  4198.        parment = parment - 100;
  4199.        }
  4200.    else if(roundf(parment) >= 50){
  4201.        backa[c] = 0.5;
  4202.        parment = parment - 50;
  4203.        }
  4204.    else if(roundf(parment) >= 20){
  4205.        backa[c] = 0.2;
  4206.        parment = parment - 20;
  4207.        }
  4208.    else if(roundf(parment) >= 10){
  4209.        backa[c] = 0.1;
  4210.        parment = parment - 10;
  4211.        }
  4212.    else if(roundf(parment) >= 5){
  4213.        backa[c] = 0.05;
  4214.        parment = parment - 5;
  4215.        }
  4216.    else if(roundf(parment) >= 2){
  4217.        backa[c] = 0.02;
  4218.        parment = parment - 2;
  4219.        }
  4220.    else if(roundf(parment) >= 1){
  4221.        backa[c] = 0.01;
  4222.        parment = parment - 1;
  4223.        }
  4224. else{
  4225. break;
  4226. }
  4227.  
  4228. c++;
  4229. }while(c!=150);
  4230.  
  4231.  
  4232.  
  4233. int i=0;
  4234.  
  4235. printf("Collect your payback:");
  4236.  
  4237. for( i=0; i<c; i++){
  4238.    if(backa[i]<1){
  4239.      printf(" %.2f", backa[i]);
  4240.      }
  4241.    if(backa[i]>= 1){
  4242.  
  4243.      printf(" %.0f", backa[i]);
  4244.      } 
  4245.  
  4246.  
  4247. }
  4248.  
  4249. printf("\n");
  4250. return 0;
  4251. }
  4252.  
  4253. SUBOR C: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  4254.  
  4255. #include <stdio.h>
  4256. #include <math.h>
  4257.  
  4258.  
  4259. float to_radians(const int angle);
  4260. float get_watchtowers_distance(const int x1, const int y1, const int x2, const int y2);
  4261. float get_boat_distance(const float d, const int alpha, const int beta);
  4262.  
  4263.  
  4264.     int main(){
  4265.        
  4266.         float Ax,Ay,Bx,By;
  4267.         float alfa, beta;
  4268.         scanf("%f %f %f",&Ax, &Ay, &alfa);
  4269.         scanf("%f %f %f",&Bx, &By, &beta);
  4270.        
  4271.         if(Ax<0 || Bx<0 || Ax>1000 || Bx>1000)
  4272.         {
  4273.             printf("-1\n");
  4274.         }
  4275.         if(alfa>=90 || alfa<=0 || beta>=90 || beta<=0)
  4276.         {
  4277.             printf("-1\n");
  4278.         }
  4279.        
  4280.        
  4281.  
  4282.            
  4283.         //printf("%.2f\n", get_boat_distance(200.9,17,17));
  4284.     //  printf("%.2f\n", get_boat_distance(70.34,25,8));   
  4285.         return 0;
  4286.     }
  4287.  
  4288.  
  4289.     float to_radians(const int angle)
  4290.     {
  4291.         if((angle>0)&&(angle<360))
  4292.         {
  4293.         float helping=angle;
  4294.         float radians=(helping*3.14159265359f)/180.0f;
  4295.         return radians;
  4296.         }
  4297.         else
  4298.         return -1;
  4299.     }
  4300.     float get_watchtowers_distance(const int x1, const int y1, const int x2, const int y2)
  4301.     {
  4302.         if(x1<=1000 && x1>=0 && x2<=1000 && x2>=0 && y1<=1000 && y1>=0 && y2<=1000 && y2>=0 && y1!=y2)
  4303.         {  
  4304.         float x=(x1-x2);
  4305.         float y=(y1-y2);
  4306.         float l= sqrt(x*x+y*y);
  4307.         return l;
  4308.         }
  4309.         else
  4310.         return -1;
  4311.  
  4312.     }
  4313.     float get_boat_distance(const float d, const int alpha, const int beta)
  4314.         {
  4315.             if(beta<90 && alpha<90 && beta>0 && alpha>0 && d>0 && d<1000)
  4316.             {
  4317.             float pi=3.14159265f;
  4318.             float alfa1=alpha*(pi/180);
  4319.             float beta1=beta*(pi/180);
  4320.             float bdist=(d*sin(alfa1)*sin(beta1))/sin(alfa1+beta1);
  4321.             return bdist;
  4322.             }
  4323.             else
  4324.                 return -1;
  4325.         }
  4326. PS6: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  4327. SUBOR A:
  4328.  
  4329. #include <stdio.h>
  4330. #include <math.h>
  4331.  
  4332.  
  4333.     int main(){
  4334.  
  4335.         int pocetfarmarov;
  4336.         double velkostfarmy;
  4337.         double pocetzvierat;
  4338.         double mieraeko;
  4339.        
  4340.         double zabranemiesto=0;
  4341.         double dokopy=0;
  4342.         scanf("%d",&pocetfarmarov);
  4343.  
  4344.         if((pocetfarmarov<0)||(pocetfarmarov>20))
  4345.         {
  4346.             printf("Wrong input!\n");
  4347.             return 1;
  4348.         }
  4349.         for (int i=0;i<pocetfarmarov;i++)
  4350.         {
  4351.         scanf("%lf", &velkostfarmy);
  4352.         if((velkostfarmy<0)||(velkostfarmy>10000))
  4353.         {
  4354.             printf("Wrong input!\n");
  4355.             return 1;
  4356.         }      
  4357.         scanf("%lf", &pocetzvierat);
  4358.         if((pocetzvierat<0)||(pocetzvierat>10000))
  4359.         {
  4360.             printf("Wrong input!\n");
  4361.             return 1;
  4362.         }
  4363.         scanf("%lf", &mieraeko);
  4364.         if((mieraeko<0)||(mieraeko>10000))
  4365.         {
  4366.             printf("Wrong input!\n");
  4367.             return 1;
  4368.         }
  4369.        
  4370.         zabranemiesto=velkostfarmy/pocetzvierat;
  4371.         zabranemiesto=(round(zabranemiesto*100)/100);
  4372.         zabranemiesto=zabranemiesto*mieraeko;
  4373.         zabranemiesto=zabranemiesto*pocetzvierat;
  4374.         dokopy=dokopy+zabranemiesto;
  4375.         zabranemiesto=0;
  4376.         }
  4377.  
  4378.         printf("Total donation: %.2f\n",dokopy);
  4379.         return 0;
  4380.  
  4381.     }
  4382.  
  4383. SUBOR B: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  4384.  
  4385. #include <stdio.h>
  4386. #include <math.h>
  4387.  
  4388.     int main(){
  4389.         int pocetludi;
  4390.         int typcloveka;
  4391.         double celkovadotacia=0;
  4392.         double dotacia=0;
  4393.             double hodnotanakupu=0;
  4394.         double pocetdotovanych=0;
  4395.         double hodnotadotovaneho=0;
  4396.         double hodnotanedotovaneho=0;
  4397.         double celkovahodnota=0;
  4398.         double celkovozaplatene=0;
  4399.         double celkovahodnotanakupu=0;
  4400.  
  4401.         scanf("%d",&pocetludi);
  4402.         if((pocetludi<0)||(pocetludi>20))
  4403.         {
  4404.             printf("Wrong input!\n");
  4405.             return 1;
  4406.         }
  4407.  
  4408.         for (int i=0;i<pocetludi;i++)
  4409.     {
  4410.         scanf("%d",&typcloveka);
  4411.         if((typcloveka<1)||(typcloveka>2))
  4412.         {
  4413.             printf("Wrong input!\n");
  4414.             return 1;
  4415.         }
  4416.  
  4417.         if(typcloveka==1)
  4418.         {
  4419.             scanf("%lf",&hodnotanakupu);
  4420.             celkovahodnotanakupu=celkovahodnotanakupu+hodnotanakupu;
  4421.             if((hodnotanakupu>=2)&&(hodnotanakupu<4))
  4422.                 {
  4423.                     dotacia=dotacia+1;
  4424.                     celkovozaplatene=celkovozaplatene-dotacia;
  4425.  
  4426.                    
  4427.                     celkovahodnota=hodnotanakupu+celkovozaplatene;
  4428.                     celkovadotacia=celkovadotacia+dotacia;
  4429.                     dotacia=0;
  4430.  
  4431.                 }
  4432.             else if((hodnotanakupu>=4))
  4433.                 {
  4434.                     dotacia=dotacia+2;
  4435.                     celkovozaplatene=hodnotanakupu-dotacia;
  4436.                     celkovahodnota=celkovahodnota+celkovozaplatene;
  4437.                     celkovadotacia=celkovadotacia+dotacia;
  4438.                     dotacia=0;
  4439.  
  4440.                 }
  4441.  
  4442.             else if(hodnotanakupu<0)
  4443.             {
  4444.                 printf("Wrong input!\n");
  4445.                 return 1;
  4446.  
  4447.             }  
  4448.         //  celkovahodnotanakupu+=hodnotanakupu;
  4449.         //  haha
  4450.         }
  4451.             else if(typcloveka==2)
  4452.                 {
  4453.             scanf("%lf",&hodnotanakupu);
  4454.                     celkovahodnotanakupu=celkovahodnotanakupu+hodnotanakupu;
  4455.                 if(hodnotanakupu>=3.6)
  4456.                     {
  4457.                             pocetdotovanych=hodnotanakupu/3.6;
  4458.                             pocetdotovanych=floor(pocetdotovanych);
  4459.                             hodnotadotovaneho=pocetdotovanych*3.6;     
  4460.                             hodnotanedotovaneho=hodnotanakupu-hodnotadotovaneho;
  4461.                             if(hodnotanedotovaneho>1.8)
  4462.                             {
  4463.                                 dotacia=(hodnotanedotovaneho*0.55)+0.42;
  4464.                                 dotacia=round(dotacia*100)/100;
  4465.                                 hodnotanedotovaneho=(hodnotanedotovaneho*0.45)-0.42;
  4466.                             }
  4467.  
  4468.                             celkovozaplatene=((hodnotadotovaneho*0.45)-(0.42*pocetdotovanych))+hodnotanedotovaneho;
  4469.                        
  4470.                         dotacia=dotacia+(hodnotadotovaneho*0.55)+(0.42*pocetdotovanych);
  4471.                         dotacia=round(dotacia*100)/100;
  4472.                         celkovahodnota=celkovahodnota+celkovozaplatene;
  4473.                         celkovadotacia=celkovadotacia+dotacia;
  4474.                         dotacia=0;
  4475.                         celkovozaplatene=0;
  4476.                     }
  4477.                     else if(hodnotanakupu<0)
  4478.                     {
  4479.                         printf("Wrong input!\n");
  4480.                         return 1;
  4481.                     }
  4482.                 else if ((hodnotanakupu<3.6)&&(hodnotanakupu>=1.8))
  4483.                 {
  4484.                     celkovozaplatene=(hodnotanakupu*0.45)-0.42;
  4485.                     dotacia=(hodnotanakupu*0.55)+0.42;
  4486.                     dotacia=round(dotacia*100)/100;
  4487.                     celkovadotacia=celkovadotacia+dotacia;
  4488.                     celkovahodnota=celkovahodnota+celkovozaplatene;
  4489.                     dotacia=0;
  4490.                     celkovozaplatene=0;
  4491.  
  4492.                 }
  4493.            
  4494.         else if( (typcloveka!=1) &&(typcloveka!=2) )
  4495.         {
  4496.             printf("Wrong input!\n");
  4497.             return 1;
  4498.         }
  4499.            
  4500.                 }
  4501. //celkovahodnotanakupu+=hodnotanakupu;;
  4502.                
  4503.     }
  4504.        
  4505.         //  celkovadotacia=round(celkovadotacia*100)/100;
  4506.                 celkovahodnotanakupu=celkovahodnotanakupu-celkovadotacia;
  4507.         printf("Total: %.2f donated, %.2f paid.\n",celkovadotacia,celkovahodnotanakupu);
  4508.         return 0;
  4509.         }  
  4510.  
  4511. SUBOR C: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  4512.  
  4513. #include <stdio.h>
  4514. #include <math.h>
  4515.  
  4516.         int is_prime(const int number);
  4517.         int next_prime(const int prime);
  4518.         int sum_digits(const long int number);
  4519.         int sum_digits_n(const int n);
  4520.         long int find_A_n(const int n);
  4521.     int constant(const int a, const int b);
  4522.  
  4523.  
  4524.         int main()
  4525.         {
  4526.  
  4527.         //printf("%d\n", is_prime(-1));
  4528.        // printf("%d\n", next_prime(7));
  4529.        // printf("%d\n", sum_digits(12345678));
  4530.     // printf("%d\n", sum_digits_n(97));
  4531.         //printf("%ld\n", find_A_n(4));
  4532. //  printf("%d\n", constant(1330,0));
  4533.     int a, b, suma;
  4534.     scanf("%d",&a);
  4535.  
  4536.     if((a<1) ||(a>5000))
  4537.     {
  4538.         printf("Wrong input!\n");
  4539.         return 1;
  4540.     }
  4541.     scanf("%d",&b);
  4542.     if((b<-20)||(b>20))
  4543.     {
  4544.         printf("Wrong input!\n");
  4545.         return 1;
  4546.     }
  4547.     scanf("%d",&suma);
  4548.     if((suma<1000)||(suma>1000000))
  4549.     {
  4550.         printf("Wrong input!\n");
  4551.         return 1;
  4552.    
  4553.     }
  4554.     int konstanta=constant(a,b);
  4555.     double cast=100-konstanta;
  4556.     double supergrant=suma*(cast/100);
  4557.  
  4558.     printf("Supergrant: %.2f\n",supergrant);
  4559.     return 0;
  4560.  
  4561.         }
  4562.         int is_prime(const int number)
  4563.         {
  4564.                 int b=number;
  4565.         if(b==-1)
  4566.         {
  4567.         return 0;
  4568.         }
  4569.         if (b == 2 || b == 3)
  4570.                 return 1;
  4571.  
  4572.         if (b % 2 == 0 || b % 3 == 0)
  4573.                 return 0;
  4574.         if (b==1)
  4575.         {
  4576.                 return 0;
  4577.         }
  4578.  
  4579.  
  4580.  
  4581.         int delitel = 6;
  4582.         while (delitel * delitel - 2 * delitel + 1 <= b)
  4583.         {
  4584.                 if (b % (delitel - 1) == 0)
  4585.                 {
  4586.                         return 0;
  4587.                 }
  4588.                 if (b % (delitel + 1) == 0)
  4589.                 {
  4590.                         return 0;
  4591.                 }
  4592.               delitel += 6;
  4593.         }
  4594.         return 1;
  4595.  
  4596.         }
  4597.         int next_prime(const int prime)
  4598.         {
  4599.         if(prime<0)
  4600.         {
  4601.             return -1;
  4602.         }
  4603.                 int a=prime;
  4604.                 if(is_prime(prime)==0)
  4605.                 {
  4606.                         return -1;
  4607.                 }
  4608.                 while (!is_prime(++a))
  4609.                 {
  4610.  
  4611.                 }
  4612.                 return a;
  4613.  
  4614.         }
  4615.  
  4616.         int sum_digits(const long int number)
  4617.         {
  4618.                 int tmp;
  4619.                 int dokopy=0;
  4620.                 if(number<0)
  4621.                 {
  4622.                         return 0;
  4623.                 }
  4624.                 int daco=number;
  4625.                 while (daco != 0)
  4626.                 {
  4627.                         tmp= daco % 10;
  4628.                         dokopy+=tmp;
  4629.                         daco=daco/10;
  4630.                 }
  4631.  
  4632.                 return dokopy;
  4633.         }
  4634.         int sum_digits_n(const int n)
  4635.         {
  4636.               int sumka=1;
  4637.               //int iteracna=1;
  4638.               int helping;
  4639.               if(n<0)
  4640.               {
  4641.                       return 0;
  4642.               }
  4643.           if(n==2)
  4644.           {
  4645.               return 1;
  4646.           }
  4647.           if(n==0)
  4648.           {
  4649.               return 0;
  4650.           }
  4651.           if(n==1)
  4652.           {
  4653.              return 1;
  4654.           }
  4655.               for(int i=1;i<n;i++)
  4656.               {
  4657.                 sumka=sumka+sum_digits(sumka);
  4658.         if(i==n-2)
  4659.         {
  4660.         helping=sum_digits(sumka);
  4661.         }
  4662.               }
  4663.               return sumka-helping;
  4664.         }
  4665.         long int find_A_n(const int n)
  4666.         {
  4667.                 if(n<1)
  4668.                 {
  4669.                         return 0;
  4670.                 }
  4671.                 if(n==1)
  4672.                 {
  4673.                         return 3;
  4674.                 }
  4675.                int primenumber=2;
  4676.                int number=0;
  4677.                int i=1;
  4678.                int right=0;
  4679.  
  4680.                 while(1)
  4681.                 {
  4682.                         for(i=1;i<=n;i++)
  4683.                         {
  4684.                                 if((number % primenumber)==i)
  4685.                                         {
  4686.                                                 right++;
  4687.                                         }
  4688.                                 primenumber= next_prime(primenumber);
  4689.                         }
  4690.                         if(right==n)
  4691.                         {
  4692.                                 return number;
  4693.                         }
  4694.                   number++;
  4695.                         primenumber=2;
  4696.                         right=0;
  4697.  
  4698.  
  4699.                 }
  4700.  
  4701.         }
  4702.  
  4703.     int constant(const int a, const int b)
  4704.     {
  4705.         int cislo1=sum_digits_n(a);
  4706.        
  4707.         int cislo2=b;
  4708.        
  4709.         if((cislo2>=1) && (cislo2<=9))
  4710.         {
  4711.              cislo2=find_A_n(b);
  4712.             cislo2=sum_digits(cislo2);
  4713.         }  
  4714.         else
  4715.         {
  4716.                 cislo2=sum_digits_n(a);
  4717.                 cislo2=sum_digits(cislo2);
  4718.         }
  4719.  
  4720.  
  4721.         int podiel;
  4722.         if(cislo1>cislo2)
  4723.         {
  4724.             podiel=cislo1/cislo2;
  4725.             podiel=round(podiel);
  4726.         }
  4727.         else
  4728.         {
  4729.             podiel=cislo2/cislo1;
  4730.         }  
  4731.         if (podiel<=49)
  4732.         {
  4733.             return podiel;
  4734.         }
  4735.         else if (podiel>=50)
  4736.         {
  4737.             while(podiel>=50)
  4738.             {
  4739.                 if(podiel % 2 == 0)
  4740.                 {
  4741.                     podiel=podiel/2;
  4742.                 }
  4743.                 else
  4744.                 {
  4745.                     podiel=sum_digits(podiel);
  4746.                 }  
  4747.             }      
  4748.         }
  4749.         return podiel; 
  4750.        
  4751.     }
  4752.  
  4753. PS7: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  4754. SUBOR A:
  4755.  
  4756. #include <stdio.h>
  4757. #include <stdlib.h>
  4758. #include <ctype.h>
  4759. #include <string.h>
  4760. #include <sys/stat.h>
  4761. #include "hangman.h"
  4762.  
  4763.  
  4764. int get_word(char secret[]){
  4765.     // check if file exists first and is readable
  4766.     FILE *fp = fopen(WORDLIST_FILENAME, "rb");
  4767.     if( fp == NULL ){
  4768.         fprintf(stderr, "No such file or directory: %s\n", WORDLIST_FILENAME);
  4769.         return 1;
  4770.     }
  4771.  
  4772.     // get the filesize first
  4773.     struct stat st;
  4774.     stat(WORDLIST_FILENAME, &st);
  4775.     long int size = st.st_size;
  4776.  
  4777.     do{
  4778.         // generate random number between 0 and filesize
  4779.         long int random = (rand() % size) + 1;
  4780.         // seek to the random position of file
  4781.         fseek(fp, random, SEEK_SET);
  4782.         // get next word in row ;)
  4783.         int result = fscanf(fp, "%*s %20s", secret);
  4784.         if( result != EOF )
  4785.             break;
  4786.     }while(1);
  4787.  
  4788.     fclose(fp);
  4789.  
  4790.     return 0;
  4791. }
  4792.  
  4793.     int is_word_guessed(const char secret[],const char letters_guessed[]){
  4794.    
  4795.         int iteracne=0;
  4796.         int pes=strlen(secret);
  4797.  
  4798.         for(int i=0;i<strlen(secret);i++)
  4799.         {
  4800.         int lengthOfWord=0;
  4801.             for(int j=0;j<strlen(letters_guessed);j++)
  4802.             {
  4803.                 if(secret[i]==letters_guessed[j])
  4804.                 {
  4805.                     lengthOfWord+=+1;
  4806.                 }
  4807.  
  4808.             }
  4809.             if(lengthOfWord==1)
  4810.             {
  4811.                 iteracne++;
  4812.             }
  4813.  
  4814.         }
  4815.         if(iteracne==pes)
  4816.         {
  4817.             return 1;
  4818.         }
  4819.  
  4820.         return 0;
  4821.     }
  4822.  
  4823.  
  4824.     void get_guessed_word(const char secret[], const char letters_guessed[], char guessed_word[])
  4825.     {
  4826.    
  4827.          int length,i,j;
  4828.           int dlh = strlen(letters_guessed);
  4829.           int tjn = strlen(secret);
  4830.          guessed_word[tjn]='\0';
  4831.        
  4832.  
  4833.          for(i=0; i<tjn; i++){
  4834.             length=0;
  4835.                 for(j=0;j<dlh;j++)
  4836.                 {
  4837.                     if(letters_guessed[j]!=secret[i])
  4838.                     {
  4839.                         length+=1;
  4840.                     }
  4841.                 }
  4842.                 if(dlh==length)
  4843.                 {
  4844.                     guessed_word[i] = '_';                 
  4845.                 }
  4846.                 else if(dlh!=length)
  4847.                 {
  4848.                     guessed_word[i]=secret[i];
  4849.                 }
  4850.  
  4851.          }
  4852.  
  4853. //          printf("\n");
  4854.    
  4855.     }
  4856.  
  4857.     void get_available_letters(const char letters_guessed[], char available_letters[])
  4858.     {
  4859.         int i,j;
  4860.         int temp=0;
  4861.         int temp1=0;
  4862.         int dlzkatip=strlen(letters_guessed);
  4863.  
  4864.         char abeceda[] = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n'
  4865.                 ,'o','p','q','r','s','t','u','v','w','x','y','z','\0'};
  4866.         int dlzkaabecedy=strlen(abeceda);
  4867.             for(i=0;i<dlzkaabecedy;i++)
  4868.             {
  4869.                 int helping=0;
  4870.                 for(j=0;j<dlzkatip;j++)
  4871.                 {
  4872.                     if(abeceda[i]!=letters_guessed[j])
  4873.                     {
  4874.                     }
  4875.                     else
  4876.                     {
  4877.                         helping++;
  4878.                     }  
  4879.                 }
  4880.                 if(helping==0)
  4881.                 {
  4882.                     available_letters[temp]=abeceda[i];
  4883.                     temp++;
  4884.                 }
  4885.                 else if(helping!=0)
  4886.                 {
  4887.                     temp1++;
  4888.                 }  
  4889.             }
  4890.             available_letters[strlen(abeceda)-temp1]='\0';
  4891.             //      printf("Available letters: %s\n", available_letters);
  4892.     }  
  4893.    
  4894.   void hangman(const char secret[]){
  4895.        
  4896.         int dlzkatajn=strlen(secret);
  4897.         char help[26];
  4898.         char hadaneslova[30];
  4899.    
  4900.         char hadane[dlzkatajn];
  4901.         char input[30];
  4902.   const char* foo = "abcdefghijklmnopqrstuvwxyz";
  4903.         int chances = 8;
  4904.  
  4905.        
  4906.        
  4907.         int dent;
  4908.    
  4909.    
  4910.     hadaneslova[0]='\0';
  4911.     printf("Welcome to the game, Hangman!\n");
  4912.     printf("I am thinking of a word that is %d letters long.\n",dlzkatajn);
  4913.     printf("-------------\n");
  4914.  
  4915.         while( chances != 0){
  4916.         printf("You have %d guesses left.\n", chances);
  4917.         get_available_letters(hadaneslova, help);
  4918.         printf("Available letters: %s\n", help);
  4919.         printf("Please guess a letter: ");
  4920.         scanf("%26s", input);
  4921.   int dlzkavstup=strlen(input);
  4922.    get_guessed_word(secret, hadaneslova, hadane);
  4923.  
  4924.  
  4925.       for(int  a = 0; a < dlzkavstup; a++){
  4926.             if(isupper(input[a])){
  4927.                 input[a]  =  tolower(input[a]);
  4928.             }
  4929.     }
  4930.    
  4931.   if ((input[strspn(input, foo)] == '\0') && (dlzkavstup==1))
  4932.   {
  4933.  
  4934.   }
  4935.   else
  4936.   {
  4937.       if(dlzkavstup==1)
  4938.       {
  4939.     printf("Oops! '%s' is not a valid letter: ",input);
  4940.     for(int i=0;i<strlen(hadane);i++)
  4941.     {
  4942.      
  4943.             if(i==strlen(hadane)-1)
  4944.             {
  4945.             printf("%c",hadane[i]);
  4946.             break;
  4947.             }
  4948.         printf("%c ",hadane[i]);
  4949.     }
  4950.     printf("\n");
  4951.     printf("-------------\n");
  4952.     continue;
  4953.       }
  4954.   }
  4955.  
  4956.    
  4957.     if(dlzkavstup == dlzkatajn){
  4958.            if(strcmp(secret, input)==0){
  4959.            printf("Congratulations, you won!\n");
  4960.            break;
  4961.            }
  4962.            else{
  4963.            printf("Sorry bad guess. The word was %s.\n", secret);
  4964.            break;
  4965.            }
  4966.         }
  4967.     else if((dlzkavstup>1) && (dlzkavstup!=dlzkatajn))
  4968.     {
  4969.         break;
  4970.     }
  4971.          
  4972.        
  4973.         for(int a = 0; a < dlzkavstup; a++){
  4974.             int helpings = 0;
  4975.             for(int b=0; b< strlen(hadaneslova); b++){
  4976.                     if(input[a] == hadaneslova[b]){
  4977.                         helpings++;
  4978.                     }
  4979.             }
  4980.  
  4981.             if(helpings!=1){
  4982.                 strcat(hadaneslova, input);
  4983.                 dent = 0;
  4984.             }
  4985.             else if((helpings==1)&&(dlzkavstup==1) ){
  4986.                 printf("Oops! You've already guessed that letter: ");
  4987.                   get_guessed_word(secret, hadaneslova, hadane);
  4988.          for(int i=0;i<strlen(hadane);i++)
  4989.     {
  4990.             if(i==strlen(hadane)-1)
  4991.             {
  4992.             printf("%c",hadane[i]);
  4993.             printf("\n");
  4994.             break;
  4995.             }
  4996.         printf("%c ",hadane[i]);
  4997.     }
  4998.                 dent = 1;
  4999.             }
  5000.         }
  5001.        
  5002.  
  5003.        
  5004.  
  5005.        
  5006.  
  5007.         if(dlzkavstup==1){
  5008.         for(int a=0; a<dlzkavstup ; a++){
  5009.         int helpings = 0;
  5010.            for( int b=0; b<dlzkatajn;b++){
  5011.            if(input[a] == secret[b]){
  5012.            helpings++;
  5013.            }
  5014.             }
  5015.      
  5016.  
  5017.          if(dent == 0 && helpings==0 && dlzkavstup==1 ){
  5018.            printf("Oops! That letter is not in my word: ");
  5019.            get_guessed_word(secret, hadaneslova, hadane);
  5020.              for(int i=0;i<strlen(hadane);i++)
  5021.     {
  5022.             if(i==strlen(hadane)-1)
  5023.             {
  5024.             printf("%c",hadane[i]);
  5025.             printf("\n");
  5026.             break;
  5027.             }
  5028.         printf("%c ",hadane[i]);
  5029.     }
  5030.            chances--;
  5031.             }
  5032.          if(dent == 0 && helpings>0 && dlzkavstup==1 ){
  5033.            printf("Good guess: ");
  5034.            get_guessed_word(secret, hadaneslova, hadane);
  5035.          for(int i=0;i<strlen(hadane);i++)
  5036.     {
  5037.             if(i==strlen(hadane)-1)
  5038.             {
  5039.             printf("%c",hadane[i]);
  5040.             printf("\n");
  5041.             break;
  5042.             }
  5043.         printf("%c ",hadane[i]);
  5044.     }
  5045.            }
  5046.             break;
  5047.         }
  5048. }
  5049. printf("-------------\n");
  5050.  
  5051. if(is_word_guessed(secret, hadaneslova)==1){
  5052. printf("Congratulations, you won!\n");
  5053. break;
  5054. }
  5055. }
  5056. if(chances==0){
  5057.     printf("Sorry, you ran out of guesses. The word was %s.\n", secret);
  5058. }
  5059.  
  5060. }
  5061.  
  5062.  
  5063. SUBOR B: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  5064.  
  5065. #define WORDLIST_FILENAME "words.txt"
  5066.  
  5067. /**
  5068.  * Function detects, whether player guessed the secret word
  5069.  * Based on the letters player used for guessing, this function detects,
  5070.  * if it is possible to construct (and guess) the secret word from this set.
  5071.  * If it is possible, function returns 1. If not, returns 0.
  5072.  * @param secret the secret word lowercase
  5073.  * @param letters_guessed the lowercase letters player already used in his guessing
  5074.  * @return 1, if word is guess; 0 otherwise.
  5075.  */
  5076. int is_word_guessed(const char secret[], const char letters_guessed[]);
  5077.  
  5078.  
  5079. /**
  5080.  * Function returns string representing the guessed word
  5081.  * This string contains visible letters, which were guessed successfuly
  5082.  * by player at their correct positions. If there are still some hidden
  5083.  * letters, the character '_' will be used for their representation.
  5084.  * @param secret the secret word lowercase
  5085.  * @param letters_guessed the lowercase letters player already used in his guessing
  5086.  * @param guessed_word the constructed string as result of this function (output parameter)
  5087.  */
  5088. void get_guessed_word(const char secret[], const char letters_guessed[], char guessed_word[]);
  5089.  
  5090.  
  5091. /**
  5092.  * Returns all letters, which were not used for guessing
  5093.  * Function returns set of lowercase letters sorted in alphabetical order. This
  5094.  * set will contain all letters from the alphabet, but it ommits those, which
  5095.  * were already guessed.
  5096.  * @param letters_guessed the lowercase letters player already used in his guessing
  5097.  * @param available_letters set of lowercase not yet used letters
  5098.  */
  5099. void get_available_letters(const char letters_guessed[], char available_letters[]);
  5100.  
  5101.  
  5102. /**
  5103.  * Starts interactive hangman game
  5104.  *
  5105.  * @param secret the secret word lowercase
  5106.  */
  5107. void hangman(const char secret[]);
  5108.  
  5109.  
  5110. /**
  5111.  * Returns the random word
  5112.  * Function opens the file with all the words and reads randomly one of them
  5113.  * into the buffer pointed by secret. Word consists of lowercase letters.
  5114.  * If there is some error with reading the file, 1 is returned.
  5115.  * Don't forget to initialize the random numbers in your main() function will srand() call!
  5116.  * Otherwise (everything is ok), 0 is returned.
  5117.  * @param secret buffer, where random word will be read
  5118.  * @return status code
  5119.  */
  5120. int get_word(char secret[]);
  5121.  
  5122.  
  5123. SUBOR C: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  5124.  
  5125. #include <stdio.h>
  5126. #include <stdlib.h>
  5127. #include <time.h>
  5128. #include <string.h>
  5129. #include "hangman.h"
  5130.  
  5131.  
  5132.  
  5133. int main(){
  5134.    
  5135.  
  5136.     srand(time (NULL));
  5137.     char secret[16];
  5138.     get_word(secret);
  5139.    
  5140.    
  5141.    
  5142.     while(0)
  5143.     {      
  5144.     printf("%d\n", is_word_guessed("hello", "aeihoul"));
  5145.    
  5146.  
  5147.     char result[30];
  5148.     if(5<4)
  5149.     get_guessed_word("yells", "abcdefghijklmnopqrstuvwxyz", result);
  5150.     //printf("%s", result);
  5151.     get_available_letters("arpstxgoieyu", result);
  5152.     printf("%s",result);
  5153.     }
  5154.     hangman(secret);
  5155.    
  5156.     return 0;
  5157.  
  5158.  
  5159. }
  5160.  
  5161. PS9: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  5162.     #include <stdio.h>
  5163.    
  5164. int main(int argc, char* argv[]){
  5165.  
  5166.    
  5167.    
  5168.    FILE *fp = fopen(argv[1], "r");
  5169.     if (fp == NULL)
  5170.     {
  5171.        
  5172.                 return 1;
  5173.     }
  5174.     char ch = fgetc(fp);
  5175.     int iteracna=0;
  5176.      while (ch != EOF)
  5177.      {
  5178.    
  5179.         ch = fgetc(fp);
  5180.     if((ch=='a')||(ch=='A'))
  5181.     {
  5182.         ch=fgetc(fp);
  5183.         if((ch=='n')||(ch=='N'))
  5184.         {
  5185.             ch=fgetc(fp);
  5186.                 if((ch=='a')||(ch=='A'))
  5187.                 {
  5188.                     ch=fgetc(fp);
  5189.                         if((ch=='n')||(ch=='N'))
  5190.                             {
  5191.                             ch=fgetc(fp);
  5192.                             if((ch=='a')||(ch=='A'))
  5193.                             {
  5194.                                 ch=fgetc(fp);
  5195.                                 if((ch=='s')||(ch=='S'))
  5196.                                 {
  5197.                                 iteracna++;
  5198.                                 }
  5199.                             }
  5200.                             }
  5201.                 }
  5202.         }
  5203.  
  5204.     }
  5205.      }
  5206.      
  5207.      fclose(fp);
  5208.  
  5209.     fp = fopen(argv[1], "w");
  5210.    
  5211.         if(iteracna>9)
  5212.         {
  5213.             int iteracna1=iteracna%10;
  5214.             iteracna=iteracna/10;
  5215.             iteracna=iteracna+'0';
  5216.             iteracna1=iteracna1+'0';
  5217.             fputc(iteracna,fp);
  5218.             fputc(iteracna1,fp);
  5219.         }
  5220.         else
  5221.         {
  5222.         iteracna=iteracna+'0';
  5223.         fputc(iteracna,fp);
  5224.         }
  5225.    
  5226.     fclose(fp);
  5227.  
  5228. return 0;
  5229.  
  5230. }
RAW Paste Data