Studentima se savetuje da programski kod ne uče napamet. Za …rti.etf.bg.ac.rs/.../P2_pripremni_zadaci_za_ispit_2018.pdf · 2018-07-06 · Materijali za pripremu ispita iz Programiranja

ELEKTROTEHNIČKI FAKULTET UNIVERZITETA U BEOGRADU

PROGRAMIRANJE 2

MATERIJALI ZA PRIPREMU ISPITA

verzija: 06.07.2018.

Studentima se savetuje da programski kod ne uče napamet.

Za pisanje i testiranje rešenja zadataka se predlaže upotreba nekog od razvojnih okruženja za programski jezik C.

Sadržaj:

OO1P2, popravni kolokvijum, jul 2008. (I način) ........................................................................ 4

OO1P2, popravni kolokvijum, jul 2008. (II način) ....................................................................... 5

OO1P2, kolokvijum, april 2009. ................................................................................................. 6


OO1P2, popravni kolokvijum, jun 2010. ..................................................................................... 8


OO1P2, kolokvijum, april 2012. ............................................................................................... 10


OO1P2, popravni kolokvijum, jun 2013. ................................................................................... 12



OO1P2, popravni kolokvijum, jun 2018. ................................................................................... 15

SI1P2, prvi kolokvijum, mart 2011. .......................................................................................... 16




SI1P2, drugi kolokvijum, april 2013. ........................................................................................ 20

SI1P2, treći kolokvijum, jun 2012. ........................................................................................... 21



SI1P2, drugi kolokvijum, 2014. ............................................................................................... 24

SI1P2, popravni drugi kolokvijum, jun 2014. ............................................................................ 25


SI1P2, drugi kolokvijum, 2015. ............................................................................................... 28

SI1P2, popravni prvi kolokvijum, jun 2015. .............................................................................. 29

SI1P2, prvi kolokvijum, mart, 2017. ......................................................................................... 30


SI1P2, popravni prvi kolokvijum, april 2018. ............................................................................ 32

P2, ispit, jun 2010. ................................................................................................................. 33

P2, ispit, septembar 2010. ...................................................................................................... 35

P2, ispit, jun 2011. ................................................................................................................. 37

P2, ispit, jun 2011. ................................................................................................................. 38

P2, ispit, jul 2011. .................................................................................................................. 39

P2, ispit, jul 2011. .................................................................................................................. 41



P2, ispit, oktobar 2011. .......................................................................................................... 46

P2, ispit, oktobar 2011. .......................................................................................................... 47

P2, ispit, jun 2012. ................................................................................................................. 49

P2, ispit, jul 2012. .................................................................................................................. 52

P2, ispit, jul 2012. .................................................................................................................. 54


P2, ispit, oktobar 2012. .......................................................................................................... 58

P2, ispit, jun 2013. ................................................................................................................. 60

P2, ispit, jul 2013. .................................................................................................................. 62



P2, ispit, jul 2014. .................................................................................................................. 66

P2, ispit, jul 2014. .................................................................................................................. 68


P2, ispit, oktobar 2014. .......................................................................................................... 72

P2, ispit, januar 2015. ............................................................................................................ 74

P2, ispit, jun 2015. ................................................................................................................. 76

P2, ispit, jun 2016. ................................................................................................................. 79

P2, ispit, jul 2016. .................................................................................................................. 81


P2, ispit, oktobar 2016. .......................................................................................................... 84

P2, ispit, jun 2017. ................................................................................................................. 86

P2, ispit, jul 2017. .................................................................................................................. 88


P2, ispit, oktobar 2017. .......................................................................................................... 92

P2, ispit, jun 2018. ................................................................................................................. 94

P2, ispit, jun 2018. ................................................................................................................. 95

P2, ispit, jul 2018. .................................................................................................................. 97

P2, ispit, jul 2018. .................................................................................................................. 99

Materijali za pripremu ispita iz Programiranja 2 4

OO1P2, popravni kolokvijum, jul 2008. (I način)

Zadatak 1.

Napisati program na programskom jeziku C koji određuje da li su dva skupa celih brojeva, u opsegu od 0 do 15,

jednaka. Program treba da učita sa standardnog ulaza elemente skupova, najpre prvog a zatim drugog. Elementi skupova se unose u proizvoljnom redosledu, a dodavanje elementa koji već postoji u skupu se ignoriše. Nakon

završenog unosa elemenata skupova, program ispiše "Skupovi su jednaki" ili "Skupovi nisu jednaki" u zavisnosti od

ishoda poređenja. Program ponavlja prethodne korake (unos skupova i poređenje) sve dok korisnik ne naznači da želi da prekine program.

#include <stdio.h>

#define MAX_SKUP 16

main () {

int skup1[MAX_SKUP], skup2[MAX_SKUP];

int i, end=1, jednaki, b;

while (end) {

for(i=0;i<MAX_SKUP;i++) skup1[i]=skup2[i]=0;

printf("Unesite elemente prvog skupa: ");

while(1) {

scanf("%d",&b);

if ((b<0) || (b>=MAX_SKUP)) break;

skup1[b]=1;

}

printf("Unesite elemente drugog skupa: ");

while(1) {

scanf("%d",&b);


skup2[b]=1;

}

jednaki=1;

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

if (skup1[i]!=skup2[i]) {

jednaki=0;

break;

}

if (jednaki) printf("Skupovi su jednaki!\n");

else printf("Skupovi nisu jednaki!\n");

printf("0 za kraj, 1 za nastavak: ");

scanf("%d",&end);

}

}


OO1P2, popravni kolokvijum, jul 2008. (II način)

Zadatak 1.

Napisati program na programskom jeziku C koji određuje da li su dva skupa celih brojeva, u opsegu od 0 do 15,

jednaka. Program treba da učita sa standardnog ulaza elemente skupova, najpre prvog a zatim drugog. Elementi skupova se unose u proizvoljnom redosledu, a dodavanje elementa koji već postoji u skupu se ignoriše. Nakon

završenog unosa elemenata skupova, program ispiše "Skupovi su jednaki" ili "Skupovi nisu jednaki" u zavisnosti od

ishoda poređenja. Program ponavlja prethodne korake (unos skupova i poređenje) sve dok korisnik ne naznači da želi da prekine program.

#include <stdio.h>

#define MAX_SKUP 16

void main () {

unsigned short skup1 = 0, skup2 = 0;

int i, end=1, b;

while (end) {

printf("Unesite elemente prvog skupa: ");

while(1) {

scanf("%d",&b);


skup1 |= 1 << b;

}

printf("Unesite elemente drugog skupa: ");

while(1) {

scanf("%d",&b);


skup2 |= 1 << b;

}

if (skup1 == skup2) printf("Skupovi su jednaki!\n");

else printf("Skupovi nisu jednaki!\n");

printf("0 za kraj, 1 za nastavak: ");

scanf("%d",&end);

}

} Napomena: Primetiti da je drugi način predstavljanja skupova znatno efikasniji sa stanovišta iskorišćenja memorije.


OO1P2, kolokvijum, april 2009.

Zadatak 1.

Napisati program na programskom jeziku C kojim se u prazan jednodimenzioni niz celih brojeva umeću pozitivni celi

brojevi u nerastućem poretku. U niz ne treba umetati broj ako on već postoji. Brojevi se čitaju sa standardnog ulaza, a

unos se prekida kada korisnik unese vrednost koja nije pozitivna. Nakon unosa, program treba da ispiše sadržaj niza.

#include <stdio.h>

#define MAX 20

void main () {

int a[MAX], i, j, b, n, ind;

n = 0;

while (n < MAX) {

printf("\nUnesite broj: ");

scanf("%d",&b);

if (b<0) break;

for(i=ind=0;i<n || a[i]>b;i++) if (a[i]==b) ind=1;

if (ind) continue;

for (i=n-1; i>=0 && a[i]<b; i--) a[i+1] = a[i];

a[i+1] = b;

n++;

}

printf("\nUnesti niz: ");

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

}



Zadatak 1.

Neka se poruka sastoji od N (N ≤ 100) celobrojnih, osmobitnih reči, tipa unsigned char. Svaka reč poruke se sastoji od

jednog 7-bitnog broja koji zauzima najniže bitove reči, dok najviši bit (bit najveće težine) predstavlja bit parnosti. Bit parnosti se postavlja na vrednost 0 ukoliko je broj binarnih jedinica u preostalih 7 bita paran, a u suprotnom se

postavlja na vrednost 1. Napisati program na programskom jeziku C koji sa glavnog ulaza pročita dužinu poruke n,

zatim učitava n celih brojeva čije vrednosti mogu biti od 0 do 127 , a zatim za svaki od učitanih brojeva računa i u njegov najviši bit upisuje bit parnosti, da bi formirao ispravnu reč. Nakon toga, program ispiše dobijenu poruku.

Program ponavlja postupak sve dok se za dužinu niza n ne unese negativna vrednost.

#include <stdio.h>

#define N 100

void main () {

unsigned char a[N];

int i, j, n, odd;

while (1) {

printf("\nN? ");

scanf("%d", &n);

if (n <= 0 || n > N) break;

printf("Unesite poruku:\n");

for(i = 0; i < n; i++) scanf("%d", &a[i]);

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

odd = 0;

for(j = 0; j < 7; j++) odd += (a[i] >> j) & 1;

a[i] |= odd % 2 ? 0x80 : 0; //alternativno: odd & 1

}

printf("Poruka za slanje:\n");

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

}

}

Napomena: primetiti da zbog ograničenog opsega vrednosti od 0 do 127, binarna reprezentacija elemenata niza zauzima samo najnižih 7 bita broja. Primer računanja bita parnosti na dužini od 8 bita Broj: 7910 = 010011112 Broj sadrži 5 aktivnih bitova (jedinica) u binarnoj predstavi. Da bi se zadovoljilo pravilo za računanje bita parnosti, najviši bit je potrebno postaviti na vrednost 1. Broj nakon dodavanja bita parnosti: 110011112 = 20710 Broj: 7810 = 010011102 Broj sadrži 4 aktivna bita (jedinice) u binarnoj predstavi. Broj ne treba menjati, jer već ima paran broj jedinica i pravilo za računanje bita parnosti je zadovoljeno.


OO1P2, popravni kolokvijum, jun 2010.

Zadatak 1.

Napisati program na programskom jeziku C koji odredi i ispiše najmanji neoznačeni ceo broj koji se može zapisati

proizvoljnim kombinovanjem heksadecimalnih cifara koje se pročitaju sa glavnog ulaza. Broj je potrebno ispisati u decimalnom i heksadecimalnom obliku. Pretpostaviti da se cifre od A do F predstavljaju isključivo velikim slovima

(ASCII kodovi cifara su manji od ASCII kodova velikih slova). Na primer, za unete cifre 5, C, 8, 5 i 2, najmanji ceo broj

je 2558C. Smatrati da se celi brojevi sastoje od najviše 6 cifara. Validnost unetih podataka ne treba proveravati.

#include <stdio.h>

#include <ctype.h>

#define N 6

void main () {

char broj[N+1], c;

int n = 0, vred, i, j;

while(((c = getchar()) != '\n') && (n < N)) {

if (!(isdigit(c) ||

(c >= 'A' && c <= 'F') ||

(c >= 'a' && c <= 'f'))) continue;

broj[n++] = c;

}

broj[n] = '\0';

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

for(j = i+1; j < n; j++)

if (broj[i] > broj[j]) {

c = broj[i];

broj[i] = broj[j];

broj[j] = c;

}

sscanf(broj, "%x", &vred);

printf("Minimalna vrednost: %d %s", vred, broj);

}



Zadatak 1.

Napisati program na programskom jeziku C koji na slučajan način generiše dva niza realnih brojeva X i Y zadate

dužine koji predstavljaju koordinate tačaka u ravni. Prvo se unese dužina nizova, a zatim se generišu koordinate tačaka u opsegu[0.0, 1.0]. Nakon generisanja tačaka, iz nizova treba ukloniti sve one tačke koje ne pripadaju krugu

jediničnog poluprečnika čiji se centar nalazi u koordinatnom početku. Na kraju programa ispisati rezultujuće nizove,

tačku po tačku. Postupak ponavljati sve dok se za dužinu nizova ne unese nedozvoljena vrednost.

#include <stdlib.h>

#include <stdio.h>

#include <time.h>

#define N 100

void main () {

float x[N], y[N];

int i, j, n;

srand(time(NULL));

while (1) {

printf("\nUnesite broj tacaka: ");

scanf("%d", &n);

if (n <= 0 || n > N) break;

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

x[i] = rand()/((float)RAND_MAX);

y[i] = rand()/((float)RAND_MAX);

}

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

if (x[i]*x[i] + y[i]*y[i] <= 1) {

x[j] = x[i];

y[j] = y[i];

j++;

}

n = j;

printf("\nTacke koje pripadaju krugu:\n");

for(i=0; i<n; i++) printf("(%f,%f) ", x[i], y[i]);

}

}



Zadatak 1.

Napisati program na programskom jeziku C koji vrši određenu obradu nad dva niza celih brojeva jednake dužine

(najviše 100 elemenata). Program treba da utvrdi i ispiše da li je prvi učitani niz moguće dobiti rotacijom drugog učitanog niza za odgovarajući broj mesta udesno, kao i broj mesta za koji ga je potrebno rotirati. Program najpre

treba da učita dimenziju nizova, zatim i same nizove. Na kraju, program treba da ispiše na standardnom izlazu ulazne

nizove i rezultat provere. Postupak ponavljati sve dok se za dužinu nizova ne unese nedozvoljena vrednost.

#include <stdio.h>

#define MAX 100

void main () {

int a[100], b[100], pom[100];

int i, j, n, rot = 0, jednaki = 0, temp;

while (1) {

printf("Unesite duzinu nizova: ");

scanf("%d", &n);

if (n <= 0 || n > MAX) break;

printf("Unesite prvi niz: ");

for(i = 0; i < n; i++) scanf("%d", &a[i]);

printf("Unesite drugi niz: ");

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

scanf("%d", &b[i]);

pom[i] = b[i];

}

rot = 0;

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

jednaki = 1;

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

if (a[j] != pom[j]) {

jednaki = 0;

break;

}

if (jednaki) break;

rot++;

temp = pom[n-1];

for (j = n-1; j > 0; j--) pom[j] = pom[j-1];

pom[0] = temp;

}

printf("Niz A: ");

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

printf("\nNiz B: ");

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

if (jednaki)

printf("\nNiz A se dobija rotacijom niza B za %d mesta udesno!\n",

rot);

else

printf("\nNiz A se ne moze dobiti rotacijom niza B!\n");

}

} Napomena: Zadatak se jednostavno može rešiti i bez upotrebe pomoćnog niza.



Zadatak 1.

Napisati program na programskom jeziku C koji vrši određenu obradu nad nizom celih brojeva. Niz može sadržati

najviše 100 elemenata. Program najpre treba da učita dužinu niza i same elemente niza, a zatim na standardnom izlazu ispiše svaki element niza kao zbir stepena dvojke od kojih se on sastoji. Obezbediti da se u niz mogu uneti samo

pozitivni celi brojevi. Ukoliko korisnik unese negativan broj ili nulu ponovo zatražiti unos. Prilikom ispisa usvojiti format

izlaza kao što je u primeru. Postupak ponavljati sve dok se za dužinu niza ne unese nekorektna vrednost.

Primer ulaza Primer izlaza

n = 4

Niz: 13 6 21 4

13 = 2^3 + 2^2 + 2^0

6 = 2^2 + 2^1 21 = 2^4 + 2^2 + 2^0

4 = 2^2

#include <stdio.h>

#define MAX 100

void main(){

int n, a[MAX], i, j;

while(1){

scanf("%d", &n);

if(n<=0 || n>MAX) break;

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

a[i] = 0;

while(a[i] <= 0) scanf("%d", &a[i]);

}

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

int isFirst = 1;

printf("\n%d = ", a[i]);

for(j = sizeof(int)*8 - 1; j >= 0; j--)

if(a[i] & 1 << j){

if(!isFirst) printf(" + "); // print the plus if not first

else isFirst = 0; // clear the flag

printf("2^%d", j);

}

putchar('\n');

}

}

Napomene: Obratiti pažnju da je broj potrebno kao sumu stepena dvojke počevši od člana najveće težine ka članu najmanje težine. Takođe, nakon poslednjeg člana sume ne treba ispisati znak +. Bitsko maskiranje i provera se mogu izvršiti i na drugačiji način:

unsigned int mask = 1 << (sizeof(int)*8-1), j = sizeof(int)*8-1;

for(; mask; mask >>=1, j--)

if(a[i] & mask){

printf("%c 2^%d", isFirst ? '' : '+', j);

if(isFirst) isFirst = 0; // clear the flag

}



Zadatak 1.

Napisati program na programskom jeziku C koji obrađuje poene studenata osvojene na ispitu. Rezultati studenata na

ispitu su predstavljeni pomoću dva niza celih brojeva, gde prvi niz predstavlja niz osmocifrenih brojeva indeksa studenata u formi ggggiiii (npr. 20130001 predstavlja broj indeksa 2013/0001), a drugi niz sadrži poene koje je

student, čiji je broj indeksa u prvom nizu na odgovarajućoj poziciji, osvojio na ispitu. Niz poena se na početku

inicijalizuje nulama. Program učitava prvo broj studenata, a zatim i niz sa brojevima indeksa studenata u kome nema ponavljanja. Korisnik potom unosi poene studentima, tako što u svakom redu unese broj indeksa željenog studenta, a

onda i broj poena koje mu želi dodati. Moguće je više puta uneti poene za istog studenta, pri čemu se poeni sabiraju. Unos poena se ponavlja sve dok se ne unese broj indeksa koji ne postoji u nizu indeksa. Nakon unosa, program treba

da odredi i ispiše prosečan broja poena na ispitu za generaciju čija se godina upisa (podatak gggg iz indeksa) unese

sa standardnog ulaza.

#include <stdio.h>

#define MAX 50

void main(){

int niz_indeksi[MAX], niz_poeni[MAX];

int indeks, poeni, n, godina, suma, broj, i, j, poz;

for(i = 0; i < MAX; i++) // ili inicijalizacija niz_poeni[MAX]={0};

niz_poeni[i] = 0;

printf("Broj studenata? "); scanf("%d", &n);

// provera prekoracenja

if(n>MAX || n<=0){

printf("Nekorektan broj studenata.\n");

return;

}

// ucitavanje indeksa

for(i=0; i<n; i++) scanf("%d", &niz_indeksi[i]);

// ucitavanje poena

while(1){

printf("indeks poeni? ");

scanf("%d %d", &indeks, &poeni); // dozvoljene negativne vrednosti

// pretraga pozicije indeksa

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

if(niz_indeksi[j]==indeks) break;

// prekid unosa poena

if(j==n) break;

// dodavanje poena

niz_poeni[j]+=poeni;

}

printf("Godina upisa? "); scanf("%d", &godina);

suma = broj = 0;

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

// provera pripadnosti generaciji

if(niz_indeksi[i]/10000 == godina){

suma+=niz_poeni[i];

broj++;

}

}

if(broj>0)

printf("Prosecan broj poena za generaciju %d iznosi %lf", godina,

(double)suma/broj);

else

printf("Nema podataka o generaciji %d.\n", godina);

}



Zadatak 1.

Napisati program na programskom jeziku C koji vrši simulaciju promene broja stanovnika u gradovima. Program

najpre učita broj gradova koje će obrađivati (najviše 100) i broj godina za simulaciju, a zatim brojeve stanovnika za sve gradove. Simulacija se radi na sledeći način: na godišnjem nivou broj stanovnika u svakom gradu se promeni za

slučajan broj koji je u opsegu od -1% do +1% broja stanovnika u gradu na početku godine. Za svaku godinu u

simulaciji u zasebnom redu treba ispisati brojeve stanovnika koje svaki grad ima na kraju te godine. Kada se završi simulacija, ispisati broj stanovnika za najnaseljeniji grad. U slučaju da se sa standardnog ulaza unese nekorektna

vrednost za bilo koji podatak, ispisati odgovarajuću poruku i prekinuti izvršavanje programa.

#include<stdio.h>

#include<stdlib.h>

#define MAX 100

