kraus svi primeri

7/23/2019 Kraus Svi Primeri

http://slidepdf.com/reader/full/kraus-svi-primeri 1/79

//poincare.matf.bg.ac.rs/~filip//color.pl?dat=pp/0405/archive/1.c.html[2/12/2011 2:53:37 PM]

/*----------------------------1.1.c--------------------------*/ /* Program stampa na ekran poruku Zdravo svima */ #i ncl ude <st di o. h>

mai n( ){ pr i nt f ( "Zdravo svi ma\ n") ;}

/*----------------------------1.2.c--------------------------*/

/* Ilustruje \n \t \\ \" i %% */ #i ncl ude <st di o. h>

mai n( ){ pr i nt f ( "\ "Zdr avo, svi ma\ "\ n" ) ; pr i nt f ( "\ \ n\ t pr el azak u novi r ed\ n" ) ; pr i nt f ( " \ \ t \ t t abul ator \ n" ) ; pr i nt f ( " \ \ \ \ \ tkosa c r ta \n" ) ; pr i nt f ( "%%%%\ t pr ocenat \ n" ) ;}

/*----------------------------1.3.c--------------------------*/ /* Prikazuje ispis vrednosti celobrojne promenjive koristeci printf("%d") */ #i ncl ude <st di o. h>

mai n( )

{ int i = 2; pr i nt f ( "Vr ednost pr omenj i ve i j e %d\ n" , i ) ;}

/*----------------------------1.4.c--------------------------*/ /* Prikazuje unos celog broja koristeci scanf("%d", &x) */ #i ncl ude <st di o. h>

mai n( ){ int x; pr i nt f ( "Unesi ceo br oj : " ) ;

/* Obratiti paznju na znak & (operator uzimanja adrese) pre imena promenjive u funkciji scanf */

scanf ( "%d" , &x) ;

/* U funkciji printf nije potrebno stavljati & */ pr i nt f ( "Unel i st e br oj %d\ n" , x) ;}

/*----------------------------1.5.c--------------------------*/ /* Prikazuje unos i ispis realnih brojeva (formati %f i %g) */ #i ncl ude <st di o. h>

mai n( ){ float x; pr i nt f ( "Unesi r eal an br oj : " ) ;

/* Eksperimentisati sa vrednoscu npr. 34.56 */ scanf ( "%f " , &x) ;

pr i nt f ( "Unel i st e br oj ( %%f ) : %f \ n" , x) ; pr i nt f ( "U naucnoj notaci j i ( %%g) : %g\ n" , x) ;}

/*----------------------------1.6.c--------------------------*/ /* Prikazuje zaukruzivanje realnog broja prilikom ispisa (%.2f) */ #i ncl ude <st di o. h>

mai n( ){ float x; pr i nt f ( "Unesi r eal an br oj : " ) ; scanf ( "%f " , &x) ; pr i nt f ( "Br oj zaokruzen na dve deci mal e j e : %. 2f \ n" , x) ;}




/*----------------------------1.7.c--------------------------*/ /* Ilustruje ispis karaktera i niski karaktera (%c i %s) kao i ascii vrednosti karaktera (%d) */

#i ncl ude <st di o. h>mai n( ){

pr i nt f ( "%s\ nkarakt er =%3c\ nvrednost =%3d\ n" , "Vel i ko sl ovo" , ' A' , ' A' ) ;pr i nt f ( "%s\ nkarakt er =%3c\ nvrednost =%3d\ n" , "Mal o sl ovo", ' a' , ' a' ) ;

}




/*----------------------------2.1.c--------------------------*/ /* Program sabira dva uneta cela broja */ #include <stdio.h>

int main(){ int a, b, c; printf("Unesi prvi broj : "); scanf("%d", &a); printf("Unesi drugi broj : ");

scanf("%d", &b); c = a + b; printf("%d + %d = %d\n", a, b, c); return 0;}

/*----------------------------2.2.c--------------------------*/ /* Aritmeticke operacije */ #include <stdio.h>main(){ int a, b; printf("Unesi prvi broj : "); scanf("%d",&a);

printf("Unesi drugi broj : "); scanf("%d",&b);

printf("Zbir a+b je : %d\n",a+b);printf("Razlika a-b je : %d\n",a-b);printf("Proizvod a*b je : %d\n",a*b);printf("Celobrojni kolicnik a/b je : %d\n", a/b);

printf("Pogresan pokusaj racunanja realnog kolicnika a/b je : %f\n", a/b); printf("Realni kolicnik a/b je : %f\n", (float)a/(float)b); printf("Ostatak pri deljenju a/b je : %d\n", a%b);

}

/*----------------------------2.2a.c--------------------------*/ /* Celobrojno i realno deljenje */ #include <stdio.h>

main()

{ int a = 5; int b = 2; int d = 5/2; /* Celobrojno deljenje - rezultat je 2 */ float c = a/b; /* Iako je c float, vrsi se celobrojno deljenje jer su i a i b celi */

/* Neocekivani rezultat 3.000000 */ printf("c = %f\n",c);

printf("Uzrok problema : 5/2 = %f\n", 5/2);

printf("Popravljeno : 5.0/2.0 = %f\n", 5.0/2.0);

printf("Moze i : 5/2.0 = %f i 5.0/2 = %f \n", 5/2.0, 5.0/2);

printf("Za promenjive mora kastovanje : %f\n", (float)a/(float)b);

}

/*----------------------------2.3.c--------------------------*/ /* Ilustracija prefiksnog i postfiksnog operatora ++ */

/* Operator ++ uvecava vrednost promenjive za 1.Operator -- je potpuno analogan operatoru ++ osim sto umanjuje vrednost za 1 */

#include <stdio.h>main(){ int x, y; int a = 0, b = 0;

printf("Na pocetku : \na = %d\nb = %d\n", a, b);




/* Ukoliko se vrednost izraza ne koristi, prefiksni i

postfiksni operator se ne razlikuju */ a++;

++b; printf("Posle : a++; ++b; \na = %d\nb = %d\n", a, b);

/* Prefiksni operator uvecava promenjivu, i rezultatje uvecana vrednost */

x = ++a;

/* Postfiksni operator uvecava promenjivu, i rezultat jestara (neuvecana) vrednost */

y = b++; printf("Posle : x = ++a; \na = %d\nx = %d\n", a, x);

printf("Posle : y = b++; \nb = %d\ny = %d\n", b, y);}

/*----------------------------2.4a.c--------------------------*/ /* Program ilustruje if i ispisuje ukoliko je uneti ceo broj negativan */ #include <stdio.h>

int main(){ int b; printf("Unesi ceo broj:"); scanf("%d", &b); if (b < 0)

printf("Broj je negativan\n"); return 0;}

/*----------------------------2.4b.c--------------------------*/ /* Program ilustruje if-else konstrukciju i ispituje znak broja */ #include <stdio.h>

int main(){ int b; printf("Unesi ceo broj : "); scanf("%d", &b); if (b < 0) printf("Broj je negativan\n"); else if (b == 0) printf("Broj je nula\n"); else

printf("Broj je pozitivan\n"); return 0;}

/*----------------------------2.4c.c--------------------------*/ /* Pogresan program sa dodelom = umesto poredjenja == */ #include <stdio.h>

int main(){ int b; printf("Unesi ceo broj : "); scanf("%d", &b);

/* Obratiti paznju na = umesto == Analizirati rad programa*/

if

(b = 0) printf("Broj je nula\n"); else if (b < 0) printf("Broj je negativan\n"); else

printf("Broj je pozitivan\n"); return 0;}

/*----------------------------2.5a.c--------------------------*/ /* Logicke vrednosti - 0 - netacno, razlicito od 0 - tacno*/ #include <stdio.h>

main(){




int a;

printf("Unesi ceo broj : "); scanf("%d", &a); if (a) printf("Logicka vrednost broja je : tacno\n"); else

printf("Logicka vrednost broja je : netacno\n");}

/*----------------------------2.5b.c--------------------------*/ /* Logicki i relacijski operatori*/ #include <stdio.h>

main(){ int a = 3>5, /* manje */ b = 5>3, /* vece */ c = 3==5, /* jednako */ d = 3!=5; /* razlicito */

printf("3>5 - %d\n5>3 - %d\n3==5 - %d\n3!=5 - %d\n", a, b, c, d);

printf("Konjunkcija : 3>5 && 5>3 - %d\n", a && b); printf("Disjunkcija : 3>5 || 5>3 - %d\n", a || b); printf("Negacija : !(3>5) - %d\n", !a);

}

/*----------------------------2.6a.c--------------------------*/

/* Program ilustruje petlju - while */ #include <stdio.h>

int main(){ int x;

x = 1; while (x<10) { printf("x = %d\n",x); x++; /* x++ je isto kao i x=x+1 */ }

}

/*----------------------------2.6b.c--------------------------*/

/* Program ilustruje petlju do-while */ #include <stdio.h>

int main(){ int x;

x = 1; do

{ printf("x = %d\n",x); x++; /* x++ je isto kao i x=x+1 */ } while (x<=10);

}

/*----------------------------2.6c.c--------------------------*/ /* Program ilustruje petlju - for */ #include <stdio.h>

int main(){ int x;

for (x = 1; x < 10; x++) printf("x = %d\n",x);

}

/*----------------------------2.7a.c--------------------------*/ /* Konverzija centimetara u ince - while petlja*/




#include <stdio.h>

/* Definicija simbolickih konstanti preko #define direktiva */ /* U fazi pretprocesiranja se vrsi doslovna zamena konstanti

njihovim vrednostima */

#define POCETAK 0#define KRAJ 100#define KORAK 10

int main(){

int

a; a = POCETAK; while (a <= KRAJ) { printf("%4d cm = %4.2f in\n", a, a/2.54); a += KORAK; /* isto sto i a = a + KORAK; */ } return 0;}

/*----------------------------2.7b.c--------------------------*/ /* Konverzija centimetara u ince - for petlja */ #include <stdio.h>#define POCETAK 0#define KRAJ 100#define KORAK 10

int main(){ int a; for (a = POCETAK; a <= KRAJ; a += KORAK) printf("%4d cm = %4.2f in\n", a, a/2.54);

return 0;}




/*----------------------------3.1.c--------------------------*/ /* Cita jedan karakter i ispisuje ga - demonstracija putchar i getchar */ #include <stdio.h>

main(){ int c; /* Karakter - obratiti paznju na int */ c = getchar(); /* cita karakter sa standardnog ulaza */ putchar(c); /* pise karakter c na standardni izlaz */

putchar('\n'); /* prelazak u novi red */ putchar('a'); /* ispisuje malo a */ putchar(97 ); /* ekvivalentno prethodnom */ }

/*----------------------------3.2.c--------------------------*/ /* Program prepisuje standardni ulaz na standardni izlaz */ /* Ilustracija redirekcije standardnog ulaza i izlaza : pokrenuti program sa :

./a.out <3.2.c

./a.out >tekst.txt ./a.out <3.2.c >kopija.c*/ #include <stdio.h>

main(){

int c; /* Obratiti paznju na raspored zagrada */ while ((c = getchar()) != EOF) putchar(c);}

/*----------------------------3.3.c--------------------------*/ /* Program ispisuje broj cifara na ulazu */

#include <stdio.h>

/* zbog isdigit */ #include <ctype.h>main(){ int c; int br_cifara = 0;

while ((c = getchar()) != EOF) if ('0'<=c && c<='9') /* moze i if (isdigit(c)) */ br_cifara++;

printf("Broj cifara je : %d\n", br_cifara);}

/*----------------------------3.4.c--------------------------*/ /* Brojanje pojavljivanja karaktera 0, 1 i 2. Program ilustruje switch */ #include <stdio.h>

main(){ int c; int br_0=0, br_1=0, br_2=0;

while

((c = getchar()) != EOF) { switch(c) { /* Obratiti paznju da nije case 0: niti case '0'; */ case '0':

br_0++; break; /* Isprobati veziju bez break */ case '1': br_1++; break; case '2': br_2++; break; } }




printf("Br 0 : %d\nBr 1 : %d\nBr 2 : %d\n",br_0, br_1, br_2);}

/*----------------------------3.5.c--------------------------*/ /* Program proverava da li su zagrade ( i ) dobro uparene */ #include <stdio.h>#include <stdlib.h>

main(){ int c; int br_otv = 0; while((c=getchar()) != EOF)

{ switch(c) { case '(': br_otv++; break; case ')': br_otv--; if (br_otv<0) { printf("Visak zatvorenih zagrada\n"); exit(1); } } }

if (br_otv == 0) printf("Zagrade su u redu\n"); else

printf("Visak otvorenih zagrada\n");}

/*----------------------------3.6.c--------------------------*/ /* Program ilustruje koriscenje statickih nizova.

Ispisuje 10 unetih brojeva unazad. */

#include <stdio.h>

main(){ int a[10]; int i;

for

(i = 0; i<10; i++) { printf("a[%d]=",i); scanf("%d",&a[i]); }

printf("Unazad : \n");

for (i = 9; i>=0; i--) printf("a[%d]=%d\n",i,a[i]);}

/*----------------------------3.7a.c--------------------------*/ /* Program pronalazi maksimum brojeva sa ulaza - verzija sa nizom */

#include <stdio.h>#define BR_ELEM 5main()

{ int a[BR_ELEM]; int i; int max;

/* Ucitavamo niz brojeva */ for (i = 0; i < BR_ELEM; i++) scanf("%d",&a[i]);

/* Pronalazimo maksimum */ max = a[0]; for (i = 1; i < BR_ELEM; i++) if (a[i]>max) max = a[i];

/* Ispisujemo maksimum */




printf("Max = %d\n",max);}

/*----------------------------3.7b.c--------------------------*/ /* Program pronalazi maksimum brojeva sa ulaza - verzija bez niza */

#include <stdio.h>#define BR_ELEM 5

main(){ int a, max, i; scanf("%d",&a);

max = a; for (i = 1; i < BR_ELEM; i++) { scanf("%d",&a); if (a>max) max = a; }

printf("Max : %d\n", max);}

/*----------------------------3.8.c--------------------------*/ /* Brojanje pojavljivanja svake od cifara. Koriscenje niza brojaca */

#include <stdio.h>#include <ctype.h>main()

{ /* Niz brojaca za svaku od cifara */ int br_cifara[10]; int i, c;

/* Resetovanje brojaca */ for (i = 0; i < 10; i++) br_cifara[i] = 0;

/* Citamo sa ulaza i povecavamo odgovarajuce brojace */ while ((c = getchar()) != EOF) if (isdigit(c)) br_cifara[c-'0']++;

/* Ispis rezultata */ for (i = 0; i < 10; i++) printf("Cifra %d se pojavila %d put%s\n", i, br_cifara[i], br_cifara[i]==1?"":"a"); }




/*----------------------------4.1.c--------------------------*/ /* Demonstracija sizeof operatora */

/* sizeof operator izracunava velicinu tipa odnosno promenjive */ main(){ int i; float f; int n[10];

printf("sizeof(int)=%d\n", sizeof(int)); printf("sizeof(long)=%d\n", sizeof(long)); printf("sizeof(short)=%d\n", sizeof(short)); printf("sizeof(signed)=%d\n", sizeof(signed )); printf("sizeof(unsigned)=%d\n", sizeof(unsigned )); printf("sizeof(char)=%d\n", sizeof(char)); printf("sizeof(float)=%d\n", sizeof(float)); printf("sizeof(double)=%d\n", sizeof(double));

printf("sizeof(i)=%d\n", sizeof(i)); printf("sizeof(f)=%d\n", sizeof(f)); printf("sizeof(n)=%d\n", sizeof(n)); printf("Broj elemenata niza n : %d\n", sizeof(n)/sizeof(int)); }

/*----------------------------4.2.c--------------------------*/ /* Program ilustruje inicijalizaciju nizova */ #include <stdio.h>

main(){ /* Niz inicijalizujemo tako sto mu navodimo vrednosti

u viticasnim zagradama. Dimenzija niza se odredjujena osnovu broja inicijalizatora */

int a[] = {1, 2, 3, 4, 5, 6 };

/* Isto vazi i za niske karaktera */ char s[] = {'a', 'b', 'c'};

/* Ekvivalentno prethodnom bi bilochar s[] = {97, 98, 99};

*/

/* Broj elemenata niza */ int a_br_elem = sizeof(a)/sizeof(int); int s_br_elem = sizeof(s)/sizeof(char);

/* Ispisujemo nizove */

int i; for (i = 0; i < a_br_elem; i++) printf("a[%d]=%d\n",i, a[i]);

for (i = 0; i < s_br_elem; i++) printf("s[%d]=%c\n",i, s[i]);

}/*----------------------------4.3.c--------------------------*/ /* Program uvodi niske karaktera terminisane nulom */

#include <stdio.h>

main(){ /* Poslednji bajt niske karaktera se postavlja na '\0' tj. 0 */ char s[] = {'a', 'b', 'c', '\0' };

/* Kraci nacin da se postigne prethodno */ char t[] = "abc";

/* Ispis niske s karakter po karakter*/




int i; for (i = 0; s[i] != '\0'; i++) putchar(s[i]); putchar('\n');

/* Ispis niske s koristeci funkciju printf */ printf("%s\n", s);

/* Ispis niske t karakter po karakter*/ for (i = 0; t[i] != '\0'; i++) putchar(t[i]); putchar('\n');

/* Ispis niske t koristeci funkciju printf */ printf("%s\n", t);

}

/*----------------------------4.4a.c--------------------------*/ /* sum - najjednostavnija funkcija koja sabira dva broja */

/* Definicija funkcije */ int sum(int a, int b){ return a+b;}

main(){

/* Poziv funkcije */ printf("%d\n", sum(3,5));}

/*----------------------------4.4b.c--------------------------*/ /* sum - najjednostavnija funkcija koja sabira dva broja -

verzija sa deklaracijom (prototipom)*/

/* Prototip (deklaracija) funkcije */ int zbir(int, int);

main(){ /* Poziv funkcije */ printf("%d\n", zbir(3,5));}

/* Definicija funkcije */ int zbir(int a, int b){ return a+b;}

