API tools faq
paste
Advertisement
Solomid

Zadaća 4

Solomid
Jan 6th, 2020
112
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 12.02 KB | None | 0 0
raw download clone embed print report
  1. 1.
  2. #include <stdio.h>
  3. #include <math.h>
  4. #define e 0.0001
  5.  
  6. void unesi(char niz[], int velicina)
  7. {
  8.     char znak = getchar();
  9.     if (znak == '\n') znak = getchar();
  10.     int i = 0;
  11.     while(i < velicina - 1 && znak != '\n') {
  12.         niz[i] = znak;
  13.         i++;
  14.         znak = getchar();
  15.     }
  16.     niz[i]='\0';
  17. }
  18.  
  19. char* nadji_zbir(char *s)
  20. {
  21.     int predznak = 1, broj = 0;
  22.     int tmp = 0, decimal = 0,brojac = 0;
  23.     char* pom1, *p = s;
  24.     double br1, br2, br3;
  25.     while(*s != '\0') {
  26.         if((*s >= '0' && *s <= '9')||(*s == '-')) {
  27.             broj++;
  28.             if(broj == 1) p = s;
  29.  
  30.             predznak = 1;
  31.             brojac = 0;
  32.             decimal = 0;
  33.             tmp = 0;
  34.  
  35.             if(*s == '-') {
  36.                 predznak = -1;
  37.                 s++;
  38.             }
  39.             while((*s >= '0' && *s <= '9')||(*s == '.')) {
  40.                 if(*s == '.') decimal=1;
  41.                 else {
  42.                     tmp = tmp * 10 + *s - '0';
  43.                     if(decimal) brojac++;
  44.                 }
  45.                 s++;
  46.             }
  47.             if(broj == 1) {
  48.                 pom1 = s;
  49.                 if(decimal)
  50.                     br1 = (tmp*predznak)/pow(10,brojac);
  51.                 else br1 = tmp*predznak;
  52.             }
  53.             if(broj == 2) {
  54.                 if(decimal)
  55.                     br2 = (tmp*predznak)/pow(10,brojac);
  56.                 else br2 = tmp*predznak;
  57.             }
  58.             if(broj == 3) {
  59.                 broj = 0;
  60.                 if(decimal)
  61.                     br3 = (tmp*predznak)/pow(10,brojac);
  62.                 else br3 = tmp*predznak;
  63.                 if(fabs(br1+br2-br3) < e) return p;
  64.                 else if(*s == '\0') return NULL;
  65.                 else s = pom1;
  66.             }
  67.         }
  68.         s++;
  69.     }
  70.     return NULL;
  71. }
  72.  
  73. void razlike(char* s)
  74. {
  75.     int predznak = 1, broj = 0;
  76.     int tmp = 0, decimal = 0,brojac = 0;
  77.     char* pom = s;
  78.     double br1 = 0,br2 = 0;
  79.     char* p = nadji_zbir(s);
  80.     if(p == NULL) return;
  81.     while(*p != '\0') {
  82.         if((*p >= '0' && *p <= '9')||(*p == '-')) {
  83.             broj++;
  84.  
  85.             predznak = 1;
  86.             brojac = 0;
  87.             decimal = 0;
  88.             tmp = 0;
  89.  
  90.             if(*p == '-') {
  91.                 predznak = -1;
  92.                 p++;
  93.             }
  94.             while((*p >= '0' && *p <= '9')||(*p == '.')) {
  95.                 if(*p == '.') decimal=1;
  96.                 else {
  97.                     tmp = tmp * 10 + *p - '0';
  98.                     if(decimal) brojac++;
  99.                 }
  100.                 p++;
  101.             }
  102.             if(broj == 1) {
  103.                 pom = p;
  104.                 if(decimal)
  105.                     br1 = (tmp*predznak)/pow(10,brojac);
  106.                 else br1 = tmp*predznak;
  107.             }
  108.             if(broj == 2) {
  109.                 if(decimal)
  110.                     br2 = (tmp*predznak)/pow(10,brojac);
  111.                 else br2 = tmp*predznak;
  112.                 broj = 0;
  113.                 printf("%g - %g = %g\n",br1,br2,br1-br2);
  114.                 p = nadji_zbir(pom);
  115.                 if(p == NULL) return;
  116.                 else p--;
  117.             }
  118.         }
  119.         p++;
  120.     }
  121.     return;
  122. }
  123.  
  124.  
  125. int main()
  126. {
  127.     char tekst[1000];
  128.     printf("Unos:\n");
  129.     unesi(tekst,1000);
  130.     razlike(tekst);
  131.     return 0;
  132. }
  133.  
  134. 2.
  135. #include <stdio.h>
  136. #include <string.h>
  137.  
  138. void unesi(char niz[], int velicina)
  139. {
  140.     char znak = getchar();
  141.     if (znak == '\n') znak = getchar();
  142.     int i = 0;
  143.     while(i < velicina - 1 && znak != '\n') {
  144.         niz[i] = znak;
  145.         i++;
  146.         znak = getchar();
  147.     }
  148.     niz[i]='\0';
  149. }
  150.  
  151. void slova(char *s1, char *s2)
  152. {
  153.     while(*s1 != '\0') {
  154.         if(*s1>='A' && *s1<='Z')
  155.             *s1 = *s1 + 32;
  156.         s1++;
  157.     }
  158.     while(*s2 != '\0') {
  159.         if(*s2>='A' && *s2<='Z')
  160.             *s2 = *s2 + 32;
  161.         s2++;
  162.     }
  163. }
  164.  
  165. int provjera(char s1[], char s2[], int i)
  166. {
  167.     int k,l,error = 0;
  168.     char c;
  169.     int br1 = 0, br2 = 0;
  170.     for(k = 0; k < i; k++) {
  171.         slova(s1,s2);
  172.         c = s1[k];
  173.         for(l = 0; l < i; l++) {
  174.             if(s1[l] == c) br1++;
  175.             if(s2[l] == c) br2++;
  176.         }
  177.         if(br1 != br2) {
  178.             error = 1;
  179.             break;
  180.         } else {
  181.             br1 = 0;
  182.             br2 = 0;
  183.         }
  184.     }
  185.     if(error) return 1;
  186.     return 0;
  187. }
  188.  
  189. char* izbaci_anagrame(char *s1, char *s2)
  190. {
  191.     char *p, *q, *pom1, *pom2, *string1, *string2 = s2;
  192.     p = q = pom1 = string1 = s1;
  193.     char rijec[10001] = "",anagram[10001] = "";
  194.     int i = 0, j = 0, gasi_prvu = 0, gasi_drugu = 0;
  195.     while(1) {
  196.         if(gasi_prvu) break;
  197.         if(!((*string2 >= 'a' && *string2 <= 'z')||(*string2 >= 'A' && *string2 <= 'Z')) || *string2 == '\0') {
  198.             if(i == 0) {
  199.                 if(*string2 == '\0') gasi_prvu = 1;
  200.                 string2++;
  201.                 continue;
  202.             }
  203.             rijec[i] = '\0';
  204.             while(1) {
  205.                 if(gasi_drugu) {
  206.                     gasi_drugu = 0;
  207.                     break;
  208.                 }
  209.                 if(!((*string1 >= 'a' && *string1 <= 'z')||(*string1 >= 'A' && *string1 <= 'Z')) || *string1 == '\0') {
  210.                     if(j == 0) {
  211.                         if(*string1 == '\0') gasi_drugu = 1;
  212.                         string1++;
  213.                         continue;
  214.                     }
  215.                     anagram[j] = '\0';
  216.                     q = string1;
  217.  
  218.                     if(i != j) {
  219.                         pom1 = q;
  220.                         pom2 = q;
  221.                     } else {
  222.                         if(provjera(rijec,anagram,i) == 0) {
  223.                             pom2 = pom1;
  224.                             while(*pom1++ = *q++);
  225.  
  226.                             if(*p == '\0') break;
  227.  
  228.                             pom1 = pom2;
  229.                             string1 = pom2;
  230.                         }
  231.                     }
  232.                     j=0;
  233.                 } else {
  234.                     anagram[j] = *string1;
  235.                     j++;
  236.                 }
  237.                 if(*string1 == '\0') break;
  238.                 string1++;
  239.             }
  240.             string1 = p;
  241.             pom1 = p;
  242.             pom2 = p;
  243.             i=0;
  244.         } else {
  245.             rijec[i] = *string2;
  246.             i++;
  247.         }
  248.         if(*string2 == '\0') break;
  249.         string2++;
  250.     }
  251.     return p;
  252. }
  253.  
  254. int main()
  255. {
  256.     char string1[10001], string2[10001];
  257.     printf("Unesite prvi string:");
  258.     unesi(string1,10001);
  259.     printf("Unesite drugi string:");
  260.     unesi(string2,10001);
  261.     printf("'%s'", izbaci_anagrame(string1, string2));
  262.     return 0;
  263. }
  264.  
  265. 3.
  266. #include <stdio.h>
  267. #include <math.h>
  268. #include <string.h>
  269.  
  270. void unesi(char niz[], int velicina)
  271. {
  272.     char znak = getchar();
  273.     if (znak == '\n') znak = getchar();
  274.     int i = 0;
  275.     while(i < velicina - 1 && znak != '\n') {
  276.         niz[i] = znak;
  277.         i++;
  278.         znak = getchar();
  279.     }
  280.     niz[i]='\0';
  281. }
  282.  
  283. void slova(char *s1, char *s2)
  284. {
  285.     while(*s1 != '\0') {
  286.         if(*s1>='A' && *s1<='Z')
  287.             *s1 = *s1 + 32;
  288.         s1++;
  289.     }
  290.     while(*s2 != '\0') {
  291.         if(*s2>='A' && *s2<='Z')
  292.             *s2 = *s2 + 32;
  293.         s2++;
  294.     }
  295. }
  296.  
  297. int samoglasnik(char s)
  298. {
  299.     if(s == 'a' || s == 'e' || s == 'i' || s == 'o' || s == 'u' || s == 'A' || s == 'E' || s == 'I' || s == 'O' || s == 'U')
  300.         return 1;
  301.     return 0;
  302. }
  303.  
  304. void max_slog(char *s1, char *s2)
  305. {
  306.     char *p = s1, *q = s1;
  307.     char *pom1, *pom2;
  308.  
  309.     char slog[10001] = "",slogovi[10001] = "",max[10001] = "";
  310.     int i = 0, j = 0, k = 0, br = 0, pronadjen = 0,maxbr = 0, provjera = 0, error = 0, duzina = 0, najduzi = 0;
  311.     while(*p != '\0') {
  312.         if((*p >= 'a' && *p<= 'z')||(*p >= 'A' && *p<= 'Z')) {
  313.             slog[i] = *p;
  314.             i++;
  315.             if(samoglasnik(*p)) {
  316.                 slog[i] = '\0';
  317.                 pronadjen = 1;
  318.             }
  319.         }
  320.         if(!((*p >= 'a' && *p <= 'z')||(*p >= 'A' && *p <= 'Z')) || *p == '\0') {
  321.             if(i == 0) {
  322.                 p++;
  323.                 continue;
  324.             }
  325.             slog[i] = '\0';
  326.             pronadjen = 1;
  327.         }
  328.         if(pronadjen) {
  329.             duzina = i;
  330.             while(*q != '\0') {
  331.                 if((*q >= 'a' && *q<= 'z')||(*q >= 'A' && *q<= 'Z')) {
  332.                     slogovi[j] = *q;
  333.                     j++;
  334.                     if(samoglasnik(*q)) {
  335.                         slogovi[j] = '\0';
  336.                         provjera = 1;
  337.                     }
  338.                 }
  339.                 if(!((*q >= 'a' && *q <= 'z')||(*q >= 'A' && *q <= 'Z')) || *q == '\0') {
  340.                     if(j == 0) {
  341.                         q++;
  342.                         continue;
  343.                     }
  344.                     slogovi[j] = '\0';
  345.                     provjera = 1;
  346.                 }
  347.                 if(provjera) {
  348.                     slova(slog,slogovi);
  349.                     if(duzina != j) {
  350.                         q++;
  351.                         j = 0;
  352.                         provjera = 0;
  353.                         continue;
  354.                     } else {
  355.                         for(k = 0; k < duzina; k++) {
  356.                             if(slog[k] == slogovi[k]) continue;
  357.                             else {
  358.                                 error = 1;
  359.                                 break;
  360.                             }
  361.                         }
  362.                     }
  363.                     if(error) error = 0;
  364.                     else br++;
  365.                     j = 0;
  366.                     provjera = 0;
  367.                 }
  368.                 q++;
  369.             }
  370.             if(br > maxbr) {
  371.                 najduzi = duzina;
  372.                 maxbr = br;
  373.                 pom1 = max;
  374.                 pom2 = slog;
  375.                 while(*pom1++ = *pom2++);
  376.             } else if(br == maxbr) {
  377.                 if(duzina > najduzi) {
  378.                     najduzi = duzina;
  379.                     pom1 = max;
  380.                     pom2 = slog;
  381.                     while(*pom1++ = *pom2++);
  382.                 }
  383.             }
  384.             br = 0;
  385.             i = 0;
  386.             pronadjen = 0;
  387.             q = s1;
  388.         }
  389.         p++;
  390.     }
  391.     char* pom = max;
  392.     char* upis = s2;
  393.     while(*upis++ = *pom++);
  394. }
  395.  
  396. int main()
  397. {
  398.     char tekst[10001] = "";
  399.     char slog[10001] = "";
  400.     printf("Unesite tekst:");
  401.     unesi(tekst,10001);
  402.     max_slog(tekst, slog);
  403.     printf("'%s'", slog);
  404.     return 0;
  405. }
  406.  
  407. 4.
  408. #include <stdio.h>
  409. #include <math.h>
  410.  
  411. void unesi(char niz[], int velicina)
  412. {
  413.     char znak = getchar();
  414.     if (znak == '\n') znak = getchar();
  415.     int i = 0;
  416.     while(i < velicina - 1 && znak != '\n') {
  417.         niz[i] = znak;
  418.         i++;
  419.         znak = getchar();
  420.     }
  421.     niz[i]='\0';
  422. }
  423.  
  424. int izracunaj(char *s, int *ok)
  425. {
  426.     char *provjera = s, *operandi = s,*p = s;
  427.     int predznak = 1, brojac = 0, tmp, j = 0, i = 0, k = 0,l;
  428.     char operacija[100] = "";
  429.     int brojevi[101];
  430.     int temp = 0;
  431.     *ok = 1;
  432.     while(*provjera != '\0') {
  433.         if(!(*provjera >= '0' && *provjera <= '9') && *provjera != '+' && *provjera != '-'
  434.                 && *provjera != '*' && *provjera != '/' && *provjera != '^') {
  435.             *ok = 0;
  436.             break;
  437.         }
  438.  
  439.         if(provjera == s && !(*provjera >= '0' && *provjera <= '9')) {
  440.             if(*provjera == '-') {
  441.                 provjera++;
  442.                 if(*provjera == '-') {
  443.                     *ok = 0;
  444.                     break;
  445.                 }
  446.             } else {
  447.                 *ok = 0;
  448.                 break;
  449.             }
  450.         }
  451.  
  452.         while(*provjera >= '0' && *provjera <= '9') provjera++;
  453.  
  454.         if(*provjera == '+' || *provjera == '-' || *provjera == '*' || *provjera == '/' || *provjera == '^') {
  455.             provjera++;
  456.             if(*provjera == '-') {
  457.                 provjera++;
  458.                 if(!(*provjera >= '0' && *provjera <= '9')) {
  459.                     *ok = 0;
  460.                     break;
  461.                 }
  462.             }
  463.             if(*provjera == '+' || *provjera == '*' || *provjera == '/' || *provjera == '^' || *provjera == '\0') {
  464.                 *ok = 0;
  465.                 break;
  466.             }
  467.         }
  468.         if(*provjera == '\0') break;
  469.         provjera++;
  470.     }
  471.  
  472.     while(*s != '\0') {
  473.         if((*s >= '0' && *s <= '9')||(*s == '-')) {
  474.             if(*s == '-') {
  475.                 if(s == p)
  476.                     predznak = -1;
  477.                 else if(*(s-1) >= '0' && *(s-1) <= '9')
  478.                     predznak = 1;
  479.                 else
  480.                     predznak = -1;
  481.             } else if(*s >= '0' && *s <= '9') {
  482.                 tmp = 0;
  483.                 while(*s >= '0' && *s <= '9') {
  484.                     tmp = tmp * 10 + *s - '0';
  485.                     s++;
  486.                 }
  487.                 brojevi[j] = tmp*predznak;
  488.                 predznak = 1;
  489.                 brojac++;
  490.                 j++;
  491.                 s--;
  492.             }
  493.         }
  494.         s++;
  495.     }
  496.  
  497.     if(!*ok) {
  498.         return brojevi[0];
  499.     } else {
  500.         while(*operandi != '\0') {
  501.             if(operandi == p && *operandi == '-') {
  502.                 operandi++;
  503.                 continue;
  504.             }
  505.             if(!(*operandi >= '0' && *operandi <= '9')) {
  506.                 operandi++;
  507.                 if(*operandi == '-') {
  508.                     operacija[i] = *(operandi-1);
  509.                     operandi++;
  510.                 } else
  511.                     operacija[i] = *(operandi-1);
  512.                 i++;
  513.             }
  514.             operandi++;
  515.         }
  516.         operacija[i] = '\0';
  517.  
  518.         operandi = operacija;
  519.         while(*operandi != '\0') {
  520.             while(*operandi != '^' && *operandi != '\0') {
  521.                 k++;
  522.                 operandi++;
  523.             }
  524.             if(*operandi == '\0') {
  525.                 operandi = operacija;
  526.                 k = 0;
  527.                 break;
  528.             } else {
  529.                 temp = (int)pow(brojevi[k],brojevi[k+1]);
  530.                 brojevi[k] = temp;
  531.                 for(l = k+1; l < brojac; l++) {
  532.                     brojevi[l] = brojevi[l+1];
  533.                 }
  534.                 brojac--;
  535.                 while(*operandi != '\0') {
  536.                     *operandi = *(operandi+1);
  537.                     if(*operandi == '\0') break;
  538.                     operandi++;
  539.                 }
  540.                 i--;
  541.                 operandi = operacija;
  542.                 k = 0;
  543.             }
  544.         }
  545.         while(*operandi != '\0') {
  546.             while(*operandi != '*' && *operandi != '/' && *operandi != '\0') {
  547.                 k++;
  548.                 operandi++;
  549.             }
  550.             if(*operandi == '\0') {
  551.                 operandi = operacija;
  552.                 k = 0;
  553.                 break;
  554.             } else {
  555.                 if(*operandi == '*')
  556.                     temp = brojevi[k] * brojevi[k+1];
  557.                 else{
  558.                     if(brojevi[k+1] == 0){
  559.                         *ok = 0;
  560.                         return brojevi[0];
  561.                     }else
  562.                     temp = brojevi[k] / brojevi[k+1];
  563.                 }
  564.                 brojevi[k] = temp;
  565.                 for(l = k+1; l < brojac; l++) {
  566.                     brojevi[l] = brojevi[l+1];
  567.                 }
  568.                 brojac--;
  569.                 while(*operandi != '\0') {
  570.                     *operandi = *(operandi+1);
  571.                     if(*operandi == '\0') break;
  572.                     operandi++;
  573.                 }
  574.                 i--;
  575.                 operandi = operacija;
  576.                 k = 0;
  577.             }
  578.         }
  579.         while(*operandi != '\0') {
  580.             while(*operandi != '+' && *operandi != '-' && *operandi != '\0') {
  581.                 k++;
  582.                 operandi++;
  583.             }
  584.             if(*operandi == '\0') {
  585.                 operandi = operacija;
  586.                 k = 0;
  587.                 break;
  588.             } else {
  589.                 if(*operandi == '+')
  590.                     temp = brojevi[k] + brojevi[k+1];
  591.                 else
  592.                     temp = brojevi[k] - brojevi[k+1];
  593.                 brojevi[k] = temp;
  594.                 for(l = k+1; l < brojac; l++) {
  595.                     brojevi[l] = brojevi[l+1];
  596.                 }
  597.                 brojac--;
  598.                 while(*operandi != '\0') {
  599.                     *operandi = *(operandi+1);
  600.                     if(*operandi == '\0') break;
  601.                     operandi++;
  602.                 }
  603.                 i--;
  604.                 operandi = operacija;
  605.                 k = 0;
  606.             }
  607.         }
  608.     }
  609.     return brojevi[0];
  610. }
  611.  
  612. int main()
  613. {
  614.     char string[500];
  615.     int ok, rez;
  616.     printf("Unesite matematički izraz za proračun:(dozovoljene računske operacije:'+','-','*','/','^')\n");
  617.     unesi(string,500);
  618.     rez = izracunaj(string, &ok);
  619.     printf("Rezultat: %d Prijava greške: %d", rez, ok);
  620.     return 0;
  621. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!