void main() {

int godine, n, i, j, max, int gradovi[MAX];

double slucajan;

printf("Unesite broj gradova: ");

scanf("%d", &n);

if (n < 1 || n > MAX) {

printf("Greska: Broj gradova je neodgovarajuci.\n");

exit(1);

}

printf("Unesite broj stanovnika za gradove:\n");

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

scanf("%d", &gradovi[i]);

if (gradovi[i] < 2) {

printf("Greska: Broj stanovnika grada je

neodgovarajuci.\n"); exit(1);

}

}

printf("Unesite broj godina: ");

scanf("%d", &godine);

if (godine < 1) {

printf("Greska: Broj godina je neodgovarajuci.\n"); exit(1);

}

for (i = 0; i < godine; i++) {

for (j = 0; j < n; j++) {

slucajan = rand() / (double)RAND_MAX * 2 - 1;

gradovi[j] += gradovi[j] * slucajan / 100;

if (gradovi[j] < 2) {

printf("Greska: Broj stanovnika grada je

neodgovarajuci.\n"); exit(1);

}

}

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

printf("%d ", gradovi[j]);

printf("\n");

}

max = gradovi[0];

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

if (max < gradovi[i])

max = gradovi[i];

printf("Grad sa najvecim brojem stanovnika je %d.\n", max);

}



Zadatak 1.

Napisati program na programskom jeziku C koji pomaže organizatorima takmičenja u kucanju uskršnjim jajima da

izaberu pobednike po kategorijama. Svako uskršnje jaje je organizaciona komisija opisala sledećim podacima: rednim brojem takmičara (ceo broj), jačinom ljuske (realan broj) i kategorijom jajeta (0 – kokošije, 1 – guščije, 2 – drveno ili

neidentifikovano). Redni brojevi takmičara se nalaze u opsegu od 0 do 100, a u takmičenju učestvuje najviše 1000

jaja. Jedan takmičar se može takmičiti sa više uskršnjih jaja. Program najpre treba da učita broj uskršnjih jaja (dužinu nizova) koje komisija treba da obradi, a zatim i podatke o svakom pojedinačnom jajetu razdvojene blanko znakom, za

svako jaje iz posebnog reda. Pročitane podatke treba smeštati u tri niza odgovarajućeg tipa. Nakon učitavanja, program treba da ispiše podatke o pobedničkim jajima po kategorijama, ne uzimajući u obzir jaja diskvalifikovanih

takmičara. Diskvalifikovani su oni takmičari koji su prijavili barem jedno drveno ili neidentifikovano jaje. Jaje je

pobedničko ukoliko ima najjaču ljusku u svojoj kategoriji.

#include <stdio.h>

#define MAX_JAJA 1000

#define MAX_TAKMICARA 100

enum kategorija_jaja {KOKOSIJE, GUSCIJE, DRVENO};

int main () {

int redni_broj[MAX_JAJA], kategorija[MAX_JAJA], takmicari[MAX_JAJA] = {0},

n, i, max_k_ind, max_g_ind;

float jacina_ljuske[MAX_JAJA], max_k, max_g;

printf("Unesite broj jaja na takmicenju: ");

scanf("%d", &n);

if (n <= 0 || n > MAX_JAJA) return 1;

printf("Unesite podatke o svakom jajetu:\n");

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

scanf("%d %f %d", &redni_broj[i], &jacina_ljuske[i], &kategorija[i]);

takmicari[redni_broj[i]]++;

}

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

if (kategorija[i] == DRVENO) takmicari[redni_broj[i]] = -1;

max_k = max_g = 0;

max_k_ind = max_g_ind = -1;

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

if (kategorija[i] == KOKOSIJE && jacina_ljuske[i] > max_k

&& takmicari[redni_broj[i]] > 0) {

max_k = jacina_ljuske[i]; max_k_ind = i;

};

if (kategorija[i] == GUSCIJE && jacina_ljuske[i] > max_g

&& takmicari[redni_broj[i]] > 0) {

max_g = jacina_ljuske[i]; max_g_ind = i;

};

}

if (max_k_ind != -1)

printf("Najjace kokosije jaje: %d %0.2f.\n", redni_broj[max_k_ind],

jacina_ljuske[max_k_ind]);

else

printf("Nije bilo kokosijih jaja u regularnoj konkurenciji!\n");

if (max_g_ind != -1)

printf("Najjace guscije jaje: %d %0.2f.\n", redni_broj[max_g_ind],

jacina_ljuske[max_g_ind]);

else

printf("Nije bilo guscijih jaja u regularnoj konkurenciji!\n");

return 0;

}



Zadatak

Napisati program na programskom jeziku C koji za dati delimično poznat neoznačeni ceo broj pronalazi njemu

najsličniji broj u nekom skupu neoznačenih celih brojeva. Program sa standardnog ulaza prvo učitava dva broja N i M, a zatim N neoznačenih celih brojeva koji predstavljaju skup u kome se traži najsličniji broj. Nakon toga se unosi

delimično poznati broj i to na sledeći način. Unosi se niz od M brojeva koji predstavljaju M najnižih binarnih cifara

nepoznatog broja. U nizu se mogu naći vrednosti 0, 1, i -1. Vrednost -1 označava da vrednost cifre nije poznata. Unesene cifre su na pozicijama od M – 1 do 0, gde je cifra na poziciji 0 najmanje težine. Cifre koje nisu unete su

nepoznate. Program treba da ispiše najsličniji broj delimično poznatom broju (ako ih ima više, ispisati sve). Najsličniji je onaj broj koji ima najviše istih binarnih cifara na pozicijama kao i delimično poznat broj. Broj N ne može biti veći od 100 i broj M ne može biti veći od konstante sizeof(unsigned)*8. Za sve operacije sa bitovima koristiti bitske

operatore.

Primer ulaza: Primer izlaza:

3 4

10 6 7

-1 1 1 -1

6 7

#include <stdio.h>

#define MAX (100)

int main() {

unsigned set[MAX];

int n, m;

unsigned similarity[MAX];

scanf("%d %d", &n, &m);

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

scanf("%u", &set[i]);

similarity[i] = 0;

}

for (int i = m - 1; i >= 0; i--) {

int value;

scanf("%d", &value);

if (value == -1) { continue; }

unsigned mask = 1 << i;

for (int j = 0; j < n; j++) {

unsigned one_bit = (set[j] & mask) >> i;

if (one_bit == value) {

similarity[j]++;

}

}

}

unsigned max = 0;

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

if (max < similarity[i]) {

max = similarity[i];

}

}

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

if (max == similarity[i]) {

printf("%u ", set[i]);

}

}

putchar('\n');

return 0;

}


SI1P2, prvi kolokvijum, mart 2011.

Zadatak 1.

Napisati program na programskom jeziku C koji generiše pseudoslučajan broj u opsegu od 10 do 10000, a zatim vrši

proveru da li je generisani broj Fibonačijev broj. Fibonačijevi brojevi se računaju po formuli f0=1, f1=1, fn=fn-1 + fn-2, a

generisane brojeve je potrebno ispisivati na standardnom izlazu. Na kraju programa ispisati rezultat provere.

#include <stdio.h>

#include <stdlib.h>

#include <time.h>

#define LOW 10

#define HIGH 10000

void main () {

int broj, f0, f1, f2;

srand(time(NULL));

broj = rand()/((double)RAND_MAX)*(HIGH - LOW) + LOW;

printf("Pseudoslucajni broj: %d\n", broj);

printf("Generisem Fibonacijeve brojeve: \n");

for(f0=f1=f2=1; f2 < broj;) {

f0 = f1;

f1 = f2;

f2 = f0 + f1;

printf("%d ", f2);

}

putchar('\n');

if (f2 == broj)

printf("Generisani broj je Fibonacijev broj.\n");

else

printf("Generisani broj nije Fibonacijev broj.\n");

}



Zadatak 2.

Napisati program na programskom jeziku C koji sa glavnog ulaza učitava niz od 12 realnih brojeva koji predstavljaju

prosečnu mesečnu temperaturu za svaki mesec u godini. Program treba da izračuna i ispiše na standardnom izlazu prosečnu temperaturu po kvartalima (tromesečjima) u toku zadate godine, kao i redni broj kvartala sa najmanjom i

najvećom prosečnom temperaturom. Program treba da ponavlja prethodni postupak sve dok korisnik ne učita sve

vrednosti 0 u ulazni niz.

#include <stdio.h>

#define BROJ_MESECI 12

#define KVARTALI 4

#define KVARTAL 3

void main () {

double temperature[BROJ_MESECI], kvartali[KVARTALI] = {0};

int i, min, max, uslov;

while(1) {

printf("Unesite prosecne mesecne temperature: ");

for(i=0; i<BROJ_MESECI; i++) scanf("%lf", &temperature[i]);

for(uslov=i=0; i<BROJ_MESECI; i++) uslov = uslov || (int)temperature[i];

if (!uslov) break;

for(i=0; i<KVARTAL; i++) {

kvartali[0] += temperature[i + 0*KVARTAL];




}

printf("Prosecna temperatura po kvartalima: \n");

for(i=0; i<KVARTALI; i++) {

kvartali[i] /= KVARTAL;

printf("%d: %2.2f\n", i, kvartali[i]);

}

min = max = 0;

for(i=1; i<KVARTAL; i++) {

if (kvartali[i] < kvartali[min]) min = i;

if (kvartali[i] > kvartali[max]) max = i;

}

printf("\nKvartal sa najmanjom prosecnom temperaturom: %d\n", min);

printf("Kvartal sa najvecom prosecnom temperaturom: %d\n", max);

}

}



Zadatak 1.

Vrednost broja PI se može statistički odrediti uz pomoć generatora pseudoslučajnih

brojeva uniformne raspodele. Potrebno je generisati tačke u ravni sa obema koordinatama u realnom opsegu [0, 1]. Vrednost broja PI se tada može odrediti na

osnovu odnosa broja tačaka koje se nalaze u delu kruga poluprečnika 1 sa centrom u

koordinatnom početku (Tc) i broja tačaka koje pripadaju kvadratu stranice 1 koji obuhvata sve generisane tačke (Tu) pomoću sledeće formule:

u

c

T

T= 4

Napisati program na programskom jeziku C koji izračunava vrednost broja PI. Program treba da učita ukupan broj

tačaka koji treba da budu generisan, izračuna vrednost broja PI i ispiše rezultat. Program treba da ponavlja opisane

korake sve dok se za broj tačaka unosi pozitivna vrednost..

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

void main () {

double x1, y1, d, pi;

int i, in_circle = 0, n;

srand(time(NULL));

while(1) {

printf("Unesi broj tacaka koji treba generisati: ");

scanf("%d", &n);

if (n <= 0) break;

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

x1 = rand()/(double)RAND_MAX;

y1 = rand()/(double)RAND_MAX;

d = sqrt(x1*x1 + y1*y1);

in_circle += (d <= 1.0) ? 1 : 0;

}

pi = (double)4*in_circle/n;

printf("Izracunata vrednost PI: %f\n", pi);

}

}



Zadatak 2.

Napisati program na programskom jeziku C koji sa standardnog ulaza učitava niz od najviše 100 celih brojeva, a zatim

proverava da li uneti niz predstavlja bitoničku sekvencu. Bitonička sekvenca je sekvenca brojeva koja se sastoji od jedne monotono neopadajuće i jedne monotono nerastuće sekvence brojeva ili obratno (x0 ≤ ... ≤ xk ≥ ... ≥ xn-1 ili

x0 ≥ ... ≥ xk ≤ ... ≤ xn-1, gde 0 ≤ k < n). Program treba da učita dužinu i elemente niza, a zatim izvrši proveru i ispiše

odgovarajuću poruku. Obezbediti da se u niz mogu uneti samo brojevi u opsegu od 0 do 50. Ukoliko korisnik unese broj van tog opsega ponovo zatražiti unos. Program treba da ponavlja opisane korake sve dok se za dužinu niza ne

unese nekorektna vrednost.

#include <stdio.h>

#define MAX 100

void main () {

int niz[MAX], i, n, provera, tranzicija;

while(1) {

printf("Unesite duzinu niza: \n");

scanf("%d", &n);

if (n <= 0 || n > MAX) break;

printf("Unesite elemente niza u opsegu 0..50: \n");

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

int broj;

scanf("%d", &broj);

while (broj < 0 || broj > 50) {

printf("Broj van opsega! Unesite ponovo: \n");

scanf("%d", &broj);

}

niz[i] = broj;

}

if (n == 1) { printf("Sekvenca je bitonicka!\n"); continue; }

provera = 0;

tranzicija = 0;

for (i = 1; i < n; i++) {

if (niz[i-1] < niz[i]) {

if (provera == 0) provera = 1;

else if (provera == -1) {

tranzicija++;

provera = 1;

}

}

else if (niz[i-1] > niz[i]) {

if (provera == 0) provera = -1;

else if (provera == 1) {

tranzicija++;

provera = -1;

}

}

}

if (tranzicija == 1) printf("Sekvenca je bitonicka!\n");

else printf("Sekvenca nije bitonicka!\n");

}

}


SI1P2, drugi kolokvijum, april 2013.

Zadatak 2.

Napisati program na programskom jeziku C koji vrši određenu obradu nad dinamičkom matricom realnih brojeva.

Program treba učita dimenzije i elemente matrice, a zatim formira novu matricu koja sadrži samo one vrste čija je aritmetička sredina elemenata veća od aritmetičke sredine svih elemenata u polaznoj matrici. Nakon obrade ispisati

rezultujuću matricu. Voditi računa o korektnoj upotrebi dinamičke memorije.

#include <stdio.h>

#include <stdlib.h>

float ar_sred (float *arr, unsigned int n) {

unsigned int i;

float suma;

for (i = suma = 0; i < n; i++) suma += arr[i];

return suma / n;

}

int main () {

unsigned int m1, m2, n, i, j;

float **mat, **nova_mat, ar_sred_mat, ar_sred_vr;

printf("Unesite dimenzije matrice: ");

scanf("%d%d", &m1, &n);

if (m <= 0 || n <= 0) return 1;

mat = malloc(m1 * sizeof(float*));

if (mat == NULL) exit(1);

for (i = 0; i < m1; i++) {

mat[i] = malloc(n * sizeof(float));

if (mat[i] == NULL) exit(2);

for (j = 0; j < n; j++) scanf("%f", &mat[i][j]);

}

for (i = 0; i < m1; printf("\n"), i++)

for (j = 0; j < n; j++) printf("%2.2f ", mat[i][j]);

ar_sred_mat = 0;

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

ar_sred_mat += ar_sred(mat[i], n);

ar_sred_mat /= m1;

printf("Aritemticka sredina clanova matrice je: %2.2f\n", ar_sred_mat);

nova_mat = NULL;

m2 = 0;

for (i = 0; i < m1; i++) {

ar_sred_vr = ar_sred(mat[i], n);

if (ar_sred_vr > ar_sred_mat) {

float **nova_m;

nova_m = realloc(nova_mat, (m2 + 1) * sizeof(float*));

if (nova_m == NULL) exit(3);

else nova_mat = nova_m;

nova_mat[m2] = malloc(n * sizeof(float));

if (nova_mat[m2] == NULL) exit(2);

for (j = 0; j < n; j++) nova_mat[m2][j] = mat[i][j];

m2++;

}

}

for (i = 0; i < m2; printf("\n"), i++)

for (j = 0; j < n; j++) printf("%2.2f ", nova_mat[i][j]);

for (i = 0; i < m1; i++) free (mat[i]);

free (mat);

for (i = 0; i < m2; i++) free (nova_mat[i]);

free (nova_mat);

return 0;

}


SI1P2, treći kolokvijum, jun 2012.

Zadatak 2.

Napisati program na programskom jeziku C koji prepisuje sadržaj ulazne tekst datoteke u izlaznu tekst datoteku uz

izostavljanje svih pojavljivanja HTML tagova. HTML tagovi su oblika <tag> ili </tag>, gde tag može biti bilo koji niz karaktera uključujući i blanko znake. Jedan HTML tag može početi u jednom, a završiti se u nekom drugom redu.

Imena ulazne i izlazne datoteke se zadaju kao prvi i drugi argument komandne linije. Ukoliko se za ime izlazne

datoteke zada string "-" sadržaj treba ispisati na standardni izlaz (stdout). Očuvati uređenost tekst po redovima.

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

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

FILE *ulaz, *izlaz;

int c, tag = 0, br = 0;

if (argc != 3) {

printf("Neodgovarajuci broj parametara u komandnoj liniji!");

exit(1);

}

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

fprintf(stderr,"Greska u otvaranju ulazne datoteke %s\n",

argv[1]);

exit(2);

}

if (strcmp(argv[2], "-") != 0) {

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

fprintf(stderr,"Greska u otvaranju izlazne datoteke %s\n",

argv[2]);

exit(3);

}

} else izlaz = stdout;

while ((c = fgetc(ulaz)) != EOF) {

switch(c) {

case '<': tag = 1; br++; break;

case '>': tag = 0; br--; break;

default: if (!tag && !br) fputc(c, izlaz); break;

}

}

fclose(ulaz);

fclose(izlaz);

return 0;

}



Zadatak 1.

Napisati program na programskom jeziku C koji sa standardnog ulaza učitava ceo broj tipa unsigned int (pretpostaviti

da je za smeštanje jednog podatka tog tipa potrebno 16 bita), a potom proverava da li je bitska reprezentacija tog broja, posmatrana od bita najveće težine ka bitu najmanje težine, komplementarna u odnosu na bitsku reprezentaciju

posmatranu od bita namanje težine ka bitu najveće težine. U slučaju da jeste, na standardnom izlazu treba ispisati

poruku “DA“, u suprotnom poruku “NE“. Pimer: binarna reprezentacija broja 48322 je 1011110011000010, pa se ispisuje poruka “DA“.

#include<stdio.h>

int main(){

unsigned int broj, dmaska = 0x0001, lmaska = 0x8000, i, da = 1;

scanf("%d", &broj);

for (i = 0; i < 8 && da; i++, lmaska >>= 1, dmaska <<= 1)

if (!((broj & dmaska) ^ ((broj & lmaska) >> (15 - i * 2))))

da = 0;

if (da) printf("DA");

else printf("NE");

}



Zadatak 2.

Napisati program na programskom jeziku C koji uređuje zadati niz od najviše 100 celih brojeva tako da sadrži prvo

neparne brojeve u nerastućem po retku, a zatim parne brojeve u neopadajućemporetku. Elementi niza se inicijalizuju sekvencom pseudoslučajnih celih brojeva u opsegu [100,200]. Program najpre učita dužinu niza brojeva, zatim

gainicijalizuje sekvencom pseudoslučajnih brojeva izzadatog opsega, sortira elemente prema zadatom kriterijumu i na

kraju ispiše rezultujući niz.Navedeni koraci se ponavljaju sve dok se za dužinuniza ne unese nekorektna vrednost.

#include <stdio.h>

#include <stdlib.h>

#define DIM 100

void main() {

int a[DIM], n, i, j, tmp, xchg;

while (1) {

printf("Unesite broj elemenata:\n");

scanf("%d", &n);

if (n < 1 || n > DIM) break;

printf("Generisani niz:\n");

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

a[i] = ((double)rand() / RAND_MAX)*100 + 100;

printf("%d%c", a[i], (i == n - 1) ? '\n' : ' ');

}

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

for (j = i + 1; j < n; j++){

int i_paran, j_paran;

i_paran = 0 == a[i] % 2;

j_paran = 0 == a[j] % 2;

xchg = i_paran && !j_paran;

xchg = xchg || (i_paran && j_paran && a[i] < a[j]);

xchg = xchg || (!i_paran && !j_paran && a[i] > a[j]);

if (xchg) {

tmp = a[i];

a[i] = a[j];

a[j] = tmp;

}

}

printf("Obradjeni niz:\n");

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

printf("%d%c", a[i], (i == n - 1) ? '\n' : ' ');

}

}

}


SI1P2, drugi kolokvijum, 2014.

Zadatak 2.

Napisati program na programskom jeziku C koji vrši određenu obradu nad dinamičkom matricom realnih

brojeva. Program treba da učita dimenzije i elemente matrice, a zatim i same elemente. Nakon toga program iz svake kolone matrice izbaci najveći element u toj koloni. Pretpostaviti da su svi elementi kolone različiti. Nakon

izbacivanja elemenata osloboditi memorijski prostor koji se više ne koristi i ispisati rezultujuću matricu. Voditi

računa o korektnoj upotrebi dinamičke memorije i optimalnom iskorišćenju memorijskog prostora.

#include <stdio.h>

#include <stdlib.h>

void main()

{

int **matrix, tmp, m ,n;

int i, j;

scanf("%d%d", &m, &n);

if (m < 1 || n < 1)

return;

matrix = malloc(sizeof(int *) * m);

if (NULL == matrix)

return;

for (i = 0; i < m; i++) {

matrix[i] = malloc(sizeof(int) * n);

if (NULL == matrix[i])

return;

}

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

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

scanf("%d", &matrix[i][j]);

for (j = 0; j < n; j++) {

int max, index;

max = matrix[0][j];

index = 0;

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

if (max < matrix[i][j]) {

max = matrix[i][j];

index = i;

}

for (i = index; i < m - 1; i++)

matrix[i][j] = matrix[i + 1][j];

}

if (m > 1) {

m--;

free(matrix[m]);

tmp = realloc(matrix, sizeof(int *) * m);

if (NULL != tmp)

matrix = tmp;

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

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

printf("%d%c", matrix[i][j], (j == n - 1) ? '\n' : ' ');

}

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

free(matrix[i]);

free(matrix);

}


SI1P2, popravni drugi kolokvijum, jun 2014.

Zadatak 1.

Napisati program na programskom jeziku C funkciju char *num2word(char *str); koja u znakovnom nizu str

uklanja jednocifrene brojeve i zamenjuje ih rečima (nula, jedan, dva, ..., devet). Funkcija treba da vrati modifikovan znakovni niz. Za realizovanje tražene funkcije nije dozvoljeno korišćenje bibliotečkih funkcija, kao ni pomoćni niz.

Napisati program na programskom jeziku C koji učitava niz znakova kao liniju teksta sa standardnog ulaza, a zatim pomoću realizovane funkcije obradi učitani niz znakova i potom ga ispiše na standardnom izlazu. Niz znakova se