/*----------------------------4.5.c--------------------------*/ /* power - funkcija koja stepenuje realan broj na celobrojni izlozilac */ #include <stdio.h>

/* stepenuje x^k tako sto k puta pomnozi x */ int power(float x, int k){ int i; float s = 1;

for (i = 0; i<k; i++) s*=x;

return s;}

/* Verzija koja radi i za negativne izlozioce */ int power_n(float x, int k){ int i; int negative = k<0;

if (negative) k = -k;

float s = 1;




for (i = 0; i<k; i++) s*=x;

return negative ? 1.0/s : s;}

main(){ /* Poziv funkcije */ float s = power(2.0,8); printf("%f\n", s);}

/*----------------------------4.6.c--------------------------*/ /* to_upper, to_lower - funkcije konverzije u velika, odnosno mala slova */

#include <stdio.h>

/* Funkcija konvertuje mala slova u velika,a ostala ne menja */

char to_upper(char c){ if ('a'<=c && c<='z') return c-'a'+'A'; return c;}

/* Funkcija konvertuje velika slova u mala,a ostala ne menja */

char to_lower(char c){ if ('A'<=c && c<='Z') return c-'A'+'a'; return c;}

main(){ int c; while ((c = getchar()) != EOF) putchar(to_upper(c));}

/*----------------------------4.7.c--------------------------*/ /* Funkcija za ispis niza brojeva - demonstrira prenos nizova brojeva u funkciju */

#include <stdio.h>/* Nizovi se prenose tako sto se prenese adresa njihovog pocetka. Uglaste zagrade ostaju prazne!

Nizove je neophodno prenositi zajedno sa dimenzijom niza (osim niski karaktera)*/ void print_array(int a[], int n){ int i; for (i = 0; i < n; i++) printf("%d ",a[i]); putchar('\n');

/* Obratite paznju na ovo : */ printf("sizeof(a) - u okviru fje : %d\n", sizeof(a));}

main(){ int a[] = {1, 2, 3, 4, 5, 6 , 7 , 8, 9};

printf("sizeof(a) - u okviru main : %d\n", sizeof(a)); print_array(a, sizeof(a)/sizeof(int));}

/*----------------------------4.8.c--------------------------*/ /* Funkcija za ispis niske karaktera - demonstrira prenos niske karaktera u funkciju*/ #include <stdio.h>

/* Uz nisku karaktera nije potrebno prenositi dimenziju ukoliko se postuje dogovor da se svaka niska zavrsava karakterom '\0'.*/ void print_string(char s[])




{ int i; for (i = 0; s[i]; i++) putchar(s[i]);}

main(){ print_string("Zdravo\n");}




/*----------------------------5.1.c--------------------------*/ /* Demonstracija prenosa parametara po vrednosti

- preneti parametri se ne mogu menjati */ #include <stdio.h>

/* Funkcija pokusava da ucita ceo broj.Zbog prenosa parametara po vrednosti ovo ne uspeva */

void get_num(int a){ scanf("%d", &a);

printf("a = %d\n", a);}

main(){ int x = 0; printf("Unesi broj : "); get_num(x); printf("x = %d\n", x);}

/*----------------------------5.2.c--------------------------*/ /* Demonstrira prenos nizova u funkciju - preneti niz se moze menjati */

#include <stdio.h>

/* Funkcija ucitava rec sa standardnog ulaza i smesta je u niz karaktera s. Ovo uspeva zbog toga sto se po vrednosti prenosi adresa pocetka niza,a ne ceo niz */

void get_word(char s[]){ int c, i = 0;

while (!isspace(c=getchar())) s[i++] = c; s[i] = '\0';}

main(){ /* Obavezno je alocirati memoriju za niz karaktera */ char s[100];

get_word(s); printf("%s\n", s);}

/*----------------------------5.3.c--------------------------*/ /* string_reverse - obrce nisku karaktera */

#include <stdio.h>

/* Zbog funkcije strlen */ #include <string.h>

/* Ova funkcija racuna duzinu date niske karaktera. Umesto nje, moguce je koristiti standardnu funkciju strlen . */ int string_length(char s[]){ int i; for (i = 0; s[i]; i++) ;

return i;}

/* Funkcija obrce nisku karaktera */ void string_reverse(char s[]){ int i, j; for (i = 0, j = string_length(s)-1; i<j; i++, j--) { int tmp = s[i]; s[i] = s[j];




s[j] = tmp; }

/* Napomena : razlikovati prethodnu petlju od dve ugnjezdjene petlje: for ( i = 0; ....) for ( j = duzina(s)-1; ... */ }

main(){ char s[] = "Zdravo svima";

string_reverse(s); printf("%s\n", s);}

/*----------------------------5.4.c--------------------------*/ /* strlen, strcpy, strcat, strcmp, strchr, strstr -

manipulacija niskama karaktera */ /* Vezbe radi, implementirane su funkcije biblioteke string.h */ #include <stdio.h>

/* Izracunava duzinu stringa */ int string_length(char s[]){ int i; for (i = 0; s[i]; i++) ; return i;

}

/* Kopira string src u string dest.Pretpostavlja da u dest ima dovoljno prostora. */

void string_copy(char dest[], char src[]){ /* Kopira karakter po karakter, sve dok nije iskopiran karakter '\0' */ int i; for (i = 0; (dest[i]=src[i]) != '\0'; i++) ;

/* Uslov != '\0' se, naravno, moze izostaviti :

for (i = 0; dest[i]=src[i]; i++) ; */ }

/* Nadovezuje string t na kraj stringa s.Pretpostavlja da u s ima dovoljno prostora. */

void string_concatenate(char s[], char t[]){ int i, j; /* Pronalazimo kraj stringa s */ for (i = 0; s[i]; i++) ;

/* Vrsi se kopiranje, slicno funkciji string_copy */ for (j = 0; s[i] = t[j]; j++, i++) ;}

/* Vrsi leksikografsko poredjenje dva stringa.Vraca :

0 - ukoliko su stringovi jednaki <0 - ukoliko je s leksikografski ispred t >0 - ukoliko je s leksikografski iza t*/ int string_compare(char s[], char t[]){ /* Petlja tece sve dok ne naidjemo na prvi razliciti karakter */ int i; for (i = 0; s[i]==t[i]; i++) if (s[i] == '\0') /* Naisli smo na kraj oba stringa,

a nismo nasli razliku */ return 0;




/* s[i] i t[i] su prvi karakteri u kojima se niske razlikuju.Na osnovu njihovog odnosa, odredjuje se odnos stringova */

return s[i] - t[i];}

/* Pronalazi prvu poziciju karaktera c u stringu s, odnosno -1ukoliko s ne sadrzi c */

int string_char(char s[], char c){ int i; for (i = 0; s[i]; i++) if (s[i] == c) return i;

/* nikakoelse

return -1; */

/* Nije nadjeno */ return -1;

}

/* Pronalazi poslednju poziciju karaktera c u stringu s, odnosno -1ukoliko s ne sadrzi c */

int string_last_char(char s[], char c){ /* Pronalazimo kraj stringa s */ int i; for (i = 0; s[i]; i++) ;

/* Krecemo od kraja i trazimo c unazad */ for (i--; i>=0; i--) if (s[i] == c) return i;


/*

Koristeci string_length :

for (i = string_length(s) - 1; i>0; i--) if (s[i] == c) return i;

return -1;

*/ }

/* Proverava da li string str sadrzi string sub. Vraca poziciju na kojoj sub pocinje, odnosno -1 ukoliko ga nema*/ int string_string(char str[], char sub[]){ int i, j; /* Proveravamo da li sub pocinje na svakoj poziciji i */ for (i = 0; str[i]; i++) /* Poredimo sub sa str pocevsi od poziciji i

sve dok ne naidjemo na razliku */ for (j = 0; str[i+j] == sub[j]; j++) /* Nismo naisli na razliku a ispitali smo

sve karaktere niske sub */ if (sub[j+1]=='\0')

return i; /* Nije nadjeno */

return -1;}

main(){ char s[100]; char t[] = "Zdravo"; char u[] = " svima";

string_copy(s, t); printf("%s\n", s);

string_concatenate(s, u); printf("%s\n", s);




printf("%d\n",string_char("racunari", 'n'));

printf("%d\n",string_last_char("racunari", 'a'));

printf("%d\n",string_string("racunari", "rac")); printf("%d\n",string_string("racunari", "ari")); printf("%d\n",string_string("racunari", "cun")); printf("%d\n",string_string("racunari", "cna"));

}

/*----------------------------5.5.c--------------------------*/

/* atoi - konverzija niske cifara u brojnu vrednost */ /* Program omogucuje citanje celog broja bez koriscenja funkcije scanf("%d") Napomena : funkcija atoi vec postoji u zaglavlju <stdio.h> i ovde

je implementirana samo za vezbu*/

#include <stdio.h>#include <ctype.h> /* Zbog funkcije isspace */

/* Maksimalna duzina reci */ #define MAX_DIGITS 10

/* AsciiTOInteger Funkcija izracunava vrednost celog broja koji je zapisan u datom

nizu karaktera. Za izracunavanje se koristi Hornerova shema. */ int

atoi(char

s[]){ int sum = 0;

/* Obradjuju se karakteri sve dok su cifre */ int i; for (i = 0; isdigit(s[i]); i++) sum = 10*sum + (s[i]-'0');

return sum;}

main(){ char s[MAX_DIGITS]; int num;

/* Ucitavamo broj u vidu niske karaktera */

printf("Unesi ceo broj : ");

/* Obratiti paznju da uz s ne stoji & */ scanf("%s", s);

/* Izracunava se njegova vrednost */ num = atoi(s);

/* Ispisuje se vrednost */ printf("Uneo si broj : %d\n", num); printf("Broj za tri veci je : %d\n", num+3); }

/*----------------------------5.5b.c--------------------------*/ /* btoi - konverzija iz datog brojnog sistema u dekadni */ #include <stdio.h>#include <ctype.h>

/* Pomocna funkcija koja izracunava vrednost koju predstavlja karakter u datoj osnoviFunkcija vraca -1 ukoliko cifra nije validna.

Npr.cifra 'B' u osnovi 16 ima vrednost 11

cifra '8' nije validna u osnovi 6

*/ int digit_value(char c, int base){




/* Proveravamo obicne cifre */ if (isdigit(c) && c < '0'+base) return c-'0';

/* Proveravamo slovne cifre za mala slova */ if ('a'<=c && c < 'a'+base-10) return c-'a'+10;

/* Proveravamo slovne cifre za velika slova */ if ('A'<=c && c < 'A'+base-10) return c-'A'+10;

return -1;

}

/* Funkcija izracunava vrednost celog broja koji je zapisan u datomnizu karaktera u datoj osnovi. Za izracunavanje se koristi Hornerova shema.

*/ int btoi(char s[], int base){ int sum = 0;

/* Obradjuju se karakteri sve dok su cifre */ int i, vr; for (i = 0; (vr = digit_value(s[i], base)) != -1; i++) sum = base*sum + vr;

return sum;

}main(){ char bin[] = "11110000"; char hex[] = "FF";

printf("Dekadna vrednost binarnog broja %s je %d\n", bin, btoi(bin, 2)); printf("Dekadna vrednost heksadekadnog broja %s je %d\n", hex, btoi(hex, 16 )); }

/*----------------------------5.6.c--------------------------*/ /* Demonstracija pretprocesorske direktive #define */

/* Racuna sumu dva broja */

#define sum(a,b) a+b

/* Racuna kvadrat broja - pogresna verzija */ #define square_w(a) a*a

/* Racuna kvadrat broja */ #define square(a) (a)*(a)

/* Racuna minimum tri broja */ #define min(a, b, c) (a)<(b) ? ((a)<(c) ? (a) : (c)) : ((b)<(c) ? (b) : (c))

main(){

printf("sum(3,5) = %d\n", sum(3,5)); printf("square_w(5) = %d\n", square_w(5)); printf("square_w(3+2) = %d\n", square_w(3+2)); printf("square(3+2) = %d\n", square(3+2)); printf("min(1,2,3) = %d\n", min(1,2,3)); printf("min(1,3,2) = %d\n", min(1,3,2)); printf("min(2,1,3) = %d\n", min(2,1,3)); printf("min(2,3,1) = %d\n", min(2,3,1)); printf("min(3,1,2) = %d\n", min(3,1,2)); printf("min(3,2,1) = %d\n", min(3,2,1));}




/*----------------------------6.1.c--------------------------*/ /* Ilustracija lenjog izracunavanja logickih operatora */

/* Prilikom izracunavanja izraza - A && B, ukoliko je A netacno, izraz B se ne izracunava. Prilikom izracunavanja izraza - A || B, ukoliko je A tacno, izraz B se ne izracunava.*/

#include <stdio.h>

int b = 0;

/* Funkcija ispisuje da je pozvana i uvecava promenjivu b. Funkcija uvek vraca vrednost 1 (tacno)*/ int izracunaj(){ printf("Pozvano izracunaj()\n"); b++; return 1;}

main(){ /* Funkcija izracunaj() ce se pozivati samo za parne vrednosti a */ int a;

for (a = 0; a < 10; a++) if (a%2 == 0 && izracunaj())

printf("Uslov ispunjen : a = %d, b = %d\n", a, b); else

printf("Uslov nije ispunjen : a = %d, b = %d\n", a, b);

printf("----------------------------\n");

/* Funkcija izracunaj() ce se pozivati samo za neparne vrednosti a */ b = 0;

for (a = 0; a < 10; a++) if (a%2 == 0 || izracunaj()) printf("Uslov ispunjen : a = %d, b = %d\n", a, b); else

printf("Uslov nije ispunjen : a = %d, b = %d\n", a, b);

}

/*----------------------------6.2.c--------------------------*/ /* Program ispisuje sve linije standardnog ulaza u kojima se pojavljuje data rec */ #include <stdio.h>

/* Maksimalna duzina linije */ #define MAX_LINE 100

/* Funkcija ucitava liniju sa standardnog ulaza i smesta je u datu nisku karaktera s. lim oznacava maksimalnu duzinu niske i funkcija vodi racuna da se taj limit ne premasi. Oznaka za kraj reda se smatra sastavnim delom linije. Funkcija vraca broj procitanih karaktera.*/ int getline(char s[], int lim){ int c;

/* Cita se karakter po karakter i smesta u nisku sve dok se ne dodje doEOF, '\n' ili dok se ne premasi duzina niza (ostavljajuci mesto za '\0')

Napomena : zbog lenjog izracunavanja, ukoliko je duzina niza premasena ne cita se sledeci karakter. */ int i = 0; while (i < lim - 1 && (c=getchar()) != EOF && c != '\n') s[i++] = c;

/* Posto je '\n' sastavni deo linije i on se smesta u niz */ if (c == '\n') s[i++] = c;

/* Terminira se niska na kraju */ s[i] = '\0';




return i;

}

int string_string(char str[], char sub[]){ int i, j; /* Proveravamo da li sub pocinje na svakoj poziciji i */ for (i = 0; str[i]; i++) /* Poredimo sub sa str pocevsi od poziciji i sve dok ne naidjemo na razliku*/ for (j = 0; str[i+j] == sub[j]; j++) /* Nismo naisli na razliku a ispitali smo sve karaktere niske sub */

if (sub[j+1]=='\0')return i;


}

main(){ /* Ispisujemo sve linije koje sadrze petlju */

/* Niska karaktera koja ce da sadrzi tekucu liniju.Alociramo prostor od MAX_LINE karaktera */

char line[MAX_LINE];

/* Citamo liniju - getline vraca 0 kada dodje do kraja ulaza */ while(getline(line, MAX_LINE)>0)

/* Ispisujemo one linije koje sadrze rec for ili rec while */ if (string_string(line, "for") != -1 || string_string(line, "while") != -1) printf("%s",line);}

/*----------------------------6.3.c--------------------------*/ /* Demonstracija zivotnog veka i oblasti vazenja promenjivih (scope) */ #include <stdio.h>

/* Globalna promenjiva */ int a = 0;

/* Uvecava se globalna promenjiva a */ void increase(){ a++;

printf("increase::a = %d\n", a);}

/* Umanjuje se lokalna promenjiva a. Globalna promenjiva zadrzava svoju vrednost. */ void decrease(){ /* Ovo a je nezavisna promenjiva u odnosu na globalno a */ int a = 0; a--; printf("decrease::a = %d\n", a);

}

void nonstatic_var(){ /* Nestaticke promenjive ne cuvaju vrednosti kroz pozive funkcije */ int s=0;

s++; printf("nonstatic::s=%d\n",s);}

void static_var(){ /* Staticke promenjive cuvaju vrednosti kroz pozive funkcije.

Inicijalizacija se odvija samo u okviru prvog poziva. */ static int s=0; s++; printf("static::s=%d\n",s);}

main(){ /* Promenjive lokalne za funkciju main */




int i; int x = 3;

printf("main::x = %d\n", x);

for (i = 0; i<3; i++) { /* Promenjiva u okviru bloka je nezavisna od spoljne promenjive. Ovde se koristi promenjiva x lokalna za blok petlje koja ima

vrednost 5, dok originalno x i dalje ima vrednost 3*/ int x = 5; printf("for::x = %d\n", x);

} /* U ovom bloku x ima vrednost 3 */

printf("main::x = %d\n", x);

increase(); decrease();

/* Globalna promenjiva a */ printf("main::a = %d\n", a);

/* Demonstracija nestatickih promenjivih */ for (i = 0; i<3; i++) nonstatic_var();

/* Demonstracija statickih promenjivih */ for (i = 0; i<3; i++)

static_var();}

/*----------------------------6.4.c--------------------------*/ /* print_bits - stampa bitove u zapisu datog celog broja x. */

#include <stdio.h>

/* Funkcija stampa bitove datog celog broja x.Vrednost bita na poziciji i je 0 ako i samo ako se pri konjunkciji broja x sa maskom000..010....000 - sve 0 osim 1 na poziciji i, dobija 0.

Funkcija krece od pozicije najvece tezine kreirajuci masku pomeranjem jedinice u levoza duzina(x) - 1 mesto, i zatim pomerajuci ovu masku za jedno mesto u levo u svakojsledecoj iteraciji sve dok maska ne postane 0.

*/

