Studentima se savetuje da programski kod ne uče napamet ... · Materijali za pripremu ispita iz Programiranja 1 3 SI1P1, drugi kolokvijum, novembar 2012. Zadatak 1. Napisati program

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, oktobar 2012. .......................................................................................................... 19

P1, ispit, januar 2013. ............................................................................................................ 20

P1, ispit, februar 2013. ........................................................................................................... 22

P1, ispit, jul 2013. .................................................................................................................. 24


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, 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, 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, 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.


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.


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.


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.


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 = êlem;

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;


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.


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.



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.


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


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.


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 = êlem;

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;


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;


var

stari : pok;

begin

stari := prvi;


begin

prvi := prvi^.sled;

dispose(stari);

stari := prvi;

end;

end;

begin

lst := ucitaj();

max := obrada(lst);

dealociraj(lst);

end.



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


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;


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.



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.



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 = êlem;

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;


prvi := tek;

tek := tek^.sled;

dispose(prvi);


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.



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.



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 = Êlement;

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;


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.



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.


type pok = êlem;

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;


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);


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;


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.



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);


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;


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.



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 = Êlem;

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;



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;


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);


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);


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.



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 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.



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


program z2jan_1314(input, output, ulaz);

type

pokaz = ôcitavanje;

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;


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


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;


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;


tek := prvi;

prvi := prvi^.sled;

dispose(tek);

end;

close(ulaz);

end.



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.


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.


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 = êlem;

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;


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;


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.



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);


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);


readln(ulaz, linija);

br_reci := brojreci(linija);

if (br_reci mod 2 = 1) then writeln(izlaz, linija);

end;

close(ulaz);

close(izlaz);

end.



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 = êlem;

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;


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;


writeln(output, tek^.ime,' ',tek^.prezime,' ',tek^.email);

tek := tek^.sled;

end;


tek := prvi; prvi := prvi^.sled; dispose(tek);

end;

close(vencanje); close(adresar);

end.



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;


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.



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.


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 = êlem;

elem = record

naziv: string;

vreme_otvaranja: integer;

vreme_zatvaranja: integer;

cena_ulaznice: integer;

sled: êlem;

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'));


h := 10 * h + (ord(znak) - ord('0'));



m := (ord(znak) - ord('0'));


m := 10 * m + (ord(znak) - ord('0'));

citaj_vreme := h*60 + m;

end;

begin

assign(ulaz, 'muzeji.txt');

reset(ulaz);

preth := nil;

lista := nil;


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;


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;


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;


preth := tek;

tek := tek^.sled;

dispose(preth);

end;

close(ulaz);

end.



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=êlem;

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


begin

stari:= prvi;

prvi:= prvi^.sled;

dispose(stari);

end;

end;


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.



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;


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.



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=êlem;

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;


while (prvi <> nil) and ind do

begin

if (prvi^.stepen > preth^.stepen) then


ind := false;

preth:= prvi;


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;


end

else

if (prvi1^.stepen > prvi2^.stepen) then begin

dodaj(prvi3, posl, prvi1^.stepen, prvi1^.koeficijent);


end

else begin

dodaj(prvi3, posl, prvi2^.stepen, prvi2^.koeficijent);


end;

end;

if prvi1 <> nil then tek:= prvi1

else tek:= prvi2;


dodaj(prvi3, posl, tek^.stepen, tek^.koeficijent);

tek:= tek^.sledeci;

end;

zbir:= prvi3;

end;

procedure brisi(var prvi: pokaz);

var stari: pokaz;

begin


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.



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


program z2sep1617;

type pokaz=êlem;

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;


new(novi);

read(ulaz, c);

novi^.naziv:='';


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);


writeln('Gumica: '); readln(kol_gumica);

if prvi <> nil then begin

cena_min:= cena_paketa(prvi);

tek:= prvi^.sled;


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;


cena_paket:= cena_paketa(tek);

if cena_paket = cena_min then

writeln('Najbolji ponudjac je: ', tek^.naziv);

tek:= tek^.sled;

end;

end;


tek:= prvi;

prvi:= prvi^.sled;

dispose(tek);

end;

close(ulaz);

end.



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;


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.



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;


end;

newNode^.student.surname:= '';


while (temp <> ' ') do begin

newNode^.student.surname := newNode^.student.surname + 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;


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









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.



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.



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;


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.



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 = Êlem;

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;


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.



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 = êlem;

elem = record

unbroj: integer;

uputbroj: integer;

naziv: string;

sled: pok;

end;


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;


begin

new(novi);

readln(ulaz, novi^.unbroj, novi^.uputbroj, c, novi^.naziv);

novi^.sled := nil;

if preth = nil then prvi := 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;


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;


begin

tek := prvi;

prvi := prvi^.sled;

dispose(tek);

end;

close(ulaz);

close(izlaz);

end.



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.



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 = êlem;

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;


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;


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;


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;


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.

Documents

Studentima se savetuje da programski kod ne uče napamet ... · Materijali za pripremu ispita iz Programiranja 1 3 SI1P1, drugi kolokvijum, novembar 2012. Zadatak 1. Napisati program