alocira dinamički i ništa se ne pretpostavlja o njegovoj dužini. Voditi računa o korektnoj upotrebi dinamičke memorije i

optimalnom iskorišćenju memorijskog prostora.

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <ctype.h>

#define EOS (-1)

char *words[] = { "nula", "jedan", "dva", "tri", "cetiri", "pet", "sest",

"sedam", "osam", "devet" };

enum state { LOOK, DIGIT, NO_NUM };

int position_one_digit(char *str) {

int i;

enum state state;

state = LOOK;

for (i = 0; '\0' != str[i]; i++) {

switch (state){

case LOOK:

if (isdigit(str[i]))

state = DIGIT;

else

if (!isblank(str[i]))

state = NO_NUM;

break;

case DIGIT:

if (isblank(str[i]))

return i - 1;

else

state = NO_NUM;

break;

case NO_NUM:

if (isblank(str[i]))

state = LOOK;

break;

}

}

if (DIGIT == state)

return i - 1;

return EOS;

}

char *word(char c) {

return words[c - '0'];

}


int new_size(char *str) {

int size;

int i;

size = strlen(str) + 1;

while (EOS != (i = position_one_digit(str))) {

size += strlen(word(str[i])) - 1;

str += i + 1;

}

return size;

}

char *num2words(char *str) {

int nsize, osize;

char *ret;

int i, j, next;

osize = strlen(str) + 1;

nsize = new_size(str);

ret = realloc(str, nsize);

if (NULL == ret)

return str;

str = ret;

for (i = nsize - 1, j = osize - 1; j >= 0; i--, j--)

str[i] = str[j];

str = str + nsize - osize;

i = 0;

while (EOS != (next = position_one_digit(str))) {

char *w;

for (j = 0; j < next; j++)

ret[i++] = str[j];

w = word(str[next]);

for (j = 0; '\0' != w[j]; j++)

ret[i++] = w[j];

str += next + 1;

}

for (j = 0; '\0' != str[j]; j++)

ret[i++] = str[j];

ret[i] = '\0';

return ret;

}

int main() {

char *str, c;

int i;

str = NULL;

i = 0;

while ('\n' != (c = getchar())) {

if (0 == i % 10) {

str = realloc(str, i + 10);

if (NULL == str) exit(-1);

}

str[i] = c;

i++;

}

str = realloc(str, i + 1);

if (NULL == str) exit(-1);

str[i] = '\0';

str = num2words(str);

printf("%s\n", str);

free(str);

}



Zadatak 1.

Napisati program na programskom jeziku C koji pretražuje binarnu predstavu broja radi pronalaženja svih pojava

zadate binarne sekvence. Program treba sa standardnog ulaza da učita dva broja tipa unsigned int (pretpostaviti da je veličina tipa 16 bita). Prvo se učitava broj koji se pretražuje. Iz binarne predstave drugog učitanog broja izdvaja se

deo između binarnih jedinica najmanje i najveće težine (uključujući i njih), pa to predstavlja sekvencu koja se traži.

Pretraživanje se vrši počevši od cifre najveće težine. Program treba da ispiše sve početne pozicije u prvom broju gde je nađen zadati sadržaj (pozicija najveće težine je 15). Na primer neka je prvi broj 0x5B5A, a drugi broj 0x0168.

Pozicije koje treba ispisati su: 14, 11 i 6.

#include <stdio.h>

#define SIZE 16

void main() {

unsigned int a, b, mask, ones;

int first_one, last_one, i, find_start, iter;

printf("Unesite dva broja (drugi broj se pretrazuje u prvom)?\n");

scanf("%x%x", &a, &b);

mask = 1;

find_start = 1;

for (i = 0; i < SIZE; i++){

if (mask & b) {

if (find_start) {

first_one = i;

find_start = 0;

}

last_one = i;

}

mask <<= 1;

}

if (find_start) {

printf("Drugi broj je jednak nuli\n");

return;

}

ones = (1 << last_one – first_one + 1) – 1;

mask = b << (SIZE - 1) - last_one;

ones = ones << (SIZE – (last_one – first_one) – 1);

iter = SIZE - (last_one - first_one);

for (i = 0; i < iter; i++) {

if ((ones & a) == mask))

printf("%d ", (SIZE - i) - 1);

mask >>= 1;

ones >>= 1;

}

}


SI1P2, drugi kolokvijum, 2015.

Zadatak 2.

Napisati program na programskom jeziku C koji učita matricu, obradi je i na kraju ispiše na standardni izlaz.

Prilikom učitavanja matrice, prvo se učitaju dimenzije, a potom se alocira matrica odgovarajuće veličine i popuni vrednostima koje se pročitaju sa standardnog ulaza, tako da se svaka vrsta učitava iz posebnog reda. Učitana matrica

se obrađuje tako što se prvo pronađe najmanja vrednost u matrici, a zatim se izbace sve vrste koje sadrže nađenu

minimalnu vrednost. Na kraju ispisati sadržaj obrađene matrice. Voditi računa o korektnoj i optimalnoj upotrebi

korišćenih resursa.

#include <stdio.h>

#include <stdlib.h>

#define CHECK(x) do { if (NULL == (x)) { \

printf("Greska prilikom alokacije memorije.\n"); \

exit(-1); \

} \

} while (0)

void main() {

int **matrica, **nova, m, n, i, j, k, min;

printf("Unesite dimenzije matrice.\n");


if (m < 1 || n < 1) exit(0);

printf("Unesite elemente matrice.\n");

matrica = malloc(m*sizeof(int *));

CHECK(matrica);

for (i = 0; i < m; i++) {

matrica[i] = malloc(n*sizeof(int));

CHECK(matrica[i]);

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

scanf("%d", &matrica[i][j]);

}

min = matrica[0][0];

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

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

if (min > matrica[i][j])

min = matrica[i][j];

k = 0;

for (i = 0; i < m; i++) {

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

if (matrica[i][j] == min) break;

if (j == n) {

matrica[k] = matrica[i];

k++;

}

else { free(matrica[i]); }

}

m = k;

if (m > 0) {

nova = realloc(matrica, m * sizeof(int *));

if (NULL != nova) matrica = nova;

for (i = 0; i < m; i++) {

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

printf("%d ", matrica[i][j]);

putchar('\n');

}

}

for (i = 0; i < m; i++) free(matrica[i]);

free(matrica);

}


SI1P2, popravni prvi kolokvijum, jun 2015.

Zadatak 1.

Napisati program na programskom jeziku C koji obađuje niz celih neoznačenih brojeva. Program sa standardnog ulaza

učita broj elemenata niza i elemente niza, zatim iz niza izbaci sve elemente u čijoj binarnoj reprezentaciji ima više parova susednih jedinica od prosečnog broja parova susednih jedinica u reprezentacijama svih unetih brojeva, uredi

preostale elemente niza po nerastućoj vrednosti elemenata i na kraju ispiše sadržaj rezultujućeg niza. Prilikom

prebrojavanja parova jedna jedinica može da bude deo dva para (npr. u broju 10011101 postoje 2 para susednih jedinica). Smatrati da niz ima najviše 100 elemenata. Za svaki uneti broj dozvoljeno je najviše jednom računati broj

parova susednih jedinica, pa je izračunatu vrednost potrebno čuvati u pomoćnom nizu. Osim dva pomenuta niza nije

dozvoljeno koristiti druge pomoćne nizove.

#include <stdio.h>

#define MAX 100

void main() {

unsigned brojevi[100], parovi[100], n, i, j, mask;

double srednja_vrednost;

scanf("%u", &n);

if (n < 1 || n > MAX)

return;

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

scanf("%u", &brojevi[i]);

srednja_vrednost = 0;

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

mask = 3;

parovi[i] = 0;

for (j = 0; j < sizeof(unsigned) * 8 - 1; j++) {

if ((mask & brojevi[i]) == mask)

parovi[i]++;

mask <<= 1;

}

srednja_vrednost += parovi[i];

}

srednja_vrednost /= n;

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

if (parovi[i] <= srednja_vrednost)

brojevi[j++] = brojevi[i];

n = j;

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

for (j = i + 1; j < n; j++)

if (brojevi[i] < brojevi[j]) {

unsigned tmp = brojevi[i];

brojevi[i] = brojevi[j];

brojevi[j] = tmp;

}

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

printf("%u ", brojevi[i]);

putchar('\n');

}


SI1P2, prvi kolokvijum, mart, 2017.

Zadatak 1.

Napisati program na programskom jeziku C koji vrši konverziju realnog broja iz binarnog u decimalni oblik. Realan broj

u binarnom brojnom sistemu se zadaje kao niz znakova koji može sadržati samo cifre 0, 1 i eventualnu decimalnu tačku. Program treba da učita niz znakova sa standardnog ulaza do kraja tekućeg reda, izvrši konverziju zadatog broja

u odgovarajući realni tip programskog jezika C i ispiše rezultat u decimalnom brojnom sistemu. Prlikom učitavanja,

obezbediti da korisnik unosi samo dozvoljene znakove, a u slučaju unošenja nedozvoljenog znaka zahtevati ponovni unos. Smatrati da niz znakova nije duži od 50 elemenata i obezbediti prekid unosa, ukoliko korisnik pokuša da unese

više znakova. #include <stdio.h>

#define MAX 50

int main() {

char broj[MAX], znak, tacka = 0;

int i, n;

double ceo_deo = 0, realni_deo = 0, realni;

printf("Unesite broj u binarnom obliku:\n");

n = 0;

while ((znak = getchar()) != '\n' && n < MAX) {

broj[n++] = znak;

}

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

znak = broj[i];

while (znak != '0' && znak != '1' && znak != '.') {

printf("Uneli ste nedozvoljeni znak, ponovite unos!\n");

znak = getchar();

}

if (znak == '.') tacka++;

broj[i] = znak;

}

if (n == 0) {

printf("Niz je prazan!\n");

} else if (tacka > 1) {

printf("Broj je neispravan!\n");

} else {

i = 0;

if (broj[i] != '.') {

ceo_deo = broj[0] - '0';

while (++i < n && broj[i] != '.')

ceo_deo = ceo_deo * 2 + (broj[i] - '0');

}

if (i < n)

while (i < --n)

realni_deo = (realni_deo + broj[n] - '0') / 2;

realni = ceo_deo + realni_deo;

printf("Konvertovani broj je: %f\n", realni);

}

return 0;

}



Zadatak 1.

Napisati program na programskom jeziku C koji računa pobednika u nekoj kartaškoj igri. Igra se igra sa 52 karte.

Karta je određena vrednošću i znakom. Vrednost može biti ceo broj od 2 do 14. Postoje četiri znaka čije su

jednoslovne oznake K, H, T i P. Korisnik u prvom redu na standardnom ulazu unosi broj igrača N koji igraju igru, kao i glavni znak u partiji. Maksimalan broj igrača je 10. Nakon toga se u N redova, za svakog igrača u posebnom redu,

unose karte koje poseduje. Broj karata koje jedan igrač ima je 5. Za svaku kartu se unosi vrednost karte i znak, odvojeni tačno jednim razmakom. Karte u redu su međusobno odvojene jednim razmakom. Broj poena koje jedan

igrač ima računa se kao zbir poena koje svaka karta koju ima nosi. Broj poena za kartu koja ima vrednost manju od

10 je isti kao i njena vrednost. Broj poena za kartu koja ima vrednost veću ili jednaku 10 je 10. Ukoliko je znak neke karte isti kao i glavni znak u partiji, broj poena se za tu kartu duplira. Program treba da ispiše redni broj igrača (od 1

do N) i broj poena koji je osvojio taj igrač, i to u posebnim redovima, u nerastućem poretku broja poena. Smatrati da

je ulaz ispravan.

#include <stdio.h>

#define MAX_NUMBER_OF_PLAYERS 10

#define NUMBER_OF_CARDS 5

#define MAX_CARD_VALUE 10

void main() {

int numberOfPlayers, players[MAX_NUMBER_OF_PLAYERS],

points[MAX_NUMBER_OF_PLAYERS], cardValue, i, j, temp;

char cardSign, mainSign;

scanf("%d %c", &numberOfPlayers, &mainSign);

for (i = 0; i < numberOfPlayers; i++) {

players[i] = i + 1; points[i] = 0;

for (j = 0; j < NUMBER_OF_CARDS; j++) {

scanf("%d %c", &cardValue, &cardSign);

if (cardValue > MAX_CARD_VALUE) {

cardValue = MAX_CARD_VALUE;

}

if (cardSign == mainSign) {

cardValue *= 2;

}

points[i] += cardValue;

}

}

for (i = 0; i < (numberOfPlayers - 1); i++)

for (j = (i + 1); j < numberOfPlayers; j++) {

if (points[i] < points[j]) {

temp = points[i];

points[i] = points[j];

points[j] = temp;

temp = players[i];

players[i] = players[j];

players[j] = temp;

}

}

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

printf("%d %d\n", players[i], points[i]);

}


SI1P2, popravni prvi kolokvijum, april 2018.

Zadatak 1.

Napisati program na programskom jeziku C koji vrši određenu obradu nad nizom cifara celog broja (prvi element niza

je cifra najveće težine, poslednji je cifra najmanje težine). Program najpre treba da učita dužinu niza, a zatim popuni

niz brojevima u opsegu [0, 9], pri čemu prva cifra ne sme biti nula. Brojeve korisnik zadaje sa standardnog ulaza, a treba ponovljati učitavanje sve dok broj nije u odgovarajućem opsegu. Nakon toga, treba iz niza ukloniti jedan

element, tako da broj predstavljen rezultujućim nizom cifara bude najveći moguć. Formirani niz ispisati na standardnom izlazu. Niz može sadržati najviše 100 elemenata. Ukoliko se za dužinu niza unese nekorektna vrednost,

ponovo zatražiti unos.

Primer generisanog niza Primer izlaznog niza 1 2 3 8 6 2 4 1 7 5 4 2 1

2 3 8 6 4 1 7 5 4 2

#include <stdio.h>

#define MAX 100

int main()

{

int niz[MAX], i, n;

do{

printf("Uneti duzinu niza: ");

scanf("%d", &n);

} while(n<=0 || n>MAX);

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

do {

printf("Uneti %d. cifru: ", i+1);

scanf("%d", &niz[i]);

} while (niz[i]<(i==0?1:0) || niz[i]>9);

}

for(i=0; i<n-1 && niz[i]>=niz[i+1]; i++);

while(i<n){

niz[i] = niz[i+1];

i++;

}

n--;

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

printf("%d", niz[i]);

}


P2, ispit, jun 2010.

Zadatak 1.

U nekoj kompaniji, podaci o službenim automobilima se čuvaju u datoteci „automobili.txt“. Svaki red datoteke sadrži

podatke o jednom automobilu – najpre registarski broj automobila (string od tačno 6 karaktera), a zatim naziv automobila koji se može sastojati od više reči. U datoteci „putovanja.txt“ se nalaze podaci o službenim putovanjima –

u jednom redu datoteke se nalazi datum (u formatu dd-mm-gggg), registarski broj korišćenog automobila i broj

pređenih kilometara (ceo broj). Napisati program na jeziku C koji pročita sadržaj navedenih tekst datoteka i ispiše na glavnom izlazu registarski broj i naziv automobila koji su prešli najmanji i najveći broj kilometara. U slučaju postojanja

više automobila koji su prešli isti broj kilometara, uzima se u obzir onaj koji se pojavljuje prvi u datoteci.

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#define NAZIV 100

#define REG 9

#define DATUM 11

typedef struct elem {

char reg_broj[REG];

char naziv[NAZIV];

int kilometraza;

struct elem *sled;

} Elem;

void main () {

Elem *prvi = NULL, *tek = NULL, *novi = NULL, *pret = NULL, *min, *max;

char reg[REG], datum[DATUM]; int km, i;

FILE *automobili, *putovanja;

automobili = fopen("automobili.txt", "r");

putovanja = fopen("putovanja.txt", "r");

if (automobili == NULL || putovanja == NULL) {

fprintf(stderr, "Ne postoji neka od datoteka!"); exit(1);

}

while (fscanf(automobili, "%s", reg) != EOF) {

novi = malloc(sizeof(Elem));

if (novi == NULL) { fprintf(stderr,

"Neuspesna alokacija dinamicke memorije"); exit(2); }

novi->kilometraza = 0; novi->sled = NULL;

strcpy(novi->reg_broj, reg);

i = fgets(novi->naziv, NAZIV-2, automobili);

novi->naziv[strlen(novi->naziv)-1] = '\0';

if (prvi == NULL) prvi = novi;

else pret->sled = novi;

pret = novi;

}

while (fscanf(putovanja, "%s%s%d", datum, reg, &km) != EOF) {

tek = prvi;

while(tek != NULL) {

if (strcmp(reg, tek->reg_broj) == 0) {

tek->kilometraza += km;

break;

}

tek = tek->sled;

}

}


min = max = prvi; tek = prvi->sled;

while (tek != NULL) {

if (tek->kilometraza < min->kilometraza) min = tek;

else if (tek->kilometraza > max->kilometraza) max = tek;

tek = tek->sled;

}

printf("Najmanje je presao: %s%s %d km\n", min->reg_broj,

min->naziv, min->kilometraza);

printf("Najvise je presao: %s%s %d km\n", max->reg_broj,

max->naziv, max->kilometraza);

while(prvi) {

pret = prvi;

prvi = prvi->sled;

free(pret);

}

fclose(automobili);

fclose(putovanja);

}


P2, ispit, septembar 2010.

Zadatak 2.

Napisati program na programskom jeziku C koji računa i ispisuje površinu i koordinate donjeg levog i gornjeg desnog

temena pravougaonika najveće površine konstruisanog na sledeći način: iz jednostruko ulančane liste tačaka bira se par tačaka koje predstavljaju temena na jednoj od dijagonala pravougaonika čije su stranice paralelne sa x i y osama.

Program sa glavnog ulaza iz svakog reda treba da učita realne koordinate jedne tačke, sve dok se ne unesu

koordinate (0,0). Od učitanih tačaka se formira jednostruko ulančana lista. Koordinate (0,0) se ne unose u listu. Broj koordinata nije unapred poznat. Učitavanje, obradu i dealokaciju liste realizovati kao zasebne potprograme. Voditi

računa o ispravnoj alokaciji i dealokaciji dinamičke memorije.

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

typedef struct tacka { double x,y; struct tacka* sled; } Elem;

Elem* ucitaj () {

double x,y;

Elem *novi, *prvi, *preth;

printf("Unesite koordinate tacaka: \n");

preth = prvi = NULL;

while(1) {

scanf("%lf%lf",&x,&y);

if (x==0 && y==0) break;


if (novi == NULL) { printf("Greska - dinamicka memorija!"); exit(1); }

novi->x = x; novi->y = y; novi->sled = NULL;


else preth->sled = novi;

preth = novi;

}

return prvi;

}

void obradi (Elem* prvi) {

Elem *tek1, *tek2, *max1, *max2;

double p, maxp;

if (!prvi->sled) return;

tek1 = max1 = prvi;

tek2 = max2 = prvi->sled;

maxp = fabs(tek1->x - tek2->x) * fabs(tek1->y - tek2->y);

while (tek1) {

tek2 = tek1->sled;

while (tek2) {

p = fabs(tek1->x - tek2->x) * fabs(tek1->y - tek2->y);

if (p > maxp) { maxp = p; max1 = tek1; max2 = tek2; }

tek2 = tek2->sled;

}

tek1 = tek1->sled;

}

printf("\nNajveca povrisna: %f\n", maxp);

printf("Kooridnate temena: (%0.2g,%0.2g) (%0.2g,%0.2g)\n",

max1->x > max2->x ? max2->x : max1->x,

max1->y > max2->y ? max2->y : max1->y,

max1->x < max2->x ? max2->x : max1->x,

max1->y < max2->y ? max2->y : max1->y);

}


void dealociraj (Elem* prvi) {

Elem* stari;

while(prvi) {

stari = prvi;

prvi = prvi->sled;

free(stari);

}

}

void main () {

Elem* prvi;

prvi = ucitaj();

obradi(prvi);

dealociraj(prvi);

}



Zadatak 1.

Neka se u datoteci teniseri.txt nalaze podaci o teniserima po sledećem formatu: šifra igrača (ceo broj), ime (najviše 30

znakova), prezime (najviše 30 znakova) i broj poena na ATP rang listi (ceo broj). U datoteci wimbledon.txt se nalaze podaci o plasmanu tenisera na ovom teniskom turniru. U svakom redu datoteke se nalazi šifra tenisera (ceo broj), broj

poena koji brani na turniru (ceo broj) i broj poena koji je osvojio na turniru (ceo broj). Raspored tenisera u

datotekama ne mora biti identičan, niti svi teniseri iz prve datoteke moraju postojati u drugoj datoteci. Napisati program na programskom jeziku C koji pročita sadržaj ulaznih tekst datoteka i formira jednostruko ulančanu listu, a

zatim u izlaznu datoteku atplista.txt za svakog tenisera upiše novi broj poena po formatu kao u prvoj ulaznoj datoteci. Novi broj poena se dobija tako što se od starog broja poena na ATP listi oduzme broj poena koje teniser brani, a zatim