void print_bits(int x){ /* Broj bitova tipa unsigned */ int wl = sizeof(int)*8;

unsigned mask; for (mask = 1<<wl-1; mask; mask >>= 1) putchar(x&mask ? '1' : '0');

putchar('\n');}

main(){ print_bits(127 );

print_bits(128); print_bits(0x00FF00FF ); print_bits(0xFFFFFFFF );}

/*----------------------------6.5.c--------------------------*/ /* sum_of_bits - izracunava sumu bitova datog neoznacenog broja */

#include <stdio.h>

int sum_of_bits(unsigned x){ /* Broj bitova tipa unsigned */ int wl = sizeof(unsigned )*8; int br = 0;




unsigned mask;for (mask = 1<<wl-1; mask; mask>>=1)

if (x&mask) br++;

return br;}

/* Efikasnija verzija */ int sum_of_bits(unsigned x){ int br; for (br = 0; x; x>>=1)

if (x&1) br++;

return br;}

main(){ printf("%d\n",sum_of_bits(127 )); printf("%d\n",sum_of_bits(128)); printf("%d\n",sum_of_bits(0x00FF00FF )); printf("%d\n",sum_of_bits(0xFFFFFFFF ));}

/*----------------------------6.6.c--------------------------*/ /* get_bits, set_bits, invert_bits -

izdvajanje, postavljanje i invertovanje pojedinacnih bitova */ #include <stdio.h>

/* Pomocna funkcija - stampa bitove neoznacenog broja */ void print_bits(unsigned x){ int wl = sizeof(unsigned )*8;


putchar('\n');}

/* Funkcija vraca n bitova broja x koji pocinju na poziciji p */ unsigned get_bits(unsigned x, int p, int n){ /* Gradimo masku koja ima poslednjih n jedinica 0000000...00011111 tako sto sve jedinice ~0 pomerimo u levo za n mesta 1111111...1100000 a zatim komplementiramo

*/ unsigned last_n_1 = ~(~0 << n);

/* x pomerimo u desno za odgovarajuci broj mesta, a zatimkonjunkcijom sa konstruisanom maskom obrisemo pocetne cifre */

return (x >> p+1-n) & last_n_1;

}

/* Funkcija vraca modifikovano x tako sto mu je izmenjeno n bitova pocevsi od pozicije p i na ta mesta je upisano poslednjih n bitovabroja y */

unsigned set_bits(unsigned x, int p, int n, unsigned y){ /* Maska 000000...000111111 - poslednjih n jedinica */ unsigned last_n_1 = ~(~0 << n);

/* Maska 1111100..000111111 - n nula pocevsi od pozicije p */ unsigned middle_n_0 = ~(last_n_1 << p+1-n);

/* Brisemo n bitova pocevsi od pozicije p */ x = x & middle_n_0;

/* Izdvajamo poslednjih n bitova broja y i pomeramo ih na poziciju p */ y = (y & last_n_1) << p+1-n;




/* Upisujemo bitove broja y u broj x i vracamo rezultat */

return x | y; }

/* Invertuje n bitova broja x pocevsi od pozicije p */ unsigned invert_bits(unsigned x, int p, int n){ /* Maska 000000111...1100000 - n jedinica pocevsi od pozicije p */ unsigned middle_n_1 = ~(~0 << n) << p+1-n;

/* Invertujemo koristeci ekskluzivnu disjunkciju */

return x ^ middle_n_1;}

main(){ unsigned x = 0x0AA0AFA0; print_bits(x);

print_bits(get_bits(x, 15, 8)); print_bits(set_bits(x, 15, 8, 0xFF )); print_bits(invert_bits(x, 15, 8));}

/*----------------------------6.7.c--------------------------*/ /* right_rotate_bits, mirror_bits - rotiranje i simetrija bitova */ #include <stdio.h>

/* Pomocna funkcija - stampa bitove neoznacenog broja */ void print_bits(unsigned x){ int wl = sizeof(unsigned )*8;


putchar('\n');}

/* Funkcija vrsi rotaciju neoznacenog broja x za n pozicija u desno */ unsigned right_rotate(unsigned x, int n)

{ int i; int wl = sizeof(unsigned )*8;

/* Postupak se ponavlja n puta */ for (i = 0; i < n; i++) { /* Poslednji bit broja x */ unsigned last_bit = x & 1;

/* x pomeramo za jedno mesto u desno */ x >>= 1;

/* Zapamceni poslednji bit stavljamo na pocetak broja x*/

x |= last_bit<<wl-1; }

return x;}

/* Funkcija obrce binarni zapis neoznacenog broja x tako sto bitove cita unatrag */ unsigned mirror(unsigned x){ int i; int wl = sizeof(unsigned )*8;

/* Rezultat inicijalizujemo na poslednji bit broja x */ unsigned y = x & 1;

/* Postupak se ponavlja wl-1 puta */ for (i = 1; i<wl; i++) {




/* x se pomera u desno za jedno mesto */ x >>= 1; /* rezultat se pomera u levo za jedno mesto */ y <<= 1;

/* Poslednji bit broja x upisujemo na poslednje mesto rezultata */ y |= x & 1; } return y;}

main(){

unsigned x = 0xFAF0FAF0; print_bits(x); print_bits(mirror(x)); print_bits(right_rotate(x, 2));}




/*----------------------------7.1.c--------------------------*/ /* Pokazivaci - osnovni pojam */ #include <stdio.h>main(){ int x = 3;

/* Adresu promenjive x zapamticemo u novoj promeljivoj. Nova promenljiva je tipa pokazivaca na int (int*) */ int* px;

printf("Adresa promenljive x je : %p\n", &x); printf("Vrednost promenljive x je : %d\n", x);

px = &x;printf("Vrednost promenljive px je (tj. px) : %p\n", px);

printf("Vrednost promenljive na koju ukazuje px (tj. *px) je : %d\n", *px);

/* Menjamo vrednost promenljive na koju ukazuje px */ *px = 6 ; printf("Vrednost promenljive na koju ukazuje px (tj. *px) je : %d\n", *px);

/* Posto px sadrzi adresu promenljive x, ona ukazuje na x tako da je posredno promenjena i vrednost promenljive x */

printf("Vrednost promenljive x je : %d\n", x);

}

/*----------------------------7.2.c--------------------------*/ /* swap : Demonstracija prenosa argumenata preko pokazivaca */ #include <stdio.h>

/* Pogresna verzija funkcije swap. Zbog prenosa po vrednosti, funkcijarazmenjuje kopije promenljivih iz main-a, a ne samih promenljivih */

void swap_wrong(int x, int y){ int tmp;

printf("swap_wrong: "); printf("Funkcija menja vrednosti promenljivim na adresama : \n"); printf("x : %p\n", &x);

printf("y : %p\n", &y);

tmp = x; x = y; y = tmp;}

/* Resenje je prenos argumenata preko pokazivaca */ void swap(int* px, int* py){ int tmp;

printf("swap : Funkcija menja vrednosti promenljivim na adresama : \n"); printf("px = %p\n", px); printf("py = %p\n", py);

tmp = *px; *px = *py; *py = tmp;}

main(){ int x = 3, y = 5; printf("Adresa promenljive x je %p\n", &x); printf("Vrednost promenljive x je %d\n", x); printf("Adresa promenljive y je %p\n", &y); printf("Vrednost promenljive y je %d\n", y);

/* Pokusavamo zamenu koristeci pogresnu verziju funkcije */ swap_wrong(x, y);




printf("Posle swap_wrong:\n"); printf("Vrednost promenljive x je %d\n", x); printf("Vrednost promenljive y je %d\n", y);

/* Vrsimo ispravnu zamenu. Funkciji swap saljemo adrese promenljvihx i y, a ne njihove vrednosti */

swap(&x, &y);

printf("Posle swap:\n"); printf("Vrednost promenljive x je %d\n", x); printf("Vrednost promenljive y je %d\n", y);}

/*----------------------------7.3.c--------------------------*/ /* Demonstracija vise povratnih vrednosti funkcije koristeci prenos preko pokazivaca */

/* Funkcija istovremeno vraca dve vrednosti - kolicnik i ostatak dva data broja. Ovo se postize tako sto se funkciji predaju vrednosti dva broja (x i y) koji se dele i adrese dve promenljive na koje ce se smestiti rezultati */ void div_and_mod(int x, int y, int* div, int* mod){ printf("Kolicnik postavljam na adresu : %p\n", div); printf("Ostatak postavljam na adresu : %p\n", mod); *div = x / y; *mod = x % y;}

main(){

int

div, mod; printf("Adresa promenljive div je %p\n", &div); printf("Adresa promenljive mod je %p\n", &mod);

/* Pozivamo funkciju tako sto joj saljemo vrednosti dva broja (5 i 2) i adrese promenljvih div i mod na koje ce se postaviti rezultati */ div_and_mod(5, 2, &div, &mod);

printf("Vrednost promenljive div je %d\n", div); printf("Vrednost promenljive mod je %d\n", mod); }

/*----------------------------7.4.c--------------------------*/ /* Pokazivacka aritmetika */

#include <stdio.h>

main(){ char s[] = "abcde"; int t[] = {1, 2, 3, 4, 5};

/* Inicijalizujmo pokazivace ps i pt na pocetke nizova s i t */ char* ps = &s[0]; int* pt = &t[0];

/* Pokazivace je moguce sabirati sa celim brojevima iod njih je moguce oduzimati cele brojeve*/

/* Ispisimo vrednosti pokazivaca */ printf("ps = %p\n", ps); printf("ps+1 = %p\n", ps+1); printf("ps+2 = %p\n", ps+2);

printf("ps-1 = %p\n", ps-1); printf("ps-2 = %p\n", ps-2);

/* Prilikom sabiranja pokazivaca i celih brojeva,

dodaje se velicina odgovarajuceg tipa. */ printf("pt = %p\n", pt); printf("pt+1 = %p\n", pt+1); printf("pt+2 = %p\n", pt+2); printf("pt-1 = %p\n", pt-1); printf("pt-2 = %p\n", pt-2);

/* Na pokazivace je moguce primenjivati i operatore ++ i -- */ for (ps = s; *ps; ps++) putchar(*ps); putchar('\n');




/* Slicno, dva pokazivaca istog tipa se mogu oduzimati. Prilikom sracunavanja

rezultata, uzima se u obzir velicina tipa. */ ps = &s[3]; printf("s = %p\n", s); printf("ps = %p\n", ps); printf("ps - s = %d\n", ps - s); pt = &t[3]; printf("t = %p\n", t); printf("pt = %p\n", pt); printf("pt - t = %d\n", pt - t);

}

/*----------------------------7.5.c--------------------------*/ /* Veza izmedju pokazivaca i nizova */

#include <stdio.h>

void print_array(int* pa, int n);

main(){ int a[] = {1, 2, 3, 4, 5, 6 , 7 , 8, 9, 10}; int num_of_elements = sizeof(a)/sizeof(int); int* pa;

/* Niz je isto sto i adresa prvog elementa */ printf("Niz a : %p\n", a);

printf("Adresa prvog elementa niza a (&a[0]) : %p\n", &a[0]); /* Moguce je dodeliti niz pokazivacu odgovarajuceg tipa */

pa = a;

printf("Pokazivac pa ukazuje na adresu : %p\n", pa);

/* Nizu nije moguce dodeliti pokazivacku promenljivu(nizove mozemo smatrati KONSTANTNIM pokazivacima na prvi element) */

/* a = pa; */

/* Niz je moguce koristiti kao pokazivac tj. vaze pravila pokazivacke aritmetike */ printf("a + 3 = %p\n", a + 3);

/* Vazi da jea + i = &a[i]

odnosno

*(a + i) = a[i] */ printf("&a[3] = %p\n", &a[3]);

/* Identiteti a + i = &a[i]

odnosno*(a + i) = a[i]

vazi i za pokazivace i za nizove */

/* Pokazivace je na osnovu prethodnog moguce indeksirati kao nizove */ printf("pa[5] = %d\n", pa[5]); printf("*(pa + 5) = %d\n", *(pa+5));

/* Medjutim, sizeof(pa) je samo velicina pokazivaca, a ne niza */ printf("sizeof(a) = %d\n", sizeof(a));

printf("sizeof(pa) = %d\n", sizeof(pa));

/* Pozivamo funkciju za stampanje niza i saljemo joj niz */ print_array(a, num_of_elements); /* Pozivamo funkciju za stampanje niza i saljemo joj pokazivac na pocetak niza */ print_array(pa, num_of_elements);}

/* Proslednjivanje niza u funkcijuvoid print_array(int pa[], int n);

je ekvivalentno prosledjivanju pokazivaca u funkcijuvoid print_array(int* pa, int n);

Izmedju ovih konstrukcija nema nikakve razlike.*/ void print_array(int* pa, int n){




int i; for (i = 0; i<n; i++) printf("%d ", pa[i]); putchar('\n');}

/*----------------------------7.6.c--------------------------*/ /* strlen, strcpy, strcat, strcmp, strchr, strstr, ... - verzije sa pokazivacima */ /* Vezbe radi, implementirane su funkcije biblioteke string.h */ #include <stdio.h>#include <stdlib.h> /* Zbog NULL */

/* Izracunava duzinu stringa */ int string_length(char *s){ char* t; for (t = s; *t; t++) ; return t - s;}

/* Kopira string src u string dest. Pretpostavlja da u dest ima dovoljno prostora. */ void string_copy(char *dest, char *src){ /* Kopira karakter po karakter, sve dok nije iskopiran karakter '\0' */ while(*dest++ = *src++) ; }

/* Nadovezuje string t na kraj stringa s. Pretpostavlja da u s ima dovoljno prostora. */ void string_concatenate(char *s, char *t){ /* Pronalazimo kraj stringa s */ while (*s) s++;

/* Vrsi se kopiranje, slicno funkciji string_copy */ while (*s++ = *t++) ;}

/* Vrsi leksikografsko poredjenje dva stringa.Vraca :

0 - ukoliko su stringovi jednaki <0 - ukoliko je s leksikografski ispred t >0 - ukoliko je s leksikografski iza t*/ int string_compare(char *s, char *t){ /* Petlja tece sve dok ne naidjemo na prvi razliciti karakter */ for (; *s == *t; s++, t++) if (*s == '\0') /* Naisli smo na kraj oba stringa, a nismo nasli razliku */ return 0;

/* *s i *t su prvi karakteri u kojima se niske razlikuju.Na osnovu njihovog odnosa, odredjuje se odnos stringova */

return *s - *t;}

/* Pronalazi prvu poziciju karaktera c u stringu s, i vraca pokazivac na nju,odnosno NULL ukoliko s ne sadrzi c */ char* string_char(char *s, char c){ for (; *s; s++) if (*s == c) return s;

/* Nije nadjeno */ return NULL;

}

/* Pronalazi poslednju poziciju karaktera c u stringu s, i vraca pokazivac na nju, odnosno NULL ukoliko s ne sadrzi c */ char* string_last_char(char *s, char c){




char *t = s; /* Pronalazimo kraj stringa s */ while (*t++) ;

/* Krecemo od kraja i trazimo c unazad */ for (t--; t >= s; t--) if (*t == c) return t;

/* Nije nadjeno */ return NULL;

}

/* Proverava da li string str sadrzi string sub. Vraca poziciju na kojoj sub pocinje, odnosno -1 ukoliko ga nema*/ char* string_string(char *str, char *sub){ char *s, *t; /* Proveravamo da li sub pocinje na svakoj poziciji i */ for (; *str; str++) /* Poredimo sub sa str pocevsi od poziciji i sve dok ne naidjemo na razliku*/ for (s = str, t = sub; *s == *t; s++, t++) /* Nismo naisli na razliku a ispitali smo sve karaktere niske sub */ if (*(t+1) == '\0')

return str;

/* Nije nadjeno */ return NULL;}

main(){ char s[100]; char t[] = "Zdravo"; char u[] = " svima"; char r[] = "racunari";

string_copy(s, t); printf("%s\n", s);

string_concatenate(s, u); printf("%s\n", s);

printf("%d\n",string_char(r, 'n') - r); printf("%d\n",string_last_char(r, 'a') - r);

printf("%d\n",string_string(r, "rac") - r); printf("%d\n",string_string(r, "ari") - r); printf("%d\n",string_string(r, "cun") - r); printf("%p\n",string_string(r, "cna"));

}

/*----------------------------7.7.c--------------------------*/ /* Program demonstrira upotrebu pokazivaca na funkcije */ #include <stdio.h>

int kvadrat(int n)

{ return n*n;}

int kub(int n){ return n*n*n;}

int parni_broj(int n){ return 2*n;}

/* Funkcija izracunava sumu \sum_{i=1}^n f(i), gde je f data funkcija prvi argument funkcije sumiraj je

int (*f) (int)sto je pokazivac na funkciju koja ima jedan argument tipa int i




vraca vrednost tipa int*/ int sumiraj(int (*f) (int), int n){ int i, suma=0; for (i=1; i<=n; i++) suma += (*f)(i);

return suma;}

main(){ printf("Suma kvadrata brojeva od jedan do 3 je %d\n",

sumiraj(&kvadrat,3)); printf("Suma kubova brojeva od jedan do 3 je %d\n", sumiraj(&kub,3)); printf("Suma prvih pet parnih brojeva je %d\n", sumiraj(&parni_broj,5));}




/*----------------------------8.1.c--------------------------*/ /* Demonstrira dinamicku alokaciju memorije koriscenjem funkcije malloc */ /* Program unosi niz proizvoljne dimenzije i nalazi najveci element */

#include <stdio.h>

/* Neophodno je ukljuciti stdlib.h */ #include <stdlib.h>

int main()

