studentima se savetuje da programski kod ne uče napamet...
Post on 23-Jan-2021
3 Views
Preview:
TRANSCRIPT
ELEKTROTEHNIČKI FAKULTET UNIVERZITETA U BEOGRADU
PROGRAMIRANJE 1
MATERIJALI ZA PRIPREMU ISPITA
verzija: 09.01.2019.
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 Pascal.
Sadržaj:
SI1P1, drugi kolokvijum, novembar 2012. .................................................................................. 3
SI1P1, drugi kolokvijum, novembar 2013. .................................................................................. 4
SI1P1, drugi kolokvijum, decembar 2018. .................................................................................. 5
P1, ispit, januar 2011. .............................................................................................................. 6
P1, ispit, februar 2011. ............................................................................................................. 7
P1, ispit, jul 2011. .................................................................................................................... 9
P1, ispit, jul 2011. .................................................................................................................. 10
P1, ispit, septembar 2011. ...................................................................................................... 11
P1, ispit, oktobar 2011. .......................................................................................................... 12
P1, ispit, januar 2012. ............................................................................................................ 14
P1, ispit, februar 2012. ........................................................................................................... 16
P1, ispit, septembar 2012. ...................................................................................................... 17
P1, ispit, oktobar 2012. .......................................................................................................... 19
P1, ispit, januar 2013. ............................................................................................................ 20
P1, ispit, februar 2013. ........................................................................................................... 22
P1, ispit, jul 2013. .................................................................................................................. 24
P1, ispit, septembar 2013. ...................................................................................................... 26
P1, ispit, oktobar 2013. .......................................................................................................... 28
P1, ispit, januar 2014. ............................................................................................................ 29
P1, ispit, februar 2014. ........................................................................................................... 31
P1, ispit, jun 2014. ................................................................................................................. 32
P1, ispit, jul 2014. .................................................................................................................. 34
P1, ispit, septembar 2014. ...................................................................................................... 35
P1, ispit, januar 2016. ............................................................................................................ 37
P1, ispit, februar 2016. ........................................................................................................... 39
P1, ispit, jun 2016. ................................................................................................................. 40
P1, ispit, oktobar 2016. .......................................................................................................... 42
P1, ispit, januar 2017. ............................................................................................................ 44
P1, ispit, februar 2017. ........................................................................................................... 45
P1, ispit, septembar 2017. ...................................................................................................... 47
P1, ispit, januar 2018. ............................................................................................................ 49
P1, ispit, januar 2018. ............................................................................................................ 50
P1, ispit, februar 2018. ........................................................................................................... 52
P1, ispit, jul 2018. .................................................................................................................. 53
P1, ispit, jul 2018. .................................................................................................................. 54
P1, ispit, septembar 2018. ...................................................................................................... 56
P1, ispit, oktobar 2018. .......................................................................................................... 58
P1, ispit, oktobar 2018. .......................................................................................................... 59
Materijali za pripremu ispita iz Programiranja 1 3
SI1P1, drugi kolokvijum, novembar 2012.
Zadatak 1.
Napisati program na programskom jeziku Pascal koji računa dužinu izlomljene linije zadatu tačkama u ravni. Tačke se
zadaju pomoću svojih koordinata. Program treba da učita dva niza realnih brojeva x[i] i y[i] koji sadrže koordinate sukcesivnih tačaka preloma linije, a zatim, računanjem rastojanja između odgovarajućih tačaka, izračuna i ispiše
dužinu izlomljene linije u ravni. Obezbediti da minimalna dužina ulaznih nizova bude jednaka 2, tj. da izlomljena linija
sadrži bar jednu duž. Program treba da ponavlja opisani postupak sve dok se za dužinu niza ne unese nekorektna
vrednost.
program z1sik2_1112(input, output);
const
MIN = 2;
MAX = 100;
var x,y: array [1..100] of real;
d: real;
i, n: integer;
begin
write(output, 'Unesite broj tacaka: ');
read(input, n);
while (n >= MIN) and (n <= MAX) do
begin
writeln(output, 'Unesite parove tacaka (x,y): ');
for i:= 1 to n do
read(input, x[i], y[i]);
d := 0;
for i:= 2 to n do
d := d + sqrt(sqr(x[i] - x[i-1]) + sqr(y[i] - y[i-1]));
writeln('Duzina linije je: ', d:0:2);
write(output, 'Unesite broj tacaka: ');
read(input, n);
end;
end.
Materijali za pripremu ispita iz Programiranja 1 4
SI1P1, drugi kolokvijum, novembar 2013.
Zadatak 1.
Napisati program na programskom jeziku Pascal koji vrši određenu obradu nad krugovima u ravni. Svaki krug se
zadaje pomoću x i y koordinata svoga centra i poluprečnika. Program treba da učita tri niza realnih brojeva x[i], y[i] i r[i] koji predstavljaju x i y koordinate centra i poluprečnik svakog kruga, a korisnik zadaje krugove unošenjem trojki
(x, y, r). Nakon unosa, program treba da ispiše koordinate centara i ukupan broj krugova koji zadovoljavaju uslov da
se nalaze unutar nekog drugog kruga. Ukoliko se krug nalazi unutar više drugih krugova, brojati ga samo jednom.
program z1k2si1213(input, output);
const
MAX_DUZ = 100;
type
Niz = array [1..MAX_DUZ] of real;
var
x, y, r: Niz;
n, i, j, ukupno: integer;
d: real;
nasao: boolean;
begin
write(output, 'Unesite broj krugova: ');
readln(input, n);
if (n > 0) and (n <= MAX_DUZ) then
begin
writeln(output, 'Unesite krugove (x,y,r)');
for i:=1 to n do
readln(input, x[i], y[i], r[i]);
ukupno := 0;
for i:= 1 to n do
begin
nasao := false;
j := 1;
while (j <= n) and (nasao = false) do
begin
if (i <> j) then
begin
d := sqrt(sqr(x[i] - x[j]) + sqr(y[i] - y[j]));
if (d + r[j] <= r[i]) then
begin
nasao := true;
ukupno := ukupno + 1;
writeln(output, '(', x[i]:0:2, ',', y[i]:0:2, ') ');
end;
end;
j := j + 1;
end;
end;
writeln(output, 'Ukupan broj krugova koji se nalaze u nekom drugom krugu:
', ukupno);
end;
end.
Materijali za pripremu ispita iz Programiranja 1 5
SI1P1, drugi kolokvijum, decembar 2018.
Zadatak 1.
Napisati program na programskom jeziku Pascal koji vrši određenu obradu nad nizom pozitivnih celih brojeva dužine N
(N ≤ 100). Program najpre učitava dužinu niza, a zatim i same elemente niza. Nakon toga program treba da proveri da li se od elemenata niza može formirati aritmetička progresija. Elementi niza mogu biti zadati u proizvoljnom
redosledu. Ukoliko se može formirati aritmetička progresija potrebno je ispisati poruku MOŽE, a u suprotnom NE
MOŽE. Program treba da ponavlja svoje izvršavanje dok god korisnik ne unese niz od kojeg se može formirati
aritmetička progresija.
program aritmeticka_sredina ( input, output );
const
MAX_ELEM = 100;
var
a : array [1..MAX_ELEM] of integer;
i, j, n, d : integer;
nije_aritmeticka, provera : boolean;
begin
nije_aritmeticka := true;
while ( nije_aritmeticka ) do begin
writeln ( output, 'Duzina?');
readln ( input, n);
writeln ( output, 'Elementi?' );
for i := 1 to n do readln ( input, a[i] );
for i := 1 to ( n - 1 ) do
for j := ( i + 1 ) to n do
if ( a[i] > a[j] ) then begin
a[i] := a[i] + a[j];
a[j] := a[i] - a[j];
a[i] := a[i] - a[j];
end;
i := 2;
provera := true;
while ( ( i <= n ) and provera ) do begin
if ( i = 2 ) then d := a[i] - a[i - 1];
if ( ( a[i] - a[i - 1] ) <> d ) then provera := false;
i := i + 1;
end;
nije_aritmeticka := not provera;
if ( nije_aritmeticka ) then writeln ( output, 'NE MOZE' )
else writeln ( output, 'MOZE' );
end;
end.
Materijali za pripremu ispita iz Programiranja 1 6
P1, ispit, januar 2011.
Zadatak 2.
Napisati program na programskom jeziku Pascal koji pronalazi trougao najveće površine. Trouglovi se zadaju pomoću
dva niza realnih brojeva (najveće dužine 100) koji predstavljaju osnovice i visine trouglova. Program treba da učita nizove, izračuna površine svih trouglova, a zatim pronađe i ispiše podatke o trouglu najveće površine: dužinu osnovice
i visine, i površinu. Učitavanje, računanje površine i pronalaženje trougla najveće površine realizovati kao zasebne
potprograme. Potprogrami sa glavnim programom smeju da komuniciraju isključivo putem svojih argumenata i povratne vrednosti. Program treba da ponavlja prethodne korake sve dok se za dužinu nizova ne unese nekorektna
vrednost.
program z2jan1011(input, output);
const MAX_DUZ = 100;
type niz = array [1..MAX_DUZ] of real;
var a, h, p: niz;
n, indeks: integer;
function povrsina(a,h: real) : real;
begin
povrsina := a*h/2;
end;
function ucitaj (var a,h: niz; var n: integer) : boolean;
var
i: integer;
begin
ucitaj := false;
write('Unesite broj trouglova: ');
readln(n);
if (n > 0) and (n <= MAX_DUZ) then
begin
ucitaj := true;
writeln('Unesite parove vrednosti osnovica i visina trouglova: ');
for i:= 1 to n do readln(a[i],h[i]);
end;
end;
function maxpovrsina (var a,h: niz; n: integer) : integer;
var maxp: real;
i: integer;
begin
maxp := povrsina(a[1],h[1]); maxpovrsina := 1;
for i:= 2 to n do
if (povrsina(a[i],h[i]) > maxp) then
begin
maxpovrsina := i; maxp := povrsina(a[i],h[i]);
end;
end;
begin
while ucitaj(a,h,n) do
begin
indeks := maxpovrsina(a,h,n);
writeln('Trougao najvece povrsine je osnovice ', a[indeks]:0:2,', visine
', h[indeks]:0:2, ' i povrsine ', povrsina(a[indeks],h[indeks]):0:2);
end;
end.
Materijali za pripremu ispita iz Programiranja 1 7
P1, ispit, februar 2011.
Zadatak 2.
Napisati program na programskom jeziku Pascal koji pronalazi dve međusobno najudaljenije tačke u jednostruko
ulančanoj listi tačaka u ravni. Program treba da čita tačke sa glavnog ulaza sve dok se ne unese tačka koja označava koordinatni početak, pronađe dve međusobno najudaljenije i ispiše koordinate pronađenih. Učitavanje i računanje
udaljenosti realizovati kao zasebne potprograme. Potprogrami sa glavnim programom smeju da komuniciraju isključivo
putem svojih argumenata i povratne vrednosti. Pretpostaviti da ne postoje parovi tačaka sa istom udaljenošću, te da
će se pronaći tačno jedan par tačaka. Voditi računa o ispravnom korišćenju dinamičke memorije.
program z2feb1011(input, output);
type
pok = ^elem;
tacka = record
x, y: real;
end;
elem = record
t: tacka;
sled: pok;
end;
var
prvi: pok;
function ucitaj () : pok;
var prvi, novi: pok;
x, y: real;
begin
prvi := nil;
writeln('Unesite x i y koordinate tacaka ili koordinatni pocetak za
kraj:');
read(x,y);
while (x <> 0) and (y <> 0) do
begin
new(novi);
novi^.t.x := x;
novi^.t.y := y;
novi^.sled := prvi;
prvi := novi;
read(x,y);
end;
ucitaj := prvi;
end;
function rastojanje (t1, t2: tacka) : real;
begin
rastojanje := sqrt(sqr(t1.x - t2.x) + sqr(t1.y - t2.y));
end;
procedure max_rastojanje (prvi: pok);
var tek1, tek2: pok;
t1max, t2max: tacka;
d, dmax: real;
begin
dmax := 0;
t1max := prvi^.t;
t2max := prvi^.t;
tek1 := prvi;
Materijali za pripremu ispita iz Programiranja 1 8
while (tek1 <> nil) do
begin
tek2 := tek1^.sled;
while (tek2 <> nil) do
begin
d := rastojanje(tek1^.t, tek2^.t);
if ( d > dmax) then
begin
dmax := d;
t1max := tek1^.t;
t2max := tek2^.t;
end;
tek2 := tek2^.sled;
end;
tek1 := tek1^.sled;
end;
writeln('Najduze rastojanje ', dmax:0:2, ' izmedju tacaka (', t1max.x:0:2,'
', t1max.y:0:2, ') i (', t2max.x:0:2,' ', t2max.y:0:2, ').');
end;
procedure dealociraj (var prvi: pok);
var
stari : pok;
begin
stari := prvi;
while (prvi <> nil) do
begin
prvi := prvi^.sled;
dispose(stari);
stari := prvi;
end;
end;
begin
prvi := ucitaj();
max_rastojanje(prvi);
dealociraj(prvi);
end.
Materijali za pripremu ispita iz Programiranja 1 9
P1, ispit, jul 2011.
Zadatak 1.
Napisati program na programskom jeziku Pascal koji vrši obradu nad nizom znakova. Program treba da sa glavnog
ulaza učita dužinu niza N (N<256) i elemente niza znakova. Iz niza je potrebno ukloniti sve one znakove koji se ponavljuju, a u nizu ostaviti samo prvo pojavljivanje znaka. Na kraju ispisati rezultujući niz. Program treba da ponavlja
navedene korake sve dok se za dužinu niza ne unese nekorektna vrednost. Učitavanje, obradu i ispis niza realizovati
kao zasebne potprograme koji sa glavnim programom komuniciraju isključivo putem argumenata i povratnih
vrednosti.
program z1jul1011;
const MAX = 256;
type tip_niz = array [1..256] of char;
var niz: tip_niz;
i, n: integer;
function ucitaj (var niz: tip_niz; var n: integer): boolean;
var i: integer;
begin
write('Unesite duzinu niza: ');
readln(n);
if (n<=0) OR (n>256) then ucitaj := false
else
begin
write('Uneiste elemente niza: '); for i := 1 to n do read(niz[i]);
ucitaj := true;
end;
end;
procedure obradi (var niz: tip_niz; var n: integer);
var i,j: integer;
skup: set of char;
begin
j:=1; skup := [];
for i := 1 to n do
if (not(niz[i] in skup)) then
begin
niz[j] := niz[i]; j := j + 1;
skup := skup + [niz[i]];
end;
n := j - 1;
end;
procedure ispisi (var niz: tip_niz; n: integer);
var i: integer;
begin
writeln('Elementi rezultujuceg niza su: ');
for i := 1 to n do write(niz[i], ' ');
end;
begin
while (ucitaj(niz, n)) do begin
obradi(niz, n); ispisi(niz, n);
end;
end.
Materijali za pripremu ispita iz Programiranja 1 10
P1, ispit, jul 2011.
Zadatak 2.
Neka svaki red datoteke prijemni.txt sadrži podatke o jednom prijavljenom kandidatu za polaganje prijemnog ispita -
broj prijave (ceo broj), ime (do 30 znakova), prezime (do 30 znakova) i broj poena iz srednje škole (ceo broj). U datoteci poeni.txt se nalaze rezultati prijemnog ispita, u svakom redu broj prijave (ceo broj) i broj osvojenih poena na
matematici (realan broj) i fizici (realan broj) po istom redosledu kao u prvoj ulaznoj datoteci. Podaci o kandidatu
moraju postojati u obe datoteke. Napisati program na programskom jeziku Pascal koji pročita sadržaj navedenih datoteka i u datoteku rezultati.txt upiše za svakog studenta konačan rezultat na prijemnom ispitu po formatu prve
ulazne datoteke. Konačan rezultat na prijemnom ispitu se računa kao zbir broja poena iz srednje škole i boljeg
rezultata ostvarenog na testu iz matematike ili fizike.
program z2jul1011;
var ulaz1, ulaz2, izlaz: text;
ime, prezime: array[1..30] of char;
c: char;
i, m, n, prijava1, prijava2: integer;
p_skola, p_mat, p_fiz, ukupno: real;
begin
assign(ulaz1, 'prijemni.txt');
assign(ulaz2, 'poeni.txt');
assign(izlaz, 'rezultati.txt');
reset(ulaz1); reset(ulaz2); rewrite(izlaz);
while not eof(ulaz1) do
while not eof(ulaz2) do
begin
read(ulaz1, prijava1);
read(ulaz1, c);
i := 1;
repeat
read(ulaz1, c); ime[i] := c; i := i+1;
until c = ' ';
m := i-1;
i := 1;
repeat
read(ulaz1, c); prezime[i] := c; i := i+1;
until c = ' ';
n := i-1;
readln(ulaz1, p_skola);
readln(ulaz2, prijava2, p_mat, p_fiz);
if (p_mat > p_fiz) then ukupno := p_skola + p_mat
else ukupno := p_skola + p_fiz;
if (prijava1 = prijava2) then
begin
write(izlaz, prijava1, ' ');
for i:= 1 to m do write(izlaz, ime[i]);
for i:= 1 to n do write(izlaz, prezime[i]);
writeln(izlaz,ukupno:2:1);
end;
end;
close(ulaz1); close(ulaz2); close(izlaz);
end.
Materijali za pripremu ispita iz Programiranja 1 11
P1, ispit, septembar 2011.
Zadatak 1.
Napisati program na programskom jeziku Pascal koji od dva niza celih brojeva jednake dužine formira treći niz tako da
bude zadovoljen uslov c[i] = max(a[i], b[i]). Program treba da sa glavnog ulaza učita dužinu N (N<200) i elemente nizova, zatim formira i ispiše rezultujući niz. Učitavanje niza, obradu i ispis rezultata realizovati kao zasebne
potprograme koji sa glavnim programom komuniciraju isključivo putem argumenata i povratnih vrednosti. Program
treba da ponavlja opisani postupak sve dok se za dužinu nizova ne unese nekorektna vrednost.
program z1sep1011;
const MAX = 200;
type niz = array [1..200] of integer;
var a, b, c: niz;
i, n: integer;
function ucitaj (var a,b: niz; var n: integer): boolean;
var i: integer;
begin
write('Unesite duzinu niza: ');
read(n);
if (n > 0) and (n <= MAX) then
begin
write('Unesite prvi niz: ');
for i := 1 to n do read(a[i]);
write('Unesite drugi niz: ');
for i := 1 to n do read(b[i]);
ucitaj := true;
end
else
ucitaj := false;
end;
procedure ispisi (var c: niz; n: integer);
var i: integer;
begin
write('Rezultujuci niz: ');
for i := 1 to n do write(c[i],' ');
end;
procedure obradi (var a, b, c: niz; n: integer);
var i: integer;
begin
for i := 1 to n do
if (a[i] >= b[i]) then c[i] := a[i]
else c[i] := b[i];
end;
begin
while(ucitaj(a,b,n)) do
begin
obradi(a,b,c,n);
ispisi(c,n);
end;
end.
Materijali za pripremu ispita iz Programiranja 1 12
P1, ispit, oktobar 2011.
Zadatak 1.
Napisati potprogram na programskom jeziku Pascal koji vrši određenu obradu nad jednostruko ulančanom listom duži
u ravni. Svaka duž u listi je predstavljena pomoću realnih koordinata svojih krajnjih tačaka. Potprogram treba da pronađe duž sa maksimalnom dužinom i da ispiše dužinu te duži na standardni izlaz, a da kao rezultat potprograma
vrati pokazivač na element liste kojim je predstavljena ta duž. Ukoliko postoji više duži iste maksimalne dužine, uzeti u
obzir prvu od njih. Napisati glavni program na programskom jeziku Pascal koji izvrši učitavanje jednostruko ulančane liste duži u ravni, izvrši opisanu obradu i obriše listu iz memorije. Smatrati da potprogrami za učitavanje i brisanje liste
već postoje i da se mogu koristi u realizaciji glavnog programa. Potprogrami treba da komuniciraju sa glavnim
programom isključivo putem argumenata i povratnih vrednosti.
program z1okt1011;
type pok = ^elem;
tacka = record
x, y: real;
end;
elem = record
t1, t2: tacka;
sled: pok;
end;
var lst, max: pok;
function rastojanje (t1, t2: tacka) : real;
begin
rastojanje := sqrt(sqr(t1.x - t2.x) + sqr(t1.y - t2.y));
end;
function obrada (lst: pok) : pok;
var maxduz, trduz: real;
tek, maxpok: pok;
begin
obrada := nil;
tek := lst;
if (lst <> nil) then
begin
maxduz := rastojanje(tek^.t1, tek^.t2);
maxpok := tek;
tek := tek^.sled;
while tek <> nil do
begin
trduz := rastojanje(tek^.t1, tek^.t2);;
if maxduz < trduz then begin
maxduz := trduz;
maxpok := tek;
end;
tek := tek^.sled;
end;
writeln('Duzina najduze duzi je: ', maxduz:2:2);
obrada := maxpok;
end;
end;
Materijali za pripremu ispita iz Programiranja 1 13
function ucitaj () : pok;
var prvi, novi: pok;
i, n: integer;
x,y: real;
begin
prvi := nil;
writeln('Unesite broj duzi: ');
read(n);
for i:= 1 to n do
begin
new(novi);
read(x,y);
novi^.t1.x := x;
novi^.t1.y := y;
read(x,y);
novi^.t2.x := x;
novi^.t2.y := y;
novi^.sled := prvi;
prvi := novi;
end;
ucitaj := prvi;
end;
procedure dealociraj (var prvi: pok);
var
stari : pok;
begin
stari := prvi;
while (prvi <> nil) do
begin
prvi := prvi^.sled;
dispose(stari);
stari := prvi;
end;
end;
begin
lst := ucitaj();
max := obrada(lst);
dealociraj(lst);
end.
Materijali za pripremu ispita iz Programiranja 1 14
P1, ispit, januar 2012.
Zadatak 2.
Napisati program na programskom jeziku Pascal koji vrši spajanje dva neopadajuće uređena niza celih brojeva.
Program najpre treba da učita nizove, proveri da li su nizovi uređeni neopadajuće, a zatim spajanjem početnih nizova formira i ispiše treći niz koji je uređen na isti način kao početni nizovi. Početni nizovi mogu biti različite dužine (najviše
100 elemenata). Ukoliko nizovi nisu uređeni neopadajuće ispisati odgovarajuću poruku i zatražiti ponovno učitavanje
početnih nizova. Učitavanje, proveru uređenosti i spajanje nizova realizovati zasebne potprograme koji sa glavnim programom komuniciraju isključivo putem svojih argumenata i povratne vrednosti. Program treba da ponavlja
prethodne korake sve dok se za dužinu nizova ne unese nekorektna vrednost.
program z1jan1112(input,output);
const MAX = 100;
type niz = array [1..MAX] of integer;
var n1, n2, n3: integer;
a, b, c: niz;
function ucitaj (var a: niz; var n: integer) : boolean;
var i: integer;
begin
write('Unesite duzinu niza: ');
read(n);
if (n > 0) and (n <= MAX) then
begin
for i:= 1 to n do read(a[i]);
ucitaj:= true;
end
else ucitaj:= false;
end;
function provera (var a: niz; n: integer) : boolean;
var i: integer;
begin
provera := true;
for i:= 2 to n do
if (a[i-1] > a[i]) then provera:= false;
end;
procedure pisi (var a: niz; n: integer);
var i: integer;
begin
writeln('Spojeni niz: ');
for i:= 1 to n do write(a[i], ' ');
writeln;
end;
Materijali za pripremu ispita iz Programiranja 1 15
procedure spajanje (var a, b, c: niz; var n1, n2, n3: integer);
var i, j, k: integer;
begin
i:= 1;
j:= 1;
k:= 1;
while (i <= n1) and (j <= n2) do
if (a[i] < b[j]) then
begin
c[k]:= a[i];
k:= k + 1;
i:= i + 1;
end
else
begin
c[k]:= b[j];
k:= k + 1;
j:= j + 1;
end;
if (i > n1) then
while (j <= n2) do
begin
c[k]:= b[j];
j:= j + 1;
k:= k + 1;
end
else
while (i <= n1) do
begin
c[k]:= a[i];
i:= i + 1;
k:= k + 1;
end;
n3:= n1 + n2;
end;
begin
while ucitaj(a,n1) or ucitaj(b,n2) do
begin
if (provera(a,n1) and provera(b,n2)) then
begin
spajanje(a,b,c,n1,n2,n3);
pisi(c,n3);
end
else writeln('Nizovi nisu uredjeni neopadajuce! Unesite ponovo!');
end;
end.
Materijali za pripremu ispita iz Programiranja 1 16
P1, ispit, februar 2012.
Zadatak 1.
Napisati program na programskom jeziku Pascal koji od niza tačaka, zadatih sa po tri realne koordinate u prostoru,
formira i ispisuje dva nova niza, od kojih će prvi niz sadržati sve one tačke koje se nalaze unutar, a drugi niz sadržati sve one tačke koje se nalaze izvan zamišljene sfere zadate poluprečnikom sa centrom u koordinatnom početku. Ulazni
niz može sadržati najviše 100 elemenata. Program najpre treba da učita ulazne podatke, a zatim izvrši zadatu obradu i
ispis. Učitavanje niza, obradu i ispis niza realizovati kao zasebne potprograme koji sa glavnim programom komuniciraju isključivo putem svojih argumenata i povratne vrednosti. Program treba da ponavlja prethodne korake
sve dok se za dužinu ulaznog niza ne unese nekorektna vrednost.
program z1feb_1112(input, output);
const MAX = 100;
type Tacka = record x, y, z: real; end;
niz = array [1..MAX] of Tacka;
var a, b, c: niz;
i, n, n1, n2: integer; r, d: real;
function ucitaj (var a: niz; var n: integer) : boolean;
var i: integer;
begin
ucitaj:= false;
write('Unesite duzinu niza: '); readln(n);
if (n > 0) AND (n <= 100) then begin
ucitaj:= true;
writeln('Unesite elemente niza tacaka: ');
for i:= 1 to n do read(a[i].x, a[i].y, a[i].z);
end;
end;
procedure obrada (var a, b, c: niz; var n, n1, n2: integer; r: real);
var i: integer;
begin
n1:= 0; n1:= 0;
for i:= 1 to n do begin
d:= sqrt(a[i].x*a[i].x + a[i].y*a[i].y + a[i].z*a[i].z);
if (d <= r) then begin n1:= n1 + 1; b[n1]:= a[i]; end
else begin n2:= n2 + 1; c[n2]:= a[i]; end;
end;
end;
procedure pisi (var a: niz; n: integer);
var i: integer;
begin
for i:= 1 to n do writeln(a[i].x:0:2,' ', a[i].y:0:2,' ',a[i].z:0:2);
end;
begin
while (ucitaj(a,n)) do begin
write('Unesite poluprecnik sfere: '); readln(r);
obrada(a, b, c, n, n1, n2, r);
writeln('Tacke koje se nalaze unutar sfere: '); pisi(b, n1);
writeln('Tacke koje se nalaze izvan sfere: '); pisi(c, n2);
end;
end.
Materijali za pripremu ispita iz Programiranja 1 17
P1, ispit, septembar 2012.
Zadatak 1.
U nekoj zdravstvenoj ustanovi, pacijenti se prijavljuju za pregled putem interneta. Svi podaci o prijavama za jedan
radni dan se upisuju u tekst datoteku prijave.txt, po sledećem formatu: JMBG (ceo broj), vreme prijave (u formatu hh:mm:ss, gde su hh sati, mm minuti, a ss sekunde) i tip pacijenta (Z – zaposleni, P – penzioneri, T – trudnice, D –
deca), sortirani po vremenu prijavljivanja. Napisati program na programskom jeziku Pascal koji pročita sadržaj ulazne
datoteke, a zatim formira i ispiše spisak pacijenata za pregled po prioritetima. U spisku najpre treba da se nadju deca, trudnice, penzioneri, pa na kraju zaposleni. Unutar svake od grupa, pacijente poređati po vremenu prijave za pregled.
Spisak ispisati na glavni izlaz po istom formatu kao u ulaznoj datoteci. Broj prijavljenih pacijenata nije poznat unapred.
program z1sep_1112(input, output);
type
pok = ^elem;
elem = record
jmbg: integer;
vreme: integer;
tip: char;
sled: pok;
end;
var novi, l1, l2, l3, l4: pok;
str: string[12];
ulaz: text;
procedure ubaci (var prvi, novi: pok);
var tek, preth: pok;
begin
preth := nil;
tek := prvi;
while (tek <> nil) do
if (tek^.tip <> novi^.tip) or (novi^.vreme >= tek^.vreme) then
begin
preth := tek;
tek := tek^.sled;
end;
novi^.sled := tek;
if (preth = nil) then prvi := novi
else preth^.sled := novi;
end;
procedure pisi (var prvi: pok);
var tek: pok;
begin
tek := prvi;
while (tek <> nil) do begin
writeln(tek^.jmbg,' ', tek^.vreme div 3600, ':'
, tek^.vreme div 60 mod 60, ':'
, tek^.vreme mod 60, ' '
, tek^.tip);
tek := tek^.sled;
end;
end;
procedure brisi (var prvi: pok);
var tek: pok;
begin
tek := prvi;
while (tek <> nil) do begin
prvi := tek;
tek := tek^.sled;
dispose(prvi);
Materijali za pripremu ispita iz Programiranja 1 18
end;
end;
begin
assign(ulaz, 'prijave.txt');
reset(ulaz);
l1 := nil; l2 := nil; l3 := nil; l4 := nil;
while not eof(ulaz) do
begin
while not eoln(ulaz) do
begin
new(novi);
read(ulaz, novi^.jmbg);
read(ulaz, str);
novi^.vreme := ((ord(str[2]) - ord('0')) * 10 +
(ord(str[3]) - ord('0')) )* 3600 +
((ord(str[5]) - ord('0')) * 10 +
(ord(str[6]) - ord('0'))) * 60 +
((ord(str[8]) - ord('0')) * 10 +
(ord(str[9]) - ord('0')));
novi^.tip := str[11];
case novi^.tip of
'D': ubaci(l1, novi);
'T': ubaci(l2, novi);
'P': ubaci(l3, novi);
'Z': ubaci(l4, novi);
end;
end;
readln(ulaz);
end;
pisi(l1); pisi(l2); pisi(l3); pisi(l4);
brisi(l1); brisi(l2); brisi(l3); brisi(l4);
close(ulaz);
end.
Materijali za pripremu ispita iz Programiranja 1 19
P1, ispit, oktobar 2012.
Zadatak 1.
Napisati program na programskom jeziku Pascal koji sa standardnog ulaza čita tekst koji treba ispisati na standardni
izlaz, pri čemu treba izostaviti delove teksta ograđene malim, okruglim zagradama. Uređenost teksta po redovima treba zadržati, pri čemu treba odbaciti one prelaske u novi red koji su deo teksta koji se odbacuje. Čitanje teksta
završiti kada se pročita prazan red. Smatrati da su zagrade u ulaznom tekstu pravilno uparene.
program z1okt1112(input, output);
var linija: string[255];
i: integer;
ind: boolean;
begin
writeln('Unesite tekst: ');
ind := false;
readln(input, linija);
while(length(linija) > 0) do
begin
for i:= 1 to length(linija) do
begin
if linija[i] = '(' then ind := true
else if linija[i] = ')' then ind := false
else if not ind then write(output, linija[i]);
end;
if not ind then writeln(output);
readln(input, linija);
end;
end.
Materijali za pripremu ispita iz Programiranja 1 20
P1, ispit, januar 2013.
Zadatak 2.
Napisati program na programskom jeziku Paskal koji treba da pronađe sve natprosečne studente. Natprosečan
student je onaj čiji je prosek ocena veći od srednje vrednosti prosečnih ocena svih studenata. Podaci o studentima su dati u tekstualnoj datoteci studenti.txt, tako da su u svakom redu zapisani podaci za tačno jednog studenta. Podaci u
jednom redu su odvojeni blanko znakovima i navedeni po sledećem redosledu: ime (niz od maksimalno 20 znakova),
prezime (niz od maksimalno 20 znakova) i na kraju niz ocena položenih ispita. Nakon obrade, imena, prezimena i prosečne ocene natprosečnih studenata ispisati na standardni izlaz uz očuvanje redosleda pojavljivanja u ulaznom
fajlu. Učitavanje podataka iz ulazne datoteke, računanje srednje vrednosti proseka svih studenata, kao i ispis natprosečnih studenata realizovati kao zasebne potprograme. Potprogrami sa programom i drugim potprogramima
komuniciraju isključivo preko parametara i povratne vrednosti. Voditi računa o ispravnoj alokaciji i dealokaciji
korišćenih resursa.
PROGRAM Zadatak2;
TYPE PElement = ^Element;
Element = RECORD
ime : string[20]; prezime : string[20]; prosek : real; sledeci :
PElement;
END;
VAR
listaStudenata : PElement;
srednjaVrednostProseka : real;
FUNCTION ucitaj : PElement;
VAR ulaz : text; c : char; student, lista, zadnji : PElement;
ocena, n : integer; suma : real;
BEGIN
lista := NIL; zadnji := NIL;
assign(ulaz,'studenti.txt'); reset(ulaz);
WHILE NOT(eof(ulaz)) DO BEGIN
new(student);
student^.ime := ''; student^.prezime := ''; student^.prosek := 0;
student^.sledeci := NIL;
REPEAT
read(ulaz,c);
IF c <> ' ' THEN student^.ime := student^.ime + c;
UNTIL eoln(ulaz) OR (c = ' ');
REPEAT
read(ulaz,c);
IF c <> ' ' THEN student^.prezime := student^.prezime + c;
UNTIL eoln(ulaz) OR (c = ' ');
suma := 0; n := 0;
WHILE NOT(eoln(ulaz)) DO BEGIN
read(ulaz, ocena);
IF ocena>5 THEN BEGIN suma := suma + ocena; n := n + 1 END
END;
readln(ulaz);
IF n > 0 THEN student^.prosek := suma/n;
IF lista = NIL THEN lista := student
ELSE zadnji^.sledeci := student;
zadnji := student;
END;
close(ulaz);
ucitaj := lista
END;
Materijali za pripremu ispita iz Programiranja 1 21
FUNCTION nadjiSrednjuVrednostProseka(lista : PElement) : real;
VAR suma : real; n : integer;
BEGIN
suma := 0; n := 0;
WHILE lista <> NIL DO BEGIN
suma := suma + lista^.prosek; n := n + 1; lista := lista^.sledeci;
END;
nadjiSrednjuVrednostProseka := suma / n;
END;
{ova procedura nije trazena, moze se resiti i bez nje, samo ispisom
natrprosecnih}
PROCEDURE izbaci(VAR lista : PElement; srednjiProsek : real);
VAR tekuci, prethodni, pomocni : PElement;
BEGIN
tekuci := lista; prethodni := NIL;
WHILE tekuci <> NIL DO BEGIN
IF tekuci^.prosek <= srednjiProsek THEN BEGIN
IF prethodni = NIL THEN lista := tekuci^.sledeci
ELSE prethodni^.sledeci := tekuci^.sledeci;
pomocni := tekuci;
tekuci := tekuci^.sledeci;
dispose(pomocni);
END
ELSE BEGIN prethodni := tekuci; tekuci := tekuci^.sledeci; END;
END;
END;
PROCEDURE ispisi(lista : PElement);
BEGIN
WHILE lista <> NIL DO
BEGIN
writeln(lista^.ime, ' ', lista^.prezime);
lista := lista^.sledeci
END
END;
PROCEDURE obrisiListu(VAR lista : PElement);
VAR
pom : PElement;
BEGIN
WHILE lista <> NIL DO BEGIN
pom := lista^.sledeci;
dispose(lista);
lista := pom
END
END;
BEGIN
listaStudenata := ucitaj;
srednjaVrednostProseka := nadjiSrednjuVrednostProseka(listaStudenata);
izbaci(listaStudenata, srednjaVrednostProseka);
ispisi(listaStudenata);
obrisiListu(listaStudenata)
END.
Materijali za pripremu ispita iz Programiranja 1 22
P1, ispit, februar 2013.
Zadatak 2.
Napisati program na programskom jeziku Paskal koji vrši obradu SMS glasova publike na takmičenju „Prvi glas Srbije“.
U datoteci takmicari.txt se nalazi spisak takmičara po sledećem formatu: redni broj takmičara (ceo broj), ime (niz od maksimalno 20 znakova) i prezime (niz od maksimalno 20 znakova). U datoteci glasovi.txt se nalaze podaci o
pristiglim SMS glasovima po sledećem formatu: redni broj takmičara (ceo broj), broj sa koga je izvršeno glasanje (ceo
broj) i oznaka zemlje iz koje je izvršeno glasanje (RS - Srbija ili CG - Crna Gora). Program treba da pročita navedene datoteke i na standardni izlaz ispiše imena i prezimena dvoje takmičara sa najmanjim brojem glasova koji idu u duel
na takmičenju. Za oba takmičara ispisati koliko glasova su dobili iz svake od zemalja. Broj takmičara i ukupan broj
glasova nisu unapred poznati. Voditi računa o ispravnoj upotrebi korišćenih resursa.
program z2feb1213(input, output);
type pok = ^elem;
elem = record
id: integer; ime: string[30]; prezime: string[30]; glasovi_rs:
integer;
glasovi_cg: integer; sled: pok;
end;
var prvi: pok;
procedure ucitaj_takmicare(var prvi: pok);
var ulaz: text; novi, posl: pok; c: char;
begin
assign(ulaz, 'takmicari.txt'); reset(ulaz);
prvi:= nil; posl:= nil;
while not eof(ulaz) do
begin
new(novi); novi^.sled:= nil; novi^.glasovi_rs:= 0; novi^.glasovi_cg:= 0;
novi^.ime:= ''; novi^.prezime:= '';
read(ulaz, novi^.id); read(ulaz, c); read(ulaz, c);
while c <> ' ' do begin novi^.ime:= novi^.ime + c; read(ulaz, c); end;
readln(ulaz, novi^.prezime);
if prvi = nil then prvi:= novi else posl^.sled:= novi;
posl:= novi;
end;
close(ulaz);
end;
procedure azuriraj_glasove(prvi: pok; id: integer; zemlja: string);
var nasao: boolean;
begin
nasao := false;
while (prvi <> nil) and (not nasao) do begin
if (prvi^.id = id) then begin
nasao:= true;
if zemlja = 'RS' then inc(prvi^.glasovi_rs);
if zemlja = 'CG' then inc(prvi^.glasovi_cg);
end;
prvi:= prvi^.sled;
end;
end;
procedure ucitaj_glasove(prvi: pok);
var ulaz: text; tek: pok; id, telefon: integer; zemlja: string[2]; c: char;
begin
assign(ulaz, 'glasovi.txt');
reset(ulaz);
while not eof(ulaz) do begin
readln(ulaz, id, telefon, c, zemlja);
azuriraj_glasove(prvi, id, zemlja);
end;
close(ulaz);
Materijali za pripremu ispita iz Programiranja 1 23
end;
procedure duel (prvi: pok);
var min1, min2: pok;
begin
min1:= prvi;
min2:= prvi^.sled;
while prvi <> nil do begin
if (prvi^.glasovi_rs + prvi^.glasovi_cg) < (min1^.glasovi_rs +
min1^.glasovi_cg) then begin
min2:= min1;
min1:= prvi;
end
else if (prvi^.glasovi_rs + prvi^.glasovi_cg) < (min2^.glasovi_rs +
min2^.glasovi_cg) then begin
min2:= prvi;
end;
prvi:= prvi^.sled;
end;
writeln('U duel idu: ');
writeln(min1^.id, ' ', min1^.ime, ' ', min1^.prezime, ' ',
min1^.glasovi_rs, ' ', min1^.glasovi_cg);
writeln(min2^.id, ' ', min2^.ime, ' ', min2^.prezime, ' ',
min2^.glasovi_rs, ' ', min2^.glasovi_cg);
end;
procedure dealociraj (var prvi: pok);
var stari : pok;
begin
stari := prvi;
while (prvi <> nil) do begin
prvi := prvi^.sled; dispose(stari); stari := prvi;
end;
end;
begin
prvi:= nil;
ucitaj_takmicare(prvi); ucitaj_glasove(prvi); duel(prvi);
dealociraj(prvi);
end.
Materijali za pripremu ispita iz Programiranja 1 24
P1, ispit, jul 2013.
Zadatak 2.
Napisati potprogram na programskom jeziku Paskal koji vrši obradu nad dve matrice celih brojeva. Potprogram treba
da utvrdi da li se prva matrica može dobiti transponovanjem druge matrice. Svaka matrica je smeštena u posebnoj datoteci po sledećem formatu - u prvom redu datoteke se nalaze dva cela broja M i N koji predstavljaju broj vrsta i
kolona matrice, a u narednim redovima su zadate vrste matrice, u svakom redu zasebna vrsta. Imena datoteka u
kojima su smeštene matrice se čitaju sa glavnog ulaza. Napisati program na programskom jeziku Paskal koji pročita sadržaj zadatih datoteka, izvrši proveru realizovanu potprogramom i ispiše da li se prva matrica može dobiti
transponovanjem druge matrice. Potprogram sa glavnim programom treba da komunicira isključivo putem
argumenata i povratne vrednosti. Smatrati da su matrice maksimalnih dimenzija 20x20.
program z1_jul_1213(input, output);
const
MAX = 20;
type
matrica = array[1..MAX, 1..MAX] of integer;
var
ime: string;
mat1, mat2: matrica;
m1, n1, m2, n2: integer;
ind: boolean;
procedure ucitaj(var mat: matrica; var m, n: integer; var ime: string);
var ulaz: text;
i, j: integer;
begin
assign(ulaz, ime);
reset(ulaz);
i := 1; j := 1;
if not eof(ulaz) then read(ulaz, m);
if not eof(ulaz) then readln(ulaz, n);
while not eof(ulaz) do
begin
while not eoln(ulaz) do begin
read(ulaz, mat[i, j]);
j := j + 1;
end;
i := i + 1;
j := 1;
readln(ulaz);
end;
close(ulaz);
end;
function provera(var mat1, mat2: matrica; m1, n1, m2, n2: integer) : boolean;
var
i, j: integer;
begin
provera := true;
if (m1 = n2) and (n1 = m2) then
begin
for i := 1 to m1 do
for j := 1 to n1 do
if (mat1[i, j] <> mat2[j, i]) then provera := false;
end
else provera := false;
end;
Materijali za pripremu ispita iz Programiranja 1 25
begin
write('Unesite ime prve datoteke: ');
readln(ime);
ucitaj(mat1, m1, n1, ime);
write('Unesite ime druge datoteke: ');
readln(ime);
ucitaj(mat2, m2, n2, ime);
ind := provera(mat1, mat2, m1, n1, m2, n2);
if (ind) then
writeln('Prva matrica se moze dobiti transponovanjem druge matrice!')
else
writeln('Prva matrica se ne moze dobiti transponovanjem druge matrice!');
end.
Materijali za pripremu ispita iz Programiranja 1 26
P1, ispit, septembar 2013.
Zadatak 2.
Napisati program na programskom jeziku Paskal koji pomaže studentskoj službi prilikom kontrole zabrane izlaska na
ispit. Podaci o studentima kojima je zabranjen izlazak na ispit dati su u datoteci zabrane.txt. U svakom redu su zapisane informacije o tačno jednom studentu, i to broj indeksa i period u kojem je zabranjen izlazak na ispit u
sledećem formatu: gggg/bbbb dd.mm.gggg. dd.mm.gggg.. U drugoj datoteci, ispit.txt, date su informacije o ispitu.
U prvom redu datoteke zapisan je datum ispita u formatu dd.mm.gggg., dok je u nastavku dat spisak prijavljenih studenata. Za svakog studenta dati su broj indeksa u formatu gggg/bbbb, ime i prezime kao niz znakova do kraja
reda, najviše 30 znakova. Program treba da na osnovu date dve ulazne datoteke formira izlaznu datoteku dozvoljen_izlazak.txt koja je istog formata kao datoteka ispit.txt, s tim da su u izlaznoj datoteci izostavljeni oni
studenti kojima posmatrani ispit upada u period zabrane. U period zabrane uključeni su i granični datumi dati u
datoteci zabrane.txt. Datoteku zabrane.txt je dozvoljeno čitati samo jednom. Maksimalan broj studenata kojima je
zabranjen izlazak na ispit nije poznat unapred.
program z2sep1213(input,output);
type
pokaz = ^Elem;
Elem = record
br_indeksa: string[9]; datum1: string[11]; datum2: string[11]; sled:
pokaz;
end;
var prvi, preth, novi, tek: pokaz;
c: char;
zabrana, ispit, dozvoljen: text;
imeprezime: string[30];
indeks: string[9];
datum: string[11];
ok, nasao: boolean;
function dani(datum: string) : longint;
var dan, mes, god, dana: longint;
s1, s2, s3: set of 1..12;
begin
s1 := [1, 3, 5, 7, 8, 10, 12]; s2 := [4, 6, 9, 11]; s3 := [2];
dan := (ord(datum[1]) - ord('0'))*10 + ord(datum[2]) - ord('0');
mes := (ord(datum[4]) - ord('0'))*10 + ord(datum[5]) - ord('0');
god := (ord(datum[7]) - ord('0'))*1000 + (ord(datum[8]) - ord('0'))*100 +
(ord(datum[9]) - ord('0'))*10 + ord(datum[10]) - ord('0');
if mes in s1 then dana := 31;
if mes in s2 then dana := 30;
if mes in s3 then dana := 28;
dani := dan + mes * dana + god * 365;
end;
begin
assign(zabrana, 'zabrane.txt');
assign(ispit, 'ispit.txt');
assign(dozvoljen, 'dozvoljen_izlazak.txt');
reset(zabrana);
reset(ispit);
rewrite(dozvoljen);
preth := nil;
prvi := nil;
Materijali za pripremu ispita iz Programiranja 1 27
while not eof(zabrana) do begin
while not eoln(zabrana) do begin
new(novi);
novi^.br_indeksa :=''; read(zabrana, c);
while c <> ' ' do begin
novi^.br_indeksa := novi^.br_indeksa + c; read(zabrana, c);
end;
novi^.datum1 :=''; read(zabrana, c);
while c <> ' ' do begin
novi^.datum1 := novi^.datum1 + c; read(zabrana, c);
end;
novi^.datum2 :=''; read(zabrana, c);
while not eoln(zabrana) do begin
novi^.datum2 := novi^.datum2 + c; read(zabrana, c);
end;
novi^.sled := nil;
if prvi = nil then prvi := novi else preth^.sled := novi;
preth := novi;
end;
readln(zabrana);
end;
if not eof(ispit) then begin readln(ispit, datum); end;
while not eof(ispit) do begin
indeks := ''; read(ispit, c);
while c <> ' ' do begin
indeks := indeks + c;read(ispit, c);
end;
readln(ispit, imeprezime);
tek := prvi; ok := true; nasao := false;
while (tek <> nil) and (not nasao) do begin
if (tek^.br_indeksa = indeks) then begin
nasao := true;
if (dani(tek^.datum1) < dani(datum)) and
(dani(tek^.datum2) > dani(datum)) then ok := false;
end;
tek := tek^.sled;
end;
if ok = true then writeln(dozvoljen, indeks, ' ', imeprezime);
end;
while (prvi <> nil) do begin
preth := prvi; prvi := prvi^.sled; dispose(preth);
end;
close(zabrana); close(ispit); close(dozvoljen);
end.
Materijali za pripremu ispita iz Programiranja 1 28
P1, ispit, oktobar 2013.
Zadatak 1.
Napisati program na programskom jeziku Pascal koji prepisuje sadržaj ulazne tekstualne datoteke u izlaznu tekstualnu
datoteku. Prilikom prepisivanja treba izostaviti sve one reči koje sadrže bilo koji znak koji se nalazi u zadatom skupu znakova. Sadržaj skupa se učitava na početku programa sa glavnog ulaza. Smatrati da jedna reč predstavlja bilo koji
niz slova i cifara između dva blanko znaka, početka reda i blanko znaka, blanko znaka i kraja reda ili početka reda i
kraja reda. Jedan red u ulaznoj tekst datoteci nije duži od 80 znakova. Imena ulazne i izlazne datoteke se zadaju
putem glavnog ulaza.
program z1_okt_1213(input, output);
var ulaz, izlaz: text;
imeulaz, imeizlaz, rec: string;
skup: set of char;
c: char;
n, i: integer;
blanko, izbaci: boolean;
begin
writeln('Unesite ime ulazne datoteke: ');
readln(imeulaz);
writeln('Unesite ime izlazne datoteke: ');
readln(imeizlaz);
assign(ulaz, imeulaz); reset(ulaz);
assign(izlaz, imeizlaz); rewrite(izlaz);
write('Unesite broj elemenata u skupu znakova: ');
readln(n);
skup := [];
for i:= 1 to n do begin
read(c);
skup := skup + [c];
end;
while not eof(ulaz) do begin
while not eoln(ulaz) do begin
rec := '';
blanko := false;
repeat
read(ulaz, c);
rec := rec + c;
if c = ' ' then blanko := true;
until eoln(ulaz) or blanko;
izbaci := false;
for i:= 1 to length(rec) do if (rec[i] in skup) then izbaci := true;
if not izbaci then write(izlaz, rec);
end;
readln(ulaz);
writeln(izlaz);
end;
close(ulaz);
close(izlaz);
end.
Materijali za pripremu ispita iz Programiranja 1 29
P1, ispit, januar 2014.
Zadatak 2.
Napisati program na programskom jeziku Pascal koji vrši obradu podataka koji su očitani sa električnog brojila
(strujomera) tokom nekog perioda. Podaci o utrošenoj električnoj energiji su dati u datoteci struja.txt, a u svakom redu su zapisani podaci o jednom očitavanju. Podaci u jednom redu su odvojeni jednim blanko znakom i navedeni po
sledećem formatu: datum očitavanja (u obliku dd-mm-gg, gde dd označava dan, mm označava mesec, a gg godinu),
stanje brojila u višoj tarifi (ceo broj) i stanje brojila u nižoj tarifi (ceo broj). Smatrati da se sva očitavanja obavljaju navedenog datuma u ponoć. Zbog loših telekomunikacionih linija, očitavanja se ne vrše svaki dan, ali se može
smatrati da je datoteka uređena rastuće po datumu i da je naredno očitano stanje brojila veće ili jednako prethodnom. Program treba da učita podatke o utrošenoj električnoj energiji iz navedene datoteke i izračuna i ispiše
ukupnu potrošnju električne energije, kao i početak i kraj perioda između dva uzastopna očitavanja između kojih je
potrošnja električne energije bila najmanja u višoj tarifi i najveća u nižoj tarifi. Voditi računa o ispravnoj upotrebi
korišćenih resursa.
program z2jan_1314(input, output, ulaz);
type
pokaz = ^ocitavanje;
ocitavanje = record
datum: string[8];
vt: integer;
nt: integer;
sled: pokaz;
end;
var
ulaz: text;
prvi, novi, preth, tek, minvt, maxnt: pokaz;
c: char;
ukupna_potrosnja, min, max, tr: integer;
begin
assign(ulaz, 'struja.txt');
reset(ulaz);
prvi := nil;
preth := nil;
while not eof(ulaz) do begin
new(novi);
novi^.sled := nil;
read(ulaz, novi^.datum);
read(ulaz, c);
read(ulaz, novi^.vt);
readln(ulaz, novi^.nt);
if prvi = nil then prvi := novi
else preth^.sled := novi;
preth := novi;
end;
ukupna_potrosnja := preth^.vt - prvi^.vt + preth^.nt - prvi^.nt;
{min. u vt}
minvt := prvi;
min := prvi^.sled^.vt - prvi^.vt;
tek := prvi^.sled;
Materijali za pripremu ispita iz Programiranja 1 30
while tek^.sled <> nil do begin
tr := tek^.sled^.vt - tek^.vt;
if tr < min then begin
min := tr;
minvt := tek;
end;
tek := tek^.sled;
end;
{max. u nt}
maxnt := prvi;
max := prvi^.sled^.nt - prvi^.nt;
tek := prvi^.sled;
while tek^.sled <> nil do begin
tr := tek^.sled^.nt - tek^.nt;
if tr > max then begin
max := tr;
maxnt := tek;
end;
tek := tek^.sled;
end;
writeln(output, 'Ukupna potrosnja za period: ', ukupna_potrosnja, ' kW');
writeln(output, 'Minimalna potrosnja u visoj tarif u periodu: ',
minvt^.datum, ' ', minvt^.sled^.datum);
writeln(output, 'Maksimalna potrosnja u nizoj tarif u periodu: ',
maxnt^.datum, ' ', maxnt^.sled^.datum);
tek := prvi;
while prvi <> nil do begin
tek := prvi;
prvi := prvi^.sled;
dispose(tek);
end;
close(ulaz);
end.
Materijali za pripremu ispita iz Programiranja 1 31
P1, ispit, februar 2014.
Zadatak 1.
Napisati potprogram na programskom jeziku Pascal koji utvrđuje da li dve zadate vrste matrice imaju jednak zbir
elemenata. Napisati program na programskom jeziku Pascal koji sa standardnog ulaza pročita dimenzije i sadržaj matrice celih brojeva, kao i jedan ceo broj X koji predstavlja redni broj neke vrste, a zatim koristeći realizovani
potprogram ispiše redne brojeve svih onih vrsta matrice koje imaju isti zbir elemenata kao i vrsta sa rednim brojem X.
Potprogram sa glavnim programom treba da komunicira isključivo putem argumenata i povratne vrednosti. Smatrati
da je matrica maksimalnih dimenzija 20x20.
program z1feb1314(input, output);
const MAX_VR = 20;
MAX_KOL = 20;
type mat = array [1..MAX_VR, 1..MAX_KOL] of integer;
var matr: mat;
i, j, m, n, x: integer;
s: set of 1..MAX_VR;
function jednak_zbir(var matr: mat; v1, v2, n: integer) : boolean;
var i, sum1, sum2: integer;
begin
sum1 := 0;
sum2 := 0;
for i:= 1 to n do
begin
sum1 := sum1 + matr[v1, i];
sum2 := sum2 + matr[v2, i];
end;
if sum1 = sum2 then jednak_zbir := true
else jednak_zbir := false
end;
begin
writeln(output, 'Unesite dimenzije matrice: ');
read(input, m, n);
if (m > 0) and (m <= MAX_VR) and (n > 0) and (n <= MAX_KOL) then
begin
writeln(output, 'Unesite elemente matrice: ');
for i:= 1 to m do
for j:= 1 to n do
read(input, matr[i, j]);
writeln(output, 'Unesite redni broj vrste za poredjenje: ');
read(input, x);
s := [];
for i:= 1 to m do
if (i <> x) then
if jednak_zbir(matr, x, i, n) then s := s + [i];
writeln(output, 'Vrste koje imaju jednak zbir kao vrsta ', x, ' su: ');
for i:= 1 to m do
if (i in s) then write(output, i, ' ');
end;
end.
Materijali za pripremu ispita iz Programiranja 1 32
P1, ispit, jun 2014.
Zadatak 2.
Napisati program na programskom jeziku Pascal koji vrši obradu nad plejlistom muzičkih numera. Podaci o muzičkim
numerama se nalaze u datoteci numere.pls. U svakom redu se nalaze podaci o jednoj muzičkoj numeri po sledećem formatu: trajanje numere u obliku mm:ss (mm – minuti, ss – sekunde), ime izvođača (jedna reč od najviše 30
znakova) i naziv numere koji može sadržati više reči do kraja reda. Smatrati da jedan red ne sadrži više od 255
znakova. Program treba da učita podatke o numerama, a zatim za svakog izvođača koji se pojavljuje u plejlisti ispiše naziv i ukupno trajanje njegovih numera u formatu mm:ss, gde ukupni minuti mogu imati više od dve cifre. Broj
izvođača nije poznat unapred, a numere istog izvođača ne moraju biti u susednim redovima. Voditi računa o ispravnoj
upotrebi korišćenih resursa.
program z2jun1314(input, output);
type pok = ^elem;
elem = record
izvodjac: string[30];
ukupno: integer;
sled: pok;
end;
var
prvi, novi, posl, tek: pok;
c: char;
mm, ss: integer;
ulaz: text;
izvodjac, numera: string;
nasao: boolean;
begin
assign(ulaz, 'numere.txt');
reset(ulaz);
prvi:= nil;
posl:= nil;
while not eof(ulaz) do
begin
read(ulaz, c);
mm:= 0;
repeat
mm := mm * 10 + ord(c) - ord('0');
read(ulaz, c);
until c = ':';
read(ulaz, c);
ss:= 0;
repeat
ss := ss * 10 + ord(c) - ord('0');
read(ulaz, c);
until c = ' ';
read(ulaz, c);
izvodjac:= '';
repeat
izvodjac:= izvodjac + c;
read(ulaz, c);
until c = ' ';
readln(ulaz, numera);
tek:= prvi;
nasao:= false;
while (tek <> nil) and (not nasao) do
begin
if tek^.izvodjac = izvodjac then nasao:= true
else tek:= tek^.sled;
end;
Materijali za pripremu ispita iz Programiranja 1 33
if nasao then
tek^.ukupno:= tek^.ukupno + mm * 60 + ss
else
begin
new(novi);
novi^.sled:= nil;
novi^.izvodjac:= izvodjac;
novi^.ukupno:= mm * 60 + ss;
if prvi = nil then
prvi:= novi
else
posl^.sled:= novi;
posl:= novi;
end;
end;
tek:= prvi;
while tek <> nil do
begin
mm:= tek^.ukupno div 60;
ss:= tek^.ukupno mod 60;
writeln(tek^.izvodjac, ' ', mm, ':', ss);
tek:= tek^.sled;
end;
while prvi <> nil do
begin
tek:= prvi;
prvi:= prvi^.sled;
dispose(tek);
end;
close(ulaz);
end.
Materijali za pripremu ispita iz Programiranja 1 34
P1, ispit, jul 2014.
Zadatak 1.
Napisati potprogram na programskom jeziku Pascal koji izračunava broj reči u zadatom stringu. Jednu reč predstavlja
neprekidni niz znakova između dva blanko znaka, početka stringa i blanko znaka ili blanko znaka i kraja stringa. Između dve reči može postojati više od jednog blanko znaka. Napisati program na programskom jeziku Pascal koji iz
ulazne datoteke čita red po red teksta, poziva realizovani potprogram i u izlaznu datoteku prepisuje samo one redove
koji sadrže neparan broj reči. Na kraju program treba da ispiše ukupan broj obrađenih redova i redova sa parnim i neparnim brojem reči. Imena ulazne i izlazne datoteke se čitaju sa standardnog ulaza. Smatrati da jedan red datoteke
nije duži od 255 znakova, kao i da počinje i završava se znakom koji nije blanko. Voditi računa o očuvanju uređenosti teksta u redove. Potprogram sa glavnim programom treba da komunicira isključivo putem argumenata i povratne
vrednosti.
program z1jul1314(input, output, ulaz, izlaz);
var ulaz, izlaz: text;
imeul, imeizl, linija: string;
br_reci: integer;
function brojreci (linija: string) : integer;
var br_reci, i: integer;
prvi: boolean;
begin
i := 1;
while (linija[i] = ' ') AND (i < length(linija)) do i := i + 1;
prvi := true;
br_reci := 0;
while (i < length(linija)) do begin
if (prvi = true) and (linija[i] <> ' ') then begin
prvi := false;
br_reci := br_reci + 1;
end;
if (linija[i] = ' ') then prvi := true;
i := i + 1;
end;
brojreci := br_reci;
end;
begin
write(output, 'Unesite ime ulazne datoteke: ');
readln(input, imeul);
write(output, 'Unesite ime izlazne datoteke: ');
readln(input, imeizl);
assign(ulaz, imeul); assign(izlaz, imeizl);
reset(ulaz); rewrite(izlaz);
while not eof(ulaz) do begin
readln(ulaz, linija);
br_reci := brojreci(linija);
if (br_reci mod 2 = 1) then writeln(izlaz, linija);
end;
close(ulaz);
close(izlaz);
end.
Materijali za pripremu ispita iz Programiranja 1 35
P1, ispit, septembar 2014.
Zadatak 2.
Napisati program na programskom jeziku Pascal koji vrši obradu nad spiskom zvanica za venčanje. Podaci o
zvanicama se nalaze u tekst datoteci vencanje.txt. Podaci u jednom redu su odvojeni jednim blanko znakom i navedeni su po sledećem formatu: ime osobe (niz od najviše 20 znakova), prezime osobe (niz od najviše 20 znakova)
i jedan znak koji označava način uručivanja pozivnice (L – lično, E – elektronskom poštom). U datoteci adresar.txt se
nalaze kontakt podaci zvanica sa njihovim adresama elektronske pošte po sledećem formatu: ime osobe (niz od najviše 20 znakova), prezime osobe (niz od najviše 20 znakova) i zatim adresa elektronske pošte (niz od najviše 30
znakova). Ne moraju postojati kontakt podaci svih zvanica u adresaru. Program treba da učita podatke o zvanicama kojima treba poslati pozivnice elektronskom poštom u jednostruko ulančanu listu, a zatim iz liste ukloni sve one
zvanice čiji kontakt podaci nisu pronađeni u adresaru. Nakon obrade, ispisati listu zvanica na standardni izlaz po
formatu: ime osobe, prezime osobe i adresa elektronske pošte. Voditi računa o ispravnoj upotrebi korišćenih resursa.
program z2_sep_1314(input, output);
type pok = ^elem;
elem = record
ime: string[30]; prezime: string[30]; email: string[30];
poznat_email: boolean;
sled: pok;
end;
var prvi, posl, novi, tek: pok;
vencanje, adresar: text;
c: char;
ime, prezime, email: string[30];
nasao: boolean;
procedure citaj_rec(var s: string; var ulaz: text);
var c: char;
begin
s := '';
repeat
read(ulaz, c);
if c <> ' ' then s := s + c;
until (c = ' ') or (eoln(ulaz));
end;
begin
assign(vencanje, 'vencanje.txt'); assign(adresar, 'adresar.txt');
reset(vencanje); reset(adresar);
prvi := nil; posl := nil;
while not eof(vencanje) do begin
citaj_rec(ime, vencanje);
citaj_rec(prezime, vencanje);
readln(vencanje, c);
if c = 'E' then begin
new(novi);
novi^.ime := ime; novi^.prezime := prezime;
novi^.email := ''; novi^.poznat_email := false;
novi^.sled := nil;
if prvi = nil then prvi := novi
else posl^.sled := novi;
posl := novi;
end;
end;
while not eof(adresar) do begin
citaj_rec(ime, adresar);
citaj_rec(prezime, adresar);
citaj_rec(email, adresar);
tek := prvi;
nasao := false;
Materijali za pripremu ispita iz Programiranja 1 36
while (tek <> nil) and (not nasao) do begin
if (tek^.ime = ime) and (tek^.prezime = prezime) then begin
tek^.email := email;
tek^.poznat_email := true;
nasao := true;
end;
tek := tek^.sled;
end;
readln(adresar);
end;
tek := prvi;
posl := nil;
while tek <> nil do begin
if tek^.poznat_email = false then
begin
novi := tek;
tek := tek^.sled;
if posl = nil then prvi := tek
else posl^.sled := tek;
dispose(novi);
end
else begin
posl := tek;
tek := tek^.sled;
end;
end;
tek := prvi;
while tek <> nil do begin
writeln(output, tek^.ime,' ',tek^.prezime,' ',tek^.email);
tek := tek^.sled;
end;
while prvi <> nil do begin
tek := prvi; prvi := prvi^.sled; dispose(tek);
end;
close(vencanje); close(adresar);
end.
Materijali za pripremu ispita iz Programiranja 1 37
P1, ispit, januar 2016.
Zadatak 1.
Napisati potprogram na programskom jeziku Pascal koji od dva neopadajuće uređena niza celih brojeva formira treći,
takođe neopadajuće uređen niz, u kojem se svaka vrednost pojavljuje najviše jednom (odbacuju se višestruka pojavljivanja vrednosti). Napisati glavni program koji učitava dva niza brojeva, proverava da li su elementi u oba niza
uređeni neopadajuće i ukoliko jesu, poziva opisani potprogram i ispisuje rezultujući niz. Ukoliko neki od nizova nije
uređen neopadajuće, od korisnika zatražiti da ponovi unos tog niza. Smatrati da nizovi koji se učitavaju imaju najviše
100 elemenata.
program z1jan1516;
const MAX = 100;
type niz = array [1..MAX] of integer;
var a, b, c: niz;
i, n1, n2, n3: integer;
ind1, ind2: boolean;
procedure pomeri(var a: niz; var i: integer; n: integer);
begin
while (a[i-1] = a[i]) and (i <= n) do i:= i + 1;
end;
procedure spoji(var a, b, c: niz; n1, n2: integer; var n3: integer);
var i, j, k: integer;
begin
i:= 1; j:= 1; k:= 1;
while (i <= n1) and (j <= n2) do
begin
if (a[i] < b[j]) then
begin
c[k]:= a[i]; i:= i + 1; k:= k + 1;
pomeri(a, i, n1);
end;
if (a[i] > b[j]) then
begin
c[k]:= b[j]; j:= j + 1; k:= k + 1;
pomeri(b, j, n2);
end;
if (a[i] = b[j]) then
begin
c[k]:= b[j];
k:= k + 1; i:= i + 1; j:= j + 1;
pomeri(a, i, n1); pomeri(b, j, n2);
end;
end;
if (i <= n1) then while (i <= n1) do begin
c[k]:= a[i]; i:= i + 1; k:= k + 1;
pomeri(a, i, n1);
end;
if (j <= n2) then while (j <= n2) do begin
c[k]:= b[j]; j:= j + 1; k:= k + 1;
pomeri(b, j, n2);
end;
n3:= k - 1;
end;
Materijali za pripremu ispita iz Programiranja 1 38
function provera(var a: niz; n: integer) : boolean;
var i: integer;
begin
provera:= true;
i:= 2;
while (i <= n) and provera do
if (a[i-1] <= a[i]) then i:= i+1
else provera:= false;
end;
begin
write(output,'Unesi broj clanova prvog niza: ');
readln(input,n1);
ind1:= false;
while not ind1 do
begin
writeln(output,'Unesite prvi niz: ');
for i:=1 to n1 do
read(input, a[i]);
ind1:= provera(a, n1);
end;
write(output,'Unesi broj clanova drugog niza: ');
readln(input,n2);
ind2:= false;
while not ind2 do
begin
writeln(output,'Unesite drugi niz: ');
for i:=1 to n2 do
read(input, b[i]);
ind2:= provera(b, n2);
end;
if (ind1 and ind2) then
begin
spoji(a,b,c,n1,n2,n3);
write(output,'Rezultujuci niz glasi:');
for i:= 1 to n3 do
write(output, c[i],' ');
end;
readln;
end.
Materijali za pripremu ispita iz Programiranja 1 39
P1, ispit, februar 2016.
Zadatak 1.
Napisati program na programskom jeziku Pascal koji vrši određenu obradu nad dve matrice celih brojeva. Svaka
matrica je upisana u zasebnu datoteku po sledećem formatu: u prvom redu datoteke se nalaze dva cela broja M i N koji predstavljaju broj vrsta i broj kolona matrice; u narednih M redova datoteke se nalazi po N celih brojeva koji
predstavljaju sadržaj matrice. Program treba da učita imena datoteka koje sadrže matrice, a zatim da iz zadatih
datoteka učita matrice. Program potom treba da proveri da li se prva učitana matrica može dobiti transponovanjem druge učitane matrice. Rezultat provere ispisati na glavnom izlazu. Proveru da li se jedna matrica može dobiti
transponovanjem druge matrice realizovati kao zaseban potprogram koji sa glavnim programom komunicira isključivo putem argumenata i povratne vrednosti. Smatrati da celi brojevi M i N nisu veći od 100, kao i da je sadržaj datoteka
ispravan. Voditi računa o ispravnoj upotrebi korišćenih resursa.
program z1feb1516(input, output, ulaz);
const MAX = 100;
type matrica = array [1..MAX, 1..MAX] of integer;
var mat1, mat2: matrica;
m1, n1, m2, n2, i, j: integer;
ulaz1, ulaz2: text;
ime1, ime2: string;
procedure ucitaj(var ulaz: text; var mat: matrica; var m, n: integer);
var i, j: integer;
begin
if not eof(ulaz) then readln(ulaz, m, n);
for i:= 1 to m do begin
for j:= 1 to n do
if not eof(ulaz) then read(ulaz, mat[i, j]);
readln(ulaz);
end;
end;
function provera(var mat1, mat2: matrica; m1, n1, m2, n2: integer) : boolean;
var i, j: integer;
begin
provera := true;
if (m1 <> m2) or (n1 <> n2) then provera := false;
for i:= 1 to m1 do
for j:= 1 to n1 do
if mat1[i, j] <> mat2[j, i] then provera := false;
end;
begin
write(output, 'Ime prve datoteke: ');
readln(input, ime1);
write(output, 'Ime druge datoteke: ');
readln(input, ime2);
assign(ulaz1, ime1); assign(ulaz2, ime2);
reset(ulaz1); reset(ulaz2);
ucitaj(ulaz1, mat1, m1, n1);
ucitaj(ulaz2, mat2, m2, n2);
if provera(mat1, mat2, m1, n1, m2, n2) then
writeln(output, 'Prva matrica se moze dobiti transponovanjem druge
matrice!')
else
writeln(output, 'Prva matrica se ne moze dobiti transponovanjem druge
matrice!');
close(ulaz1);
close(ulaz2);
end.
Materijali za pripremu ispita iz Programiranja 1 40
P1, ispit, jun 2016.
Zadatak 2.
Neka se u tekst datoteci muzeji.txt nalaze podaci o muzejima po sledećem formatu: vreme otvaranja u formatu
hh:mm (hh – sati, mm – minuti), vreme zatvaranja u formatu hh:mm (hh – sati, mm – minuti), cena ulaznice (realan broj) i naziv muzeja (niz znakova od najviše 255 karaktera koji može sadržati blanko znake). Smatrati da je vreme
otvaranja uvek manje od vremena zatvaranja muzeja. Napisati program na programskom jeziku Pascal koji na osnovu
sadržaja datoteke formira jednostruko ulančanu listu podataka o muzejima, potom sa standardnog ulaza učita početak i kraj intervala po istom formatu kao u datoteci i na standardni izlaz ispiše sve one muzeje koji su otvoreni tokom
čitavog zadatog intervala po nerastućoj ceni ulaznice. Voditi računa o ispravnoj upotrebi korišćenih resursa.
program z2jun1516(input, output);
type pokaz = ^elem;
elem = record
naziv: string;
vreme_otvaranja: integer;
vreme_zatvaranja: integer;
cena_ulaznice: integer;
sled: ^elem;
end;
var lista, novi, preth, tek: pokaz;
ulaz: text;
znak: char;
pocetak_intervala, kraj_intervala, h, m: integer;
ind: boolean;
function citaj_vreme(var ulaz: text) : integer;
var znak: char;
h, m: integer;
begin
if not eof(ulaz) then read(ulaz, znak);
h := (ord(znak) - ord('0'));
if not eof(ulaz) then read(ulaz, znak);
h := 10 * h + (ord(znak) - ord('0'));
if not eof(ulaz) then read(ulaz, znak);
if not eof(ulaz) then read(ulaz, znak);
m := (ord(znak) - ord('0'));
if not eof(ulaz) then read(ulaz, znak);
m := 10 * m + (ord(znak) - ord('0'));
citaj_vreme := h*60 + m;
end;
begin
assign(ulaz, 'muzeji.txt');
reset(ulaz);
preth := nil;
lista := nil;
while not eof(ulaz) do begin
new(novi);
novi^.sled := nil;
novi^.vreme_otvaranja:= citaj_vreme(ulaz);
read(ulaz, znak);
novi^.vreme_zatvaranja:=citaj_vreme(ulaz);
read(ulaz, novi^.cena_ulaznice);
read(ulaz, znak);
readln(ulaz, novi^.naziv);
if (lista = nil) then lista := novi
else begin
preth := nil;
tek := lista;
ind := true;
Materijali za pripremu ispita iz Programiranja 1 41
while (tek <> nil) and ind do
begin
if (tek^.cena_ulaznice > novi^.cena_ulaznice) then
ind := false;
preth:=tek;
tek:=tek^.sled;
end;
novi^.sled:=tek;
preth^.sled:=novi;
end;
end;
writeln(output, 'Unesite pocetak intervala od interesa hh:mm: ');
pocetak_intervala:= citaj_vreme(input);
writeln(output, 'Unesite kraj intervala od interesa hh:mm: ');
kraj_intervala:= citaj_vreme(input);
tek := lista;
while (tek <> nil) do begin
if (tek^.vreme_otvaranja <= pocetak_intervala) and (kraj_intervala <=
tek^.vreme_zatvaranja) then
begin
h := tek^.vreme_otvaranja div 60;
m := tek^.vreme_otvaranja mod 60;
write(h:2, ':',m:2,' ');
h := tek^.vreme_zatvaranja div 60;
m := tek^.vreme_zatvaranja mod 60;
writeln(h:2, ':',m:2,' ', tek^.cena_ulaznice,' ',tek^.naziv);
end;
tek := tek^.sled;
end;
while (tek <> nil) do begin
preth := tek;
tek := tek^.sled;
dispose(preth);
end;
close(ulaz);
end.
Materijali za pripremu ispita iz Programiranja 1 42
P1, ispit, oktobar 2016.
Zadatak 2.
Napisati program na programskom jeziku Pascal koji sa standardnog ulaza učitava proizvoljan broj obojenih krugova u
ravni. Krug je određen poluprečnikom, koordinatama centra i bojom popunjavanja (ceo broj u opsegu 0..15). Kraj unosa se označava negativnim poluprečnikom kruga. Posle učitavanja krugova, program ciklično učitava jednu po
jednu tačku sa standardnog ulaza i određuje njenu boju koju ispisuje na standardnom izlazu. Kraj unosa se označava
tačkom (0,0). Smatrati da se učitani krugovi postavljaju na pozadinu bele boje po redosledu učitavanja. Kasnije učitani krug može zaklanjati neke od postojećih. Potrebno je napisati i iskoristiti potprogram koji određuje da li se zadata
tačka nalazi unutar zadatog kruga. Potprogram treba da komunicira sa glavnim programom isključivo putem
argumenata i povratnih vrednosti. Voditi računa o pravilnoj upotrebi zauzetih resursa.
program z2okt1516(input, output);
type tacka=record
x,y: real;
end;
pokaz=^elem;
krug=record
t: tacka;
r: real;
boja: 0..15;
end;
elem=record
k: krug;
sled: pokaz;
end;
var prvi: pokaz;
procedure ucitaj (var prvi: pokaz);
var x, y, r: real;
boja: 0..15;
novi: pokaz;
begin
prvi:=nil;
write(output, 'Unesite krug (x, y, r, c): ');
readln(input,x,y,r, boja);
while (r >= 0) do
begin
new(novi);
novi^.k.t.x:= x;
novi^.k.t.y:= y;
novi^.k.r:= r;
novi^.k.boja:= boja;
novi^.sled:= prvi;
prvi:= novi;
write(output, 'Unesite krug (x, y, r, c): ');
readln(input,x,y,r, boja);
end;
end;
procedure brisi(var prvi: pokaz);
var stari: pokaz;
begin
while (prvi <> nil) do
begin
stari:= prvi;
prvi:= prvi^.sled;
dispose(stari);
end;
end;
Materijali za pripremu ispita iz Programiranja 1 43
function u_krugu(t: tacka; k: krug) : boolean;
var d: real;
begin
d:= sqrt(sqr(k.t.x - t.x) + sqr(k.t.y - t.y));
if (d <= k.r) then u_krugu:= true
else u_krugu:= false;
end;
procedure proveri(prvi: pokaz);
var tek: pokaz;
t: tacka;
nasao: boolean;
begin
write(output, 'Unesite tacku za proveru: ');
read(input, t.x, t.y);
while (t.x <> 0) OR (t.y <> 0) do
begin
tek:= prvi;
nasao:= false;
while (tek <> nil) and not nasao do
begin
if(u_krugu(t, tek^.k)) then nasao := true
else tek:= tek^.sled;
end;
if nasao then writeln(output, t.x:2:2, ' ', t.y:2:2, ' ', tek^.k.boja)
else writeln(output, t.x:2:2, ' ', t.y:2:2, ' ', 0);
write(output, 'Unesite tacku za proveru: ');
read(input, t.x, t.y);
end;
end;
begin
ucitaj(prvi);
proveri(prvi);
brisi(prvi);
end.
Materijali za pripremu ispita iz Programiranja 1 44
P1, ispit, januar 2017.
Zadatak 1.
Napisati program na programskom jeziku Pascal koji vrši obradu tekstualne datoteke koja sadrži podatke o parovima
sličnih dokumenata u skupu od 500 dokumenata. Svaki red datoteke sadrži podatke o jednom paru sličnih dokumenata po sledećem formatu: identifikator prvog dokumenta (ceo broj u opsegu 1-500), identifikator drugog
dokumenta (ceo broj u opsegu 1-500) i procenat sličnosti (pozitivan realan broj). Par dokumenata sa njihovom
sličnošću se pojavljuje samo jednom u datoteci. Smatrati da u datoteci ne postoji više od 250 redova. Program treba da pročita sadržaj navedene datoteke i za svaki dokument koji se pojavljuje u datoteci ispiše identifikator dokumenta,
broj pojavljivanja, identifikator dokumenta sa kojim je najviše sličan i procenat te sličnosti. Kao strukturu za smeštanje
podataka iz datoteke koristiti niz.
program z1jan1617(input,output,ulaz);
const MAX_DOC = 500;
type dokument=record
br_pojavljivanja: integer;
najslicniji: integer;
slicnost: real;
end;
niz_dokumenata = array [1..MAX_DOC] of dokument;
var niz: niz_dokumenata;
i, id1, id2: integer;
ulaz: text;
naziv: string;
slicnost: real;
procedure azuriraj(var niz: niz_dokumenata;
id1, id2: integer; slicnost: real);
begin
inc(niz[id1].br_pojavljivanja);
if (slicnost > niz[id1].slicnost) then
begin
niz[id1].slicnost:= slicnost;
niz[id1].najslicniji:= id2;
end;
end;
begin
write(output,'Unesite ime ulazne datoteke:');
readln(input, naziv);
assign(ulaz, naziv);
reset(ulaz);
for i:=1 to MAX_DOC do
begin
niz[i].br_pojavljivanja:=0;
slicnost:=0;
end;
while not eof(ulaz) do
begin
readln(ulaz, id1, id2, slicnost);
azuriraj(niz, id1, id2, slicnost);
azuriraj(niz, id2, id1, slicnost);
end;
close(ulaz);
for i:=1 to MAX_DOC do
if (niz[i].br_pojavljivanja > 0) then
writeln(output, i,' ', niz[i].br_pojavljivanja, ' ',
niz[i].najslicniji,' ', niz[i].slicnost:0:2);
readln;
end.
Materijali za pripremu ispita iz Programiranja 1 45
P1, ispit, februar 2017.
Zadatak 2.
Napisati program na programskom jeziku Pascal koji određuje zbir dva polinoma predstavljena pomoću uređene
jednostruko ulančane liste. Jedan element liste predstavlja jedan član polinoma i sadrži stepen (ceo broj) i nenulti koeficijent (realan broj) uz odgovarajući član. Lista je uređena opadajuće po stepenu člana, a čuvaju se samo članovi
sa nenultim koeficijentom. Program treba da učita dva polinoma sa standardnog ulaza, izvrši proveru da li su uređeni
na traženi način i ukoliko jesu, odredi njihov zbir, takođe predstavljen u obliku jednostruko ulančane liste. Prilikom unosa, najpre uneti red polinoma, a zatim odgovarajuće članove. Rezultujući polinom ispisati na standardnom izlazu.
Voditi računa o korektnoj upotrebi korišćenih resursa.
program z2feb1617(input,output);
type pokaz=^elem;
elem=record
stepen: integer; koeficijent: real; sledeci: pokaz;
end;
var prvi1, prvi2, prvi3 : pokaz;
ind1, ind2: boolean;
procedure dodaj (var prvi, posl: pokaz; stepen: integer; koef: real);
var novi: pokaz;
begin
new(novi); novi^.sledeci:= nil;
novi^.stepen:= stepen; novi^.koeficijent:= koef;
if (prvi = nil) then prvi:= novi
else posl^.sledeci:=novi;
posl:= novi;
end;
function ucitaj : pokaz;
var prvi, posl: pokaz;
stepen: integer;
koeficijent: real;
begin
prvi:= nil; posl:= nil;
while not eoln(input) do begin
readln(input, stepen, koeficijent);
if koeficijent <> 0 then dodaj(prvi, posl, stepen, koeficijent);
end;
readln(input);
ucitaj:= prvi;
end;
procedure ispisi (prvi: pokaz);
begin
while prvi^.sledeci <> nil do
begin
write(output, '(', prvi^.koeficijent:0:2, ')*x^', prvi^.stepen, '+');
prvi:= prvi^.sledeci;
end;
writeln(output, '(', prvi^.koeficijent:0:2, ')*x^', prvi^.stepen);
end;
function proveri (prvi: pokaz) : boolean;
var ind: boolean;
preth: pokaz;
begin
ind:= true;
preth:= prvi;
prvi:= prvi^.sledeci;
while (prvi <> nil) and ind do
begin
if (prvi^.stepen > preth^.stepen) then
Materijali za pripremu ispita iz Programiranja 1 46
ind := false;
preth:= prvi;
prvi:= prvi^.sledeci;
end;
proveri:= ind;
end;
function zbir(prvi1, prvi2: pokaz) : pokaz;
var posl, prvi3, tek: pokaz;
begin
prvi3:= nil; posl:= nil;
while (prvi1 <> nil) and (prvi2 <> nil) do begin
if (prvi1^.stepen = prvi2^.stepen) then begin
if (prvi1^.koeficijent + prvi2^.koeficijent <> 0) then
dodaj(prvi3, posl, prvi1^.stepen,
prvi1^.koeficijent + prvi2^.koeficijent);
prvi1:= prvi1^.sledeci;
prvi2:= prvi2^.sledeci;
end
else
if (prvi1^.stepen > prvi2^.stepen) then begin
dodaj(prvi3, posl, prvi1^.stepen, prvi1^.koeficijent);
prvi1:= prvi1^.sledeci;
end
else begin
dodaj(prvi3, posl, prvi2^.stepen, prvi2^.koeficijent);
prvi2:= prvi2^.sledeci;
end;
end;
if prvi1 <> nil then tek:= prvi1
else tek:= prvi2;
while tek <> nil do begin
dodaj(prvi3, posl, tek^.stepen, tek^.koeficijent);
tek:= tek^.sledeci;
end;
zbir:= prvi3;
end;
procedure brisi(var prvi: pokaz);
var stari: pokaz;
begin
while prvi <> nil do
begin
stari:= prvi; prvi:= prvi^.sledeci; dispose(stari);
end;
end;
begin
writeln(output,'Unesite clanove prvog polinoma: ');
prvi1:= ucitaj;
writeln(output,'Unesite clanove drugog polinoma: ');
prvi2:= ucitaj;
if (prvi1 <> nil) and (prvi2 <> nil) then
begin
ind1:= proveri(prvi1); ind2:= proveri(prvi2);
if ind1 and ind2 then
begin
prvi3:= zbir(prvi1, prvi2); ispisi(prvi3);
end
else writeln(output, 'Polinomi nisu zadati opadajuce po stepenu clana!');
end;
brisi(prvi1); brisi(prvi2); brisi(prvi3);
end.
Materijali za pripremu ispita iz Programiranja 1 47
P1, ispit, septembar 2017.
Zadatak 2.
Napisati program na programskom jeziku Pascal koji pronalazi najpovoljniju ponudu za kupovinu đačke opreme. U
svakom redu datoteke ponude.txt se nalaze podaci o ponuđačima i jediničnim cenama pet đačkih artikala po sledećem formatu: naziv ponuđača (jedna reč od najviše 30 karaktera), cena ranca (realan broj), cena sveske (realan broj),
cena pernice (realan broj), cena olovke (realan broj), cena gumice (realan broj). Svi podaci su odvojeni po jednim
blanko znakom. Program treba da učita podatke o ponudi đačke opreme u jednostruko ulančanu listu. Nakon toga, korisnik treba da za svaki od pet artikala unese količinu koju je potrebno kupiti, a program da ispiše na standardnom
izlazu nazive jednog ili više najpovoljnijih ponuđača i cenu za taj paket opreme. Voditi računa o korektnoj upotrebi
korišćenih resursa.
program z2sep1617;
type pokaz=^elem;
elem = record
naziv: string[30];
cena_ranca, cena_sveske, cena_pernice,
cena_olovke, cena_gumice: real;
sled: pokaz;
end;
var prvi, tek, min, novi, posl: pokaz;
kol_ranac, kol_sveska, kol_pernica,
kol_olovka, kol_gumica: real;
cena_paket, cena_min: real;
ulaz: text;
c: char;
function cena_paketa(var paket: pokaz) : real;
begin
cena_paketa:= paket^.cena_ranca * kol_ranac +
paket^.cena_sveske * kol_sveska +
paket^.cena_pernice * kol_pernica +
paket^.cena_olovke * kol_olovka +
paket^.cena_gumice * kol_gumica;
end;
begin
assign(ulaz, 'ponude.txt');
reset(ulaz);
prvi:= nil;
posl:= nil;
while not eof(ulaz) do begin
new(novi);
read(ulaz, c);
novi^.naziv:='';
while c <> ' ' do begin
novi^.naziv:= novi^.naziv + c;
read(ulaz, c);
end;
readln(ulaz, novi^.cena_ranca, novi^.cena_sveske,
novi^.cena_pernice, novi^.cena_olovke,
novi^.cena_gumice);
novi^.sled:= nil;
if posl = nil then prvi:= novi
else posl^.sled:= novi;
posl:= novi;
end;
writeln('Unesite potrebne kolicine opreme.');
writeln('Ranac: '); readln(kol_ranac);
writeln('Sveska: '); readln(kol_sveska);
writeln('Pernica: '); readln(kol_pernica);
writeln('Olovka: '); readln(kol_olovka);
Materijali za pripremu ispita iz Programiranja 1 48
writeln('Gumica: '); readln(kol_gumica);
if prvi <> nil then begin
cena_min:= cena_paketa(prvi);
tek:= prvi^.sled;
while tek <> nil do begin
cena_paket:= cena_paketa(tek);
writeln(tek^.naziv, ' ', cena_paket:0:2);
if (cena_paket < cena_min) then begin
cena_min:= cena_paket;
end;
tek:= tek^.sled;
end;
tek:= prvi;
while tek <> nil do begin
cena_paket:= cena_paketa(tek);
if cena_paket = cena_min then
writeln('Najbolji ponudjac je: ', tek^.naziv);
tek:= tek^.sled;
end;
end;
while prvi <> nil do begin
tek:= prvi;
prvi:= prvi^.sled;
dispose(tek);
end;
close(ulaz);
end.
Materijali za pripremu ispita iz Programiranja 1 49
P1, ispit, januar 2018.
Zadatak 1.
Napisati program na programskom jeziku Pascal koji proverava da li su dva niza cifara anagrami. Dva niza cifara su
anagrami ako se svaka cifra pojavljuje isti broj puta i u jednom i u drugom nizu. Na primer, nizovi 1 2 3 4 i 2 3 1 4 jesu anagrami, dok 1 2 3 4 i 2 3 1 1 nisu. Program treba najpre da sa standardnog ulaza učita dužine nizova, a zatim i
same elemente nizova, da proveri da li su učitani nizovi anagrami i da na standardnom izlazu ispiše rezultat provere.
Učitavanje pojedinačnog niza i proveru da li su dva niza cifara anagrami realizovati kao zasebne potprograme, koji sa glavnim programom komuniciraju isključivo putem argumenata i povratnih vrednosti. Smatrati da su elementi nizova
decimalne cifre, kao i da nizovi nemaju više od 100 elemenata. Ukoliko se za dužinu nekog od nizova unese
nedozvoljena vrednost, ispisati poruku o grešci i prekinuti izvršavanje programa.
program Anagram;
const MAX_DUZ = 100;
type Niz = array[1..MAX_DUZ] of 0..9;
var a, b: Niz;
na, nb: integer;
function citaj_niz(var niz: Niz; var n: integer): boolean;
var i: integer;
begin
citaj_niz:=true;
writeln('Duzina niza?');
read(n);
if (n>0) and (n<=MAX_DUZ) then begin
writeln('Elementi niza?');
for i:=1 to n do read(niz[i]);
end
else citaj_niz:=false;
end;
function anagram(a, b: Niz; na, nb:integer): boolean;
var c: array[0..9] of integer;
i: integer;
begin
if na<>nb then anagram:=false
else begin
for i:=0 to 9 do c[i]:=0;
for i:=1 to na do begin
c[a[i]]:=c[a[i]]+1;
c[b[i]]:=c[b[i]]-1;
end;
anagram:=true;
i:=0;
while (i<=9) and anagram do
if c[i]<>0 then anagram:=false
else i:=i+1;
end;
end;
begin
if citaj_niz(a, na) and citaj_niz(b, nb) then
write(anagram(a, b, na, nb))
else write('Greska');
end.
Materijali za pripremu ispita iz Programiranja 1 50
P1, ispit, januar 2018.
Zadatak 2.
Napisati program na programskom jeziku Pascal koji vrši određenu obradu nad tekstualnom datotekom koja sadrži
podatke o studentima i njihovim rezultatima na ispitu. Svaki red tekstualne datoteke sadrži podatke o jednom studentu po sledećem formatu: broj indeksa (niz karaktera po formatu gggg/bbbb), ime studenta (maksimalno 20
karaktera), prezime studenta (maksimalno 20 karaktera), prisustvo studenta na ispitu (jedan karakter, vrednost ’P’
ukoliko je student izašao na ispit, vrednost ’N’ u suprotnom) i rezultat ostvaren na ispitu (realan broj; postoji jedino ukoliko je student izašao na ispit, odnosno ako indikator za prisustvo ima vrednost ’P’). Broj redova u datoj datoteci
nije poznat. Program najpre treba da pročita sadržaj datoteke od kog formira jednostruko ulančanu listu, a zatim ukloni podatke o studentima koji nisu položili ispit (nisu izašli ili je ostvareni rezultat manji ili jednak 50). Nakon toga
potrebno je u izlaznu tekstualnu datoteku ispisati informacije o studentima koji su položili ispit i to po formatu: broj
indeksa, ime, prezime i ocena. Ocena se dobija na osnovu ostvarenog rezultata (50 < X ≤ 60 ocena 6, 60 < X ≤ 70 ocena 7, itd., gde je X ostvareni rezultat). Nazive datoteka pročitati sa glavnog ulaza. Voditi računa o korektnom
rukovanju korišćenim resursima.
program Z2ER(input, output);
type StudentData = record
index : string[9]; forname : string[20];
surname : string[20]; isPresent : char; score : real; end;
StudentNodePointer = ^StudentNode;
StudentNode = record
student : StudentData; next : StudentNodePointer; end;
var inputFileName, outputFileName : string;
inputFile, outputFile : text;
head, current, old : StudentNodePointer;
function readIntoList(var inputFile:text):StudentNodePointer;
var head, last, newNode : StudentNodePointer; temp : char;
begin
head := nil; last := nil; newNode := nil;
while (not eof(inputFile)) do begin
new(newNode); read(inputFile, newNode^.student.index);
read(inputFile, temp); newNode^.student.forname := '';
read(inputFile, temp);
while (temp <> ' ') do begin
newNode^.student.forname := newNode^.student.forname + temp;
read(inputFile, temp);
end;
newNode^.student.surname:= '';
read(inputFile, temp);
while (temp <> ' ') do begin
newNode^.student.surname := newNode^.student.surname + temp;
read(inputFile, temp);
end;
read(inputFile, newNode^.student.isPresent);
if (newNode^.student.isPresent = 'P') then begin
read(inputFile, newNode^.student.score);
end else newNode^.student.score := 0;
newNode^.next := nil;
readln(inputFile);
if (head = nil) then begin head := newNode;
end else begin last^.next := newNode; end;
last := newNode;
end;
readIntoList := head;
end;
Materijali za pripremu ispita iz Programiranja 1 51
procedure removeFromList(var head : StudentNodePointer);
var
previous, current, old : StudentNodePointer;
begin
previous := nil;
current := head;
while (current <> nil) do begin
if ((current^.student.isPresent = 'N') or (current^.student.score <=
50)) then begin
old := current;
current := current^.next;
if (previous = nil) then begin
head := current;
end else begin
previous^.next := current;
end;
dispose(old);
end else begin
previous := current;
current := current^.next;
end;
end;
end;
begin
writeln(output,'Input file?'); readln(input, inputFileName);
writeln(output,'Output file?');
readln(input, outputFileName);
assign(inputFile, inputFileName); reset(inputFile);
head := readIntoList(inputFile); close(inputFile);
removeFromList(head);
assign(outputFile, outputFileName); rewrite(outputFile);
current := head;
while (current <> nil) do begin
write(outputFile, current^.student.index, ' ', current^.student.forname,
' ', current^.student.surname, ' ');
if ((current^.student.score > 50) and
(current^.student.score <= 60)) then begin
write(outputFile, 6);
end else if ((current^.student.score > 60) and
(current^.student.score <= 70)) then begin
write(outputFile, 7);
end else if ((current^.student.score > 70) and
(current^.student.score <= 80)) then begin
write(outputFile, 8);
end else if ((current^.student.score > 80) and
(current^.student.score <= 90)) then begin
write(outputFile, 9);
end else write(outputFile, 10); end;
writeln(outputFile); current := current^.next;
end;
close(outputFile);
while (head <> nil) do begin
old := head; head := head^.next; dispose(old);
end;
end.
Materijali za pripremu ispita iz Programiranja 1 52
P1, ispit, februar 2018.
Zadatak 1.
Napisati program na programskom jeziku Pascal koji vrši obradu nad nizom pozitivnih celih brojeva koji predstavljaju
visine ljudi koji stoje u koloni, jedan iza drugog. Korisnik najpre unosi dužinu niza N (N≤100), a zatim i elemente niza. Nakon toga, treba formirati novi niz čiji će i-ti element sadržati broj ljudi koje i-ti čovek može videti ispred sebe.
Čovek i ispred sebe može videti čoveka j samo ukoliko između njih ne postoji čovek k koji je viši od čoveka j.
Formirani niz ispisati na standardnom izlazu. Učitavanje, obradu i ispis rezultata realizovati kao zasebne potprograme
koji sa glavnim programom komuniciraju isključivo putem argumenata i povratnih vrednosti.
program Z1;
const
MAX_DUZ = 100;
type
niz = array[1..MAX_DUZ] of integer;
var
ulazniNiz, izlazniNiz : niz;
duzina : integer;
function citaj(var ulazniNiz:niz;var duzina:integer):boolean;
var i : integer;
begin
writeln('duzina?');
readln(duzina);
if ((duzina > 0) and (duzina < MAX_DUZ)) then begin
for i := 1 to duzina do readln(ulazniNiz[i]);
citaj := true;
end else citaj := false;
end;
procedure obrada(ulazniNiz:niz;var izlazniNiz:niz;duzina:integer);
var i, j, max : integer;
begin
for i := 1 to duzina do begin
max := -1; izlazniNiz[i] := 0;
for j := i - 1 downto 1 do
if (ulazniNiz[j] > max) then begin
izlazniNiz[i] := izlazniNiz[i] + 1;
max := ulazniNiz[j];
end;
end;
end;
procedure pisi(izlazniNiz : niz; duzina : integer);
var i : integer;
begin
writeln('izlazni niz:');
for i := 1 to duzina do write(izlazniNiz[i], ' ');
end;
begin
if (citaj(ulazniNiz, duzina)) then begin
obrada(ulazniNiz, izlazniNiz, duzina);
pisi(izlazniNiz, duzina);
end else writeln('nekorektna duzina');
end.
Materijali za pripremu ispita iz Programiranja 1 53
P1, ispit, jul 2018.
Zadatak 1.
Napisati potprogram na programskom jeziku Pascal koji za dati prirodan broj računa vrednost broja napisanog istim
ciframa u obrnutom redosledu. Napisati program na programskom jeziku Pascal koji korišćenjem napisanog potprograma u nizu prirodnih brojeva maksimalne dužine 100 pronalazi onaj za koji je vrednost broja napisanog istim
ciframa u obrnutom redosledu najveća. Program treba da učita dužinu niza i same elemente niza, a zatim odredi i
ispiše traženi element. Potprogram sa glavnim programom komunicira isključivo putem argumenata i povratnih
vrednosti. Nije potrebno proveravati ispravnost ulaznih podataka.
Primer ulaza: Primer izlaza: 6 182 6 180 178 175 17 5 172 60 5 73 176
178 176
program Z1;
const MAX_DUZ = 100;
var brojevi: array[1..MAX_DUZ] of integer;
var i, n, max, ispis, t: integer;
function racunaj(broj: integer): integer;
var r: integer;
begin
r := 0;
while(broj > 0) do
begin
r := r * 10 + broj mod 10;
broj := broj div 10;
end;
racunaj := r;
end;
begin
read(n);
for i := 1 to n do read(brojevi[i]);
max := 0;
for i := 1 to n do begin
t := racunaj(brojevi[i]);
if(t > max) then begin
max := t;
ispis := brojevi[i];
end;
end;
writeln(ispis);
end.
Materijali za pripremu ispita iz Programiranja 1 54
P1, ispit, jul 2018.
Zadatak 2.
Potrebno je napisati program na jeziku Pascal koji vrši određenu obradu nad podacima o kupovinama u jednoj prodavnici. Podaci o kupovinama se nalaze u binarnoj datoteci kupovine.dat. Svaki zapis u ovoj datoteci se odnosi
na jednu kupovinu i sadrži sledeća polja: ime kupca (jedna reč od maksimalno 20 karaktera), prezime kupca (jedna
reč od maksimalno 20 karaktera), jedinstveni identifikacioni broj kupca (ceo broj) i iznos potrošen za datu kupovinu (realan broj). Za istog kupca su identifikacioni broj, ime i prezime uvek isti. Broj zapisa u ovoj datoteci nije poznat. Na osnovu ove datoteke potrebno je formirati tekstualnu datoteku presek.txt. Svaki red ove datoteke treba da sadrži
podatke o jednom kupcu i to njegovo ime i prezime, identifikacioni broj i prosečnu potrošnju po kupovini. Voditi
računa o ispravnoj upotrebi resursa.
program z2(kupovine, presek);
type Kupovina = record
ime : string[20];
prezime : string[20];
id : integer;
iznos : real;
end;
PokElem = ^Elem;
Elem = record
k : Kupovina;
n : integer;
sled : PokElem;
end;
var kupovine : file of Kupovina;
presek : text;
k : Kupovina;
lista, novi, stari, tekuci : PokElem;
function nadji(lista : PokElem; id : integer) : PokElem;
var najden : boolean;
begin
najden := false;
nadji := nil;
while ((lista <> nil) and (not najden)) do begin
if (lista^.k.id = id) then begin
nadji := lista;
najden := true;
end else lista := lista^.sled;
end;
end;
begin
lista := nil;
assign(kupovine, 'kupovine.dat');
reset(kupovine);
while (not eof(kupovine)) do begin
read(kupovine, k);
novi := nadji(lista, k.id);
if (novi = nil) then begin
new(novi);
novi^.k := k;
novi^.n := 1;
novi^.sled := lista;
lista := novi;
end else begin
novi^.k.iznos := novi^.k.iznos + k.iznos;
novi^.n := novi^.n +1;
end;
end;
Materijali za pripremu ispita iz Programiranja 1 55
assign(presek, 'presek.txt');
rewrite(presek);
tekuci := lista;
while (tekuci <> nil) do begin
writeln(presek, tekuci^.k.ime, ' ', tekuci^.k.prezime, ' ',
tekuci^.k.id, ' ', tekuci^.k.iznos / tekuci^.n);
tekuci := tekuci^.sled;
end;
close(kupovine);
close(presek);
while (lista <> nil) do begin
stari := lista;
lista := lista^.sled;
dispose(stari);
end;
end.
Materijali za pripremu ispita iz Programiranja 1 56
P1, ispit, septembar 2018.
Zadatak 2.
Napisati program na programskom jeziku Pascal koji vrši obradu nad spiskom opasnih materija koje se nalaze u
datoteci undangergoods.txt. Jedan red datoteke sadrži identifikacioni (UN) broj opasne materije (ceo broj), broj uputstva za postupanje (ceo broj) i naziv opasne materije (niz od najviše 256 znakova koji može sadržati blanko
znake). Redovi u datoteci su sortirani po UN broju. U datoteci se mogu naći višestruki uzastopni redovi koji sadrže isti
UN broj, a različite nazive za jednu istu opasnu materiju (npr. metil alkohol i metanol). Program treba da pročita sadržaj ulazne datoteke i da u izlaznu datoteku prepiše sve podatke o opasnim materijama po istom formatu uz
spajanje redova sa nazivima opasnih materija koje imaju isti UN broj. Različite nazive iste materije razdvojiti zarezom. Spajanje i prepisivanje izvršiti samo ukoliko materije imaju identične brojeve uputstva za postupanje. U suprotnom na
standardnom izlazu ispisati sve problematične redove i poruku o grešci. Voditi računa o ispravnoj upotrebi resursa.
program z2sep1718(input, output);
type pok = ^elem;
elem = record
unbroj: integer;
uputbroj: integer;
naziv: string;
sled: pok;
end;
var ulaz, izlaz: text;
prvi, novi, preth, tek, tek2, tek3: pok;
c: char;
naziv: string;
begin
assign(ulaz, 'undangergoods.txt');
assign(izlaz, 'undangergoods2.txt');
reset(ulaz);
rewrite(izlaz);
preth := nil;
prvi := nil;
while not eof(ulaz) do
begin
new(novi);
readln(ulaz, novi^.unbroj, novi^.uputbroj, c, novi^.naziv);
novi^.sled := nil;
if preth = nil then prvi := novi
else preth^.sled := novi;
preth := novi;
end;
tek := prvi;
while tek <> nil do
begin
tek2 := tek^.sled;
while (tek2 <> nil) and (tek^.unbroj = tek2^.unbroj) do
begin
tek2 := tek2^.sled;
end;
if tek^.sled = tek2 then
writeln(izlaz, tek^.unbroj, ' ', tek^.uputbroj, ' ', tek^.naziv)
else begin
tek3 := tek;
while (tek3 <> tek2) and (tek3^.uputbroj = tek^.uputbroj) do
tek3 := tek3^.sled;
if tek3 = tek2 then
begin
naziv := tek^.naziv;
tek := tek^.sled;
Materijali za pripremu ispita iz Programiranja 1 57
while tek <> tek2 do
begin
naziv := naziv + ', ' + tek^.naziv;
tek := tek^.sled;
end;
writeln(izlaz, tek^.unbroj, ' ', tek^.uputbroj, ' ', naziv)
end
else begin
writeln(output, 'Greska!');
while tek <> tek2 do
begin
writeln(output, tek^.unbroj, ' ', tek^.uputbroj, ' ',
tek^.naziv);
tek := tek^.sled;
end;
end;
end;
tek := tek2;
end;
while prvi <> nil do
begin
tek := prvi;
prvi := prvi^.sled;
dispose(tek);
end;
close(ulaz);
close(izlaz);
end.
Materijali za pripremu ispita iz Programiranja 1 58
P1, ispit, oktobar 2018.
Zadatak 1.
Napisati program na programskom jeziku Pascal koji pronalazi preklapanja između aktivnosti. Program sa standardnog
ulaza učitava događaje koji predstavljaju početak ili završetak aktivnosti. Početak se obeležava šifrom aktivnosti (ceo broj u opsegu od 1 do 100) i slovom S. Završetak aktivnosti se obeležava šifrom aktivnosti i slovom E. Svaki događaj
se unosi u posebnoj liniji. Događaji su poređani prema vremenu u kom su se javili. Smatrati da aktivnost koja je
započeta mora imati i završetak. Ne postoje dve aktivnosti sa istom šifrom. Program treba da ispiše za svaku aktivnost u jednom redu koje druge aktivnosti su se u celosti ili delimično preklopile sa njom. Format reda je sledeći: šifra
aktivnosti koja se posmatra i nakon toga šifre aktivnosti sa kojima se preklopila. Redosled prilikom ispisa može biti
proizvoljan. Nije potrebno proveravati ispravnost ulaznih podataka.
program ispit(input, output);
const MAX = 100;
type matrix = array[1..MAX, 1..MAX] of boolean;
var
active, activities : set of 1..MAX;
conflict : matrix;
activity, i, j : integer;
begin
for i := 1 to MAX do
for j := 1 to MAX do
conflict[i, j] := false;
active := [];
activities := [];
while not eof(input) do begin
readln(input, activity);
activities := activities + [activity];
if (activity in active) then
active := active - [activity]
else
begin
for i := 1 to MAX do
if i in active then begin
conflict[i, activity] := true;
conflict[activity, i] := true;
end;
active := active + [activity];
end;
end;
for i := 1 to MAX do begin
if i in activities then begin
write(output, i, ' ');
for j := 1 to MAX do
if (conflict[i, j]) then
write(output, j, ' ');
end;
writeln(output);
end;
end.
Materijali za pripremu ispita iz Programiranja 1 59
P1, ispit, oktobar 2018.
Zadatak 2.
Napisati program na programskom jeziku Pascal koji vrši obradu nad spiskom avio letova koji se nalaze u
datoteci airflights.txt. Jedan red datoteke sadrži identifikacioni broj leta (ceo broj), vreme poletanja i vreme sletanja u formatu hh:mm, kao i cenu leta u evrima (ceo broj). Program treba da pročita ceo sadržaj
ulazne datoteke, a zatim da pronađe najbolju ponudu koja se ispisuje na standardnom izlazu. Valjanost
ponude se ocenjuje odnosom cene i dužine leta (u minutima). Ponuda je bolja što je manji odnos cene i dužine leta. Ukoliko ima više jednako dobrih ponuda, ispisati ih sve. Prilikom ispisa ponude navodi se
identifikacioni broj leta, ukupno vreme leta u minutima, kao i cena leta. Voditi računa o ispravnoj upotrebi
resursa.
program z2_okt_1718(input, output);
const IME_FAJLA = 'airflights.txt';
type tipVreme = string[5];
pok = ^elem;
elem = record
brojLeta: integer;
vremePoletanja: tipVreme;
vremeSletanja: tipVreme;
cena: integer;
duzinaLeta: integer;
ocena: integer;
sled: pok;
end;
var lista: pok;
najbolja: integer;
function konverzijaUMin(vreme: tipVreme (* vreme je oblika hh:mm *)):
integer;
begin
konverzijaUMin := ((ord(vreme[1]) - ord('0')) * 10 +
(ord(vreme[2]) - ord('0'))) * 60 +
(ord(vreme[4]) - ord('0')) * 10 +
(ord(vreme[5]) - ord('0'));
end;
function trajanjeMin(poc, kraj: tipVreme): integer;
begin
trajanjeMin := konverzijaUMin(kraj) - konverzijaUMin(poc);
end;
procedure ucitavanjePodataka(var lista: pok);
var ulaz: text;
novi: pok;
c: char;
begin
assign(ulaz, IME_FAJLA);
reset(ulaz);
lista := nil;
while not EOF(ulaz) do
begin
new(novi);
read(ulaz, novi^.brojLeta); // broj leta
read(ulaz, c); // preskakanje razmaka
read(ulaz, novi^.vremePoletanja); // vreme poletanja
read(ulaz, c); // preskakanje razmaka
readln(ulaz, novi^.vremeSletanja, novi^.cena); // vreme sletanja i cena
novi^.sled := lista;
lista := novi;
end;
close(ulaz);
end;
Materijali za pripremu ispita iz Programiranja 1 60
procedure ocenjivanjePonuda(lista: pok);
var tek: pok;
begin
tek := lista;
while(tek <> nil) do begin
tek^.duzinaLeta := trajanjeMin(tek^.vremePoletanja, tek^.vremeSletanja);
tek^.ocena := tek^.cena div tek^.duzinaLeta;
tek := tek^.sled;
end;
end;
function najboljaPonuda(lista: pok):integer;
var
tek: pok;
ocena: integer;
begin
tek := lista; ocena := -1;
while(tek <> nil) do begin
if (ocena = -1) or (tek^.ocena < ocena) then
ocena := tek^.ocena;
tek := tek^.sled;
end;
najboljaPonuda := ocena;
end;
procedure ispisPonuda(lista: pok; ocena: integer);
var tek: pok;
begin
tek := lista;
while(tek <> nil) do begin
if(tek^.ocena = ocena) then
writeln(tek^.brojLeta, ' ', tek^.duzinaLeta, ' ', tek^.cena);
tek := tek^.sled;
end;
end;
procedure brisanjeListe(lista: pok);
var tek: pok;
begin
tek := lista;
while(tek <> nil) do begin
lista := lista^.sled;
dispose(tek);
tek := lista;
end;
end;
begin
lista := nil;
ucitavanjePodataka(lista);
ocenjivanjePonuda(lista);
najbolja := najboljaPonuda(lista);
ispisPonuda(lista, najbolja);
brisanjeListe(lista);
readln;
end.
top related