doda broj poena koje je teniser osvojio na turniru. Voditi računa o ispravnom korišćenju zauzetih resursa.

#include <stdio.h>

#include <stdlib.h>

#include <string.h>


int sifra; char ime[31]; char prezime[31]; int bodovi; struct elem *sled;

} Elem;

void main () {

Elem *prvi = NULL, *poslednji = NULL, *novi, *tek;

FILE *ulaz1, *ulaz2, *izlaz;

int sifra, bod_brani, bod_osvojio, bodovi;

char ime[31], prezime[31];

if ((ulaz1 = fopen("teniseri.txt","r")) == NULL) {

printf("Greska u otvaranju ulazne datoteke!"); exit(1); }

if ((ulaz2 = fopen("wimbledon.txt","r")) == NULL) {

printf("Greska u otvaranju ulazne datoteke!"); exit(1); }

if ((izlaz = fopen("atplista.txt","w")) == NULL) {

printf("Greska u otvaranju izlazne datoteke!"); exit(4);

}

while(fscanf(ulaz1, "%d%s%s%d", &sifra, ime, prezime, &bodovi)!=EOF) {

if ((novi = malloc(sizeof(Elem))) == NULL) {

printf("Greska u alociranju dinamicke memorije!"); exit(3); }

novi->sled = NULL; novi->bodovi = bodovi; novi->sifra = sifra;

strcpy(novi->ime, ime); strcpy(novi->prezime, prezime);


else poslednji->sled = novi;

poslednji = novi;

}

while(fscanf(ulaz2, "%d%d%d", &sifra, &bod_brani, &bod_osvojio)!=EOF) {

tek = prvi;

while (tek != NULL && tek->sifra != sifra) tek = tek->sled;

if (tek != NULL) { tek->bodovi += (bod_osvojio - bod_brani); }

}

tek = prvi;


fprintf(izlaz,"%d %s %s %d\n", tek->sifra,

tek->ime, tek->prezime, tek->bodovi);

tek = tek->sled;

}

tek = prvi;

while (tek != NULL) { poslednji = tek;tek = tek->sled;free(poslednji); }

fclose(ulaz1); fclose(ulaz2); fclose(izlaz);

}



Zadatak 2.

Napisati program na programskom jeziku C koji vrši određenu obradu nad matricom celih brojeva maksimalnih

dimenzija 20x20. Program treba da učita dimenzije i elemente matrice, pronađe minimalni element u matrici, a zatim ispiše u posebnim redovima sve one vrste koje ne sadrže taj minimalni element u matrici. Program treba da ponavlja

izvršavanje sve dok se sa standardnog ulaza ne učitaju nekorektne dimenzije matrice. Učitavanje, obradu i ispis

matrice realizovati kao zasebne potprograme koji sa glavnim programom komuniciraju isključivo putem argumenata i

povratnih vrednosti.

#include <stdio.h>

#define MAX_DIM 20

int loadMatrix(int matrix[MAX_DIM][MAX_DIM], int *m,int *n) {

int i,j;

scanf("%d %d",m,n);

if (*m < 1 || *n < 1 || *m > MAX_DIM || *n > MAX_DIM)

return 0;

for (i = 0;i < *m;i++)

for (j = 0;j < *n;j++)

scanf("%d",&matrix[i][j]);

return 1;

}

void searchMin(int matrix[MAX_DIM][MAX_DIM],int m, int n, int *min) {

int i,j;

*min = matrix[0][0];

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

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

if (matrix[i][j] < *min) *min = matrix[i][j];

}

void writeRows(int matrix[MAX_DIM][MAX_DIM], int m, int n,int min) {

int i,j;

int cond;

for (i = 0;i < m;i++){

cond = 0;

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

if (matrix[i][j] == min) cond = 1;

if (cond == 0){

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

printf("%d ",matrix[i][j]);

printf("\n");}

}

}

void main() {

int matrix[MAX_DIM][MAX_DIM];

int m,n,min;

while (loadMatrix(matrix,&m,&n) == 1) {

searchMin(matrix,m,n,&min);

writeRows(matrix,m,n,min);

}

}


P2, ispit, jul 2011.

Zadatak 1.

Dat je polinom oblika P(x)=a0Xn+a1Xn-1+ a2Xn-2 + ... +an-1X+an, gde su (a0,a1,...,an) realni koeficijenti

polinoma, X je celobrojna promenljiva, dok je n stepen polinoma (pretpostaviti da je an≠0). Napisati program na

programskom jeziku C koji vrši tabeliranje polinoma datog oblika. Program prvo treba da učita stepen polinoma (maksimalno 20), a zatim se redom učitavaju koeficijenti, počevši od an. Kada se učitaju koeficijenti potrebno je

ispisati zadati polinom na standardni izlaz prema formatu koji je zadat na početku zadatka (na primer za a0=4,a1=0,a2=3,a3=6 ispisati 4*x^3 + 3*x + 6. Nakon ispisa polinoma potrebno je izvršiti njegovo tabeliranje

za vrednosti promeljive X u opsegu [1,100],sa korakom 1. U svakom koraku tabeliranja polinoma, potrebno je na

standardni izlaz ispisati vrednost promenljive X i njoj odgovarajuću vrednost polinoma. Program treba da ponavlja

prethodne korake sve dok se za stepen polinoma ne unese -1.Učitavanje, tabeliranje i ispis polinoma realizovati kao

zasebne potprograme koji sa glavnim programom komuniciraju isključivo putem argumenata i povratnih vrednosti.

#include <stdio.h>

#include <math.h>

#define MAX_POW 21

#define UP_LIMIT 100

#define DOWN_LIMIT 1

#define STEP 1

#define EXIT -1

void read(double a[], int *n){

int i;

printf("Unesiti najveci nenulti stepen polinoma:\n");

scanf("%d",n);

if (*n >= MAX_POW) return;

for (i = *n;i >= 0;i--){

scanf("%lf",&a[i]);

}

}

void calc(double a[], int n){

int x,i;

x = DOWN_LIMIT;

printf("Tabelirani polinom je:\n");

while (x <= UP_LIMIT){

double sum = 0;

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

sum += pow(x,i) * a[i];

}

printf("x = %-3d P(x) = %-5.2f\n",x,sum);

x += STEP;

}

}

void print(double [],int);

void main(){

double a[MAX_POW];

int n;

while(22){

read(a,&n);

if (n == EXIT) break;

if (n < 0 || n >= MAX_POW){

printf("Nepodrzan stepen.\n");

continue;

}

print(a,n);

calc(a,n);

}

}


void print(double a[],int n){

int i, zero = 1;

printf("Polinom je:\n");

for (i = n;i > 1;i--){

if (a[i] != 0){

zero = 0;

if (i == n){

printf("%.2f*x^%d",a[i],i);

}

else{

if (a[i] < 0){

printf(" - %.2f*x^%d",-a[i],i);

}

else{

printf(" + %.2f*x^%d",a[i],i);

}

}

}

}

if (n > 0 && a[1] != 0){

if (zero != 0){

printf("%.2f*x",a[1]);

}

else{

if (a[1] < 0){

printf(" - %.2f*x",-a[1]);

}

else{

printf(" + %.2f*x",a[1]);

}

}

zero = 0;

}

if (a[0] != 0){

if (zero != 0){

printf("%.2f",a[0]);

}

else{

if (a[0] < 0){

printf(" - %.2f",-a[0]);

}

else{

printf(" + %.2f",a[0]);

}

}

zero = 0;

}

if (zero == 0){

printf("\n");

}

else{

printf("0\n");

}

}



Zadatak 2.

Napisati program na programskom jeziku C koji treba da proveri da li je dan pred praznik potrebno uvesti još neki

autobus na postojećim linijama. Podaci o standardnom redu vožnje su zapisani u tekstualnoj datoteci linije.txt. U svakom redu ove datoteke se nalazi zapis o tačno jednoj autobuskoj liniji i to u sledećem formatu: šifra (ceo

broj kojim se identifikuje linija i koji je jedinstven u ovoj datoteci), broj sedišta koje autobus na toj liniji ima (ceo

broj), vreme (hh:mm, gde su hh i mm, redom, sat i minut polaska) i naziv odredišnog grada (uvek samo jedna reč bez blanko znakova). Druga datoteka, rezervacije.txt, sadrži spisak sa rezervacijama. U svakom redu je

zapis o tačno jednoj rezervaciji i to u sledećem formatu: ime (jedna reč), prezime (jedna reč) i šifra linije za koju važi rezervacija (ceo broj). Skup šifara koje se pojavljuju u datoteci rezervacije.txt je podskup šifara koje se pojavljuju u

datoteci linije.txt. Dozvoljeno je samo jednom pročitati obe datoteke. Na standardnom izlazu ispisati podatke o svim

linijama za koje postoji više rezervacija od broja raspoloživih sedišta i uz svaku liniju ispisati broj rezervacija za koje

nema mesta. Voditi računa o korektnoj upotrebi zauzetih resursa.

#include <stdio.h>

#include <stdlib.h>

#define MAX_CHAR 20

typedef struct linija{

int id,br_sed,br_rez,hh,mm; char grad[MAX_CHAR+1];

struct linija *next;

} Linija;

typedef struct rez{

char ime[MAX_CHAR+1],prezime[MAX_CHAR+1]; int id;

struct rez *next;

}Rez;

void main(){

FILE *linije,*rez;

Linija *lLinije = NULL, *tekLinije,*noviLinije;

Rez *lRez = NULL,*tekRez = NULL,*noviRez;

linije = fopen("linije.txt", "r");

if (linije == NULL) {

printf("Greska prilikom otvaranja linije.txt\n");exit(-1);}

rez = fopen("rezervacije.txt", "r");

if (linije == NULL) {

printf("Greska prilikom otvaranja rezervacije.txt\n");exit(-1);}

tekLinije = NULL;

while(22){

noviLinije = (Linija*)malloc(sizeof(Linija));

if (noviLinije == NULL) {

printf("Greska prilikom rezervacije memorije\n");exit(-1);}

if (0 >= fscanf(linije,"%d%d%d:%d%s",

&(noviLinije->id),

&(noviLinije->br_sed),

&(noviLinije->hh),

&(noviLinije->mm),

noviLinije->grad)) {

free(noviLinije);

break;

}

if (tekLinije == NULL)

lLinije = tekLinije = noviLinije;

else{

tekLinije->next = noviLinije;

tekLinije = noviLinije;

}

noviLinije->br_rez = 0;

noviLinije->next = NULL;

}


while(22){

noviRez = (Rez*)malloc(sizeof(Rez));

if (noviRez == NULL) {

printf("Greska prilikom rezervacije memorije\n");exit(-1);}

if (0 >= fscanf(rez,"%s%s%d",

noviRez->ime,noviRez->prezime,&(noviRez->id))){

free(noviRez);

break;

}

if (tekRez == NULL)

lRez = tekRez = noviRez;

else{

tekRez->next = noviRez;

tekRez = noviRez;

}

noviRez->next = NULL;

}

tekRez = lRez;

while(tekRez != NULL){

tekLinije = lLinije;

while(tekLinije != NULL){

if (tekLinije->id == tekRez->id){

tekLinije->br_rez++;

break;

}

tekLinije = tekLinije->next;

}

tekRez = tekRez->next;

}

tekLinije = lLinije;

while(tekLinije != NULL){

if (tekLinije->br_rez > tekLinije->br_sed)

printf("%d %d %02d:%02d %s %d\n",tekLinije->id,

tekLinije->br_sed,

tekLinije->hh,

tekLinije->mm,tekLinije->grad,

tekLinije->br_rez);

noviLinije = tekLinije;

tekLinije = tekLinije->next;

free(noviLinije);

}

lLinije = NULL;

tekRez = lRez;

while (tekRez != NULL){

noviRez = tekRez;

tekRez = tekRez->next;

free(noviRez);

}

lRez = NULL;

fclose(linije);

fclose(rez);

}



Zadatak 1.

Napisati program na programskom jeziku C koji vrši određenu obradu nad tekst datotekom koja predstavlja plejlistu

muzičkih numera. Svaki red ulazne datoteke sadrži podatke o jednoj muzičkoj numeri po sledećem formatu: naziv numere (najviše 255 znakova i može sadržati blanko znake) i trajanje numere u sekundama (ceo broj). Program treba

da pročita ulaznu datoteku i na standardnom izlazu ispiše ukupan broj numera u plejlisti i ukupno trajanje plejliste u

formatu hh:mm:ss, gde su hh sati, mm minuti, a ss sekunde. Ime ulazne datoteke se zadaje kao prvi argument

komandne linije.

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#define MAXLINE 300

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

FILE *ulaz;

int ukupno = 0, trajanje, numere = 0, hh, mm, ss;

char linija[MAXLINE];

ulaz = fopen(argv[1], "r");

if (ulaz == NULL) {

printf("Neuspesno otvaranje datoteke!");

exit(1);

}

while (fgets(linija, MAXLINE, ulaz) != NULL) {

int i = strlen(linija) - 1;

while (linija[i] != ' ') i--;

trajanje = atoi(linija + i);

ukupno += trajanje;

numere++;

}

hh = ukupno / 3600;

mm = (ukupno / 60) % 60;

ss = ukupno % 60;

printf("Ukupan broj numera u plejlisti: %d\n", numere);

printf("Ukupno trajanje plejliste: %2.2d:%2.2d:%2.2d", hh, mm, ss);

fclose (ulaz);

return 0;

}



Zadatak 2.

Napisati program na programskom jeziku C koji vrši obradu kvadratne matrice celih brojeva koji se nalaze u opsegu

od 0 do 255. Program najpre treba da učita dimenzije matrice, a zatim i samu matricu. Maksimalna veličina matrice nije unapred poznata, pa je memoriju potrebno dinamički alocirati. U matrici treba pronaći sve one vrednosti koje se

pojavljuju i na glavnoj i na sporednoj dijagonali matrice. Pronađene vrednosti treba ispisati na standardni izlaz. Ako se

neka vrednost pojavljuje više puta i na glavnoj i na sporednoj dijagonali matrice, ta vrednost treba da bude ispisana samo jednom. Učitavanje, obradu i ispis rezultata implementirati kao zasebne potprograme koji sa glavnim

programom komuniciraju isključivo putem liste argumenata i povratne vrednosti.

#include <stdio.h>

#include <stdlib.h>

#define MAX 255

#define MIN 0

void ucitaj(int*** matrix, int *n){

int i,j;

printf("Unesite dimenziju kvadratne matrice: ");

scanf("%d",n);

if (*n < 1) exit(-1);

printf("Unesite elemente matrice:\n");

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

if (*matrix == NULL)

exit(-1);

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

(*matrix)[i] = (int*)malloc(*n*sizeof(int));

if ((*matrix)[i] == NULL)

exit(-1);

for(j = 0;j < *n;j++){

scanf("%d",&(*matrix)[i][j]);

if ((*matrix)[i][j] < MIN || (*matrix)[i][j] > MAX)

exit(-1);

}

}

}

int hash(int value){

return value - MIN;

}

void obrada(int **matrix,int n,int *result,int *num_result){

int vector[MAX - MIN + 1] = {0},i,j,k = 0,*pom;

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

if (vector[hash(matrix[i][i])] != 0) continue;

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

if (matrix[i][i] == matrix[j][n - j - 1]){

result[k++] = matrix[i][i];

vector[hash(matrix[i][i])] = 1;

break;

}

}

*num_result = k;

}


void ispis(int *result, int n){

int i;

if (n > 0)

printf("Pronadjeni brojevi su:'n");

else

printf("Nisu pronadjeni.\n");

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

printf("%d ",result[i]);

printf("\n");

}

void brisi(int **matrix,int n){

int i;

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

free(matrix[i]);

free(matrix);

}

void main(){

int n,**matrix,*result,num_result;

ucitaj(&matrix,&n);

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

if (result == NULL)

exit(-1);

obrada(matrix,n,result,&num_result);

ispis(result,num_result);

free(result);

brisi(matrix,n);

}


P2, ispit, oktobar 2011.

Zadatak 1.

Neka se u datoteci meteo.txt nalaze podaci o vremenskim prilikama na određenim meteorološkim mernim mestima. U

svakom redu se nalazi naziv mernog mesta (niz od najviše 30 znakova), temperatura (realan broj), pritisak (realan broj), brzina vetra (realan broj) i vlažnost vazduha (realan broj). Napisati program na programskom jeziku C koji

pročita sadržaj ulazne tekst datoteke i formira jednostruko ulančanu listu, a zatim na standardni izlaz ispiše nazive,

temperaturu i vlažnost vazduha na svim onim mernim mestima kod kojih je izmeren vazdušni pritisak između 1010 i

1015 milibara, a brzina vetra je manja od 1 m/s. Voditi računa o ispravnom korišćenju zauzetih resursa.

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#define MIN_NORM_VLAZNOST 1010.0

#define MAX_NORM_VLAZNOST 1015.0

#define MAX_BRZINA_VETRA 1.0

typedef struct meteo {

char naziv[31]; float temperatura, pritisak, brzina_vetra, vlaznost;

struct meteo *sled;

} Elem;

void main () {

FILE *ulaz;

Elem *novi, *prvi = NULL, *posl = NULL, *tek;

char naziv[31]; float temperatura, pritisak, brzina_vetra, vlaznost;

if ((ulaz = fopen("meteo.txt", "r"))==NULL) {

printf("Neuspesno otvaranje datoteke!"); exit(1); }

while(fscanf(ulaz, "%s %f %f %f %f",

naziv, &temperatura, &pritisak, &brzina_vetra, &vlaznost)!=EOF) {


if (novi == NULL) {

printf("Neuspesna dodela dinamicke memorije!"); exit(2);

}

novi->sled = NULL;

strcpy(novi->naziv, naziv);

novi->temperatura = temperatura; novi->pritisak = pritisak;

novi->brzina_vetra = brzina_vetra; novi->vlaznost = vlaznost;

if (!prvi) prvi = novi;

else posl->sled = novi;

posl = novi;

}

printf("Merna mesta koja zadovoljavaju uslove: \n");

printf("1010 mb < pritisak < 1015 mb \n");

printf("brzina vetra < 1 m/s \n\n");

printf("Naziv - temperatura - vlaznost\n");

tek = prvi;

while (tek) {

if (tek->pritisak > MIN_NORM_VLAZNOST &&

tek->pritisak < MAX_NORM_VLAZNOST &&

tek->brzina_vetra < MAX_BRZINA_VETRA) {

printf("%s %2.1f %2.1f\n", tek->naziv,

tek->temperatura, tek->vlaznost);

}

tek = tek->sled;

}

while (prvi) { posl = prvi->sled; free(prvi); prvi = posl; }

fclose(ulaz);

}



Zadatak 2.

Napisati program na programskom jeziku C za obradu i kriptovanje poruka. Poruka se unosi sa standardnog ulaza sve

dok se ne unese znak za novi red. Poruku sačinjavaju mala i velika slova engleske abecede, zapete, razmaci i tačke. Maksimalna dužina poruke je 80 znakova. Nakon unosa i smeštanja poruke u niz, sva višestruka, uzastopna

pojavljivanja blanko znaka zameniti jednim blanko znakom, a zatim izvršiti kriptovanje. Kriptovanje pripremljene

poruke se vrši tako što se redom za svaki znak u poruci generiše pseudoslučajan broj u opsegu od 0 do 255, a zatim se na tekući karakter i generisani psedoslučajni broj primeni bitska operacija „ekskluzivno ili“ i dobijena vrednost

smesti u novi niz. Elemente niza ispisati na standardnom izlazu u heksadecimalnom brojnom sistemu. Učitavanje, obradu (uklanjanje suvišnih razmaka i kriptovanje) i ispis rezultata implementirati kao zasebne potprograme koji sa

glavnim programom komuniciraju isključivo putem liste argumenata i povratne vrednosti.

#include <stdio.h>

#include <ctype.h>

#include <stdlib.h>

#define MSG_BUFFER_SIZE 80

#define RANDOM_GEN_SEED 22

#define FALSE 0

#define TRUE (!FALSE)

int readMessage(unsigned char* aMsgBuffer, int aBuffCapacity) {

int i = 0;

char c;

printf("Unesite poruku:\n");

while((c=getchar()) != '\n' && i<aBuffCapacity) {

if (isalpha(c) || isspace(c) || '.'==c || ','==c)

{

aMsgBuffer[i++] = c;

}

else

{

printf("Wrong character: %c", c);

}

}

printf("Zavrseno citanje poruke (duzina=%d).\n", i);

return i;

}

int removeExtraSpaces(unsigned char* aMessage, int aMessageLength) {

char c;

int i = 0, j=0, spaceSequenceActive=FALSE;

while (i<aMessageLength)

{

c=aMessage[i];

if (!isspace(c))

{

if (spaceSequenceActive && c != '.' && c != ',')

aMessage[j++] = ' ';

aMessage[j++] = c;

}

spaceSequenceActive = isspace(c);

i++;

}

return j;

}


void writeMessage(unsigned char* aMsg, int aMsgLength, int toHex)

{

int i;

printf("Vasa poruka je (duzina=%d):\n", aMsgLength);

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

{

if (toHex)

printf("%x ", aMsg[i]);

else

printf("%c", aMsg[i]);

}

printf("\n");

}