{ int n;

/* Deklaracijaint a[n];

nije dozvoljena jer kompilator ne moze u vreme prevodjenjada odredi potrebnu kolicinu memorije. Umesto ovoga, memoriju cemoalocirati dinamicki tj. u fazi izvrsavanja programa kada bude poznatavrednost broja n. Zbog toga je potrebno upamtiti samo adresu pocetkaalociranog bloka memorije sto cemo uraditi koriscenjem sledeceg pokazivaca:

*/ int* a;

int i, max;

printf("Unesi dimenziju niza : "); scanf("%d", &n);

/* U ovom treunutku znamo koliko nam je memorije potrebno i pozivamofunkciju malloc za dinamicku alokaciju. malloc-u se prosledjuje kolicina

potrebne memorije u bajtovima, a on vraca genericki pokazivac (void*) koji pre koriscenja treba konvertovati u odgovarajuci realni pokazivacki tip. */

a = (int*) malloc(n*sizeof(int));

/* U slucaju da nema dovoljno memorije malloc vraca NULL */ if (a == NULL) { printf("Greska : Nema dovoljno memorije!\n"); return 1; }

/* Nadalje a koristimo kao obican niz */ for (i = 0; i<n; i++) { printf("a[%d]=", i); scanf("%d", &a[i]); }

/* Nalazimo maksimum */ max = a[0];

for (i = 1; i<n; i++) if (a[i] > max) max = a[i];

printf("Najveci element je %d\n", max);

/* Duzni smo da rucno alociranu memoriju rucno i oslobodimo */ free(a);

return 0;

}

/*----------------------------8.1b.c--------------------------*/ /* Vracanje niza iz funkcije */ /* Program unosi niz proizvoljne dimenzije i nalazi najveci element */

#include <stdio.h>

/* Neophodno je ukljuciti stdlib.h */ #include <stdlib.h>

/* Moguce je vratiti pokazivac na dinamicki alocirani niz jer se onalocira na hip-u i taj prostor je rezervisan i posle zavrsetka rada funkcije */




int* CreateIntArray(int n){ return (int*) malloc(n*sizeof(int));}

/* Nije moguce vratiti pokazivac na lokalni niz jer se on alocira na stekui taj prostor nije rezervisan posle zavrsetka rada funkcije */

int* Create10ElementIntArray(){ int a[10]; return a;}

int main(){ int n;

int* a; int i, max;

printf("Unesi dimenziju niza : "); scanf("%d", &n);

/* Alociramo memoriju */ a = CreateIntArray(n);

/* U slucaju da nema dovoljno memorije malloc vraca NULL */ if (a == NULL) { printf("Greska : Nema dovoljno memorije!\n"); return 1; }

/* Nadalje a koristimo kao obican niz */ for (i = 0; i<n; i++) { printf("a[%d]=", i); scanf("%d", &a[i]); }

/* Nalazimo maksimum */ max = a[0];

for (i = 1; i<n; i++) if (a[i] > max) max = a[i];

printf("Najveci element je %d\n", max);

/* Duzni smo da rucno alociranu memoriju rucno i oslobodimo */ free(a);

return 0;

}

/*----------------------------8.2.c--------------------------*/ /* Program demonstrira niz kome se velicina tokom rada povecava

- verzija sa funkcijom realloc */

#include <stdio.h>#include <stdlib.h>

#define KORAK 10int main(){ /* Niz je u pocetku prazan */ int* a = NULL;

/* duzina predstavlja broj popunjenih elemenata,dok alocirano predstavlja broj alociranih elemenata */

int duzina = 0, alocirano = 0;

int n, i;

do {




printf("Unesi ceo broj (-1 za kraj): "); scanf("%d", &n); /* Ukoliko nema vise slobodnih mesta, vrsi se prosirivanje */ if (duzina == alocirano) { /* Niz se prosiruje na 10 elemenata vise */ alocirano = alocirano + KORAK; a = realloc(a, alocirano*sizeof(int)); } a[duzina++] = n;

} while (n != -1);

/* Ispisujemo niz a */ printf("Uneto je %d brojeva. Alocirano je ukupno %d bajtova\n",duzina, alocirano*sizeof(int));

printf("Brojevi su : "); for (i = 0; i<duzina; i++) printf("%d ", a[i]);

/* Oslobadjamo niz a */ free(a);

return 0;}

/*----------------------------8.2b.c--------------------------*/ /* Program demonstrira niz kome se velicina tokom rada povecava

- verzija sa rucnom realokacijom */


/* Niz ce se uvecavati u koracima od po 10 brojeva */ #define KORAK 10

int main(){ /* Niz je u pocetku prazan */ int* a = NULL;

/* duzina predstavlja broj popunjenih elemenata,dok alocirano predstavlja broj alociranih elemenata */

int duzina = 0, alocirano = 0; int n, i;

do { printf("Unesi ceo broj (-1 za kraj): "); scanf("%d", &n); /* Ukoliko nema vise slobodnih mesta, vrsi se prosirivanje */ if (duzina == alocirano) { /* Kreira se novi niz */ int* new_a;

/* Za njega se alocira 10 elemenata vise od prethodnog */ alocirano = alocirano + KORAK; new_a = malloc(alocirano*sizeof(int));

/* Kopira se sadrzaj starog niza u novi */

for (i = 0; i<duzina; i++) new_a[i] = a[i];

/* Oslobadja se stari niz */ free(a);

/* Stari niz postaje novi */ a = new_a; }

/* Ucitani broj se upisuje u niz */ a[duzina++] = n;

} while (n != -1);

/* Ispisujemo niz a */




printf("Uneto je %d brojeva. Alocirano je ukupno %d bajtova\n",duzina, alocirano*sizeof(int));

printf("Brojevi su : "); for (i = 0; i<duzina; i++) printf("%d ", a[i]);

/* Oslobadjamo niz a */ free(a);

return 0;}

/*----------------------------8.3.c--------------------------*/ /* Demonstracija funkcije calloc - funkcija inicijalizuje sadrzaj memorije na 0*/


#define BR_ELEM 10

main(){ int *m, *c, i;

/* Niz m NE MORA garantovano da ima sve nule */ m = malloc(BR_ELEM*sizeof(int));

/* Niz c MORA garantovano da ima sve nule */ c = calloc(BR_ELEM, sizeof(int));

for (i = 0; i<BR_ELEM; i++) printf("m[%d] = %d\n", i, m[i]);

for (i = 0; i<BR_ELEM; i++) printf("c[%d] = %d\n", i, c[i]);

free(m); free(c);}

/*----------------------------8.4.c--------------------------*/ /* Program uvodi strukture - geometrijske figure */ #include <stdio.h>

/* Zbog funkcije sqrt. */ #include <math.h>/* Upozorenje : pod linux-om je potrebno program prevoditi sa

gcc -lm 7.4.ckada god se koristi <math.h>

*/

/* Tacke su predstavljene sa dve koordinate. Strukturom gradimo novi tip podataka. */ struct point{ int x; int y;};

/* Izracunava duzinu duzi zadatu sa dve tacke */ float segment_length(struct point A, struct point B){

int dx = A.x - B.x; int dy = A.y - B.y; return sqrt(dx*dx + dy*dy);}

/* Izracunava povrsinu trougla Heronovim obrascem.Argumenti funkcije su tri tacke koje predstavljaju temena trougla */

float Heron(struct point A, struct point B, struct point C){ /* Duzine stranica */ float a = segment_length(B, C); float b = segment_length(A, C); float c = segment_length(A, B);

/* Poluobim */ float s = (a+b+c)/2;




return sqrt(s*(s-a)*(s-b)*(s-c));}

/* Izracunava obim poligona. Argumenti funkcije su niz tacakakoje predstavljaju temena poligona kao i njihov broj */

float circumference(struct point polygon[], int num){ int i; float o = 0.0;

/* Dodajemo duzine stranica koje spajaju susedna temena */ for (i = 0; i<num-1; i++)

o += segment_length(polygon[i], polygon[i+1]);

/* Dodajemo duzinu stranice koja spaja prvo i poslednje teme */ o += segment_length(polygon[num-1], polygon[0]);

return o;}

/* Izracunava povsinu konveksnog poligona. Argumenti funkcije su niz tacakakoje predstavljaju temena poligona kao i njihov broj */

float area(struct point polygon[], int num){ /* Povrsina */ float a = 0.0; int i;

/* Poligon delimo na trouglove i posebno izracunavamo povrsinu svakoga od njih */ for (i = 1; i < num -1; i++) a += Heron(polygon[0], polygon[i], polygon[i+1]);

return a;}

main(){ /* Definisemo dve promenljive tipa tacke */ struct point a;

/* Inicijalizujemo tacku b na (1,2) */ struct point b = {1, 2};

/* triangle je niz od tri tacke - trougao (0,0), (0,1), (1,0) */ struct point triangle[3];

/* square je niz od cetiri tacke - jedinicni kvadrat.Obratiti paznju na nacin inicijalizacije niza struktura */

struct point square[4] = {{0, 0}, {0, 1}, {1, 1}, {1, 0}};

/* Postavljamo vrednosti koordinata tacke a*/ a.x = 0; a.y = 0;

/* Gradimo trougao (0,0), (0,1), (1,0) */ triangle[0].x = 0; triangle[0].y = 0; triangle[1].x = 0; triangle[1].y = 1; triangle[2].x = 1; triangle[2].y = 0;

/* Ispisujemo velicinu strukture tacka */ printf("sizeof(struct point) = %d\n", sizeof(struct point));

/* Ispisujemo vrednosti koordinata tacaka */ printf("x koordinata tacke a je %d\n", a.x); printf("y koordinata tacke a je %d\n", a.y); printf("x koordinata tacke b je %d\n", b.x); printf("y koordinata tacke b je %d\n", b.y);

printf("Obim trougla je %f\n",circumference(triangle, 3));

printf("Obim kvadrata je %f\n",circumference(square, 4));

printf("Povrsina trougla je %f\n",Heron(triangle[0], triangle[1], triangle[2]));

/* Broj tacaka je moguce odrediti i putem sizeof */ printf("Povrsina kvadrata je %f\n",

area(square, sizeof(square)/sizeof(struct point)));




}

/*----------------------------8.4b.c--------------------------*/ /* Koriscenje typedef radi lakseg rada */ #include <stdio.h>

#include <math.h>/* Ovim se omogucava da se nadalje u programu umesto int moze

koristiti ceo_broj */ typedef int ceo_broj ;

/* Ovim se omogucuje da se nadalje u programu umesto struct point

moze koristiti POINT */ typedef struct point POINT;

struct point{ int x; int y;};

main(){ /* Umesto int mozemo koristiti ceo_broj */ ceo_broj x = 3;

/* Definisemo promenljivu tipa tacke.Umesto struct point mozemo koristiti POINT */

POINT a;

printf("x = %d\n", x);

/* Postavljamo vrednosti koordinata tacke a*/ a.x = 1; a.y = 2; /* Ispisujemo velicinu strukture tacka */ printf("sizeof(struct point) = %d\n", sizeof(POINT));

/* Ispisujemo vrednosti koordinata tacaka */ printf("x koordinata tacke a je %d\n", a.x); printf("y koordinata tacke a je %d\n", a.y);

}

/*----------------------------8.4c.c--------------------------*/ /* Koriscenje typedef radi lakseg rada */

#include <stdio.h>

#include <math.h>

/* Deklaraciju strukture i typedef mozemo spojiti */ typedef struct point{ int x; int y;} POINT;

main(){ /* Definisemo promenljivu tipa tacke.

Umesto struct point mozemo koristiti POINT */ POINT a; /* Postavljamo vrednosti koordinata tacke a*/ a.x = 1; a.y = 2; /* Ispisujemo velicinu strukture tacka */ printf("sizeof(struct point) = %d\n", sizeof(POINT));

/* Ispisujemo vrednosti koordinata tacaka */ printf("x koordinata tacke a je %d\n", a.x); printf("y koordinata tacke a je %d\n", a.y);

}

/*----------------------------8.5.c--------------------------*/ /* Strukture se u funkcije prenose po vrednosti.

Moguce je koristiti pokazivace na strukture */

#include <stdio.h>




typedef struct point{ int x, y;} POINT;

/* Zbog prenosa po vrednosti tacka ne moze biti ucitana */ void get_point_wrong(POINT p){ printf("x = "); scanf("%d", &p.x); printf("y = "); scanf("%d", &p.y);

}

/* Koriscenjem prenosa preko pokazivaca, uspevamo */ void get_point(POINT* p){ /* p->x je skraceni zapis za (*p).x */

printf("x = "); scanf("%d", &p->x); printf("y = "); scanf("%d", &p->y);}

main(){ POINT a = {0, 0};

printf("get_point_wrong\n"); get_point_wrong(a); printf("a: x = %d, y = %d\n", a.x, a.y);

printf("get_point\n"); get_point(&a); printf("a: x = %d, y = %d\n", a.x, a.y);

}




/*----------------------------9.1.c--------------------------*/ /* Argumenti komandne linije programa */

/* Program pozivati sa npr.: ./a.out

./a.out prvi

./a.out prvi drugi treci

./a.out -a -bc ime.txt*/

#include <stdio.h>/* Imena ovih promenljivih mogu biti proizvoljna. Npr.

main (int br_argumenata, char* argumenti[]);

ipak, uobicajeno je da se koriste sledeca imena:*/ main(int argc, char* argv[]){ int i;

printf("argc = %d\n", argc); for (i = 0; i<argc; i++) printf("argv[%d] = %s\n", i, argv[i]);}

/*----------------------------9.2.c--------------------------*/ /* Program ispisuje opcije navedene u komandnoj liniji. K&R resenje. */

/* Opcije se navode koriscenjem znaka -, pri cemu je moguce da iza jednog -sledi i nekoliko opcija.

Npr. za -abc -d -fg su prisutne opcije a b c d e f g */

/* Resnje se intenzivno zasniva na pokazivackoj aritmetici i prioritetu operatora */

#include <stdio.h>

int main(int argc, char* argv[]){

char c; /* Dok jos ima argumenata i dok je karakter na poziciji 0 upravo crtica */ while(--argc>0 && (*++argv)[0]=='-')

/* Dok god ne dodjemo do kraja tekuceg stringa */ while (c=*++argv[0]) printf("Prisutna opcija : %c\n",c);

}

/*----------------------------9.2b.c--------------------------*/ /* Program ispisuje opcije navedene u komandnoj liniji - jednostavnija verzija */

#include <stdio.h>

main(int argc, char* argv[]){ /* Za svaki argument komande linije, pocevsi od argv[1]

(preskacemo ime programa) */ int i;

for

(i = 1; i < argc; i++) { /* Ukoliko i-ti argument pocinje crticom */ if (argv[i][0] == '-') { /* Ispisujemo sva njegova slova pocevsi od pozicije 1 */ int j; for (j = 1; argv[i][j] != '\0'; j++) printf("Prisutna je opcija : %c\n", argv[i][j]); } /* Ukoliko ne pocinje crticom, prekidamo */ else break; }}

/*----------------------------9.3.c--------------------------*/




/* Program demonstrira otvaranje datoteka ("r" - read i "w" - write mod) i osnovne tehnike rada sa datotekama */

/* U datoteku se upisuje prvih 10 prirodnih brojeva, a zatim se iz iste datotekecitaju brojevi dok se ne stigne do kraja i ispisuju se na standardni izlaz */

#include <stdio.h>

/* Zbog funkcije exit */ #include <stdlib.h>

main(){

int i; /* Otvaramo datoteku sa imenom podaci.txt za pisanje */ FILE* f = fopen("podaci.txt", "w");

/* Ukoliko otvaranje nije uspelo, fopen vraca NULL. U tom slucaju, prijavljujemo gresku i zavrsavamo program */

if (f == NULL) { printf("Greska prilikom otvaranja datoteke podaci.txt za pisanje\n"); exit(1); }

/* Upisujemo u datoteku prvih 10 prirodnih brojeva (svaki u posebnom redu) */ for (i = 0; i<10; i++) fprintf(f, "%d\n", i);

/* Zatvaramo datoteku */ fclose(f);

/* Otvaramo datoteku sa imenom podaci.txt za citanje */ f = fopen("podaci.txt", "r");

/* Ukoliko otvaranje nije uspelo, fopen vraca NULL. U tom slucaju, prijavljujemo gresku i zavrsavamo program */

if (f == NULL) { printf("Greska prilikom otvaranja datoteke podaci.txt za citanje\n"); exit(1); }

/* Citamo brojeve iz datoteke dok ne stignemo do kraja i ispisujemo ihna standardni izlaz */

while(1)

{ int br; /* Pokusavamo da procitamo broj */ fscanf(f, "%d", &br);

/* Ukoliko smo dosli do kraja datoteke, prekidamo */ if (feof(f)) break;

/* Ispisujemo procitani broj */ printf("Procitano : %d\n", br);

}

/* Funkciju feof ne bi trebalo pozivati pre pokusaja citanja. Sledeci kod moze dovesti do greske:

while (!feof(f)) scanf("%d",&br);

*/


}

/*----------------------------9.3b.c--------------------------*/ /* Program demonstrira "a" - append mod datoteka - nadovezivanje */ #include <stdio.h>




main(){

FILE* datoteka;

/* Otvaramo datoteku za nadovezivanje i proveravamo da li je doslo do greske */ if ( (datoteka=fopen("dat.txt","a"))==NULL) {

fprintf(stderr,"Greska : nisam uspeo da otvorim dat.txt\n"); return 1; }

/* Upisujemo sadrzaj u datoteku */ fprintf(datoteka,"Zdravo svima\n");

/* Zatvaramo datoteku */ fclose(datoteka);}

/*----------------------------9.4.c--------------------------*/ /* Program ilustruje rad sa datotekama. Program kopira datoteku cije

se ime zadaje kao prvi argument komandne linije u datoteku cije se ime zadaje kao drugi argument komandne linije. */ /* Uz svaku liniju se zapisuje i njen broj */ #include <stdio.h>

#define MAX_LINE 256

/* Funkcija getline iz K&R jednostavno realizovana preko funkcije fgets */

int getline(char s[], int lim)

{ char* c = fgets(s, lim, stdin); return c==NULL ? 0 : strlen(s);}