unsigned char randomNumber(unsigned int start, unsigned int end)

{

int num = rand();

return start + (num*1.0/RAND_MAX) * (end - start);

}

void encryptMessage(unsigned char* aMessage, int aMsgLength,

unsigned char* aEncryptBuff)

{

int i;

srand(RANDOM_GEN_SEED);

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

{

aEncryptBuff[i] = aMessage[i] ^ randomNumber(0, 255);

}

}

int main()

{

unsigned char message[MSG_BUFFER_SIZE],

encryptedMessage[MSG_BUFFER_SIZE];

// Read message.

int msgLength = readMessage(message, MSG_BUFFER_SIZE);

writeMessage(message, msgLength, FALSE);

// Correct the message.

msgLength = removeExtraSpaces(message, msgLength);

writeMessage(message, msgLength, FALSE);

// Encrypt the message.

encryptMessage(message, msgLength, encryptedMessage);

writeMessage(message, msgLength, TRUE);

return 0;

}



Zadatak 2.

Tekstualna datoteka kalendar.txt u svakom redu sadrži informacije o zakazanim aktivnostima u jednom danu. Za

svaku aktivnost navodi se vreme početka, vreme završetka i kratak opis. Format jednog reda datoteke je dat u priloženom primeru. Napisati program na programskom jeziku C koji čita red po red iz datoteke, pravi strukturu

aktivnosti na osnovu podataka iz pročitanog reda i stavlja je u listu u hronološkom poretku. Potom, polazeći od početka liste pronalazi aktivnosti koje se preklapaju. Ako se detektuje preklapanje između dve aktivnosti, iz liste se

izbacuje aktivnost koja počinje kasnije ili, ako obe počinju u isto vreme, izbacuje se ona koja je druga u poretku.

Aktivnost se može preklapati sa proizvoljno mnogo drugih aktivnosti. Aktivnosti koje se izbace iz liste, ispisuju se u izlaznu tekstualnu datoteku preklapanja.txt. Za kratak opis aktivnosti koristi se maksimalno 80 znakova. Na kraju

program treba da ispravno oslobodi zauzete resurse.

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

typedef struct sTime {

int hours, minutes;

} Time;

typedef struct sActivity {

Time startTime, endTime;

char description[81]; // #define...

} Activity;

typedef struct sListElement {

Activity* pActivity;

Struct sListElement* next;

} ListElement;

int isBefore(Time t1, Time t2) {

return (t1.hours<t2.hours)||(t1.hours==t2.hours&&

t1.minutes<t2.minutes);

}

int isBeforeOrEqual(Time t1, Time t2) {

return (t1.hours<t2.hours) ||

(t1.hours==t2.hours && t1.minutes<=t2.minutes);

}

int isBeforeOrEqual(Activity* a1, Activity* a2) {

return isBeforeOrEqual(a1->startTime, a2->startTime);

}

Activity* readActivity(FILE* f) {

int startHour;

Activity* actv = (Activity*) malloc(sizeof(Activity));

int status = fscanf(f, "%d:%d-%d:%d ",

&actv->startTime.hours, &actv->startTime.minutes,

&actv->endTime.hours, &actv->endTime.minutes);

if (status == EOF) {

free(actv);

return NULL;

}

fgets(actv->description, 120, f);

return actv;

}

void print (ListElement* aList, FILE* f) {

ListElement* p = aList;

while (p) {

print(p->pActivity, f);

p=p->next;

}

}


ListElement* insert(ListElement* lstFirst, Activity* actv) {

ListElement* newActv = (ListElement*) malloc (sizeof(ListElement));

newActv->pActivity = actv;

ListElement* curr=lstFirst, *prev = NULL;

while (curr) {

if (isBeforeOrEqual(curr->pActivity, actv))

prev=curr, curr=curr->next;

else break;

}

if (!prev) lstFirst=newActv;

else prev->next=newActv;

newActv->next=curr;

return lstFirst;}

void print(Activity* actv, FILE* f) {

fprintf(f, "%d:%d-%d:%d ",actv->startTime.hours,

actv->startTime.minutes,

actv->endTime.hours, actv->endTime.minutes, actv->description);

fputs(actv->description, f);

}

int isOverlaped(Activity* a1, Activity* a2) {

return

(isBeforeOrEqual(a1->startTime,a2->startTime) &&

isBefore(a2->startTime, a1->endTime))

||

(isBeforeOrEqual(a2->startTime,a1->startTime) &&

isBefore(a1->startTime, a2->endTime));

}

ListElement* removeOverlappedActivities(ListElement* aList, FILE* output) {

ListElement *pi=aList, *pj=NULL, *pjPrev, *old;

while (pi) {

pj = pi->next;

while (pj) {

if (isOverlaped(pi->pActivity, pj->pActivity)) {

pi->next=pj->next;

print(pj->pActivity, output);

free(pj->pActivity); free(pj);

pj=pi->next;

}

else { pj=pj->next; }

}

pi = pi->next;

}

return aList;

}

int main () {

ListElement* activityList=NULL;

Activity* currActivity;

FILE* scheduleFile = fopen("kalendar.txt", "r");

FILE* overlapingFile=fopen("preklapanja.txt", "w");

FILE* debugFile=fopen("debug.txt", "w");

if (scheduleFile==NULL) {printf("Cannot open input file."); return 1; }

if (overlapingFile==NULL) {printf("Cannot open..."); return 1; }

while ((currActivity=readActivity(scheduleFile))!=NULL) {

activityList = insert(activityList, currActivity);

}


print(activityList, debugFile);

removeOverlappedActivities(activityList, overlapingFile);

print(activityList, debugFile);

fclose(scheduleFile);

fclose(overlapingFile);

fclose(debugFile);

// dealocate the list...

}



Zadatak 1.

Napisati program na programskom jeziku C koji vrši određenu obradu nad listom tačaka u ravni sa realnim

koordinatama. Program treba da utvrdi i na standardni izlaz ispiše sve one trojke tačaka koje čine jedan trougao, svaku pronađenu trojku u zasebnom redu. Tri tačke se ne nalaze na istoj pravoj ukoliko važi formula za kolinearnost

tačaka. Program treba da učitava elemente jednostruko ulančane liste sve dok se ne unese tačka koja označava

koordinatni početak, a zatim izvrši zahtevanu obradu. Učitavanje i obradu liste implementirati kao zasebne potprograme koji sa glavnim programom komuniciraju isključivo preko liste argumenata i povratne vrednosti. Voditi

računa o korektnoj upotrebi dinamičke memorije.

#include <stdio.h>

#include <stdlib.h>


float x, y; struct elem *sled;

} Elem;

Elem* ucitaj () {

Elem *prvi = NULL, *novi, *posl = NULL;

float x, y;

printf("Unesite koordinate tacaka:\n");

while (1) {

scanf("%f%f", &x, &y);

if ((x == 0) && (y == 0)) break;


if (novi == NULL) {

printf("Problem u alokaciji dinamicke memorije!"); exit(1); }

novi->x = x; novi->y = y; novi->sled = NULL;



posl = novi;

}

return prvi;

}

void obradi (Elem *prvi) {

Elem *tek1, *tek2, *tek3;

tek1 = prvi;

while (tek1) {

tek2 = tek1->sled;

while(tek2) {

tek3 = tek2->sled;

while(tek3) {

if (tek1->x * (tek2->y - tek3->y) +

tek2->x * (tek3->y - tek1->y) +

tek3->x * (tek1->y - tek2->y)) {

printf("Tacke (%2.2f,%2.2f) (%2.2f,%2.2f) (%2.2f,%2.2f)

cine trougao!\n", tek1->x, tek1->y, tek2->x, tek2->y, tek3->x, tek3->y);

}

tek3 = tek3->sled;

}

tek2 = tek2->sled;

}

tek1 = tek1->sled;

}

}


void dealociraj (Elem *prvi) {

Elem *stari;

while (prvi) {

stari = prvi;

prvi = prvi->sled;

free(stari);

}

}

void main () {

Elem *prvi = ucitaj();

obradi(prvi);

dealociraj(prvi);

}



Zadatak 2.

Napisati program na programskom jeziku C koji određuje osvajače medalja na atletskim trkama. Informacije o trkama se nalaze u datoteci trke.txt. Za svaku trku postoji informacija o broju učesnika i nakon toga u sledećem redu su

redom navedeni učesnici. Za svakog učesnika su navedeni prijavni broj učesnika i njegovo prolazno vreme u formatu MM:SS (MM minuti i SS sekunde). Program treba da odredi tri najbolja učesnika u svakoj trci i da ih upiše u datoteku

medalje.txt. Za pobednika trke program treba da upiše prijavni broj učesnika i njegovo prolazno vreme, a za

učesnike koji su osvojili drugo i treće mesto treba da upiše prijavni broj i vreme zaostatka za pobednikom u formatu +MM:SS. Pretpostaviti da ni na jednoj trci ne učestvuje više od 20 učesnika.

Primer trke.txt Primer medalje.txt

4

1 00:48 2 00:49 5 00:48 4 00:47

2

5 00:24 4 00:21

4 00:47 1 +00:01 5 +00:01

4 00:21 5 +00:03

#include <stdio.h>

#include <stdlib.h>

#define MAX 20

struct Ucesnik{

int prijavniBroj;

int minut;

int sekunda;

};

void main(){

FILE *ulaz, *izlaz;

int brojUcesnika,i,j;

struct Ucesnik ucesnici[MAX];

ulaz = fopen("trke.txt","r");

if(ulaz == NULL) {

printf("Ne moze da se otvori ulazni fajl!\n");

exit(1);

}

izlaz = fopen("medalje.txt","w");

if(ulaz == NULL) {

printf("Ne moze da se otvori izlazni fajl!\n");

fclose(ulaz);

exit(1);

}

while (1 == fscanf(ulaz,"%d",&brojUcesnika)){

if (brojUcesnika < 1 || brojUcesnika>MAX)break;

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

fscanf(ulaz,"%d %d:%d",&ucesnici[i].prijavniBroj,

&ucesnici[i].minut, &ucesnici[i].sekunda);

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

for (j = i + 1;j < brojUcesnika;j++)

if (ucesnici[i].minut > ucesnici[j].minut ||

(ucesnici[i].minut == ucesnici[j].minut &&

ucesnici[i].sekunda > ucesnici[j].sekunda)){

struct Ucesnik tmp = ucesnici[j];

ucesnici[j] = ucesnici[i];

ucesnici[i] = tmp;

}


fprintf(izlaz,"%d %02d:%02d",ucesnici[0].prijavniBroj,

ucesnici[0].minut,ucesnici[0].sekunda);

for (i = 1;i<3 && i < brojUcesnika;i++){

int min, sec;

min = ucesnici[i].minut - ucesnici[0].minut;

sec = ucesnici[i].sekunda - ucesnici[0].sekunda;

if (sec < 0){ min--; sec += 60; }

fprintf(izlaz," %d +%02d:%02d",

ucesnici[i].prijavniBroj,min,sec);

}

fprintf(izlaz,"\n");

}

fclose(ulaz);

fclose(izlaz);

}



Zadatak 1.

Napisati program na programskom jeziku C koji u jednostruko ulančanoj listi tačaka pronalazi onu tačku koja je centar

najmanjeg kruga od svih krugova koji obuhvataju sve tačke. Posmatraju se samo oni krugovi kojima je centar u nekoj od tačaka iz date ulančane liste. Koordinate tačaka se unose preko standardnog ulaza kao uređeni parovi realnih

brojeva. Podatke treba čitati sve dok se na ulazu ne pojavi koordinatni početak koji se ne stavlja u ulančanu listu.

Učitavanje, obradu i ispis rezultata realizovati kao tri zasebna potprograma koji sa glavnim programom komuniciraju isključivo preko liste argumenata i povratne vrednosti. Ukoliko postoji više tačaka koje zadovoljavaju zadati kriterijum,

navesti samo prvu. Voditi računa o korektnoj upotrebi dinamičke memorije.

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

typedef struct elem { float x, y; float max_distanca;

struct elem* sled; } Elem;

Elem* ucitaj () {

Elem *prvi = NULL, *novi; float x, y;

printf("Unesite koordinate tacaka:\n");

while(1) {

scanf("%f%f", &x, &y); if (x==0 && y==0) break;


if (novi == NULL) {

printf("Greska u alokaciji dinamicke memorije!\n");

exit(1);

}

novi->x = x;

novi->y = y;

novi->max_distanca = 0;

novi->sled = prvi;

prvi = novi;

}

return prvi;

}

void obradi (Elem *prvi) {

Elem *tek1, *tek2;

tek1 = prvi;

while (tek1) {

tek2 = prvi;

while (tek2) {

float dist = sqrtf((tek1->x - tek2->x)*(tek1->x - tek2->x) +

(tek1->y - tek2->y)*(tek1->y - tek2->y));

if (dist > tek1->max_distanca) tek1->max_distanca = dist;

tek2 = tek2->sled;

}

tek1 = tek1->sled;

}

}

void ispisi (Elem *prvi) {

Elem *tek = prvi, *min = NULL;

if (!prvi) return;

if (tek) { min = tek; tek = tek->sled; }

while(tek) {

if (tek->max_distanca < min->max_distanca) min = tek; tek = tek->sled;

}

printf("Tacka koja je centar najmanjeg kruga koji obuhvata sve tacke je

(%2.2f,%2.2f)\n", min->x, min->y);

printf("Poluprecnik takvog kruga je: %2.2f\n", min->max_distanca);

}


void brisi (Elem *prvi) {

Elem *stari;

while(prvi) {

stari = prvi;

prvi = prvi->sled;

free(stari);

}

}

void main () {

Elem *prvi = NULL;

prvi = ucitaj();

obradi(prvi);

ispisi(prvi);

brisi(prvi);

}



Zadatak 1.

Napisati potprogram na programskom jeziku C koji u zadatom nizu znakova zamenjuje sve pojave arapskih cifara

odgovarajućim rimskim ciframa. Ukoliko se više cifara nalaze jedna za drugom, potrebno ih je razdvojiti znakom "-". Napisati program na programskom jeziku C koji čita sadržaj datoteke ulaz.txt, poziva opisani potprogram za svaki red

ulazne datoteke i rezultat upisuje u datoteku izlaz.txt. Smatrati da jedan red ulazne datoteke nije duži od 80 znakova,

a da rezultujući string ne može biti duži od 255 znakova. Komunikaciju između glavnog programa i funkcije obavljati

isključivo putem argumenata i povratne vrednosti.

#include <stdio.h>

#include <string.h>

#define MAX_LINE 80

#define MAX_STR 255

void pomeri (char *string, int pomeraj) {

int n = strlen(string), i;

for (i = n + 1; i >= 0; i--)

string[i + pomeraj] = string[i];

}

void tranformisi (char *string) {

int i, ind = 0, pomeraj;

while (*string) {

if (*string >= '0' && *string <= '9') {

if (ind) {

pomeri(string, 1);

*string = '-';

string++;

}

switch(*string) {

case '1': *string = 'I'; break;

case '2': pomeri(string, 1); *string++ = 'I'; *string = 'I'; break;

case '3': pomeri(string, 2); *string++ = 'I'; *string++ = 'I';

*string = 'I'; break;

case '4': pomeri(string, 1); *string++ = 'I'; *string = 'V'; break;

case '5': *string = 'V'; break;

case '6': pomeri(string, 1); *string++ = 'V'; *string = 'I'; break;

case '7': pomeri(string, 2); *string++ = 'V'; *string++ = 'I';

*string = 'I'; break;

case '8': pomeri(string, 3); *string++ = 'V'; *string++ = 'I';

*string++ = 'I'; *string = 'I'; break;

case '9': pomeri(string, 1); *string++ = 'I'; *string = 'X'; break;

}

ind = 1;

}

else ind = 0;

string++;

}

}

void main () {

FILE *ulaz, *izlaz;

char string[MAX_STR];

ulaz = fopen("ulaz.txt", "r");

izlaz = fopen("izlaz.txt", "w");

if (ulaz == NULL || izlaz == NULL) {

printf("Greska prilikom otvaranja datoteke!");

exit(1);

}


while (fgets(string, 80, ulaz) != NULL) {

tranformisi(string);

fputs(string, izlaz);

}

fclose(ulaz);

fclose(izlaz);

}



Zadatak 2.

Napisati program na programskom jeziku C koji vrši određenu obradu nad tekst datotekom koja predstavlja plejlistu

muzičkih numera. Svaki red ulazne i izlazne datoteke sadrži podatke o jednoj muzičkoj numeri po sledećem formatu: naziv numere (najviše 255 znakova i može sadržati blanko znake) i trajanje numere u formatu mm:ss, gde su mm

minuti, a ss sekunde. Program treba da pročita ulaznu datoteku, a zatim jedan ceo broj length koji predstavlja dužinu

nove plejliste u sekundama. Program treba da na osnovu učitanih podataka formira novu plejlistu čije ukupno trajanje neće biti duže od zadate dužine length. Novu plejlistu formirati tako da u nju stane što više numera. Redosled numera

u novoj plejlisti nije bitan. Imena ulazne i izlazne datoteke se zadaju kao prvi i drugi argument komandne linije. Voditi

računa o korektnoj upotrebi zauzetih resursa.

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#define MAXLINE 300


char numera[256];

unsigned int length;

struct elem *sled;

} Elem;

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

FILE *ulaz, *izlaz;

unsigned int mm, ss, length, trajanje;

char linija[MAXLINE];

Elem *prvi, *tek, *preth, *novi;

ulaz = fopen(argv[1], "r");

izlaz = fopen(argv[2], "w");

if (ulaz == NULL || izlaz == NULL) {

printf("Neuspesno otvaranje datoteke!"); exit(1);

}

prvi = NULL;

// Citanje i smestanje u listu sortirano po duzini

while (fgets(linija, MAXLINE, ulaz) != NULL) {

int i = strlen(linija) - 1;

while (linija[i] != ' ') i--;

sscanf(linija + i, "%d:%d", &mm, &ss);

novi = malloc(sizeof(Elem)); if (novi == NULL) exit(2);

novi->sled = NULL;

novi->length = mm * 60 + ss;

strncpy(novi->numera, linija, i);

novi->numera[i] = '\0';

tek = prvi;

preth = NULL;

while(tek != NULL) {

if (tek->length > novi->length) break;

preth = tek;

tek = tek->sled;

}

if (preth == NULL) {

novi->sled = prvi;

prvi = novi;

}

else {

novi->sled = tek;

preth->sled = novi;

}

}


printf("Unesite duzinu nove plejliste: ");

scanf("%d", &length);

// Obrada

tek = prvi;

trajanje = 0;


trajanje += tek->length;

if (trajanje > length) break;

mm = tek->length / 60;

ss = tek->length % 60;

fprintf(izlaz, "%s %d:%d\n", tek->numera, mm, ss);

tek = tek->sled;

}

// Dealokacija liste

preth = NULL;

while(prvi) {

preth = prvi;

prvi = prvi->sled;

free(preth);

}

fclose (ulaz);

fclose (izlaz);

return 0;

}



Zadatak 1.

Napisati na programskom jeziku C potprogram koji u zadatom nizu celih (pozitivnih i negativnih) brojeva pronalazi

najduži podniz čija je aritmetička sredina veća ili jednaka zadatom broju K. Podniz sadrži uzastopne elemente početnog podniza. Potprogram vraća indeks početka nađenog podniza, kao i njegovu dužinu. Napisati i glavni program

koji sa standardnog ulaza najpre učita dužinu niza i elemente, zatim pozove dati potprogram i na kraju na standardni

izlaz ispiše elemente pronađenog podniza. Potprogram sa glavnim programom komunicira isključivo pomoću

argumenata i povratne vrednosti.

#include <stdio.h>

#include <stdlib.h>

void pronadji(int* niz, int n, int* indeks,int *duzina){

int i,j,k,max_duz = 0, ind = -1;

double sum;

printf("Broj K?\n");

scanf("%d",&k);

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

sum = 0;

for (j = 0;j < n - i;j++){

sum += niz[i + j];

if (sum/(j+1) > k && (j+1) > max_duz){

max_duz = j+1;

ind = i;

}

}

}

*indeks = ind;

*duzina = max_duz;

}

int main(){

int *niz,n,i;

int rezultat, duzina;

printf("Broj elemenata niza?\n");

scanf("%d",&n);

niz = calloc(n,sizeof(int));

if (NULL == niz){

printf("Greska: Nema memorije!\n");

return 1;

}

printf("Elemenati niza?\n");

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

scanf("%d",&niz[i]);

pronadji(niz,n,&rezultat,&duzina);

if (duzina < 1){

printf("Nema takvog podniza!\n");

return 0;

}

printf("Pronadjeni podniz:\n");

for (i = rezultat;i < rezultat + duzina;i++)

printf("%d ",niz[i]);

putchar('\n');

free(niz);

return 0;

}



Zadatak 1.

Napisati program na programskom jeziku C koji vrši obradu nad kvadratnom matricom dimenzije NxN (N≤20).

Program najpre treba da učita N, a zatim i elemente matrice, tako da je svaka vrsta u posebnom redu. Nakon učitavanja, program treba proveri da li je element na poziciji (i,j) iznad glavne dijagonale veći od elementa na poziciji

(j,i) ispod glavne dijagonale matrice i ukoliko jeste, zameni im mesta. Nakon obrade, ispisati rezultujuću matricu na

standardni izlaz. Obradu matrice realizovati u potprogramu koji sa glavnim programom komunicira isključivo pomoću

argumenata i povratne vrednosti.

#include <stdio.h>

#define MAX 20

void obrada (int a[][MAX], int dim) {

int i, j, t;

for (i = 1; i < dim; i++)

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

if (a[i][j] < a[j][i]) {

t = a[i][j]; a[i][j] = a[j][i]; a[j][i] = t;

}

}

int main () {

int a[MAX][MAX], i, j, n;

printf ("Unesite dimenziju matrice: ");

scanf ("%d", &n);

if ((n <= 0) || (n > MAX)) return 1;

printf("Unesite elemente matrice: \n");

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

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

scanf("%d", &a[i][j]);

obrada(a, n);

printf("Rezultujuca matrica: \n");

for(i = 0; i < n; printf("\n"), i++)

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

printf("%d ", a[i][j]);

return 0;

}



Zadatak 2.

Napisati na programskom jeziku C program koji računa maksimalnu promenu srednje vrednosti nekretnina između dva susedna meseca. U tekstualnoj datoteci nekretnine.txt se nalaze podaci o vrednosti nekretnina po danima. U

jednom redu datoteke se nalazi datum (u formatu dd.mm.gggg.) i cena nekretnina na taj dan (realan broj). Podaci u

datoteci su zadati u proizvoljnom redosledu (nisu sortirani po datumu). Smatrati da će podaci obuhvatiti sve mesece u nekom periodu, tj. da će za svaki mesec tog perioda postojati cena nekretnina za bar jedan dan. Program najpre treba

da izračuna prosečnu mesečnu vrednost nekretnina po svim danima datog meseca za koje postoje podaci, za svaki mesec u datom periodu. Zatim za svaka dva uzastopna meseca treba odrediti promenu prosečne vrednosti nekretnina

kao apsolutnu vrednost razlike prosečnih vrednosti nekretnina za ta dva meseca. Na kraju treba naći maksimalnu

promenu srednje vrednosti nekretnina u dva susedna meseca za period za koji su dati podaci u datoteci. Voditi računa

o korektnoj upotrebi zauzetih resursa.

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

struct nekretnina{

int dd,mm,yy;

double price;

};

struct elem{

struct nekretnina day;

struct elem* next;

};

#define INORDER 1

#define OUTORDER -1

#define EQUAL 0

int compare(struct nekretnina d1, struct nekretnina d2){

if (d1.yy < d2.yy) return INORDER;

if (d1.yy > d2.yy) return OUTORDER;

if (d1.mm < d2.mm) return INORDER;

if (d1.mm > d2.mm) return OUTORDER;

if (d1.dd < d2.dd) return INORDER;

if (d1.dd > d2.dd) return OUTORDER;

return EQUAL;

}

void main(){

FILE* input;

struct elem* list = NULL, *cur1, *cur2;

struct nekretnina tmp;

double avg_month1,avg_month2,max;

int n_month1, n_month2, last_mm, last_yy;

input = fopen("nekretnine.txt", "r");

if (NULL == input){

printf("Greska: Ne moze da se otvori datoteka\n"); return;

}

while(EOF != fscanf(input,"%d.%d.%d.

%lf",&tmp.dd,&tmp.mm,&tmp.yy,&tmp.price)) {

struct elem* novi = malloc(sizeof(struct elem));

if (NULL == novi){

printf("Greska: Ne moze da se dodeli memorija\n");

return;

}

novi->day = tmp;

novi->next = list;

list = novi;

}


fclose(input);

for (cur1 = list;NULL != cur1;cur1 = cur1->next)

for (cur2 = cur1->next;NULL != cur2;cur2 = cur2->next)

if (OUTORDER == compare(cur1->day, cur2->day)){

tmp = cur1->day;

cur1->day = cur2->day;

cur2->day = tmp;

}

n_month2 = 0; last_mm = 0;

avg_month2 = max = 0;

for (cur1 = list;NULL != cur1;cur1 = cur1->next){

tmp = cur1->day;

if (0 == n_month2 || (tmp.mm == last_mm && tmp.yy == last_yy)){

n_month2++;

avg_month2 += tmp.price;

}

else{

if (0 != last_mm){

if (max < fabs(avg_month1/n_month1 –

avg_month2/n_month2))

max = fabs(avg_month1/n_month1 –

avg_month2/n_month2);

}

avg_month1 = avg_month2;

n_month1 = n_month2;

avg_month2 = tmp.price;

n_month2 = 1;

last_mm = tmp.mm;

last_yy = tmp.yy;

if (NULL == cur1->next){

if (max < fabs(avg_month1/n_month1 –

avg_month2/n_month2))

max = fabs(avg_month1/n_month1 –

avg_month2/n_month2);

}

}

}

if (n > 0)

printf("Maks je %.2f.\n",max);

for (cur1 = list;NULL != cur1;){

cur2 = cur1;

cur1 = cur1->next;

free(cur2);

}

}



Zadatak 1.

Napisati program na programskom jeziku C za izračunavanje plata radnika u skladu sa njihovim učinkom. Učinak

svakog radnika se zadaje kao jedan red matrice. Element matrice (i,j) je vreme zapisano kao realan broj sati koje je radnik i proveo radeći na aktivnosti j. Cene radnih sati za aktivnosti se zadaju nizom realnih brojeva. Element sa

indeksom j je cena radnog sata aktivnosti j. Na početku, program sa standardnog ulaza pročita broj radnika, kao i broj

različitih aktivnosti, a potom učita niz sa cenama radnih sati aktivnosti i matricu sa učinkom radnika. Potom, program izračuna plate svih radnika i iz niza izbaci plate koje su ispod prosečne plate za taj mesec. Na kraju, program ispiše

iznose plata koje nisu izbačene iz niza. Za potrebe računanja plata napisati potprogram koji kao rezultat vraća niz sa iznosima plata svih radnika. Program sa potprogramom komunicira isključivo preko argumenata i povratne vrednosti

potprograma. Prilikom implementacije nije dozvoljeno koristiti pomoćne nizove. Voditi računa o pravilnom rukovanju

korišćenim resursima.

#include <stdio.h>

#include <stdlib.h>

void izracunaj (float** sati, float* cene, float* plate, int broj_radnika,

int broj_aktivnosti) {

int i, j;

float sum = 0;

for (i=0; i<broj_radnika; i++) {

sum = 0;

for (j=0; j<broj_aktivnosti; j++) {

sum += sati[i][j]*cene[j];

}

plate[i] = sum;

}

}

void main () {

float **sati, *cene, *plate, avg = 0;

int broj_radnika, broj_aktivnosti, i, j;

printf ("Unesite broj radnika i broj aktivnosti na kojima oni rade:\n");

scanf ("%d%d", &broj_radnika, &broj_aktivnosti);

if (broj_radnika <= 0 || broj_aktivnosti <= 0) {

printf("Nekorektni ulazni podaci!\n");

exit(1);

}

sati = (float**) malloc (broj_radnika*sizeof(float*));

cene = (float*) malloc (broj_aktivnosti*sizeof(float));

plate = (float*) malloc (broj_radnika*sizeof(float));

if (sati == NULL || cene == NULL || plate == NULL) {

printf("Neuspesna alokacija memorije!\n");

exit(2);

}

for (i=0; i<broj_radnika; i++) {

sati[i] = (float*) malloc (broj_aktivnosti*sizeof(float));

if (sati[i] == NULL) {

printf("Neuspesna alokacija memorije!\n");

exit(2);

}

printf ("Unesite brojeve sati po aktivnostima za %d. radnika:\n", i+1);

for (j=0; j<broj_aktivnosti; j++) {

scanf ("%f", &sati[i][j]);

if (sati[i][j] < 0) {

printf("Nekorektni ulazni podaci!\n");

exit(1);

}

}

}


for (i=0; i<broj_aktivnosti; i++) {

printf("Unesite cenu radnog sata za %d. aktivnost:\n", i+1);

scanf("%f", &cene[i]);

if (cene[i] <= 0) {

printf("Nekorektni ulazni podaci!\n"); exit(1);

}

}

izracunaj(sati, cene, plate, broj_radnika, broj_aktivnosti);

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

avg += plate[i];

if (broj_radnika > 0)

avg /= broj_radnika;

for (i = j = 0; i<broj_radnika; i++) {

if (plate[i] >= avg)

plate[j++] = plate[i];

}

broj_radnika = j;

printf("Plate radnika koje su iznad proseka:\n");

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

printf("%f ", plate[i]);

for (i=0; i<broj_radnika; i++) free (sati[i]); free (sati);

free(cene); free(plate);

}



Zadatak 2.

Napisati program na programskom jeziku C za poređenje dva teksta. U datotekama original.txt i kopija.txt se nalaze

tekstovi koji se porede. Program na standardnom izlazu treba da ispiše broj reči koje su iste u oba teksta, broj reči koje postoje u originalu ali ne postoje u kopiji i broj reči koje postoje u kopiji ali ne postoje u originalu. Ukoliko se

jedna reč pojavi N puta u originalu i M puta u kopiji, računa se na sledeći način. Ukoliko je N jednako M, tada se

računa da je to N istih reči. Ukoliko je N veće od M, tada se računa da ima M istih reči, dok original ima N-M reči koje ne postoje u kopiji. Analogno, ako je N manje od M, tada ima N istih reči, dok ima M-N reči koje se pojavljuju samo u

kopiji. Reč je neprekidni niz od maksimalno 30 slova. Prilikom poređenja reči zanemariti razliku u malim i velikim slovima. Voditi računa o pravilnom rukovanju korišćenim resursima. Nije dozvoljeno ponavljati čitanje bilo koje od dve

datoteke.

#include <stdio.h>

#include <stdlib.h>

#include <ctype.h>

#include <string.h>

#define MAX 30

enum Status {WORD, WORDEND, END};

typedef char Rec[MAX + 1];

struct elem {

Rec rec;

int broj;

struct elem *next;

};

enum Status ucitaj_rec(FILE *input, Rec rec) {

char z;

int i;

i = 0;

while (1) {

z = fgetc(input);

if (EOF == z) {

rec[i] = '\0';

return END;

}

if (isalpha(z)) {

rec[i++] = tolower(z);

break; } }

while (1) {

z = fgetc(input);

if (EOF == z) {

rec[i] = '\0';

return WORDEND;

}

if (isalpha(z)) {

rec[i++] = tolower(z);

}

else {

rec[i] = '\0';

return WORD; } } }


struct elem *ucitaj(FILE *input) {

struct elem *lista, *tek, *novi;

int radi;

Rec rec;

radi = 1;

lista = NULL;

while (radi) {

switch(ucitaj_rec(input, rec)) {

case WORDEND: radi = 0;

case WORD:

for (tek = lista; NULL != tek; tek = tek->next)

if (!strcmp(tek->rec, rec)) {

tek->broj++;

break; }

if (NULL == tek) {

novi = malloc(sizeof(struct elem));

if (NULL == novi)

exit(1);

strcpy(novi->rec, rec);

novi->broj = 1;

novi->next = lista;

lista = novi; }

break;

case END: radi = 0;

break; } }

return lista; }

void obradi(struct elem *lista, FILE *kopija) {

int isti, org, kpj, radi;

Rec rec;

struct elem *tek;

isti = org = kpj = 0;

radi = 1;

while (radi) {

switch(ucitaj_rec(kopija, rec)) {

case WORDEND: radi = 0;

case WORD:


if (!strcmp(tek->rec, rec)) {

if (tek->broj > 0) {

tek->broj--;

isti++;

break;

}

}

if (NULL == tek)

kpj++;

break;

case END: radi = 0;

break;

}

}


org += tek->broj;

printf("isto - %d\norginal - %d\nkopija - %d\n", isti, org, kpj);

}


void obrisi(struct elem *lista) {

struct elem *stari;

while (NULL != lista) {

stari = lista;

lista = lista->next;

free(stari); } }

void main () {

FILE *org, *kpj;

struct elem *lista;

org = fopen("original.txt", "r");

kpj = fopen("kopija.txt", "r");

if (NULL == org || NULL == kpj)

exit(1);

lista = ucitaj(org);

obradi(lista, kpj);

obrisi(lista);

fclose(org); fclose(kpj);

}



Zadatak 1.

Napisati funkciju na programskom jeziku C hexByteToDec, kojoj se predaje string čiji je sadržaj predstava

označenog celog broja u komplementu dvojke na širini od 8 bita u heksadecimalnom sistemu. Povratna vrednost funkcije je označeni ceo broj, čijoj predstavi odgovara dati string. Heksadecimalne cifre koje koriste slovne oznake se

mogu predstavljati i pomoću velikih i pomoću malih slova. Ukoliko string sadrži znak koji nije heksadecimalna cifra,

konverziju izvršiti na osnovu dozvoljenih uzastopnih heksadecimalnih cifara koje se nalaze ispred njega, a ostatak zanemariti. Suvišne heksadecimalne cifre takođe zanemariti, imajući u vidu da se radi o osmobitnoj predstavi. Ukoliko

string počinje znakom koji nije heksadecimalna cifra, funkcija treba da vrati vrednost nula. Napisati glavni program koji, koristeći opisanu funkciju, izvrši konverziju argumenata komandne linije u dekadne brojeve i ispiše ih na

standardnom izlazu. Ukoliko komandna linija ne sadrži podatke za konverziju, prekinuti izvršavanje programa.

Učitavanje bilo kakvih podataka sa standardnog ulaza nije dozvoljeno. Primer ulaza i izlaza se nalazi na stranici sa

uputstvom.

#include "stdio.h"

/*

Converts a number which is given by its reperesentation in 2's complement

into a signed byte

*/

signed char hexToDec(const char* string){

const char* c = string;

signed char num = 0;

int i=0;

while(i<2){

int digit = 0;

// skip spaces - mandatory

while(*c && *c==' ') c++;

if(!*c) break; // stop if the end of string is reached

// Checking if c is hex digit

if(*c<='9' && *c>=0)

// calucalating the number corresponding to that digit

digit = *c - '0'; // value 0-9

else if(*c<='F' && *c>='A')

digit = *c - 'A' + 10; // value 10-15

else if(*c<='f' && *c>='a')

digit = *c - 'a' + 10; // value 10-15

else break; // stopping if c is not hex digit

// appending the representation of hex digit placed in c to binary

// representation of the number

num <<= 4; num |= digit;

i++; c++; // move through the loop and the string

}

return num;

// Other possibilities: int hexToDec(...) etc

// but it requires to perform a manual (explicit) 2's complement

// transformation of representaiton of a negative number into

// a negative integer val(ret= ret&0x8000 ? ~ret+1 : ret)

}

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

if(argc == 1) return 1;

argv++;

for(; *argv; argv++)

printf("%s = %d\n", *argv, hexToDec(*argv));

return 0;

}



Zadatak 1.

Na programskom jeziku C napisati funkciju kodiraj, kojoj se kao argumenti predaju string koji treba kodirati i niz

kodnih zapisa koji se koriste za kodiranje. Svaki kodni zapis se sastoji od jednog slova i jedne reči kojom se slovo zamenjuje prilikom kodiranja. Smatrati da u nizu kodnih zapisa ne postoje dva zapisa za isto slovo. String se kodira

tako što se svako slovo zameni odgovarajućom reči iz kodnog zapisa. Ako za neko slovo ne postoji kodni zapis, to

slovo se ne menja prilikom kodiranja. Funkcija kao rezultat vraća novi string koji sadrži rezultat kodiranja. Napisati glavni program koji, koristeći opisanu funkciju, kodira string koji se učitava sa standardnog ulaza. Niz kodnih zapisa se

učitava sa standardnog ulaza, tako što se u svakom redu navodi prvo jedno slovo, a zatim posle znaka razmaka i jedna reč koja predstavlja zamenu (sa najviše 10 slova). Potprogram sa glavnim programom komunicira isključivo

putem argumenata i povratne vrednosti. Voditi računa o korektnom upravljanju korišćenim resursima.

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#define MAX_REC 30

#define MAX_STR 255

#define SLOVA 26

struct zamena {

char zamena[MAX_REC];

int duzina;

};

int indeks(char a);

char *kodiraj(char *str, struct zamena niz[SLOVA]);

void main() {

char str[MAX_STR], rec[MAX_REC], linija[MAX_STR], slovo, *rezultat;

struct zamena niz[SLOVA];

int i;

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

niz[i].duzina = 0;

scanf("%s%*c",rec);

if (strcmp(rec,"String:") != 0){

printf("Greska u ulaznom fajlu");

exit(-1);

}

fgets(str, MAX_STR, stdin);

str[strlen(str) - 1] = '\0';

fgets(linija, MAX_STR, stdin);

linija[strlen(linija) - 1] = '\0';

if (strcmp(linija,"Niz kodnih zapisa:") != 0){

printf("Greska u ulaznom fajlu");

exit(-1);

}

do{

fgets(linija, MAX_STR, stdin);

if (strlen(linija) <= 1)

break;

sscanf(linija, "%c %s", &slovo, rec);

niz[indeks(slovo)].duzina = strlen(rec);

strcpy(niz[indeks(slovo)].zamena, rec);

}while(1);

rezultat = kodiraj(str, niz);

printf("%s\n", rezultat);

free(rezultat);

}


int indeks(char a)

{

if (a < 'a' || a > 'z') {

printf("Greska nije malo slovo");

exit(-1);

}

return a - 'a';

}

char *kodiraj(char *str, struct zamena niz[SLOVA])

{

char *ret, *tmp;

int i, duz;

ret = NULL;

duz = strlen(str) + 1;

ret = realloc(ret,duz*sizeof(char));

if (NULL == ret) {

printf("Greska prilikom alokacije memorije");

exit(-1);

}

i = 0;

while (*str) {

if (*str == ' ' || niz[indeks(*str)].duzina == 0){

ret[i++] = *str;

}

else

{

duz += niz[indeks(*str)].duzina - 1;

ret = realloc(ret,duz*sizeof(char));

tmp = niz[indeks(*str)].zamena;

while (*tmp)

ret[i++] = *tmp++;

}

str++;

}

ret[i] = '\0';

return ret;

}


P2, ispit, januar 2015.

Zadatak 2.

Napisati program na programskom jeziku C koji pronalazi sve krugove u ravni koji nemaju preklapanja ni sa

jednim drugim krugom i među njima pronalazi i ispisuje površinu najvećeg kruga. Podaci o krugovima dati su u obliku tri niza, gde odgovarajući elementi niza predstavljaju: x koordinatu centra kruga, y koordinatu centra

kruga i poluprečnik kruga. Napisati potprogram koji izbacuje iz nizova sve krugove koji imaju preklapanja, kao i

potprogram koji nalazi najveću površinu kruga. Napisati glavni program koji učita broj krugova, zatim koordinate i poluprečnik za svaki krug iz posebnog reda, zatim poziva navedene potprograme i na kraju za svaki krug koji nije

izbačen ispiše podatke u posebnom redu. Zatim treba ispisati površinu najvećeg kruga. Potprogrami sa programom

komuniciraju isključivo preko argumenata i povratne vrednosti potprograma.

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

int preklapanje(double x1, double y1, double r1,

double x2, double y2, double r2) {

if (sqrt(pow(x1 - x2, 2) + pow(y1 - y2, 2)) > r1 + r2) return 0;

return 1;

}

void izbaci(int *nn, double **xx, double **yy, double **rr) {

int n = *nn, *izbaciti, i, j;

double *x = *xx, *y = *yy, *r = *rr;

izbaciti = (int *)calloc(n, sizeof(int));

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

if (izbaciti[i]) continue;

for (j = i + 1; j < n;j++) {

if (i == j) continue;

if (preklapanje(x[i], y[i], r[i], x[j], y[j], r[j])) {

izbaciti[i] = 1;

izbaciti[j] = 1;

break;

}

}

}

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

if (!izbaciti[i]) {

x[j] = x[i];

y[j] = y[i];

r[j] = r[i];

j++;

}

n = j;

*xx = realloc(x, n*sizeof(double));

*yy = realloc(y, n*sizeof(double));

*rr = realloc(r, n*sizeof(double));

*nn = n;

free(izbaciti);

}

#define PI (3.14)

double najveci_krug(int n, double *x, double *y, double *r) {

int i;

double max = 0;

if (n < 1) return 0;

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

double p = pow(r[i], 2) * PI;

if (p > max) max = p;

}

return max;

}


void main() {

double *x, *y, *r;

int i, n;

double maxP;

scanf("%d", &n);

x = calloc(n, sizeof(double));

y = calloc(n, sizeof(double));

r = calloc(n, sizeof(double));

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

scanf("%lf %lf %lf", &x[i], &y[i], &r[i]);

izbaci(&n, &x, &y, &r);

maxP = najveci_krug(n, x, y, r);

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

printf("(%.2f, %.2f) %.2f\n", x[i], y[i], r[i]);

printf("MaxP = %.2f\n", maxP);

free(x); free(y); free(r);

}



Zadatak 2.