main(int argc, char* argv[]){

char line[MAX_LINE]; FILE *in, *out; int line_num;

if (argc != 3) {

fprintf(stderr,"Upotreba : %s ulazna_datoteka izlazna_datoteka\n", argv[0]); return 1;

} if ((in = fopen(argv[1],"r")) == NULL) {

fprintf(stderr, "Neuspesno otvaranje datoteke %s\n", argv[1]); return 1; }

if ((out = fopen(argv[2],"w")) == NULL) {

fprintf(stderr, "Neuspesno otvaranje datoteke %s\n",argv[2]); return 1; }

/* Prepisivanje karakter po karakter je moguce ostvariti preko: int c; while ((c=fgetc(ulaz)) != EOF)

putc(c,izlaz); */

line_num = 1; /* Citamo liniju po liniju sa ulaza*/ while (fgets(line, MAX_LINE, in) != NULL) {

/* Ispisujemo broj linije i sadrzaj linije na izlaz */ fprintf(out, "%-3d :\t", line_num++); fputs(line, out); }

/* Zatvaramo datoteke */ fclose(in);

fclose(out);}




/*----------------------------9.5.c--------------------------*/ /* Citanje niza struktura iz tektsualne datoteke - artikli prodavnice */

/* Datoteka cije se ime unosi sa standardnog ulaza sadrzi podatke o proizvodima koji se prodaju u okviru odredjene prodavnice.Svaki proizvod se odlikuje sledecim podacima :

bar-kod - petocifreni pozitivan broj ime - niska karaktera cena - realan broj zaokruzen na dve decimale

pdv - stopa poreza - realan broj zaokruzen na dve decimale Pretpostavljamo da su podaci u datoteci korektno zadati.

Pretpostavljamo da se u prodavnici ne prodaje vise od 1000 razlicitih artikala. Na standardni izlaz ispisati podatke o svim proizvodima koji se prodaju.*/ #include <stdio.h>

/* Maksimalna duzina imena proizvoda */ #define MAX_IME 30

/* Struktura za cuvanje podataka o jednom artiklu */ typedef struct _artikal{ int bar_kod;

char ime[MAX_IME]; float cena; float pdv;} artikal;

/* Maksimalni broj artikala */ #define MAX_ARTIKALA 1000

/* Niz struktura u kome se cuvaju podaci o artiklima */ artikal artikli[MAX_ARTIKALA];

/* Broj trenutno ucitanih artikala */ int br_artikala = 0;

/* Ucitava podatke o jednom artiklu iz date datoteke.Vraca da li su podaci uspesno procitani */

int ucitaj_artikal(FILE* f, artikal* a){ /* Citamo bar kod */ fscanf(f, "%d", &(a->bar_kod));

/* Ukoliko smo dosli do kraja datoteke prijavljujemo neuspeh */ if (feof(f)) return 0;

/* Citamo ime proizvoda */ fscanf(f, "%s", a->ime); /* Citamo cenu */ fscanf(f, "%f", &(a->cena)); /* Citamo stopu poreza */ fscanf(f, "%f", &(a->pdv));

/* Prijavljujemo uspeh */ return 1;}

/* Izracunava ukupnu cenu datog artikla */ float

cena(artikal a){ return a.cena*(1+a.pdv);}

/* Ispisuje podatke o svim artiklima */ void ispisi_artikle(){ int i; for (i = 0; i<br_artikala; i++) printf("%-5d %-10s %.2f %.2f = %.2f\n",

artikli[i].bar_kod, artikli[i].ime,artikli[i].cena, artikli[i].pdv, cena(artikli[i]));

}

main(int argc, char* argv[])




{ FILE* f;

/* Ukoliko nije navedeno ime kao argument komandne linije,trazimo od korisnika da ga unese */

if (argc<2) { /* Ucitavamo ime datoteke */ char ime_datoteke[256 ]; printf("U kojoj datoteci se nalaze podaci o proizvodima: "); scanf("%s", ime_datoteke);

/* Otvaramo datoteku i proveravamo da li smo uspeli */

if ( (f = fopen(ime_datoteke, "r")) == NULL) { printf("Greska : datoteka %s ne moze biti otvorena\n",

ime_datoteke); } } /* Ime datoteke je prvi argument komandne linije */ else {

/* Otvaramo datoteku i proveravamo da li smo uspeli */ if ( (f = fopen(argv[1], "r")) == NULL) { printf("Greska : datoteka %s ne moze biti otvorena\n",

argv[1]); }

}

/* Ucitavamo artikle */ while (ucitaj_artikal(f, &artikli[br_artikala])) br_artikala++;

/* Ispisujemo podatke o svim artiklima */ ispisi_artikle();

/* Zatvaramo datoteku */ fclose(f);}




/*----------------------------10.1a.c--------------------------*/ /* Rekurzija : funkcija koja stepenuje realan broj na celobrojni izlozilac */

#include <stdio.h>float power(float f, int k){ /* if (k == 0) return 1; else

return f*power(f, k-1); */

/* Krace : */

return k==0 ? 1 : f*power(f, k-1);

}

/* Iterativna verzija prethodne funkcije */ float power_iterative(float x, int k){ int i; float s = 1; for (i = 0; i<k; i++) s*=x;

return s;}

main(){ printf("%f", power(2.5, 8));}

/*----------------------------10.1b.c--------------------------*/ /* Rekurzija : faktorijel */ long factorial(int n){ /*

if (n == 1) return 1; else return n*factorial(n-1); */

/* Krace */ return n == 1 ? 1 : n*factorial(n-1);}

long factorial_iterative(int n){ long f = 1; int i; for (i = 1; i<=n; i++) f *= i; return f;}

main(){ printf("5! = %d\n", factorial(5));}

/*----------------------------10.1c.c--------------------------*/ /* Rekurzija : Fibonacijevi brojevi */

/* Fibonacijev niz brojeva se definise kao niz u kome su prva dva brojajednaka 1, a za ostale brojeve vazi da je svaki sledeci zbir dva prethodna. tj.

f(0) = 1, f(1) = 1, f(n) = f(n-1) + f(n-2)*/





/* Rekurzivna implementacija - obratiti paznju na neefikasnost funkcije */ int Fib(int n){ printf("Racunam Fib(%d)\n",n); return (n == 0 || n == 1) ? 1 : Fib(n-1) + Fib(n-2);}

/* Iterativna implementacija sa nizom */ int Fib_array(int n){

int *fib; int i, result;

/* Alociramo niz */ if ((fib = malloc(n*sizeof(int))) == NULL) return -1;

/* Racunamo elemente */ fib[0] = 1; fib[1] = 1;

for (i = 2; i<=n; i++) fib[i] = fib[i-2] + fib[i-1];

/* Moramo upamtiti rezultat kako bismo oslobodili niz */ result = fib[n];

/* Oslobadjamo niz */ free(fib);

return result;}

/* Iterativna verzija bez niza */ int Fib_iterative(int n){ /* Promenljiva pp cuva pretposlednji, a p poslednji element niza */ int pp = 1, p = 1; int i; for (i = 0; i <= n-2; i++) { int tmp = pp; pp = p; p = p + tmp; }

return p;}

main(){ printf("Fib(5) = %d\n", Fib(5)); printf("Fib(5) = %d\n", Fib_array(5)); printf("Fib(5) = %d\n", Fib_iterative(5));

}

/*----------------------------10.1d.c--------------------------*/ /* Rekurzija : sumiranje niza brojeva */

/* Rekurzivna verzija */

int array_sum(int a[], int n){ return n == 0 ? 0 : array_sum(a, n-1)+a[n-1];}

/* Iterativna verzija */ int array_sum_iterative(int a[], int n){ int sum = 0; int i; for (i = 0; i<n; i++) sum += a[i]; return sum;}




main(){ int a[] = {1, 2, 3, 4, 5, 6 , 7 }; printf("sum = %d\n", array_sum(a, sizeof(a)/sizeof(int))); printf("sum = %d\n", array_sum_iterative(a, sizeof(a)/sizeof(int)));

}

/*----------------------------10.2.c--------------------------*/ /* Linearna pretraga niza brojeva */ #include <stdio.h>

/* Funkcija proverava da li se dati element x nalaziu datom nizu celih brojeva.Funkcija vraca poziciju u nizu na kojoj je x pronadjen

odnosno -1 ukoliko elementa nema.*/ int linear_search(int a[], int n, int x){ int i; for (i = 0; i<n; i++) if (a[i] == x) return i; /* nikako else */

return -1;}

main(){ int a[] = {4, 3, 2, 6 , 7 , 9, 11}; int n = sizeof(a)/sizeof(int); int x, i; printf("Unesi broj koji trazimo : "); scanf("%d",&x);

i = linear_search(a, n, x); if (i == -1) printf("Element %d nije nadjen\n",x); else

printf("Element %d je nadjen na poziciji %d\n",x, i);}

/*----------------------------10.3a.c--------------------------*/ /* Binarna pretraga niza celih brojeva - iterativna verzija*/

#include <stdio.h>

/* Funkcija proverava da li se element x javlja unutar nizacelih brojeva a.

Funkcija vraca poziciju na kojoj je element nadjen odnosno -1 ako ga nema.

!!!!! VAZNO !!!!! Pretpostavka je da je niz a uredjen po velicini*/

int binary_search(int a[], int n, int x){ /* Pretrazujemo interval [l, d] */ int l = 0; int d = n-1;

/* Sve dok interval [l, d] nije prazan */ while (l <= d) { /* Srednja pozicija intervala [l, d] */ int s = (l+d)/2;

/* Ispitujemo odnos x-a i srednjeg elementa */ if (x == a[s]) /* Element je pronadjen */ return s; else if (x < a[s]) { /* Pretrazujemo interval [l, s-1] */

d = s-1; } else




{ /* Pretrazujemo interval [s+1, d] */ l = s+1; } }

/* Element je nadjen */ return -1;}

main(){ int a[] = {3, 5, 7 , 9, 11, 13, 15};

int x; int i;

printf("Unesi element kojega trazimo : "); scanf("%d",&x); i = binary_search(a, sizeof(a)/sizeof(int), x);

if (i==-1) printf("Elementa %d nema\n", x); else printf("Pronadjen na poziciji %d\n", i);}

/*----------------------------10.3b.c--------------------------*/ /* Binarna pretraga niza celih brojeva - rekurzivna verzija*/ #include <stdio.h>

/* Funkcija proverava da li se element x javlja unutar nizacelih brojeva a.

Funkcija vraca poziciju na kojoj je element nadjen odnosno -1 ako ga nema.

!!!!! VAZNO !!!!! Pretpostavka je da je niz a uredjen po velicini*/

int binary_search(int a[], int l, int d, int x){ /* Ukoliko je interval prazan, elementa nema */ if (l > d) return -1;

/* Srednja pozicija intervala [l, d] */ int s = (l+d)/2;

/* Ispitujemo odnos x-a i srednjeg elementa */ if (x == a[s]) /* Element je pronadjen */ return s; else if (x < a[s]) /* Pretrazujemo interval [l, s-1] */ return binary_search(a, l, s-1, x); else /* Pretrazujemo interval [s+1, d] */ return binary_search(a, s+1, d, x);}

main(){

int a[] = {3, 5, 7 , 9, 11, 13, 15}; int x; int i;

printf("Unesi element kojega trazimo : "); scanf("%d",&x); i = binary_search(a, 0, sizeof(a)/sizeof(int)-1, x);

if (i==-1) printf("Elementa %d nema\n", x); else printf("Pronadjen na poziciji %d\n", i);}

/*----------------------------10.3c.c--------------------------*/ /* Binarna pretraga niza celih brojeva : koriscenje ugradjene funkcije bsearch */




#include <stdlib.h>

/* Potrebno je izgraditi funkciju poredjenja */ int poredi(const void * a, const void *b){ return *(int*)a - *(int*)b; }

main(){ int a[] = {3, 5, 7 , 9, 11, 13, 15}; int x, *e;

printf("Unesi element kojega trazimo : "); scanf("%d",&x);

/* Adresa elementa koji trazimo, pocetak niza, broj elemenata,velicina jednog elementa, adresa funkcije poredjenja */

e = (int*)bsearch((void *)&x,(void *)a,

sizeof(a)/sizeof(int), sizeof(int), &poredi);

if (e == NULL) printf("Elementa %d nema\n", x); else printf("Pronadjen na poziciji %d\n", e-a);}

/*----------------------------10.4a.c--------------------------*/

/* Sortiranje niza celih brojeva - Selection sort algoritam */ #include <stdio.h>

/* Funkcija sortira dati niz brojeva koji ima n elemenata */ void selection_sort(int a[], int n){ int i, j; /* Na svaku poziciju od 0 do pretposlednje */ for (i = 0; i < n-1; i++) /* Dovodimo minimalni element ostatka niza */ for(j = i+1; j < n; j++) if (a[i]>a[j]) { int tmp = a[i]; a[i] = a[j]; a[j] = tmp; }

}

main(){ int a[] = {5, 8, 2, 4, 1, 9, 3, 7 , 6 }; int n = sizeof(a)/sizeof(int); int i;

selection_sort(a, n);

for (i = 0; i < n; i++) printf("%d ", a[i]); printf("\n"); }

/*----------------------------10.4b.c--------------------------*/ /* Sortiranje niza celih brojeva - QuickSort algoritam */

/* Funkcija menja mesto i-tom i j-tom elementu niza a */ void swap(int a[], int i, int j){ int tmp = a[i]; a[i] = a[j]; a[j] = tmp;}

/* Funkcija particionise interval [l, r] niza a, tako da levo od pivotabudu svi elementi manji od njega, a desno svi veci od njega.Ovi podnizovi ne moraju biti sortirani.




Funkcija vraca poziciju pivota.*/ int partition(int a[], int l, int r){ int last, i;

/* Srednji element uzimamo za pivot i postavljamo ga na pocetak */ swap(a, l, (l + r)/2);

/* Niz organizujemo tako da pivot postavimo na pocetak, zatim da izanjega budu svi elementi manji od njega, pa zatim svi elementi kojisu veci od njega tj. piv < < < < > > > >*/

/* last je pozicija poslednjeg elementa niza za koji znamo da je manji od pivota. U pocetku takvih elemenata nema */ last = l; for (i = l+1; i <= r; i++) /* Ukoliko je element na poziciji i manji od pivota,

postavljamo ga iza niza elemenata manjih od pivota, menjajuci mu mesto sa prvim sledecim */ if (a[i] < a[l]) swap(a, ++last, i);

/* Zahtevanu konfiguraciju < < < < piv > > > > dobijamo takosto zamenimo mesto pivotu i poslednjem elementu manjem od njega */

swap(a, l, last);

/* Pivot se sada nalazi na poziciji last */ return last;}

/* Funkcija sortira deo niza brojeva a izmedju pozicija l i r*/ void quick_sort(int a[], int l, int r){ int i, last;

/* Ukoliko je interval [l, r] prazan nema nista da se radi */ if (l >= r)

return;

/* Particionisemo interval [l, r] */ int pivot = partition(a, l, r);

/* Rekurzivno sortiramo elemente manje od pivota */ quick_sort(a, l, pivot-1); /* Rekurzivno sortiramo elemente vece pivota */

quick_sort(a, pivot+1, r);}

main(){ int a[] = {5, 8, 2, 4, 1, 9, 3, 7 , 6 }; int n = sizeof(a)/sizeof(int); int i;

quick_sort(a, 0, n-1);

for (i = 0; i < n; i++) printf("%d ", a[i]); printf("\n"); }

/*----------------------------10.4c.c--------------------------*/ /* Sortiranje niza celih brojeva - koriscenje ugradjene funkcije qsort */

#include <stdlib.h>#include <stdio.h>

/* Potrebno je napraviti funkciju poredjenja */ int poredi(const void * a, const void * b){ return *((int*)a)-*((int*)b); }

main(){ int a[] = {5, 8, 2, 4, 1, 9, 3, 7 , 6 }; int n = sizeof(a)/sizeof(int);




int i;

/* Pocetak niza, broj elemenata, velicina jednog elementa, adresafunkcije poredjenja */

qsort((void *)a, n, sizeof(int), &poredi);

for (i = 0; i < n; i++) printf("%d ", a[i]); printf("\n");}

/*----------------------------10.4d.c--------------------------*/ /* Sortiranje niza celih brojeva : implementacija genericke funkcije

sortiranja - funkcija je nezavisna od tipa elemenata niza koji sesortira */ #include <stdlib.h>

/* Funkcija Selection sort algoritmom sortira niz elemenata proizvoljnogtipa. Argumenti funkcije su :

adresa pocetka niza data kao void* broj elemenata niza velicina jednog elementa niza pokazivac na funkciju poredjenja dva elementa niza*/ void sort(void * a, int n, int size, int (*poredi)(void *, void *)){ int i, j; for (i = 0; i<n-1; i++) for (j = i+1; j<n; j++) { void * adresa_itog = (char*)a+i*size; void * adresa_jtog = (char*)a+j*size;

if (poredi(adresa_itog, adresa_jtog)) { void * tmp = malloc(size); memcpy(tmp, adresa_itog, size); memcpy(adresa_itog, adresa_jtog, size); memcpy(adresa_jtog, tmp, size); free(tmp); }

}}

int poredi_br(void * a, void * b){ int br_a = *(int*)a; int br_b = *(int*)b;

return br_a>br_b;}

main(){ int a[] = {8, 2, 1, 9, 3, 7 , 6 , 4, 5}; int n = sizeof(a)/sizeof(int); int i;

sort(a, n, sizeof(int), &poredi_br);

for (i = 0; i < n; i++) printf("%d ", a[i]); putchar('\n');}

/*----------------------------10.5a.c--------------------------*/ /* Binarna pretraga niza struktura - pretraga studenata po broju indeksa */

/* Datoteka sadrzi podatke o uspehu studenata na kolokvijumima iz osnova programiranja. Prva linija datoteke sadrži broj studenata, a zatim svaka sledeca linija sadrži ime iprezime odredjenog studenta, njegov broj indeksa (u obliku korisnickog imena na alas-u npr.mr01123)

i broj poena na prvom i na drugom kolokvijumu. Redosled studenata u datoteci je odredjenna

osnovu njihovog broja indeksa, i to tako da su na pocetku datoteke navedeni stariji




studentisa manjim brojevima indeksa (npr. mv02234 je ispred mn03123 jer je stariji, a mr03123 je

ispredml03234 jer ima manji broj indeksa).

a) Definisati strukturu podataka za cuvanje podataka o studentima b) Napraviti funkciju koja poredi dva indeksa u skladu sa poretkom opisanim u uvoduzadatka c) Napsati rekurzivnu funckiju

int binary_search_recursive(char* indeks, .....)

koja izracunava broj poena studenta sa datim brojem indeksa, ukoliko je student polaga

kolokvijum, odnosno -1 ukoliko nije.d) Napisati iterativnu varijantu prethodne funkcije

int binary_search_iterative(char* indeks, ......)

e) Napisati funkciju

int binary_search_stdlib(char* indeks, .....)

koja prethodnu funkcionalnost ostvaruje kroz poziv bibliotecke funkcije bsearch. f) Napisati program koji ucitava podatke o studentima iz datoteke cije je ime navedeno ka

argument komandne linije, zatim koristeci funkcije iz prethodnog dela zadatka ispisujeukupan

broj poena za svakog studenata ciji indeks korisnik unese sa standardnog ulaza, sve done unese

rec kraj za kraj.*/