U tekstualnoj datoteci univerziteti.txt nalazi se spisak univerziteta. U svakom redu zapisan je naziv univerziteta (reč do

30 znakova), a zatim i četiri cela broja koji predstavljaju faktore prisutnosti, uticaja, otvorenosti i izuzetnosti. Univerziteti se rangiraju po dve metodologije, staroj i novoj. Za svaki univerzitet, pored osnovnih podataka u datoteci,

u listi treba dodatno čuvati i sledeće podatke: poene i rang po staroj metodologiji, kao i poene i rang po novoj

metodologiji rangiranja. Po staroj metodologiji rangiranja, uticaji pojedinih faktora na bodove redom iznose 20%, 50%, 15% i 15%. Po novoj metodologiji rangiranja, prvi faktor na bodove utiče sa 1/2, dok ostala tri utiču sa po 1/6.

Napisati potprogram koji za zadate faktore i uticaje faktora računa broj bodova za jedan univerzitet. Koristeći prethodni potprogram, napisati potprogram koji pročita podatke o univerzitetima iz datoteke u dinamičku listu i za

svaki univerzitet izračuna broj bodova po obe metodologije. Potom napisati potprogram koji za svaki univerzitet u listi

odredi rang (redni broj, na osnovu već izračunatih poena) po obe metodologije. Najbolji univerzitet je onaj koji ima najmanje bodova. Potom napisati potprogram koji među svim univerzitetima nađe onaj/one čiji rang se najviše

povećao prelaskom na novu metodologiju rangiranja.Napisati i glavni program koji, pozivajući tražene potprograme, učita podatke o univerzitetima i formira listu sa bodovima univerziteta, zatim dopuni podatke o rangu svakog

univerziteta po obe metodologije, nađe univerzitet(e) čiji rang se najviše povećao prelaskom na novu metodologiju i naziv tog/tih univerziteta upiše u datoteku izlaz.txt. Voditi računa o pravilnom rukovanju korišćenim resursima. Sadržaj

ulaznih datoteka je dozvoljeno pročitati samo jednom, maksimalan broj redova u datotekama nije unapred poznat,

sme postojati samo jedna lista, dok redosled elemenata liste ne mora da bude isti kao u ulaznoj datoteci.

#include <stdio.h>

#include <stdlib.h>

#define NAME_LENGTH 30

#define NUM_FACTOR 4

enum method {OLD, NEW, NUM_METHOD};

const double factors [NUM_METHOD][NUM_FACTOR] = {{0.2, 0.5, 0.15, 0.15},

{0.5, 1./6, 1./6, 1./6}};

struct university {

char name[NAME_LENGTH + 1];

int factors[NUM_FACTOR];

double points[NUM_METHOD];

int rang[NUM_METHOD];

int max;

};

struct elem {

struct university data; struct elem *next;

};

void point_calc(struct university *u, enum method m) {

int i;

u->points[m] = 0;

for (i = 0; i < NUM_FACTOR; i++) {

u->points[m] += factors[m][i] * u->factors[i];

}

}

void delete(struct elem *list) {

struct elem *tek, *old;

for (tek = list; tek != NULL; ) {

old = tek; tek = tek->next; free(tek);

}

}


struct elem *read(FILE *in) {

struct university u;

struct elem *list = NULL;

while (fscanf(in, "%s", u.name) != EOF) {

int i, kraj;

struct elem *new;

enum method m;

kraj = 0;

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

if (EOF == fscanf(in, "%d", &u.factors[i])) kraj = 1;

if (kraj) break;

for (m = OLD; m < NUM_METHOD; m++)

point_calc(&u, m);

new = malloc(sizeof(struct elem));

if (NULL == new) break;

new->data = u;

new->next = list;

list = new;

}

return list;

}

void rang_calc(struct elem *list) {

struct elem *tek1, *tek2;

enum method m;

int i;

for (m = OLD; m < NUM_FACTOR; m++) {

for (tek1 = list; tek1 != NULL; tek1 = tek1->next)

for (tek2 = tek1->next; tek2 != NULL; tek2 = tek2->next)

if (tek1->data.points[m] > tek2->data.points[m]) {

struct university t;

t = tek1->data;

tek1->data = tek2->data;

tek2->data = t;

}

i = 0;

for (tek1 = list; tek1 != NULL; tek1 = tek1->next)

tek1->data.rang[m] = i++;

}

}

int rang_delta(struct university *u) {

int ret;

ret = u->rang[NEW] - u->rang[OLD];

return ret;

}

void max_calc(struct elem *list) {

struct elem *tek;

int max;

max = 0;

for (tek = list; tek != NULL; tek = tek->next) {

int delta = rang_delta(&tek->data);

tek->data.max = 0;

if (max < delta) max = delta;

}

for (tek = list; tek != NULL; tek = tek->next)

if (max == rang_delta(&tek->data)) tek->data.max = 1;

}


void print(FILE *out, struct elem *list) {

struct elem *tek;

for (tek = list; tek != NULL; tek = tek->next)

if (tek->data.max == 1)

fprintf(out, "%s\n", tek->data.name);

}

int main() {

FILE *in, *out;

struct elem *list = NULL;

in = fopen("univerziteti.txt", "r");

if (NULL == in) exit(1);

list = read(in);

fclose(in);

rang_calc(list);

max_calc(list);

out = fopen("izlaz.txt", "w");

if (NULL == out) exit(1);

print(out, list);

fclose(out);

delete(list);

return 0;

}



Zadatak 2.

U svakom redu datoteke korisnici.txt zapisani su podaci o jednom korisniku i to po sledećem formatu: korisničko ime

i email adresa, razdvojeni jednim blanko znakom. Korisničko ime, kao i email adresa su jedinstveni podaci i pojavljuju se u najviše jednom redu. U svakom redu datoteke log.txt nalaze se podaci o istoriji prijavljivanja i odjavljivanja

korisnika u sistem i to u sledećem formatu: korisničko ime, akcija, vreme. Akcija može imati vrednosti: „p“ ili „o“ čime

se govori da se korisnik prijavio ili odjavio sa sistema, dok je vreme ceo broj i predstavlja trenutak u kome se akcija izvršila. Jedan korisnik se može više puta prijaviti i odjaviti sa sistema. Napisati potprogram koji formira listu

korisnika tako što dodaje svakog pročitanog korisnika iz prve datoteke u listu. Zatim napisati potprogram za učitavanje podataka iz druge datoteke i ažuriranje liste na osnovu korisničkog imena. Za svaki element liste se pamti

poslednja akcija tog korisnika, trenutak te akcije i ukupno vreme boravka korisnika u sistemu. Koristeći

implementirane potprograme napisati program koji ispisuje email adresu korisnika koji je proveo najviše vremena u

sistemu. Ukoliko ima više takvih korisnika, ispisati email adrese svih njih. Voditi računa o korektnoj upotrebi resursa.

korisnici.txt log.txt Izlaz milan [email protected]

zoran [email protected]

ana [email protected]

milan p 10

zoran p 20

milan o 30

zoran o 35

milan p 40

milan o 60

ana p 50

ana o 90

[email protected] [email protected]

#include<stdio.h>

typedef struct e{

char *ime; char *email;

int vremePrijave;

int vreme;

struct e *sled;

} Elem;

char* citajRec(FILE *f) {

char *rec = malloc(10);

int zn, br = 0;

while ((zn = fgetc(f)) != EOF && zn == ' ');

do {

if (zn == ' ' || zn == '\n' || zn == EOF) break;

if (br % 10 == 0) rec = realloc(rec, br + 10);

// provera...

rec[br++] = zn;

} while ((zn = fgetc(f)) != EOF);

rec = realloc(rec, br+1);

// provera...

rec[br] = '\0';

if (br == 0) return NULL;

return rec;

}


Elem* formirajKorisnike(FILE *f) {

char *rec;

Elem *novi, *prvi = NULL;

while (1) {

if ((rec = citajRec(f)) == NULL) break;


// provera...

novi->sled = NULL;

novi->vremePrijave = 0;

novi->vreme = 0;

novi->ime = rec;

rec = citajRec(f);

novi->email = rec;

if (prvi != NULL) novi->sled = prvi;

prvi = novi;

}

return prvi;

}

void racunajVreme(FILE *f, Elem *prvi) {

char *rec;

Elem *tek;

while (1) {

if ((rec = citajRec(f)) == NULL) break;

tek = prvi;

while (tek) {

if (strcmp(rec, tek->email) == 0) {

rec = citajRec(f);

if (strcmp(rec, "p") == 0)

tek->vremePrijave = atoi(citajRec(f));

else

tek->vreme += atoi(citajRec(f)) - tek->vremePrijave;

break;

}

tek = tek->sled;

}

}

}

void main() {

Elem *prvi;

FILE *korisnici = fopen("korisnici.txt","r");

// provera...

FILE *log = fopen("log.txt", "r");

// provera...

prvi = formirajKorisnike(korisnici);

racunajVreme(log, prvi);

ispisiKorisnika(prvi);

brisiListu(prvi);

fclose(korisnici);

fclose(log);

}



Zadatak 1.

Napisati program na programskom jeziku C koji u dinamičkom nizu neoznačenih celih brojeva pronalazi i ispisuje sve

one elemente koji predstavljaju palindrom. Broj elemenata niza nije poznat unapred. Ceo broj predstavlja palindrom, ukoliko mu se bitska reprezentacija isto čita sleva na desno i sdesna na levo. Proveru da li ceo broj predstavlja

palindrom realizovati kao zaseban potprogram koji sa glavnim programom komunicira samo putem liste argumenata i

povratne vrednosti. Voditi računa o pravilnoj upotrebi korišćenih resursa.

#include <stdio.h>

#include <stdlib.h>

#include <limits.h>

typedef unsigned int Neoznaceni;

int bit_palindrom (Neoznaceni broj) {

Neoznaceni i, nbit, ind, mask1, mask2;

nbit = sizeof(Neoznaceni) * CHAR_BIT;

ind = 1;

mask1 = 1;

mask2 = 1 << (nbit - 1);

for(i = 0; i < nbit / 2; i++) {

ind = ((mask1 & broj) >> i) ==

((mask2 & broj) >> (nbit - 1 - i));

if (!ind) break;

mask1 <<= 1;

mask2 >>= 1;

}

return ind;

}

int main () {

Neoznaceni *niz, n, i;

printf("Unesite duzinu niza: ");

scanf("%d", &n);

if (n <= 0) {

printf("Nekorektna duzina niza!\n");

return 1;

}

niz = (Neoznaceni*) malloc(n * sizeof(Neoznaceni));

if (niz == NULL) {

printf("Neuspela alokacija dinamicke memorije!\n");

return 2;

}

printf("Unesite elemente niza: ");

for(i = 0; i < n; i++) scanf("%x", niz + i);

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

if (bit_palindrom(niz[i])) printf("%x ", niz[i]);

free(niz);

return 0;

}



Zadatak 2.

Napisati program na programskom jeziku C koji pomaže enigmatičaru u sastavljanju ukrštenih reči. U tekst datoteci

ukrstenica.txt se nalazi šema ukrštenice po sledećem formatu: u prvom redu se nalazi ceo broj N (N ≤ 20) koji predstavlja dimenziju ukrštenice, a u narednih N redova se u svakom redu nalazi N celih brojeva koji označavaju da li

je polje ukrštenice prazno (označava se nulom), gde se može pri popunjavanju ukrštenice upisati slovo, ili crni

kvadratić (označava se jedinicom), gde se ne može upisati slovo. Brojevi su razdvojeni jednim blanko znakom. U datoteci recnik.txt se nalazi spisak reči koje enigmatičar želi da upotrebi u sastavljanju ukrštenice, jedna reč u svakom

redu datoteke. Reči nisu duže od N karaktera. Program treba da na osnovu prve datoteke koja sadrži šemu ukrštenice utvrdi minimalnu i maksimalnu dozvoljenu dužinu reči koja se može smestiti u zadatu ukrštenicu po vertikali ili po

horizontali, a zatim na standardnom izlazu ispiše sve reči iz zadatog spiska čija dužina se nalazi između minimalne i

maksimalne dozvoljene dužine.

#include <stdio.h>

#include <string.h>

#define N 20

#define DODELA(a, b, c) (a) = ((b) != 0 && (b) c (a)) ? (b) : (a)

void minimax(int ukrstenica[][N], int n, int *min, int *max) {

int i, j, k, trduz;

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

trduz = 0;

for(j = 0; j < n;) {

while (ukrstenica[i][j++] == 0 && j < n) trduz++;

DODELA(*min, trduz, <);

DODELA(*max, trduz, >);

trduz = 0;

}

}

for(j = 0; j < n; j++) {

trduz = 0;

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

while (ukrstenica[i++][j] == 0 && i < n) trduz++;

DODELA(*min, trduz, <);

DODELA(*max, trduz, >);

trduz = 0;

}

}

}

int main () {

FILE *shema, *recnik;

int ukrstenica[N][N], i, j, n, min, max;

char rec[N];

if ((shema = fopen("ukrstenica.txt", "r")) == NULL) {

printf("Neuspelo otvaranje datoteke!\n");

return 1;

}

fscanf(shema, "%d", &n);

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

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

fscanf(shema, "%d", &ukrstenica[i][j]);

min = n; max = 0;

minimax(ukrstenica, n, &min, &max);

if ((recnik = fopen("recnik.txt", "r")) == NULL) {

printf("Neuspelo otvaranje datoteke!\n");

return 1;

}


while(fscanf(recnik, "%s", rec) > 0) {

int duz = strlen(rec);

if (min <= duz && duz <= max) printf("%s\n", rec);

}

fclose(shema);

fclose(recnik);

return 0;

}



Zadatak 1

Napisati program na programskom jeziku C koji vrši nadovezivanje ulaznih tekstualnih datoteka i rezultat upisuje u

izlaznu tekst datoteku. Sadržaj datoteke čine slova i beli znakovi (razmaci i znakovi za novi red). Ime izlazne datoteke se zadaje kao prvi argument komandne linije, dok se imena ulaznih datoteka zadaju kao preostali argumenti

komandne linije. Ulaznih datoteka može biti proizvoljno mnogo. Prilikom nadovezivanja teksta potrebno je izostaviti

sve prazne redove. Na kraju izlazne datoteke ispisati ukupan broj slova, belih znakova, linija teksta i ukupan broj prepisanih reči u izlaznu datoteku. Dužina jednog reda u ulaznim datotekama nije ograničena. Reč predstavlja

neprekidan niz slova.

#include <stdio.h>

#include <ctype.h>

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

FILE *ulaz, *izlaz;

int i, zn, trslovo, trrec, ukslova, ukbelih, uklinija, ukreci;

if (argc < 3) {

printf("Nedovoljan broj argumenata komandne linije!\n");

return 1;

}

if ((izlaz = fopen(argv[1], "w")) == NULL) {

printf("Neuspesno otvaranje izlazne datoteke!");

return 2;

}

ukslova = ukbelih = uklinija = ukreci = 0;

for(i = 2; i < argc; i++) {

if ((ulaz = fopen(argv[i], "r")) == NULL) {

printf("Neuspesno otvaranje ulazne datoteke!");

fclose(izlaz);

return 3;

}

trslovo = trrec = 0;

while ((zn = fgetc(ulaz)) != EOF) {

if (zn != '\n') trslovo++; // proverava postojanje jednog znaka u redu

if (trslovo) fputc(zn, izlaz);

ukbelih += (zn == ' '); // broji bele

if (isalpha(zn)) { // broji slova

ukslova++;

trrec++;

}

uklinija += trslovo > 0 && (zn == '\n'); // broji linije

if (zn == ' ' || zn == '\n') { // obrada reci

if (trrec > 0) {

ukreci++;

trrec = 0;

}

}

if (zn == '\n') trslovo = 0;

}

fputc('\n', izlaz);

uklinija++; // zbog obrade nakon EOF

if (trrec > 0) {

ukreci++;

trrec = 0;

}

fclose(ulaz);

}


fprintf(izlaz, "\nUkupno slova: %d\n", ukslova);

fprintf(izlaz, "Ukupno belih znakova: %d\n", ukbelih);

fprintf(izlaz, "Ukupno linija: %d\n", uklinija);

fprintf(izlaz, "Ukupno reci: %d", ukreci);

fclose(izlaz);

return 0;

}



Zadatak 1.

Napisati program na programskom jeziku C koji rešava jedan šahovski problem na tabli proizvoljnih dimenzija MxN.

Šahovska tabla se predstavlja pomoću dve matrice karaktera (jedna za pozicije belih, a druga za pozicije crnih figura) i može sadržati sledeće karaktere: K – kralj, D – dama, T – top, L – lovac, S – skakač, P – pešak i O – prazno polje.

Dimenzije table nisu poznate unapred, pa se mora vršiti dinamička alokacija memorije. Potrebno je odrediti i ispisati

pozicije svih skakača zadate boje, koji u narednom potezu mogu da „pojedu“ neku drugu figuru, kao i oznake i pozicije figura koje mogu da pojedu. Skakač može da se pomera na jedno od polja koje je najbliže polju na kome se

nalazi, a koje nije u istoj horizontali, vertikali ili dijagonali, kao na slici. Učitavanje table i obradu realizovati kao zasebne potprograme koji sa glavnim programom komuniciraju samo putem argumenata i povratnih vrednosti.

Prilikom učitavanja, obezbediti da se u matricu učitavaju samo dozvoljeni karakteri. Ukoliko se unese pogrešan

karakter, ponoviti unos. Voditi računa o ispravnom korišćenju dinamičke memorije.

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#define CHECK_ALLOC(x) if(!x) \

{ printf("Greska prilikom alokacije dinamicke memorije!"); exit(1);}

char **alociraj(int m, int n) {

char **mat;

int i;

mat = (char**)malloc(m * sizeof(char*));

CHECK_ALLOC(mat);

for (i = 0; i < m; i++) {

mat[i] = (char*)malloc(n * sizeof(char));

CHECK_ALLOC(mat[i]);

memset(mat[i], 'O', n * sizeof(char));

}

return mat;

}

void oslobodi(char **mat, int m) {

int i;

for (i = 0; i < m; i++) free(mat[i]);

free(mat);

}

void ucitaj(char **mat, int m, int n) {

int i, x, y, k;

char tip;

printf("Koliko figura zelite da unesete? ");

scanf("%d", &k);

for (i = 0; i < k; i++) {

do {

printf("Unesite poziciju i tip figure: ");

scanf("%d%d %c", &x, &y, &tip);

fflush(stdin);

if (x < 0 || x >= m) continue;

if (y < 0 || y >= n) continue;

if ((tip == 'K' || tip == 'D' || tip == 'T' ||

tip == 'L' || tip == 'S' || tip == 'P')) break;

} while (1);

mat[x][y] = tip;

}

}


int proveri(int posx, int posy, int m, int n) {

if (posx < 0 || posx >= m) return 0;

if (posy < 0 || posy >= n) return 0;

return 1;

}

void obrada(char **mat1, char **mat2, int m, int n) {

static const int pomeraj[][2] = {

{ 1,-2 }, { 2,-1 }, { 2,1 }, { 1,2 },

{ -1,2 }, { -2,1 }, { -2,-1 }, { -1,-2 }

};

int i, j, k;

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

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

if (mat1[i][j] == 'S')

for (int k = 0; k < 8; k++) {

int x = i + pomeraj[k][0], y = j + pomeraj[k][1];

if (proveri(x, y, m, n) && mat2[x][y] != 'O') {

printf("Skakac na (%d,%d)

moze da pojede %c na (%d,%d).\n",

i, j, mat2[x][y], x, y);

}

}

}

int main() {

char **beli, **crni, boja;

int m, n, i, j;

printf("Unesite dimenzije table: ");


beli = alociraj(m, n);

crni = alociraj(m, n);

printf("Ucitavanje pozicija belih figura.\n");

ucitaj(beli, m, n);

printf("Ucitavanje pozicija crnih figura.\n");

ucitaj(crni, m ,n);

fflush(stdin);

printf("Unesite boju skakaca za proveru (C ili B): ");

scanf(" %c", &boja);

if (boja == 'B') obrada(beli, crni, m, n);

else obrada(crni, beli, m, n);

oslobodi(beli, m);

oslobodi(crni, m);

return 0;

}



Zadatak 1.

Napisati program na programskom jeziku C koji pronalazi ljude koji neće dobiti poruku. Ljudi su međusobno povezani,

a svaki čovek može imati najviše dva prijatelja od poverenja kojima može preneti poruku. Sa standardnog ulaza se učitava broj ljudi N (N≤100). Ljudi su numerisani brojevima od 0 do N-1. Zatim se za svakog čoveka unose dva redna

broja prijatelja od poverenja sa kojima je u vezi i kojima posmatrani čovek može poslati poruku. Ukoliko neki prijatelj

ne postoji, unosi se vrednost -1. Uneti podaci moraju biti takvi da ako je osoba A prijatelj sa osobom B, onda je i osoba B prijatelj sa osobom A. Nakon unosa sa standardnog ulaza se unosi broj čoveka kojem se daje poruka da je

razglasi. Čovek koji primi poruku, posleđuje je prijateljima kojima može da pošalje poruku i oni dalje prosleđuju poruku prijateljima kojima mogu i tako dalje. Svaki čovek samo jednom prosleđuje poruku. Program treba da odredi i

ispiše sve ljude koji neće primiti poruku. Učitavanje ljudi i obradu realizovati kao zasebne potprograme koji sa glavnim

programom komuniciraju isključivo putem argumenata i povratnih vrednosti.

#include <stdio.h>

#define MAX_DIM 100

#define MAX 2

struct Osoba {

int prijatelji[MAX];

};

void ucitaj(struct Osoba osobe[], int *n) {

int broj, i, j;

printf("Unesite broj osoba\n");

scanf("%d", &broj);

*n = broj;

printf("Unesite prijatelje\n");

for (i = 0; i < broj; i++) {

for (j = 0; j < MAX; j++) {

scanf("%d", &osobe[i].prijatelji[j]);

}

}

}

void posalji(struct Osoba osobe[], int primili[], int n, int primalac) {

int i, kraj = 0;

while (!kraj) {

kraj = 1;

for (i = 0; i < MAX; i++) {

int sused = osobe[primalac].prijatelji[i];

if (sused != -1 && !primili[sused]) {

primalac = sused;

primili[sused] = 1;

kraj = 0;

break;

}

}

}

}


void obradi(struct Osoba osobe[], int n) {

int i, prvi;

int primili[MAX_DIM] = {0};

printf("Unesite ko prima poruku\n");

scanf("%d", &prvi);

primili[prvi] = 1;

for (i = 0; i < MAX; i++) {

int sused = osobe[prvi].prijatelji[i];

if (sused != -1) {

primili[sused] = 1;

posalji(osobe, primili, n, sused);

}

}

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

if (!primili[i]) {

printf("%d\n", i);

}

}

}

int main()

{

int n;

struct Osoba osobe[MAX_DIM];

ucitaj(osobe, &n);

obradi(osobe, n);

}



Zadatak 1.

Napisati program na programskom jeziku C koji pronalazi najfrekventnije slovo u dinamičkoj matrici slova engleske

abecede. Svaka vrsta ove dinamičke matrice sadrži jednu reč, učitanu iz posebnog reda, a maksimalna dužina jedne reči je 20 slova. Broj reči nije poznat unapred, a unos reči prestaje kada se učita prazan red. Potrebno je pročitati sa

standardnog ulaza reči i smestiti ih u dinamičku matricu, tako da reči ne zauzimaju više prostora nego što je potrebno.

Nakon toga, potrebno je pronaći i ispisati slovo koje se najviše puta pojavljuje u formiranoj matrici. Veliko i njemu odgovarajuće malo slovo treba tretirati na isti način. Ukoliko se više različitih slova pojavljuje isti broj puta, ispisati ih

sve. Učitavanje reči i obradu realizovati kao zasebne potprograme koji sa glavnim programom komuniciraju isključivo putem argumenata i povratnih vrednosti. Voditi računa o korektnoj upotrebi dinamičke memorije i optimalnom

iskorišćenju memorijskog prostora.

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <ctype.h>

#define DUZ 10

#define DUZ_REC 20

#define BR_SLOVA 26

char** ucitaj(int* br_reci) {

char** reci, **nove_reci, rec[DUZ_REC + 1]; int broj = 0;

reci = malloc(DUZ * sizeof(char*));

if (!reci) {

printf("Neuspesna alokacija memorije!"); exit(1);

}

while (1) {

fgets(rec, DUZ_REC + 1, stdin);

rec[strlen(rec) - 1] = '\0'; if (strlen(rec) == 0) break;

if (broj % DUZ == 0) {

nove_reci = realloc(reci, (broj + DUZ) * sizeof(char*));

if (!nove_reci) {

printf("Neuspesna alokacija memorije!"); break;

}

else reci = nove_reci;

}

reci[broj] = malloc((strlen(rec) + 1)*sizeof(char));

if (!reci[broj]) {

printf("Neuspesna alokacija memorije!"); exit(1);

}

strcpy(reci[broj++], rec);

}

nove_reci = realloc(reci, broj * sizeof(char*));

if (!nove_reci) printf("Neuspesna alokacija memorije!");

else reci = nove_reci;

*br_reci = broj;

return reci;

}


void obrada(char** reci, int br_reci) {

int frekvencije[BR_SLOVA], i, j, max = 0;

for (i = 0; i < BR_SLOVA; i++) frekvencije[i] = 0;

for (i = 0; i < br_reci; i++) {

int br_slova = strlen(reci[i]);

for (j = 0; j < br_slova; j++) {

if (isupper(reci[i][j])) frekvencije[reci[i][j] - 'A']++;

else frekvencije[reci[i][j] - 'a']++;

}

}

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

if (frekvencije[i] > max) max = frekvencije[i];

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

if (frekvencije[i] == max) printf("%c ", 'a' + i);

}

void main() {

char** reci; int i, br_reci = 0;

reci = ucitaj(&br_reci);

obrada(reci, br_reci);

for (i = 0; i < br_reci; i++) free(reci[i]);

free(reci);

}



Zadatak 2.

Napisati program na programskom jeziku C koji pomaže u vođenju posla kurirskoj službi. Svaki dan kurir vozi od

zadatog mesta i do zadatog mesta j, uz eventualni prolazak kroz druga mesta redom na tom putu. Podaci o dnevnoj maršruti prevoznika se učitavaju sa standardnog ulaza, tako što se najpre učita broj mesta na maršruti, a zatim se

redom unose imena mesta, od polaznog do krajnjeg, svako ime u jednom redu. Ime mesta je jedna reč od

maksimalno 30 znakova. Maksimalan broj mesta na putu od i do j nije poznat unapred, pa se memorija mora alocirati dinamički. Iz datoteke teret.txt se učitavaju podaci o paketima koji se prevoze. Za svaki paket su podaci zadati u

jednom redu datoteke po sledećem formatu: šifra paketa (ceo broj), masa u kilogramima (realan broj), ime mesta preuzimanja i ime mesta isporuke. Svi podaci su razdvojeni jednim blanko znakom. U datoteci se mogu nalaziti podaci

o paketima čije mesto isporuke nije na dnevnoj maršruti. Program treba da na standardnom izlazu ispiše podatke o

svim onim paketima koji nisu isporučeni tog dana, kao i ukupnu dnevnu isporučenu masu tereta. Voditi računa o

korektnoj upotrebi resursa.

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#define MAX 30


char mesto[MAX+1];

struct elem *sled;

} Elem;

void main() {

Elem *prvi, *posl, *novi, *tek;

int n, i, id, pos_preuzimanje, pos_isporuka;

float uk_teret = 0, teret;

FILE *ulaz;

char m_preuzimanja[MAX+1], m_isporuke[MAX+1];

printf("Broj mesta na marsruti: ");

scanf("%d", &n);

prvi = posl = NULL;

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


if (novi == NULL) exit(1);

printf("Unesite ime %d. mesta na marsruti: ", i+1);

scanf("%s", novi->mesto);

novi->sled = NULL;



posl = novi;

}

if ((ulaz = fopen("teret.txt", "r")) == NULL) exit(2);

while (fscanf(ulaz, "%d%f%s%s", &id, &teret, m_preuzimanja, m_isporuke)

== 4) {

printf("%s %s\n", m_preuzimanja, m_isporuke);

pos_preuzimanje = pos_isporuka = -1;

tek = prvi; i = 0;

while (tek) {

if (strcmp(tek->mesto, m_preuzimanja) == 0) pos_preuzimanje = i;

if (strcmp(tek->mesto, m_isporuke) == 0) pos_isporuka = i;

i++; tek = tek->sled;

}

if ((pos_preuzimanje < pos_isporuka) && (pos_preuzimanje != -1))

uk_teret += teret;

else printf("Paket %d %f %s %s nije isporucen.\n",

id, teret, m_preuzimanja, m_isporuke);

}


printf("Ukupna masa isporucenog tereta: %2.2f\n", uk_teret);

while (prvi) {

tek = prvi;

prvi = prvi->sled;

free(tek);

}

fclose(ulaz);

}

* Zadatak kompletno može biti rešen i korišćenjem dinamičkog niza stringova, što se prihvata kao potpuno validno

rešenje



Zadatak 1.

Napisati program na programskom jeziku C koji za svaku firmu određuje da li je poslovala sa dobitkom ili gubitkom u

zadatom periodu. Program na početku učitava broj firmi, a zatim se za svaku firmu u novom redu unosi broj dana koliko je firma poslovala i za svaki od tih dana unosi se celobrojna vrednost: pozitivna (koja predstavlja dnevni

dobitak) ili negativna (koja predstavlja dnevni gubitak). Smatrati da su svi uneti podaci korektni. Za učitavanje ulaznih podataka neophodno je realizovati funkciju int** ucitavanje(int *brojFirmi);. Nakon toga je potrebno

izvršiti zahtevanu obradu realizacijom funkcije int* obrada(int **firme, int *brojFirmi);, koja treba da

vrati niz nula ili jedinica. Nula označava da je firma poslovala sa gubitkom, a jedinica da je poslovala dobitkom. Glavni

program treba da pozove funkciju za učitavanje podataka sa standardnog ulaza, zatim pozove funkciju za obradu i na

kraju ispiše dobijeni niz na standardnom izlazu. Voditi računa o ispravnom korišćenju dinamičke memorije.

2

6 1 2 3 -5 4 3 7 2 -1 1 0 4 3 -10

Primer izlaza:

1 0

#include <stdio.h>

#include <stdlib.h>

#define CALLOCATE(ptr, cnt)\

{ if(!(ptr = calloc(cnt, sizeof(*ptr)))) { printf("Greska u alokaciji!\n");

exit(1); }}

int** ucitavanje(int *brojFirmi) {

int **firme, dani;

scanf("%d", brojFirmi);

CALLOCATE(firme, *brojFirmi);

for (int i = 0; i<*brojFirmi; i++) {

scanf("%d", &dani);

CALLOCATE(firme[i], dani + 1);

firme[i][0] = dani;

for (int j = 1; j <= dani; j++) scanf("%d", &firme[i][j]);

}

return firme;

}

int* obrada(int **firme, int *brojFirmi) {

int *periodi, dani, balans;

CALLOCATE(periodi, *brojFirmi);

for (int i = 0; i < *brojFirmi; i++) {

dani = firme[i][0];

balans = 0;

for (int j = 1; j <= dani; j++)

balans += firme[i][j];

if (balans >= 0) periodi[i] = 1;

}

return periodi;

}

int main(void) {

int brojFirmi;

int **firme = ucitavanje(&brojFirmi);

int *periodi = obrada(firme, &brojFirmi);

for (int i = 0; i < brojFirmi; i++) {

printf("%d ", periodi[i]);

free(firme[i]);

}

free(periodi); free(firme);

return 0;

}



Zadatak 2.

Napisati program na programskom jeziku C koji pomaže maturantu iz unutrašnjosti da organizuje prevoz za Beograd.

Maturant Miki treba da polaže probni prijemni ispit i želi da u jednom danu dođe za Beograd i da se nakon obavljenog posla vrati kući. Iz njegovog grada za Beograd postoji veći broj termina za odlazak i povratak koji su zapisani u

datoteci redvoznje.txt. U prvoj liniji se nalaze podaci o svim odlascima za Beograd, a svaki odlazak je opisan

vremenom polaska i dolaska u formatu hh:mm (hh – sati, mm – minuti). U drugoj liniji se nalaze podaci o povratku iz Beograda, po istom formatu kao u prvoj liniji. Smatrati da su podaci o odlascima i povratcima uređeni hronološki po

vremenu polaska i da se odlasci i polasci uvek završavaju istog dana. Broj odlazaka i povrataka nije poznat unapred. Program treba da učita podatke o redu vožnje iz datoteke i početku i trajanju probnog prijemnog ispita (u minutima)

sa standardnog ulaza, a zatim formira tekstualnu datoteku prevoz.txt koja sadrži sve moguće kombinacije odlazaka i

povrataka, takvih da Miki može na vreme da stigne u Beograd, polaže ispit i vrati se kući istog dana. Jedna linija izlazne datoteke treba da bude po formatu: vreme_odlaska vreme_povratka. Voditi računa o ispravnoj upotrebi

resursa.

#include <stdio.h>

#include <stdlib.h>

#define SAT 60

typedef struct prevoz {

int vreme_polaska, vreme_dolaska; struct prevoz *sled;

} Prevoz;

int vreme_u_min(int hh, int mm) {

return hh * SAT + mm;

}

Prevoz* citaj_voznje(FILE *ulaz) {

Prevoz *prvi = NULL, *novi, *posl = NULL;

int hh1, hh2, mm1, mm2, ret;

char c;

while ((ret = fscanf(ulaz, "%d:%d %d:%d%c", &hh1, &mm1, &hh2, &mm2, &c)) >

0) {

novi = malloc(sizeof(Prevoz)); if (!novi) return 2;

novi->vreme_polaska = vreme_u_min(hh1, mm1);

novi->vreme_dolaska = vreme_u_min(hh2, mm2);

novi->sled = NULL;



posl = novi;

if (c == '\n' || ret == 4) break;

}

return prvi;

}

void dealociraj(Prevoz* prvi) {

Prevoz *stari;

while (prvi) {

stari = prvi;

prvi = prvi->sled;

free(stari);

}

}

int main() {

FILE *ulaz, *izlaz;

Prevoz *odlasci, *povratci;

int hh_pr, mm_pr, pocetak_pr, trajanje_pr;

ulaz = fopen("redvoznje.txt", "r"); izlaz = fopen("prevoz.txt", "w");

if (!ulaz || !izlaz) {

printf("Greska pri radu sa datotekom!\n");

return 1;

}


odlasci = citaj_voznje((ulaz));

povratci = citaj_voznje((ulaz));

printf("Unesite pocetak prijemnog u formatu hh:mm: ");

scanf("%d:%d", &hh_pr, &mm_pr);

printf("Unesite trajanje prijemnog u minutima: ");

scanf("%d", &trajanje_pr);

pocetak_pr = vreme_u_min(hh_pr, mm_pr);

for (Prevoz* tek1 = odlasci; tek1; tek1 = tek1->sled) {

if (tek1->vreme_dolaska > pocetak_pr) break;

for (Prevoz* tek2 = povratci; tek2; tek2 = tek2->sled) {

if (tek2->vreme_polaska < pocetak_pr + trajanje_pr) continue;

fprintf(izlaz, "%2.2d:%2.2d %2.2d:%2.2d\n",

tek1->vreme_polaska / SAT, tek1->vreme_polaska % SAT,

tek2->vreme_polaska / SAT, tek2->vreme_polaska % SAT);

}

}

dealociraj(odlasci);

dealociraj (povratci);

fclose(ulaz);

fclose(izlaz);

return 0;

}



Zadatak 1.

Napisati program na programskom jeziku C koji rotira matricu za 90 stepeni u smeru kazaljke na satu. Program na

početku učitava dimenzije matrice, a zatim i njene elemente po vrstama. Smatrati da su svi uneti podaci korektni. Za učitavanje matrice neophodno je realizovati funkciju int** readMatrix(int *numrows, int *numcols);.

Nakon toga je potrebno izvršiti zahtevanu rotaciju matrice realizacijom funkcije int** rotateMatrix90(int

**matrix, int numrows, int numcols);, koja treba da vrati novu, rotiranu matricu. Glavni program treba da

pozove funkciju za učitavanje matrice sa standardnog ulaza, zatim pozove funkciju za formiranje nove, rotirane matrice i na kraju ispiše rotiranu matricu na standardnom izlazu. Voditi računa o ispravnom korišćenju dinamičke

memorije.

#include <stdio.h>

#include <stdlib.h>

#define CALLOCATE(ptr, cnt)\

{ if(!(ptr = malloc(cnt * sizeof(*ptr)))) { printf("Greska u alokaciji!\n");

exit(1); }}

int** allocateMatrix(int rows, int cols) {

int **m, i;

CALLOCATE(m, rows)

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

CALLOCATE(m[i], cols)

return m;

}

void dealocateMatrix(int** m, int rows, int cols) {

for (int i = 0; i < rows; free(m[i++]));

free(m);

}

int** readMatrix(int* rows, int* cols) {

int **m, i, j;

printf("Unesite dimenzije matrice, a zatim njene elemente po vrstama\n");

scanf("%d%d", rows, cols);

m = allocateMatrix(*rows, *cols);

for (i = 0; i < *rows; i++)

for (j = 0; j < *cols; j++) scanf("%d", &m[i][j]);

return m;

}

int** rotateMatrix90(int** m, int rows, int cols) {

int rowsNew = cols;

int colsNew = rows;

int** mNew = 0;

mNew = allocateMatrix(rowsNew, colsNew);

for (int i = 0; i < rows; i++)

for (int j = 0; j < cols; j++)

mNew[j][rows - i - 1] = m[i][j];

dealocateMatrix(m, rows, cols);

return mNew;

}

void writeMatrix(int** m, int rows, int cols) {

printf("\n");

for (int i = 0; i < rows; i++) {

for (int j = 0; j < cols; printf("%d ", m[i][j++]));

printf("\n");

}

}


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

int **m, rows, cols;

m = readMatrix(&rows, &cols);

m = rotateMatrix90(m, rows, cols);

writeMatrix(m, cols, rows);

dealocateMatrix(m, cols, rows);

return 0;

}



Zadatak 2

Maturant Miki je polagao prijemni ispit i želi da nakon objavljenih preliminarnih rezultata proceni svoj uspeh.

Preliminarne rezultate prijemnog ispita komisija je objavila u datoteci prijemni.txt. U datoteci su za svakog kandidata u zasebnom redu zapisani šifra kandidata (tačno 5 cifara), rezultat na prijemnom iz matematike i rezultat na prijemnom

iz fizike, razdvojeni jednim znakom razmaka. Ukoliko neko od kandidata nije polagao prijemni ispit iz nekog predmeta,

broj poena je 0. Ocene iz srednje škole zapisane su u datoteci ocene.txt. U datoteci su za svakog kandidata u zasebnom redu zapisani šifra kandidata i prosečna ocena za svaki od četiri razreda. Ukupan broj poena računa se kao

zbir poena na prijemnom ispitu (pri čemu se računa bolji rezultat ako je kandidat polagao i matematiku i fiziku) i poena iz škole, koji se računaju kao suma prosečnih ocena pomnožena brojem dva. Napisati program na

programskom jeziku C koji, nakon što Miki unese svoju šifru preko standardnog ulaza, proveri i na standardni izlaz

ispiše da li je Miki prema preliminarnim rezultatima ostvario dovoljan rezultat za upis na budžet (400 mesta),

samofinansiranje (100 mesta), ili nije ostvario dovoljan broj poena za upis. Voditi računa o ispravnoj upotrebi resursa.

#include <stdio.h>

#include <stdlib.h>

typedef struct kandidat {

int sifra;

double poeni;

struct kandidat *sled;

} Kandidat;

Kandidat* citaj_prijemni(FILE *prijemni) {

Kandidat *prvi = NULL, *novi, *posl = NULL;

int sifra, mat, fiz, ret;

while ((ret = fscanf(prijemni, "%d %d %d", &sifra, &mat, &fiz)) > 0) {

novi = malloc(sizeof(Kandidat)); if (!novi) return 2;

novi->sifra = sifra;

novi->poeni = mat > fiz ? mat : fiz; novi->sled = NULL;



posl = novi;

}

return prvi;

}

void dodaj_ocene(FILE *ocene, Kandidat *lista) {

int sifra, ret, i;

double o;

while ((ret = fscanf(ocene, "%d", &sifra)) > 0) {

Kandidat *tek = lista;

while(tek){

if (tek->sifra == sifra) {

for (i = 0; i < 4; i++) {

fscanf(ocene, "%lf", &o);

tek->poeni += 2*o;

}

break;

} tek = tek->sled;

}

}

}

void dealociraj(Kandidat* prvi) {

Kandidat *stari;

while (prvi) {

stari = prvi;

prvi = prvi->sled;

free(stari);

}

}


int main() {

FILE *prijemni, *ocene;

Kandidat *lista, *tek;

int mikisif, mikirang = 1;

double mikip;

prijemni = fopen("prijemni.txt", "r");

ocene = fopen("ocene.txt", "r");

if (!prijemni || !ocene) {

printf("Greska pri radu sa datotekom!\n"); return 1;

}

lista = citaj_prijemni((prijemni));

dodaj_ocene(ocene, lista);

printf("Unesite sifru: ");

scanf("%d", &mikisif);

tek = lista;

while (tek) {

if (tek->sifra == mikisif) {

mikip = tek->poeni;

break;

}

tek = tek->sled;

}

tek = lista;

while (tek) {

if (tek->poeni > mikip) mikirang++;

tek = tek->sled;

}

if (mikirang <= 400) printf("budzet!");

else if (mikirang <= 494) printf("samofinansiranje!");

else printf("nedovoljno poena!");

dealociraj(lista);

fclose(prijemni);

fclose(ocene);

return 0;

}

Documents

Studentima se savetuje da programski kod ne uče napamet. Za …rti.etf.bg.ac.rs/.../P2_pripremni_zadaci_za_ispit_2018.pdf · 2018-07-06 · Materijali za pripremu ispita iz Programiranja