#include <stdio.h>#include <stdlib.h>#include <string.h>

/* Definicija strukture za cuvanje podataka o jednom studentu */ typedef struct _student{ char ime[15]; char prezime[15]; char indeks[8]; int kol_1; int kol_2;} student;

/* Studenti se smestaju u niz koji ce se dinamicki alocirati.Pretpostavlja se da je niz sve vreme sortiran kako bi se

moglo vrsiti binarno pretrazivanje */ student* studenti;int br_stud;

/* Funkcija vrsi poredjenje indeksa. Manjim se smatraju stariji studentisa manjim brojem indeksa. Funkca vraca negativnu vrednost ukoliko je prvi indeks manji, pozitivnu ukoliko je veci, a 0 ukoliko su indeksi

jednaki. Informacije o smerovima se u potpunosti zanemaruju.*/ int poredi_indekse(char* indeks_1, char* indeks_2){ /* Izdvaja se informacija o godini upisa i

broju indeksa za oba studenta*/ char s_godina_1[3], s_godina_2[3]; int godina_1, godina_2; char s_broj_1[4], s_broj_2[4];

int broj_1, broj_2; /* Godina upisa je zapisana u 3 i 4 karakteru

indeksa. Za nultu godinu uzimamo 1900. i smatramo da sustudenti ciji je broj indeksa ispod 50 upisani sto godina posle. */

strncpy(s_godina_1, indeks_1+2, 2); godina_1 = atoi(s_godina_1); if (godina_1 < 50) godina_1 += 100;

strncpy(s_godina_2, indeks_2+2, 2); godina_2 = atoi(s_godina_2); if (godina_2 < 50) godina_2 += 100;

/* Prvo poredimo godine */ if (godina_1 < godina_2)




return -1;

if (godina_1 > godina_2)return 1;

/* Ukoliko su godine jednake, izdvajamo brojeve indeksakoji su zapisani u 5. 6. i 7. karakteru indeksa */

strncpy(s_broj_1, indeks_1+4, 3); broj_1 = atoi(s_broj_1); strncpy(s_broj_2, indeks_2+4, 3);

broj_2 = atoi(s_broj_2);

/* Umesto ovoga, prolazi i return strcmp(indeks_1+4, indeks_2+4); */

/* Poredimo godine upisa */ return broj_1-broj_2;}

/* Najjednostavnija rekurzivna implementacija algoritmabinarne pretrage */

int binary_search_recursive(char* indeks, int l, int d){ int s, cmp;

if (l>d) return -1;

s = (l+d)/2; cmp = poredi_indekse(studenti[s].indeks, indeks); if (cmp == 0) return studenti[s].kol_1 + studenti[s].kol_2; else if (cmp < 0) return binary_search_recursive(indeks, s+1, d); else

return binary_search_recursive(indeks, l, s-1);}

/* Iterativna varijanta prethodnog algoritma */ int binary_search_iterative(char* indeks){ int l = 0, d = br_stud - 1; while (l <= d) { int s = (l+d)/2; int cmp = poredi_indekse(studenti[s].indeks, indeks); if (cmp == 0) return studenti[s].kol_1 + studenti[s].kol_2; else if (cmp < 0) l = s+1; else

d = s-1; } return -1;}

/* Funkcija poredjenja koja je potrebna prilikom pozivaugradjene funkcije bsearch */

int poredi(const void * indeks, const void * indeks_2){ return poredi_indekse((char*)indeks, ((student*)indeks_2)->indeks);}

int binary_search_stdlib(char* indeks){student* s = bsearch(indeks, studenti, br_stud, sizeof(student), poredi);

return s==NULL ? -1 : s->kol_1+s->kol_2;}

/* Glavni program */ main(int argc, char* argv[]){ FILE* datoteka; int i; char indeks[8];

/* Proveravamo prisutnost argumenata komandne linije */ if (argc<2) { printf("Upotreba %s : ime_datoteke\n",argv[0]);




return -1; }

/* Otvaramo datoteku */ if ((datoteka = fopen(argv[1], "r")) == NULL)

{ printf("Greska prilikom otvaranja datoteke %s\n",argv[1]); return -1; }

/* Ucivamo broj studenata i alociramo niz */ fscanf(datoteka, "%d", &br_stud); studenti = (student*)malloc(br_stud*sizeof(student));

/* Ucitavamo podatke o studentima */ for (i = 0; i < br_stud; i++) { fscanf(datoteka, "%s",studenti[i].ime); fscanf(datoteka, "%s",studenti[i].prezime); fscanf(datoteka, "%s",studenti[i].indeks); fscanf(datoteka, "%d", &studenti[i].kol_1); fscanf(datoteka, "%d", &studenti[i].kol_2);

}

/* Ispisujemo poene za svakog studenta kojeg korisnik trazi */ do { printf("Unesi broj indeksa : "); scanf("%s",indeks); printf("Broj poena : %d\n",binary_search_stdlib(indeks)); } while (strcmp(indeks,"kraj") != 0);

/* Oslobadjamo alociranu memoriju */ free(studenti);

return 0; }

/*----------------------------10.5b.c--------------------------*/ /* Sortiranje niza reci - leksikografski odnosno po duzini - koriscenje

ugradjene qsort funkcije*/

#include <stdlib.h>#include <string.h>

/* Funkcija koja vrsi leksikografsko poredjenje dve reci */ int lexicographic_compare(const void * a, const void * b){ return strcmp(*(char**)a,*(char**)b); }

/* Funkcija koja vrsi poredjenje po duzini dve reci, opadajuce*/ int length_compare(const void * a, const void * b){ return strlen(*(char**)b)-strlen(*(char**)a); }

main(){ int i; char* a[] = {"Jabuka", "Kruska", "Sljiva", "Dinja", "Lubenica"}; int n = sizeof(a)/sizeof(int);

/* Sortiramo leksikografski i ispisujemo rezultat */ qsort((void *)a, n, sizeof(char*), &lexicographic_compare);

for (i=0; i<n; i++)

printf("%s ", a[i]); putchar('\n');

/* Sortiramo po duzini i ispisujemo rezultat */ qsort((void *)a, n, sizeof(char*), &length_compare);

for (i=0; i<n; i++) printf("%s ", a[i]); putchar('\n');

}

/*----------------------------10.5c.c--------------------------*/ /* Sortiranje : program pronalazi sve anagrame medju unetim recima */ /* Dve reci su anagrami ako i samo ako se sastoje od istog broja istih slova */




/* Algoritam se zasniva na odredjivanju kanonske forme svake reci.Kanonska forma se odredjuje sortiranjem slova svake reci.Reci su anagrami ako i samo ako su im kanonske forme jednake.

Sortiranjem niza reci na osnovu kanonskih formi anagrami se pojavejedan uz drugi u nizu */

#include <stdlib.h>#include <string.h>#include <stdio.h>

/* Pomocna funkcija koja ucitava rec. Pod recju se smatra niz slova */

int getword(char s[], int lim){ int c; int i = 0; while (!isalpha(c = getchar())) if (c == EOF)

return 0; do { s[i++] = c; } while (i<lim-1 && isalpha(c = getchar()));

s[i] = '\0'; return i;}

/* Maksimalna duzina reci */ #define MAX_WORD 50

/* Struktura reci je odredjena originalnom recju i njenim kanonskim predstavnikom */ struct word{ char original[MAX_WORD]; char cannonical[MAX_WORD];};

/* Funkcija koja vrsi poredjenje dva slova u reci */ int letter_compare(const void * a, const void * b){ return *(char*)a - *(char*)b; }

/* Funkcija koja vrsi poredjenje po dve reci, na osnovu njihovih kanonskih formi*/ int cannonical_compare(const void * a, const void * b){ return strcmp(((struct word*)a)->cannonical,

((struct word*)b)->cannonical);}

/* Dve reci su anagrami ako imaju istu kanonsku formu a razlicite su */ int is_anagram(struct word a, struct word b){ return strcmp(a.cannonical, b.cannonical) == 0

&& strcmp(a.original, b.original) != 0;}

main(){ int i, n; struct word words[1000];

/* Ucitavamo reci sa standardnog ulaza dok ih ima */ for (i = 0; getword(words[i].original, MAX_WORD) != 0; i++) { /* Odredjujemo kanonsku formu svake reci */ strcpy(words[i].cannonical, words[i].original); qsort(words[i].cannonical, strlen(words[i].cannonical),

sizeof(char), &letter_compare); }

/* Broj ucitanih reci */ n = i;

printf("Procitano %d reci\n", n);




/* Sortiramo niz reci na osnovu kanonske forme */ qsort(words, n, sizeof(struct word), &cannonical_compare);

/* Pronalazimo anagrame kao susedne elemente niza i ispisujemo ih */ for (i = 1; i<n; i++)

if (is_anagram(words[i-1], words[i])) { printf("Anagram : %s - %s",

words[i-1].original, words[i].original); while(i+1 < n && is_anagram(words[i], words[i+1])) { printf(" - %s", words[i+1].original);

i++; }

printf("\n");

}

}

/*----------------------------10.5d.c--------------------------*/ /* Sortiranje (selection sort) i binarna pretraga niza struktura - artikliu prodavnici */

#include <stdio.h>

/* Maksimalna duzina imena artikla */ #define MAX_IME 30

/* Struktura za predstavljanje pojedinacnih artikala */ typedef struct _artikal{ int bar_kod;

char ime[MAX_IME]; float cena; float pdv;} artikal;

/* Maksimalni broj artikala koji se prodaju */ #define MAX_ARTIKALA 1000artikal artikli[MAX_ARTIKALA];int br_artikala = 0;

/* Ucitava podatke o jednom artiklu. Vraca da li su podaci uspesno procitani */ int ucitaj_artikal(artikal* a){ scanf("%d", &(a->bar_kod)); if (a->bar_kod == -1) return 0;

scanf("%s", a->ime); scanf("%f", &(a->cena)); scanf("%f", &(a->pdv));

return 1;}

/* Selection sort algoritmom se sortiraju artikli na osnovu bar koda */ void sortiraj_artikle(){ int i, j; for (i = 0; i<br_artikala - 1; i++) for (j = i + 1; j<br_artikala; j++) {

if (artikli[i].bar_kod > artikli[j].bar_kod) { artikal tmp = artikli[i]; artikli[i] = artikli[j]; artikli[j] = tmp; } }}

/* Binarnom pretragom se pronalazi pozicija artikla sa datim bar kodom.Funkcija vraca -1 ako takav artikal ne postoji */

int pronadji_artikal(int bar_kod){ int l = 0, d = br_artikala -1; while (l<=d) { int s = (l+d)/2; if (artikli[s].bar_kod == bar_kod) s;




return else if (artikli[s].bar_kod < bar_kod) l = s + 1; else d = s - 1; } return -1;}

/* Funkcija izracunava ukupnu cenu datog artikla */ float cena(artikal a){ float c = a.cena*(1+a.pdv);

printf("Dodajem na racun : %-10s - %.2f\n", a.ime, c); return c;}

/* Funkcija ispisuje podatke o svim artiklima */ void ispisi_artikle(){ int i; for (i = 0; i<br_artikala; i++) printf("%8d %10s %.2f %.2f\n",

artikli[i].bar_kod, artikli[i].ime,artikli[i].cena, artikli[i].pdv);

}

main(){

while

(ucitaj_artikal(&artikli[br_artikala++])) ; br_artikala--;

sortiraj_artikle();printf("Artikli uspesno sortirani :\n");

ispisi_artikle();

float racun = 0.0;

int bar_kod; do { int i; do

{ scanf("%d", &bar_kod); } while (bar_kod != -1 && (i = pronadji_artikal(bar_kod)) == -1);

if (bar_kod != -1) racun += cena(artikli[i]);

} while (bar_kod != -1);

printf("Vas ukupan racun je : %.2f\n", racun);}




/*----------------------------11.1a.c--------------------------*/ /* Ubacivanje na pocetak jednostruko povezane liste - verzija sa **. Ispis i oslobadjanje liste realizovani iterativno. */


typedef struct cvor{ int br;

struct cvor* sl;} CVOR;

/* Pomocna funkcija koja kreira cvor liste sa datim sadrzajem.Funkcija kreira cvor i postavlja mu sadrzaj na dati broj.Polje sl ostaje nedefinisano.Funkcija vraca pokazivac na kreirani cvor. */

CVOR* napravi_cvor(int br){ CVOR* novi = (CVOR*)malloc(sizeof(CVOR)); if (novi == NULL) { fprintf(stderr, "Greska prilikom alokacije memorije\n"); exit(1); } novi->br = br; return novi;}

/* Zbog prenosa po vrednosti, sledeca funkcija ne radi ispravno */ /*void ubaci_na_pocetak(CVOR* l, int br){ CVOR* novi = napravi_cvor(br); novi->sl = l; l = novi; /* Ovde se menja lokalna kopija pokazivaca l, a

ne l iz funkcije pozivaoca (main) */ }*/

/* Ubacuje dati broj na pocetak liste.Pokazivac na pocetak liste se prenosi preko pokazivaca, umesto povrednosti, kako bi mogla da mu se izmeni vrednost. */

void ubaci_na_pocetak(CVOR** pl, int br){ CVOR* novi = napravi_cvor(br); novi->sl = *pl; *pl = novi;}

/* Ispisivanje liste : iterativna verzija */ void ispisi_listu(CVOR* l){ CVOR* t; for (t = l; t != NULL; t=t->sl) printf("%d ", t->br);}

/* Sledeca funkcija je neispravna */ /*void oslobodi_listu(CVOR* l){ CVOR* t;

for (t = l; t!=NULL; t = t->sl) free(t);

/* Ovde se unistava sadrzaj cvora na koji ukazuje t. Korak petlje t = t->sl nece moci da se izvrsi */ }*/

/* Oslobadjanje liste : iterativna verzija */ void oslobodi_listu(CVOR* l){




while (l) { CVOR* tmp = l->sl; free(l); l = tmp; }}

main(){ CVOR* l = NULL; int i; for (i = 0; i<10; i++)

ubaci_na_pocetak(&l, i); ispisi_listu(l); putchar('\n');

oslobodi_listu(l);}

/*----------------------------11.1b.c--------------------------*/ /* Ubacivanje na pocetak jednostruko povezane liste - verzija sa

eksplicitnim vracanjem novog pocetka liste.Ispis i oslobadjanje liste su realizovani rekurzivno

*/


typedef struct cvor{ int br; struct cvor* sl;} CVOR;


CVOR* napravi_cvor(int br){ CVOR* novi = (CVOR*)malloc(sizeof(CVOR)); if (novi == NULL) { fprintf(stderr, "Greska prilikom alokacije memorije\n"); exit(1); } novi->br = br; return novi;}

/* Ubacuje dati broj na pocetak date liste.Funkcija pozivaocu eksplicitno vraca pocetak rezultujuce liste.*/

CVOR* ubaci_na_pocetak(CVOR* l, int br){ CVOR* novi = napravi_cvor(br); novi->sl = l; return novi;}

/* Ispisivanje liste : rekurzivna verzija */

void ispisi_listu(CVOR* l){ if (l != NULL) { printf("%d ", l->br); ispisi_listu(l->sl); }}

/* Ispisivanje liste unatrag : rekurzivna verzija */ /* Prethodna funkcija se lako modifikuje tako da ispisuje listu unazad */ void ispisi_listu_unazad(CVOR* l){ if (l != NULL) {




ispisi_listu_unazad(l->sl); printf("%d ", l->br); }}

/* Oslobadjanje liste : rekurzivna verzija */ void oslobodi_listu(CVOR* l){ if (l != NULL) { oslobodi_listu(l->sl); /* Prvo se oslobadja poslednji element liste */ /* printf("Oslobadjam %d\n", l->br); */

free(l); }}

main(){ CVOR* l = NULL; int i; for (i = 0; i<10; i++) l = ubaci_na_pocetak(l, i);

ispisi_listu(l); putchar('\n');

ispisi_listu_unazad(l); putchar('\n');

oslobodi_listu(l);}

/*----------------------------11.2a.c--------------------------*/ /* Ubacivanje na kraj jednostruko povezane liste

- verzija sa **- iterativna i rekurzivna verzija

*/




CVOR* napravi_cvor(int br){ CVOR* novi = (CVOR*)malloc(sizeof(CVOR)); if (novi == NULL) { fprintf(stderr, "Greska prilikom alokacije memorije\n"); exit(1); } novi->br = br; return novi;

}/* Ubacuje dati broj na pocetak liste.

Pokazivac na pocetak liste se prenosi preko pokazivaca, umesto povrednosti, kako bi mogla da mu se izmeni vrednost.Iterativna verzija funkcije */

/* Ubacivanje na kraj liste je neefikasna operacija */ void ubaci_na_kraj(CVOR** pl, int br){ CVOR* novi = napravi_cvor(br); novi->sl = 0;

if (*pl == NULL) *pl = novi; else {




/* Pronalazimo poslednji element liste - t*/ CVOR* t; for (t=*pl; t->sl!=NULL; t=t->sl) ; t->sl = novi; } }

/* Rekurzivna varijanta prethodne funkcije */ void ubaci_na_kraj_rekurzivno(CVOR** pl, int br){ if (*pl == NULL)

{ CVOR* novi = napravi_cvor(br); *pl = novi; } else ubaci_na_kraj_rekurzivno( &((*pl)->sl) ,br);}

/* Ispisivanje liste : iterativna verzija */ void ispisi_listu(CVOR* l){ CVOR* t; for (t = l; t != NULL; t=t->sl) printf("%d ", t->br);}

/* Iterativna verzija funkcije koja oslobadja listu */ void oslobodi_listu(CVOR* l){ while (l) { CVOR* tmp = l->sl; free(l); l = tmp; }}

main(){ CVOR* l = NULL; int i; for (i = 0; i<5; i++)

ubaci_na_kraj(&l, i); for (; i<10; i++) ubaci_na_kraj_rekurzivno(&l, i);


oslobodi_listu(l);}

/*----------------------------11.2b.c--------------------------*/ /* Ubacivanje na kraj jednostruko povezane liste

- verzija sa eksplicitnim vracanjem nove liste- iterativna i rekurzivna verzija */




CVOR* napravi_cvor(int br){ CVOR* novi = (CVOR*)malloc(sizeof(CVOR)); if (novi == NULL)




{ fprintf(stderr, "Greska prilikom alokacije memorije\n"); exit(1); } novi->br = br; return novi;}

/* Funkcija vraca pocetak rezultujuce liste */ CVOR* ubaci_na_kraj(CVOR* l, int br){ CVOR* novi = napravi_cvor(br); novi->sl = NULL;

if (l == NULL) return novi; else { CVOR* t;

for (t = l; t->sl!=NULL; t=t->sl) ; t->sl = novi;

/* Pocetak se nije promenio */ return l; }}

/* Rekurzivna varijanta prethodne funkcije. I ova funkcija vraca pokazivac na pocetak rezultujuce liste */ CVOR* ubaci_na_kraj_rekurzivno(CVOR* l, int br){ if (l == NULL) { CVOR* novi = napravi_cvor(br); return novi; }

l->sl = ubaci_na_kraj_rekurzivno(l->sl, br); return l;}

/* Ispisivanje liste : iterativna verzija */ void ispisi_listu(CVOR* l){ CVOR* t;

for (t = l; t != NULL; t=t->sl) printf("%d ", t->br);}


main()

{ CVOR* l = NULL; int i; for (i = 0; i<5; i++) l = ubaci_na_kraj(l, i); for (; i<10; i++) l = ubaci_na_kraj_rekurzivno(l, i);


oslobodi_listu(l);}

/*----------------------------11.3a.c--------------------------*/ /* Ubacivanje na odgovarajuce mesto sortirane jednostruko povezane liste




- verzija sa **- iterativna i rekurzivna verzija

*/




CVOR* napravi_cvor(int br){ CVOR* novi = (CVOR*)malloc(sizeof(CVOR)); if (novi == NULL) { fprintf(stderr, "Greska prilikom alokacije memorije\n"); exit(1); } novi->br = br; return novi;}/* Kljucna ideja u realizaciji ove funkcije je pronalazenje poslednjeg

elementa liste ciji je kljuc manji od datog elementa br.*/ void ubaci_sortirano(CVOR** pl, int br){ CVOR* novi = napravi_cvor(br);

/* U sledeca dva slucaja ne postoji cvor ciji je kljuc manjiod datog broja (br)

- Prvi je slucaj prazne liste- Drugi je slucaj kada je br manji od prvog elementa

U oba slucaja ubacujemo na pocetak liste. */ if (*pl == NULL || br < (*pl)->br) {

novi->sl = *pl; *pl = novi; return; }

/* Krecemo od pocetka i idemo dalje sve dok t nije poslednjimanji element liste ili eventualno bas poslednji */

CVOR* t; for (t = *pl; t->sl!=NULL && t->sl->br < br; t=t->sl) ; novi->sl = t->sl; t->sl = novi;}

/* Rekurzivna verzija prethodne funkcije */ void ubaci_sortirano_rekurzivno(CVOR** pl, int br){ if (*pl == NULL || br < (*pl)->br)

{ CVOR* novi = napravi_cvor(br); novi->sl = *pl; *pl = novi; return; }

ubaci_sortirano(&((*pl)->sl), br);}

/* Ispisivanje liste : iterativna verzija */ void ispisi_listu(CVOR* l){ CVOR* t; for (t = l; t != NULL; t=t->sl) printf("%d ", t->br);




}


main(){ CVOR* l = NULL; CVOR* k = NULL; int i;

ubaci_sortirano(&l, 5); ubaci_sortirano(&l, 8); ubaci_sortirano(&l, 7 ); ubaci_sortirano(&l, 6 ); ubaci_sortirano(&l, 4);

ubaci_sortirano_rekurzivno(&k, 5); ubaci_sortirano_rekurzivno(&k, 8); ubaci_sortirano_rekurzivno(&k, 7 ); ubaci_sortirano_rekurzivno(&k, 6 );

ubaci_sortirano_rekurzivno(&k, 4);


ispisi_listu(k); putchar('\n');

oslobodi_listu(l);}

/*----------------------------11.4.c--------------------------*/ /* Provera uparenosti HTML etiketa - stek se implementira preko liste */ #include <stdio.h>#include <string.h>#include <stdlib.h>#include <assert.h>

/* Maksimalna duzina etikete */ #define MAX_TAG 100

#define OPEN 1#define CLOSED 2#define ERROR 0

/* Funkcija ucitava sledecu etiketu i smesta njen naziv u niz s duzine max. Vraca OPEN za otvorenu etiketu, CLOSED za zatvorenu etiketu,

odnosno ERROR inace */ int gettag(char s[], int max){ int c, i; int type=OPEN;

/* Preskacemo sve do znaka '<' */ while ((c=getchar())!=EOF && c!='<')

; /* Nismo naisli na etiketu */ if (c==EOF) return ERROR;

/* Proveravamo da li je etiketa zatvorena */ if ((c=getchar())=='/') type = CLOSED; else ungetc(c,stdin);

/* Citamo etiketu dok nailaze slova i smestamo ih u nisku*/ for (i=0; isalpha(c=getchar()) && i<max-1; s[i++] = c)

; s[i]='\0';




/* Preskacemo atribute do znaka > */ while (c!=EOF && c!='>') c = getchar();

/* Greska ukoliko nismo naisli na '>' */ return c=='>' ? type : ERROR;}

/***********************************************************************/ /* Stek ce biti implementiran koriscenjem liste */ typedef struct node{ char string[MAX_TAG];

struct node* next;} NODE;

/* Funkcija postavlja dati string na stek */ void push(NODE** pstack, char* s){ NODE* tmp = (NODE*)malloc(sizeof(NODE)); if (tmp == NULL) { fprintf(stderr, "Greska prilikom alokacije memorije\n"); exit(1); } strcpy(tmp->string, s); tmp->next = *pstack; *pstack = tmp;}

/* Funkcija cita podatak sa vrha steka */ char* peek(NODE* stack){ /* Stek ne sme da bude prazan */ assert(stack != NULL);

return stack->string;}

/* Funkcija uklanja podatak sa vrha steka */ void pop(NODE** pstack){ /* Ukoliko je stek prazan ne radimo nista */ if (*pstack == NULL) return;

NODE* tmp = (*pstack)->next; free(*pstack); *pstack = tmp;}

/* Funkcija proverava da li je dati stek prazan */ int empty(NODE* stack){ return stack == NULL;}/* ********************************************************************* */

main(){

char tag[MAX_TAG]; NODE* stack = NULL;

int type; while ((type = gettag(tag,MAX_TAG)) != ERROR) { if (type == OPEN) { /* Svaku otvorenu etiketu stavljamo na stek */ push(&stack, tag); printf("Postavio <%s> na stek\n", peek(stack)); } else { /* Za zatvorene etikete proveravamo da li je stek prazan

odnosno da li se na vrhu steka nalazi odgovarajuca otvorena etiketa*/ if (!empty(stack) && strcmp(peek(stack), tag) == 0)




{ printf("Skidam <%s> sa steka\n", peek(stack)); /* Uklanjamo etiketu sa steka */ pop(&stack); } else { /* Prijavljujemo gresku */ printf("Neodgovarajuce : </%s>\n",tag); exit(1); } } }

/* Proveravamo da li je stack ispraznjen */ if (!empty(stack)) fprintf(stderr, "Nisu sve etikete zatvorene\n");}




/*----------------------------12.1a.c--------------------------*/ /* Binarno pretrazivacko drvo - drvo sadrzi cele brojeve.

Ubacivanje realizovano preko ** */


/* Struktura jednog cvora drveta */ typedef struct _cvor{

/* Podatak */ int broj; /* Pokazivac na levo i desno podstablo */ struct _cvor *l, *d;} cvor;

/* Pomocna funkcija koja kreira novi cvor na osnovu datog broja */ cvor* napravi_cvor(int b){ cvor* novi = (cvor*)malloc(sizeof(cvor)); if (novi == NULL) { fprintf(stderr, "Greska prilikom alokacije memorije"); exit(1); }

/* Postavljamo brojnu vrednost */ novi->broj = b;

/* Novi cvor se kreira kao list */ novi->l = NULL; novi->d = NULL; return novi;}

/* Rekurzivna funkcija koja ubacuje dati broj u dato drvo */ void ubaci_u_drvo(cvor** pdrvo, int b){ /* Ukoliko je drvo prazno kreira se novi cvor */ if (*pdrvo == NULL) { *pdrvo = napravi_cvor(b); return;

} /* Ukoliko je broj koji se ubacuje manji od broja u korenu,

rekurzivno ga ubacujemo u levo podstablo.Ukoliko je broj koji se ubacuje veci od broja u korenu,rekurzivno ga ubacujemo u desno podstablo.

*/

if (b < (*pdrvo)->broj) ubaci_u_drvo(&((*pdrvo)->l), b); else if (b > (*pdrvo)->broj) ubaci_u_drvo(&((*pdrvo)->d), b);}

/* Rekurzivna funkcija koja proverava da li dati broj postoji u drvetu */ int pronadji(cvor* drvo, int b)

{ /* U praznom drvetu ne postoji broj */ if (drvo == NULL) return 0;

/* Ukoliko je jednak vrednosti u korenu, onda postoji */ if (drvo->broj == b) return 1;

/* Ukoliko je broj koji trazimo manji od vrednosti u korenu,trazimo ga samo u levom podstablu, a inace ga trazimosamo u desnom podstablu */

if (b < drvo->broj) return pronadji(drvo->l, b); else return pronadji(drvo->d, b);




}

/* Rekurzivna funkcija koja ispisuje drvo u inorder redosledu */ void ispisi_drvo(cvor* drvo){ if (drvo != NULL) { ispisi_drvo(drvo->l); printf("%d ", drvo->broj); ispisi_drvo(drvo->d); }}

/* Rekurzivna funkcija koja uklanja drvo. Obilazak mora biti postorder. */ void obrisi_drvo(cvor* drvo){ if (drvo != NULL) { obrisi_drvo(drvo->l); obrisi_drvo(drvo->d); free(drvo); }}

main(){ cvor* drvo = NULL; ubaci_u_drvo(&drvo, 1); ubaci_u_drvo(&drvo, 8);

ubaci_u_drvo(&drvo, 3); ubaci_u_drvo(&drvo, 5); ubaci_u_drvo(&drvo, 7 ); ubaci_u_drvo(&drvo, 6 ); ubaci_u_drvo(&drvo, 9);

if (pronadji(drvo, 3)) printf("Pronadjeno 3\n"); if (pronadji(drvo, 2)) printf("Pronadjeno 2\n"); if (pronadji(drvo, 7 )) printf("Pronadjeno 7\n");

ispisi_drvo(drvo); putchar('\n');

obrisi_drvo(drvo);}

/*----------------------------12.1b.c--------------------------*/ /* Binarno pretrazivacko drvo - drvo sadrzi cele brojeve. Ubacivanje realizovano preko eksplicitnog vracanja korena

rezultujuceg drveta*/


typedef struct _cvor{ int broj; struct _cvor *l, *d;} cvor;

cvor* napravi_cvor(int

b){ cvor* novi = (cvor*)malloc(sizeof(cvor)); if (novi == NULL) { fprintf(stderr, "Greska prilikom alokacije memorije"); exit(1); } novi->broj = b; novi->l = NULL; novi->d = NULL; return novi;}

cvor* ubaci_u_drvo(cvor* drvo, int b){




if (drvo == NULL) return napravi_cvor(b);

if (b < drvo->broj) drvo->l = ubaci_u_drvo(drvo->l, b); else

drvo->d = ubaci_u_drvo(drvo->d, b);

return drvo;}

/* Funkcija proverava da li dati broj postoji u drvetu */ int pronadji(cvor* drvo, int b)

{if (drvo == NULL)

return 0;

if (drvo->broj == b) return 1;

if (b < drvo->broj) return pronadji(drvo->l, b); else return pronadji(drvo->d, b);}

void ispisi_drvo(cvor* drvo){ if (drvo != NULL)

{ ispisi_drvo(drvo->l); printf("%d ", drvo->broj); ispisi_drvo(drvo->d); }}

void obrisi_drvo(cvor* drvo){ if (drvo != NULL) { obrisi_drvo(drvo->l); obrisi_drvo(drvo->d); free(drvo); }}

main(){ cvor* drvo = NULL; drvo = ubaci_u_drvo(drvo, 1); drvo = ubaci_u_drvo(drvo, 8); drvo = ubaci_u_drvo(drvo, 5); drvo = ubaci_u_drvo(drvo, 3); drvo = ubaci_u_drvo(drvo, 7 ); drvo = ubaci_u_drvo(drvo, 6 ); drvo = ubaci_u_drvo(drvo, 9);

if (pronadji(drvo, 3)) printf("Pronadjeno 3\n"); if (pronadji(drvo, 2)) printf("Pronadjeno 2\n"); if (pronadji(drvo, 7 )) printf("Pronadjeno 7\n");

ispisi_drvo(drvo); putchar('\n');

obrisi_drvo(drvo);}

/*----------------------------12.3.c--------------------------*/ /* Rekurzivne funkcije za rad sa celobrojnim stablima (ne obavezno pretrazivackim):

broj_cvorova, broj_listova, suma_cvorova, dubina, najveci_cvor, ... */


typedef struct _cvor




{ int broj; struct _cvor *l, *d;} cvor;

cvor* napravi_cvor(int b){ cvor* novi = (cvor*)malloc(sizeof(cvor)); if (novi == NULL) { fprintf(stderr, "Greska prilikom alokacije memorije"); exit(1); }

novi->broj = b; novi->l = NULL; novi->d = NULL; return novi;}

void ubaci_u_drvo(cvor** drvo, int b){ if (*drvo == NULL) { *drvo = napravi_cvor(b); return; }

if (b < (*drvo)->broj) ubaci_u_drvo(&((*drvo)->l), b);

else

ubaci_u_drvo(&((*drvo)->d), b);}

void ispisi_drvo(cvor* drvo){ if (drvo != NULL) { ispisi_drvo(drvo->l); printf("%d ", drvo->broj); ispisi_drvo(drvo->d); }}

void obrisi_drvo(cvor* drvo){

if (drvo != NULL) { obrisi_drvo(drvo->l); obrisi_drvo(drvo->d); free(drvo); }}

/* Izracunava sumu svih elemenata u cvorovima drveta */ int suma_cvorova(cvor* drvo){ if (drvo == NULL) return 0; return suma_cvorova(drvo->l) + drvo->broj +

suma_cvorova(drvo->d);}

/* Izracunava broj cvorova datog drveta */ int broj_cvorova(cvor* drvo){ if (drvo == NULL) return 0; return broj_cvorova(drvo->l) +

1 +broj_cvorova(drvo->d);

}

/* Izracunava broj listova datog drveta */ int broj_listova(cvor* drvo){ if (drvo == NULL)




return 0;

/* Cvor je list ukoliko nema ni jednog naslednika */ if (drvo->l == NULL && drvo->d == NULL) return 1;

return broj_listova(drvo->l) +broj_listova(drvo->d);

}

/* Izracunava sumu svih elemenata u listovima drveta */ int suma_listova(cvor* drvo){

if (drvo == NULL) return 0;

if (drvo->l == NULL && drvo->d == NULL) return drvo->broj;

return suma_listova(drvo->l) +suma_listova(drvo->d);

}

/* Ispisuje sve elemente u listovima drveta */ void ispisi_listove(cvor* drvo){ if (drvo == NULL) return;

ispisi_listove(drvo->l); if (drvo->l == NULL && drvo->d == NULL) printf("%d ", drvo->broj);

ispisi_listove(drvo->d);}

/* Izracunava vrednost najveceg cvora u proizvoljnom drvetu.Vraca -1 ukoliko je drvo prazno */

int najveci_cvor(cvor* drvo){

if (drvo == NULL) return -1; else {

int max_l = najveci_cvor(drvo->l); int max_d = najveci_cvor(drvo->d);

return max_l<max_d ? (max_d<drvo->broj?drvo->broj:max_d) : (max_l<drvo->broj?drvo->broj:max_l); }}

/* Izracunava dubinu (broj nivoa drveta) */ int dubina(cvor* drvo){ if (drvo == NULL) return 0; else

{

int dl = dubina(drvo->l); int dd = dubina(drvo->d);

return dl<dd ? dd + 1 : dl + 1; }}

main(){ cvor* drvo = NULL; ubaci_u_drvo(&drvo, 1); ubaci_u_drvo(&drvo, 8); ubaci_u_drvo(&drvo, 5); ubaci_u_drvo(&drvo, 3); ubaci_u_drvo(&drvo, 7 ); ubaci_u_drvo(&drvo, 6 );




ubaci_u_drvo(&drvo, 9);

printf("Suma cvorova : %d\n", suma_cvorova(drvo)); printf("Broj cvorova : %d\n", broj_cvorova(drvo)); printf("Broj listova : %d\n", broj_listova(drvo)); printf("Suma listova : %d\n", suma_listova(drvo)); printf("Najveci cvor : %d\n", najveci_cvor(drvo)); printf("Dubina : %d\n", dubina(drvo)); printf("Listovi : "); ispisi_listove(drvo); putchar('\n');

obrisi_drvo(drvo);

}/*----------------------------12.4.c--------------------------*/ /* Program sa ulaza cita tekst i ispisuje broj pojavljivanja svake od reci

koje su se javljale u tekstu. Verzija sa binarnim pretrazivackim drvetom.*/


/* Cvor drveta sadrzi ime reci i broj njenih pojavljivanja */ typedef struct _cvor{ char ime[80]; int br_pojavljivanja; struct _cvor* levo, *desno;} cvor;

/* Funkcija ispisuje drvo u inorder redosledu */ void ispisi_drvo(cvor* drvo){ if (drvo!=NULL) { ispisi_drvo(drvo->levo); printf("%s %d\n",drvo->ime,drvo->br_pojavljivanja); ispisi_drvo(drvo->desno); }}

/* Funkcija uklanja binarno drvo iz memorije */ void obrisi_drvo(cvor* drvo){ if (drvo!=NULL) { obrisi_drvo(drvo->levo); obrisi_drvo(drvo->desno); free(drvo); }}

/* Funkcija ubacuje datu rec u dato drvo i vraca pokazivac na koren drveta */ cvor* ubaci(cvor* drvo, char rec[]){

/* Ukoliko je drvo prazno gradimo novi cvor */ if (drvo==NULL) { cvor* novi_cvor=(cvor*)malloc(sizeof(cvor)); if (novi_cvor==NULL) { printf("Greska prilikom alokacije memorije\n"); exit(1); } strcpy(novi_cvor->ime, rec); novi_cvor->br_pojavljivanja=1;

return novi_cvor; } int cmp = strcmp(rec, drvo->ime);

/* Ukoliko rec vec postoji u drvetu uvecavamo njen broj pojavljivanja */ if (cmp==0) { drvo->br_pojavljivanja++; return drvo; }

/* Ukoliko je rec koju ubacujemo leksikografski ispred reci koja je ukorenu drveta, rec ubacujemo u levo podstablo */

if (cmp<0) { drvo->levo=ubaci(drvo->levo, rec);

return drvo; }




/* Ukoliko je rec koju ubacujemo leksikografski iza reci koja je ukorenu drveta, rec ubacujemo u desno podstablo */

if (cmp>0) { drvo->desno=ubaci(drvo->desno, rec);

return drvo; }}

/* Pomocna funkcija koja cita rec sa standardnog ulaza i vraca njenuduzinu, odnosno -1 ukoliko se naidje na EOF */

int getword(char word[], int lim){ int c, i=0;

while (!isalpha(c=getchar()) && c!=EOF) ;

if (c==EOF) return -1; do { word[i++]=c; } while (i<lim-1 && isalpha(c=getchar()));

word[i]='\0'; return i;}

main(){ /* Drvo je na pocetku prazno */

cvor* drvo=NULL; char procitana_rec[80];

/* Citamo rec po rec dok ne naidjemo na kraj datoteke iubacujemo ih u drvo */

while(getword(procitana_rec,80)!=-1) drvo=ubaci(drvo,procitana_rec);

/* Ispisujemo drvo */ ispisi_drvo(drvo);

/* Uklanjamo ga iz memorije */ obrisi_drvo(drvo);

}

/*----------------------------12.4a.c--------------------------*/ /* Program koji broji pojavljivanja svih etiketa u HTML datoteci- etikete se ispisuju opadajuci po broju pojavljivanja

*/

#include <stdio.h>#include <stdlib.h>#include <string.h>#include <ctype.h>

/* Struktura cvora drveta u kome se cuvaju etikete zajedno sa brojem pojavljivanja. Drvo je pretrazivacko i sortirano je lekikografski po

etiketama */ typedef struct _node{ char tag[30]; int num; struct _node *l,*r;

} node;

/* Zbog sortiranja po broju cvorova, paralelno sa strukturom drveta,odrzavamo niz pokazivaca na njegove cvorove */

node* nodes[100];/* Dosadasnji broj cvorova drveta (razlicitih etiketa) */ int num_nodes = 0;

/* Funkcija kreira cvor koji sadrzi datu etiketu */ node* make_node(char *tag){ node* new_node = (node*) malloc(sizeof(node)); if(new_node == NULL) {




fprintf(stderr,"Greska prilikom alokacije memorije\n"); exit(1); }

strcpy(new_node->tag, tag); new_node->l=NULL; new_node->r=NULL; new_node->num = 1;

/* Dopisujemo cvor u niz postojecih cvorova */ nodes[num_nodes++] = new_node;

return new_node;

}/* Funkcija umece datu etiketu u postojece drvo. Ukoliko etiketa postoji, povecava se njen broj pojavljivanja */ void insert(node** ptree, char tag[]){ int cmp; if(*ptree==NULL) {

*ptree = make_node(tag); return; }

cmp = strcmp(tag, (*ptree)->tag);

if (cmp < 0) insert(&((*ptree)->l), tag);

else if (cmp > 0) insert(&((*ptree)->r), tag); else (*ptree)->num++;}

/* Funcija za ispis drveta */ void print(node* tree){ if(tree != NULL) { print(tree->l); printf("%-10s - %3d\n", tree->tag, tree->num); print(tree->r); }}

/* Funkcija koja uklanja drvo */ void remove_tree(node* tree){ if(tree != NULL) {

remove_tree(tree->l); remove_tree(tree->r); free(tree); }}

/* Funkcija poredjenja za poziv ugradjene funkcije qsort. Porede sedva cvora drveta na osnovu broja pojavljivanja etiketa */

int compare(const void * pa, const void * pb){

return (*((node**)pb))->num - (*((node**)pa))->num;}

/* Funkcija ucitava etiketu iz date datoteke. Funkcija vraca logicku vrednost koja indikuje da li je etiketa uspesno

procitana */ int get_tag(FILE* f, char tag[]){ int c; int i = 0;

/* Preskacemo sve do prvog znaka '<' ili kraja */ while ((c = fgetc(f)) != EOF && c != '<') ;

/* Nije bilo vise etiketa */




if (c == EOF) return 0;

/* Citamo prvi karakter etiketa*/ c = fgetc(f);

/* Gutamo / kod zatvorenih etiketa */ if (c == '/') c = fgetc(f);

/* Ime etikete cine slova */ while(isalpha(c)) {

tag[i++] = c; c = fgetc(f); } tag[i] = '\0';

/* Preskacemo sve do > ili do kraja */ while (c != '>' && c != EOF) c = fgetc(f);

if (c == EOF) return 0;

return 1;}

main(int argc, char* argv[]){ /* Tekuca procitana etiketa */ char tag[30];

/* Drvo koje je leksikografski sortirano zbog brze pretrage */ node* tree = NULL;

/* Datoteka iz koje se cita */ FILE* f; int i;

/* Proverava se korektnost argumenata komandne linije */ if (argc < 2) { printf("Upotreba : %s ime_datoteke\n", argv[0]); exit(1); }

/* Otvara se datoteka */ f = fopen(argv[1], "r"); if (f == NULL) { fprintf(stderr, "Greska prilikom otvaranja %s\n", argv[1]); return; }

/* Kreiramo drvo na osnovu sadrzaja datoteke */ while(get_tag(f, tag) == 1) insert(&tree, tag);


/* Sortiramo cvorove niza na osnovu broja pojavljivanja etiketa */

qsort(nodes, num_nodes, sizeof(node*), &compare);

/* Ispisujemo sortirane cvorove */ for (i = 0; i<num_nodes; i++) printf("%-10s - %3d\n", nodes[i]->tag, nodes[i]->num);

/* Uklanjamo drvo */ remove_tree(tree);

}




/*----------------------------13.2.c--------------------------*/ /* Implementacija dinamickih kvadratnih matrica preko pokazivaca na niz pokazivaca na kolone*/ #include <stdio.h>#include <stdlib.h>

/* Tip elemenata matrice ce biti float */ typedef float tip;

/* Funkcija alocira matricu dimenzije n*n */

tip** allocate(int n){ tip **m; int i; /* Alocira se niz pokazivaca na kolone */ m=(tip**)malloc(n*sizeof(tip*)); for (i=0; i<n; i++) /* Alociraju se nizovi brojeva koji predstavljaju kolone */ m[i]=(tip*)malloc(n*sizeof(tip));

return m;}

/* Funkcija vrsi dealociranje date matrice dimenzije n */ void deallocate(tip** m, int n){ int i; /* Uklanjaju se kolone */

for

(i=0; i<n; i++) free(m[i]);

/* Uklanja se niz pokazivaca na kolone */ free(m);}

/* Funkcija ispisuje datu matricu dimenzije n */ void IspisiMatricu(tip** matrica, int n){ int i,j; for (i=0; i<n; i++) { for(j=0; j<n; j++) printf("%f\t",matrica[i][j]); printf("\n"); }}

/* Funkcija ucitava datu matricu i njenu dimenziju */

void UnesiMatricu(tip*** matrica,int *pn){ int i,j; printf("Unesite dimenziju kvadratne matrice :"); scanf("%d",pn);

*matrica=allocate(*pn); for (i=0; i<*pn; i++) for(j=0; j<*pn; j++) { printf("A[%d][%d]=",i+1,j+1); scanf("%f",&((*matrica)[i][j])); }}

/* Rekurzivna funkcija koja vrsi Laplasov razvoj -neefikasna, ali dobra vezba */

tip determinanta(tip** matrica, int n){ int i; tip** podmatrica; int det=0,znak;

/* Izlaz iz rekurzije je matrica 1x1 */ if (n==1)

return matrica[0][0]; /* Podmatrica ce da sadrzi minore polazne matrice */

podmatrica=allocate(n-1); znak=1; for (i=0; i<n; i++) { int vrsta,kolona; for (kolona=0; kolona<i; kolona++) for(vrsta=1; vrsta<n; vrsta++) podmatrica[vrsta-1][kolona]=matrica[vrsta][kolona]; for (kolona=i+1; kolona<n; kolona++)




for(vrsta=1; vrsta<n; vrsta++) podmatrica[vrsta-1][kolona-1]=matrica[vrsta][kolona];

det+=znak*matrica[0][i]*determinanta(podmatrica,n-1); znak*=-1;

} deallocate(podmatrica,n-1); return det;}

main(){

/* Matrica i njena dimenizija */

tip **matrica; int n;

/* Unosi se matrica */ UnesiMatricu(&matrica,&n);

/* Ispisuje se determinanta */ printf("Determinanta je : %f\n",determinanta(matrica,n));

return 0;}

/*----------------------------13.2a.c--------------------------*/ /* Implementacija matrica realnih brojeva preko niza */


/* Makro pristupa clanu na poziciji i, j */ #define a(i,j) (a[(i)*n+(j)])

main(){ /* Dimenzije matrice */ int m, n; /* Matrica */ float *a;

int i,j;

/* Unos i alokacija */ printf("Unesi broj vrsta matrice : ");

scanf("%d",&m);

printf("Unesi broj kolona matrice : "); scanf("%d",&n);

/* Alocira se niz dimenizije m*n */ a = (float*)malloc(m*n*sizeof(float));

/* Unose se jedan po jedan element matrice */ for (i=0; i<m; i++) for (j=0; j<n; j++) {

printf("Unesi element na poziciji (%d,%d) : ",i,j); scanf("%f",&a(i,j)); }

/* Ispis unete matrice */

printf("Uneli ste matricu : \n"); for (i=0; i<m; i++) { for (j=0; j<n; j++) printf("%7.3f ",a(i,j)); printf("\n"); }

/* Uklanja se matrica */ free(a);}

/*----------------------------13.3.c--------------------------*/ /* MINESWEEPER - primer jednostavne igrice */ /* Program demonstrira rad sa matricama, slucajnim brojevima i

rekurzivnu implementaciju DFS algoritma za obilazak grafova */

#include <stdlib.h>




#include <stdio.h>#include <time.h>

/* Dimenzija table */ int n;

/* Tabla koja sadrzi 0 i 1 u zavisnosti od toga da li na polju postoji bomba */ int** bombe;

/* Tabla koja opisuje tekuce stanje igre. Moze da sadrzi sledece vrednosti : ZATVORENO - opisuje polje koje jos nije bilo otvarano PRAZNO - polje na kome ne postoji ni jedna bomba broj od 1-8 - polje koje je otvoreno i na kome pise koliko bombi postoji u okolini

ZASTAVICA - polje koje je korisnik oznacio zastavicom*/ #define PRAZNO (-1)#define ZATVORENO 0#define ZASTAVICA 9

int** stanje;

/* Ukupan broj bombi */ int broj_bombi;

/* Ukupan broj postavljenih zastavica */ int broj_zastavica = 0;

/* Pomocne funkcije za rad sa matricama */ int** alociraj(int n)

{ int i; int** m=malloc(n*sizeof(int*)); for (i=0; i<n; i++) m[i]=calloc(n,sizeof(int)); return m;}

void obrisi(int** m, int n){ int i; for (i=0; i<n; i++) free(m[i]);

free(m);}

/* Funkcija postavlja bombe */

void postavi_bombe(){ broj_bombi=(n*n)/6 ; int kolona; int vrsta; int i;

/* Inicijalizujemo generator slucajnih brojeva */ srand(time(NULL));

for (i=0; i<broj_bombi; i++) { /* Racunamo slucajni polozaj bombe */ kolona=rand()%n; vrsta=rand()%n;

/* Ukoliko bomba vec postoji tu, opet idemo u istu iteraciju */

if (bombe[vrsta][kolona]==1)

{ i--;continue;

}

/* Postavljamo bombu */ bombe[vrsta][kolona]=1;

}}

/* Funkcija ispisuje tablu sa bombama */ void ispisi_bombe(){ int i,j; for (i=0; i<n; i++) { for (j=0; j<n; j++) printf("%d",bombe[i][j]);




printf("\n"); }}

/* Funkcija ispisuje tekuce stanje */ void ispisi_stanje(){ int i,j;

/* Brisemo ekran pozivajuci komandu operativnog sistema */ system("clear");

for (i=0; i<n; i++)

{ for (j=0; j<n; j++) { if (stanje[i][j]==ZATVORENO) printf("."); else if (stanje[i][j]==PRAZNO) printf(" "); else if (stanje[i][j]==ZASTAVICA) printf("*"); else

printf("%d",stanje[i][j]); } printf("\n"); }

}

/* Funkcija postavlja zastavicu na dato polje ili je uklanjaukoliko vec postoji */

void postavi_zastavicu(int i, int j){ if (stanje[i][j]==ZATVORENO) { stanje[i][j]=ZASTAVICA; broj_zastavica++; } else if (stanje[i][j]==ZASTAVICA) { stanje[i][j]=ZATVORENO; broj_zastavica--; }}

/* Funkcija izracunava koliko bombi postoji u okolini date bombe */ int broj_bombi_u_okolini(int v, int k){ int i, j; int br=0; /* Prolazimo kroz sva okolna polja */

for (i=-1; i<=1; i++) for(j=-1; j<=1; j++) { /* preskacemo centralno polje */ if (i==0 && j==0) continue; /* preskacemo polja "van table" */ if (v+i<0 || k+j<0 || v+i>=n || k+j>=n) continue; if (bombe[v+i][k+j]==1) br++; }

return br;

}

/* Centralna funkcija koja vrsi otvaranje polja i pritom se otvaranje "siri" i na polja koja su oko datog */

void otvori_polje(int v, int k){ /* Ukoliko smo "nagazili" bombu zavrsavamo program */ if (bombe[v][k]==1) { printf("BOOOOOOOOOOOOOOOOM!!!!\n"); ispisi_bombe(); exit(1); } else { /* Brojimo bombe u okolini */ int br=broj_bombi_u_okolini(v,k);

/* Azuriramo stanje ovog polja */ stanje[v][k]=(br==0)?PRAZNO:br;




/* Ukoliko u okolini nema bombi, rekurzivno otvaramo sva polja u okolini koja su zatvorena */ if (br==0) { /* Petlje indeksiraju sva okolna polja */ int i,j; for (i=-1; i<=1; i++) for (j=-1; j<=1; j++) { /* Preskacemo centralno polje */ if (i==0 && j==0) continue; /* Preskacemo polja van table */ if (v+i<0 || v+i>=n || k+j<0 || k+j>=n)

continue; /* Ukoliko je okolno polje zatvoreno, otvaramo ga */ if (stanje[v+i][k+j]==ZATVORENO) otvori_polje(v+i, k+j); } } }}

/* Funkcija utrdjuje da li je partija gotovaPartija je gotova u trenutku kada su sve bombe pokrivene zastavicama ikada nijedno drugo polje nije pokriveno zastavicom

*/

int gotova_partija()

{int

i,j; for (i=0; i<n; i++) for (j=0; j<n; j++) { /* Ukoliko postoji nepokrivena bomba, partija nije zavrsena */ if (bombe[i][j]==1 && stanje[i][j]!=ZASTAVICA) return 0; }

/* Partija je zavrsena samo ukoliko je broj zastavica jednak broj bombi */ return broj_zastavica==broj_bombi;

}

main(){

/* Unosimo dimenziju table */

printf("Unesite dimenziju table : "); scanf("%d",&n);

/* Alociramo table */ bombe=alociraj(n); stanje=alociraj(n);

/* Postavljamo bombe */ postavi_bombe();

/* Sve dok partija nije gotova */ while(!gotova_partija()) { int v,k; char akcija;

/* Ispisujemo tekuce stanje */

ispisi_stanje();

/* Sve dok korisnik ne unese o ili z trazimo od njega da upise odgovarajucu akciju */ do { printf("Unesi akciju (o - otvaranje polja, z - postavljanje zastavice) : "); while(isspace(akcija = getchar())); } while (akcija!='o' && akcija!='z');

/* Trazimo od korisnika da unese koordinate polja sve dok ih ne unese ispravno Korisnicke koordinate krecu od 1, a interne od 0 */ do { printf("Unesi koordinate polja : "); scanf("%d",&v); scanf("%d",&k); } while(v<1 || v>n || k<1 || k>n);



/* Reagujemo na akciju */ switch(akcija) { case 'o': otvori_polje(v-1,k-1); break; case 'z': postavi_zastavicu(v-1,k-1); } }

/* Konstatujemo pobedu */ ispisi_stanje();

obrisi(stanje, n); obrisi(bombe, n);

printf ("Cestitam! Pobedili ste\n");

}

kraus svi primeri

Documents