Funkcije Procedure Nizovi

Програмирање није само написати програм који решава одређени проблем.
Програмирање је више од тога, много више. Програмирање је уметност.

Сваки, па био то и најједноставнији задатак може се решити тако да буде
на ваш начин занимљив, необичан, привлачан, заводљиво оригиналан, ...
Ако желите да се бавите програмирањем радите то из љубави, нека сваки
програмски ред буде стих у поеми вашег живота, мисао која плени духом.
Ако и не будете програмери у свом будућем животу, чак и тада посао који
обављате нека буде прављење најлепшег букета који ћете поклањати свету.
miroslav.ilic@devetagimnazija.edu.rs
ЗБИРКА
решених задатака
из програмирања
Мирослав Илић 2
4 Уметност програмирања
Задаци који следе биће урађени на два начина: први ће бити сирово решавање задатка
уз минимално коришћење уметничког надахнућа, а други начин ће бити покушај да неке
од читалаца ових редова убеди да свет програмирања може бити цветни аранжман који
креирамо срцем и свом својом душом.
4.1. Саставити програм који одређује n-ти степен уписног броја.

Задаци са функцијама и процедурама се решавају као и сви други, разлика је само што
неке, погодне делове програма замењујемо позивима функција или процедура и на тај
начин олакшавамо писање, читање и разумевање програма. Овај први задатак ћемо
објаснити детаљно (чак много детаљније него што је потребно) да би се схватила
суштина и предност коришћења кориснички дефинисаних функција и процедура, док
ћемо наредне задатке решавату у "тишини", односно, са много мање коментарисања,
препуштајући читаоцима да сами дођу до неких (корисних) закључака.
Креирати форму као на слици десно. Двокликом на први едит аутоматски ће се
декларисати процедура Edit1Change коју ћемо дефинисати као у претходним задацима:
procedure TForm1.Edit1Change(Sender: TObject);
begin Edit3.Clear;
end;
Кликнућемо на други едит и у Object Inspector-у на листићу Events дефинисати реакцију овог објекта на
догађај OnChange истом процедуром. Двокликом на тастер ОДРЕДИ декларисати и дефинисати процедуру
Button1Click:
procedure TForm1.Button1Click(Sender: TObject);
var n,b,s:integer;
begin n:=StrToIntDef(Edit1.Text,1);
If n<0 then n:=0;
Edit1.Text:=IntToStr(n);
b:=StrToIntDef(Edit2.Text,1);
Edit2.Text:=IntToStr(b);
s:=Stepen(b,n);
Edit3.Text:=IntToStr(s);
end;
Функцију Stepen(b,n) ћемо прво декларисати у делу за декларације (изнад службене речи private):
function Stepen(o,e:integer):integer;
private
Функција има формалне целобројне параметре о - основа и е - експонент и целобројна је. Сада функцију треба
дефинисати. То можемо урадити било где у телу програма, а најједноставније је пре самог краја програма (пре
краја са тачком, испред end. додаћемо ред и уписати дефиницију функције):
function TForm1.Stepen(o,e:integer):integer;
var s:integer;
begin s:=1;
While e>0 do
begin s:=s*o;e:=e-1;
end;
stepen:=s;
end;
Приметили смо да се заглавље у дефиницији функције и у декларацији разликују само у додатом TForm1. које
одређује припадност функције програму који пишемо. Формални параметри у заглављу дефиниције и
декларације морају бити истог имена, истог типа и написани у истом редоследу, тип функције, такође, мора
бити исти. У телу функције бар једном се имену функције мора доделити вредност и име функције не сме да се
појави са десне стране знака доделе или у оквиру неке друге функције или процедуре. У позиву функције из
главног програма користимо стварне параметре Stepen(b,n) који су у овом случају променљиве, али осим тога
могу бити и конкретни бројеви или неке друге функције. Једини услов за стварне параметре је да се морају
слагати по типу са формалним параметрима.
Посебна врста функција су рекурзивне функције, функције које саме себе позивају и на тај начин се формално
избегава коришћење наредби циклуса (али саме функције представљају једну нову врсту наредби циклуса,
Програмирање - први кораци 2

3 Програмирање - први кораци
тако да употребом ових функција не избегавамо коришћење циклуса, већ само користимо другу, специјалну
врсту циклуса. При креирању рекурзивних функција мора се водити рачуна да постоји коректан услов који ће
одређивати колико пута ће се функција позивати. Ако се напише погрешан услов програм неће давати
коректне резултате или се "блокира". Све наредне функције писаћемо у оба облика. Па, да почнемо:
function TForm1.Stepen(o,e:integer):integer;
begin If e=0
then stepen:=1
else stepen:=stepen(o,e-1)*o;
end;
Приметили смо колико је рекурзивна функција једноставније записана, то је њена главна предност. Услов e=0
је јако важан и одлучује да ли ће се функцији доделити вредност или ће се поново позвати иста функција.
Понекад су рекурзивне функције много једноставније (за писање, не и за разумевање) и тада се оправдано
користе, други пут су компликованије и нема оправдања за њихово коришћење. На читаоцима је да се определе
да ли ће и када користити рекурзивну функцију у решавању неког задатка.
Решићемо сада задатак са процедуром за степеновање. Разлика је у декларацији и дефиницији процедуре за
степеновање као и у позиву из главног програма (позив процедуре је независна наредба програма и не сме се
наћи у оквиру неке друге наредбе). Двокликом на тастер ОДРЕДИ декларисати и дефинисати процедуру
Button1Click:
var n,b,s:integer;
If n<0 then n:=0;
b:=StrToIntDef(Edit2.Text,1);
Stepen(b,n,s);
end;
Процедуру Stepen(b,n,s) ћемо прво декларисати у делу за декларације (изнад службене речи private):
procedure Stepen(o,e:integer;var s:integer);
private
Процедура има формалне целобројне параметре о - основа, е - експонент и s, при чему је овај трећи означен
службеном речи VAR, то значи да је то излазни, а прва два су улазни параметри. Сада процедуру треба
дефинисати. То можемо урадити било где у телу програма, а најједноставније је пре самог краја програма (пре
краја са тачком, испред end. додаћемо ред и уписати дефиницију процедуре):
procedure TForm1.Stepen(o,e:integer;var s:integer);
begin s:=1;
While e>0 do
begin s:=s*o;e:=e-1;
end;
end;
Приметили смо да се заглавље у дефиницији процедуре и у декларацији разликују само у додатом TForm1.
које одређује припадност процедуре програму који пишемо. Формални параметри у заглављу дефиниције и
декларације морају бити истог имена, истог типа и написани у истом редоследу. У телу процедуре име те
процедуре не сме да се појави. У позиву процедуре из главног програма користимо стварне параметре
Stepen(b,n,s) који су у овом случају променљиве, али осим тога улазни параметри могу бити и конкретни
бројеви или неке друге функције. Услов за стварне параметре је да се морају слагати по типу са формалним
параметрима и излазни параметри морају бити променљиве.
Посебна врста процедура су рекурзивне процедуре, процедуре које саме себе позивају и на тај начин се
формално избегава коришћење наредби циклуса (али саме процедуре представљају једну нову врсту наредби
циклуса, тако да употребом ових процедура не избегавамо коришћење циклуса, већ само користимо другу,
специјалну врсту циклуса. При креирању рекурзивних процедура мора се водити рачуна да постоји коректан
услов који ће одређивати колико пута ће се процедура позивати. Ако се напише погрешан услов програм неће
давати коректне резултате или се "блокира". Све наредне процедуре писаћемо у оба облика. Па, да почнемо:
procedure TForm1.Stepen(o,e:integer;var s:integer);
begin If e=0
then s:=1;
else begin stepen(o,e-1,s);s:=s*o;
end;
end;
Приметили смо да рекурзивна процедура није много једноставније записана, али то не мора бити увек тако.
Понекад су рекурзивне процедуре много једноставније и тада се оправдано користе, други пут су
компликованије и нема оправдања за њихово коришћење. На читаоцима је да се определе да ли ће и када
користити рекурзивну процедуру у решавању неког задатка.
3 Мирослав Илић
Додатак:
Ако желимо да кориснику олакшамо коришћење програма можемо обрадити и неке додатне догађаје који
прате коришћење нашег програма. Један од важнијих је коришћење тастера ентер. Да корисник не би стално
прелазио са тастатуре на миша и обрнуто можемо дефинисати понашање нашег програма на коришћење
тастера ентер. Селектоваћемо први едит, затим у Object Inspector-у на листићу Events двокликом дефинисати
реакцију овог објекта на догађај OnKeyPress, односно, на притисак тастера на тастатури процедуром:
procedure TForm1.Edit1KeyPress(Sender: TObject; var Key: Char);
begin If key=#13 then Edit2.SetFocus;
If not (key in ['0'..'9',#8,#128]) then key:=#27
end;
Прва наредба дефинише да ако смо притиснули тастер ентер (#13) курсор пређе у други едит. Друга наредба
дефинише да су остали дозвољени тастери цифре декадног бројног система и тастери Delete и Back Space на
све остале тастере едит неће реаговати (#27 је тастер ESC коме нисмо доделили никакву функцију, тако да се
ништа не дешава, ништа се не исписује у едиту). Овако смо програм заштитили од уноса слова уместо бројева.
Урадићемо сличну процедуру и за други едит:
begin If key=#13 then Button1.Click;
end;
Процедура Button1.Click симулира клик мишем на тастер. Да би се комплетирао поступак, на крају процедуре
Button1Click треба додати још један ред (још једну наредбу) тако да се процедура завршава овако:
Edit1.SetFocus;
end;
На крају програма курсор се враћа у први едит. Сада је програм динамичнији и ефикаснији јер корисник може
да користи само тастатуру кроз цео програм, а могуће грешке уноса података су сведене на минимум.
4.2. Саставити програм који одређује факторијел уписаног броја.

Двокликом на едит декларисаће се процедура Edit1Change коју ћемо дефинисати са:
begin Edit3.Clear;
end;
Као у претходном задатку у Object Inspector-у на листићу Events двокликом ћемо
дефинисати понашање едита на догађај OnKeyPress, односно, на притисак тастера на
тастатури процедуром Edit1KeyPress:
end;
Двокликом на тастер ОДРЕДИ декларисати и дефинисати процедуру Button1Click:
var n:integer;
If n<0 then n:=0;
Edit2.Text:=IntToStr(Fakt(n));
Edit1.SetFocus;
end;
Декларисаћемо у делу за декларације, а затим ћемо дефинисати функцију за одређивање факторијела:
function TForm1.Fakt(n:integer):integer;
var f:integer;
begin f:=1;
While n>0 do
begin f:=f*n;n:=n-1;
end;
fakt:=f;
end;
рекурзивна функција за одређивање факторијела:
function TForm1.Fakt(n:integer):integer;
begin If n=0
then fakt:=1
else fakt:=fakt(n-1)*n;
end;
Исто, са процедуром. Двокликом на тастер ОДРЕДИ декларисати и дефинисати процедуру Button1Click:

var n,f:integer;
If n<0 then n:=0;
Fakt(n);
Edit2.Text:=IntToStr(f);
end;
Декларисаћемо у делу за декларације, а затим ћемо дефинисати процедуру за одређивање факторијела:
procedure TForm1.Fakt(n:integer;var f:integer);
begin f:=1;
While n>0 do
begin f:=f*n;n:=n-1;
end;
end;
рекурзивна процедура за одређивање факторијела:
procedure TForm1.Fakt(n:integer;var f:integer);
begin If n=0
then f:=1
else begin fakt(n-1);f:=f*n;
end;
end;
4.3. Саставити програм који одређује све Армстронгове бројеве до n.

Креираћемо форму као на слици, а затим двокликом на едит декларисати и дефинисати
процедуру Edit1Change:
begin Memo1.Clear;
end;
У Object Inspector-у на листићу Events двокликом ћемо дефинисати понашање едита на
догађај OnKeyPress, односно, на притисак тастера на тастатури процедуром Edit1KeyPress:
end;
var n,b:integer;
For b:=1 to n do
If b=Cifre(b) then Memo1.Lines.Add(IntToStr(b));
Edit1.SetFocus;
end;
Декларисаћемо у делу за декларације, а затим ћемо дефинисати функцију за одређивање збира кубова цифара:
function TForm1.Cifre(n:integer):integer;
var c,z:integer;
begin z:=0;
While n>0 do
begin c:=n mod 10;
n:=n div 10;
z:=z+c*c*c;
end;
cifre:=z;
end;
Рекурзивна функција за одређивање збира кубова цифара:
function TForm1.Cifre(n:integer):integer;
var c:integer;
begin If n=0 then cifre:=0
else begin c:=n mod 10;cifre:=Cifre(n div 10)+c*c*c;
end;
end;
var n,b,z:integer;
For b:=1 to n do
begin Cifre(b,z);
If b=z then Memo1.Lines.Add(IntToStr(b));
end;
Edit1.SetFocus;
end;
Декларисаћемо у делу за декларације, а затим дефинисати процедуру за одређивање збира кубова цифара:
procedure TForm1.Cifre(n:integer;var z:integer);
var c:integer;
begin z:=0;
While n>0 do
begin c:=n mod 10;
n:=n div 10;
z:=z+c*c*c;
end;
end;
Рекурзивна процедура за одређивање збира кубова цифара:
procedure TForm1.Cifre(n:integer;var z:integer);
var c:integer;
begin If n=0 then z:=0
else begin c:=n mod 10;
Cifre(n div 10,z);
z:=z+c*c*c;
end;
end;
4.4. Саставити програм који исписује све просте бројеве мање од n са две исте цифре.
begin Memo1.Clear;
end;
догађај OnKeyPress, односно, на притисак тастера на тастатури процедуром
Edit1KeyPress:
end;
Двокликом на тастер ОДРЕДИ декларисати и дефинисати процедуру Button1Click (jасно је да, осим 11, нема
двоцифрених простих бројева са две исте цифре јер су сви они дељиви бар са 11. Зато ћемо тестирање почети
од 101):
var n,b:integer;
Memo1.Clear;
If n>11 then Memo1.Lines.Add('11');
For b:=101 to n do
If Prost(b) and Isto(b)
then Memo1.Lines.Add(IntToStr(b));
Edit1.SetFocus;
end;
Декларисаћемо у делу за декларације, а затим ћемо дефинисати логичке функције Prost која одређује да ли је
број прост и Isto која одређује да ли број има истих цифара:
function TForm1.Prost(a:integer):boolean;
var d:integer;
begin d:=2;
While (a mod d<>0)and(d<=Sqrt(a)) do d:=d+1;

prost:=d>Sqrt(a);
end;
function TForm1.Isto(a:integer):boolean;
var c:integer;
sc:set of 0..9;
begin sc:=[a mod 10];
a:=a div 10;
isto:=false;
Repeat c:=a mod 10;
a:=a div 10;
If c in sc
then isto:=true
else sc:=sc+[c];
Until a=0;
end;
Нова, рекурзивна, функција која одређује да ли је број прост (у процедури Button1Click позив функције треба
изменити у Prost(b,2), односно, ред:
треба заменити редом:
If Prost(b,2) and Isto(b)
како бисмо задали почетну вредност за потенцијалне делиоце) могла би изгледати овако:
function TForm1.Prost(b,d:integer):boolean;
begin prost:=true;
If(b mod d<>0)and(d<=Sqrt(b))
then prost:=Prost(b,d+1)
else If b mod d=0 then prost:=false;
end;
var n,b:integer;
p:boolean;
For b:=101 to n do
begin Prost(b,p);
If p then
begin Isto(b,p);
If p then Memo1.Lines.Add(IntToStr(b));
end;
end;
Edit1.SetFocus;
end;
Декларисаћемо у делу за декларације, а затим ћемо дефинисати процедуре Prost која одређује да ли је број
прост и Isto која одређује да ли број има истих цифара:
procedure TForm1.Prost(a:integer;var p:boolean);
var d:integer;
begin d:=2;
p:=d>Sqrt(a);
end;
procedure TForm1.Isto(a:integer;var p:boolean);
var c:integer;
sc:set of 0..9;
a:=a div 10;
p:=false;
Repeat c:=a mod 10;
a:=a div 10;
If c in sc
then p:=true
else sc:=sc+[c];
Until a=0;
end;
Процедуру и функцију Isto, такође, можемо написати као рекурзивне, али оне не постају ништа једноставније,
па се овог пута нећемо тиме оптерећивати.
4.5. Саставити програм који исписује све просте бројеве мање од n са свим различитим
цифрама.
begin Memo1.Clear;
end;
догађај OnKeyPress, односно, на притисак тастера на тастатури процедуром
Edit1KeyPress:
end;
Двокликом на тастер ОДРЕДИ декларисати и дефинисати процедуру Button1Click (jасно је да, осим 11, нема
двоцифрених простих бројева са две исте цифре јер су сви они дељиви бар са 11. Зато ћемо тестирање почети
од 101):
var n,b:integer;
Memo1.Clear;
For b:=101 to n do
then Memo1.Lines.Add(IntToStr(b));
Edit1.SetFocus;
end;
Декларисаћемо у делу за декларације, а затим ћемо дефинисати логичке функције Prost која одређује да ли је
број прост и Isto која одређује да ли број има истих цифара:
function TForm1.Prost(a:integer):boolean;
var d:integer;
begin d:=2;
prost:=d>Sqrt(a);
end;
function TForm1.Isto(a:integer):boolean;
var c:integer;
sc:set of 0..9;
a:=a div 10;
isto:=true;
Repeat c:=a mod 10;
a:=a div 10;
If c in sc
then isto:=false
else sc:=sc+[c];
Until a=0;
end;
var n,b:integer;
p:boolean;
For b:=101 to n do
begin Prost(b,p);
If p then
begin Isto(b,p);
If p then Memo1.Lines.Add(IntToStr(b));
end;
end;
Edit1.SetFocus;
end;
Декларисаћемо у делу за декларације, а затим ћемо дефинисати процедуре Prost која одређује да ли је број
прост и Isto која одређује да ли број има истих цифара:
procedure TForm1.Prost(a:integer;var p:boolean);
var d:integer;
begin d:=2;
p:=d>Sqrt(a);
end;
procedure TForm1.Isto(a:integer;var p:boolean);
var c:integer;
sc:set of 0..9;
a:=a div 10;
p:=true;
Repeat c:=a mod 10;
a:=a div 10;
If c in sc
then p:=false
else sc:=sc+[c];
Until a=0;
end;
4.6. Саставити програм који одређује све савршене бројеве до n.

begin Memo1.Clear;
end;
Дефинисаћемо понашање едита на притисак неког тастера на тастатури процедуром
Edit1KeyPress:
end;
var n,b:integer;
For b:=1 to n do If b=ZbirDelioca(b) then Memo1.Lines.Add(IntToStr(b));
end;
Декларисаћемо у делу за декларације, а затим ћемо дефинисати функцију ZbirDelioca која одређује збир свих
делиоца бројева од 1 до n:
function TForm1.ZbirDelioca(b:integer):integer;
var s,d:integer;
begin s:=1;
For d:=2 to b div 2 do If b mod d=0 then s:=s+d;
zbirdelioca:=s;
end;
Исто са процедуром:
var n,b,s:integer;
For b:=1 to n do
begin ZbirDelioca(b,s);
If b=s then Memo1.Lines.Add(IntToStr(b));
end;
end;
procedure TForm1.ZbirDelioca(b:integer;var s:integer);
var d:integer;
begin s:=1;
end;
4.7. Саставити програм који одређује парове пријатељских бројева до n.

begin Memo1.Clear;
end;
Дефинисаћемо понашање едита на притисак неког тастера на тастатури процедуром
Edit1KeyPress:
end;
За сваки број од 1 до n ћемо одредити збир делилаца, тај збир је потенцијални пријатељ првог броја, а да би то
стварно и био потребно је да његов збир делилаца буде једнак првом броју. Двокликом на тастер ОДРЕДИ
декларисати и дефинисати процедуру Button1Click:
var n,a,s,b:integer;
begin n:=StrToIntDef(Edit1.Text,1);Edit1.Text:=IntToStr(n);
For a:=1 to n do
begin b:=ZbirDelioca(a);
s:=ZbirDelioca(b);
If (s=a)and(a<b) then Memo1.Lines.Add(Format('%5d%5d',[a,b]));
end;
end;
Искористићемо исту функцију као у претходном задатку. Декларисаћемо у делу за декларације, а затим ћемо
дефинисати функцију ZbirDelioca која одређује збир делиоца броја:
function TForm1.ZbirDelioca(b:integer):integer;
var s,d:integer;
begin s:=1;
zbirdelioca:=s;
end;
Исто са процедуром:
var n,a,s,b:integer;
begin n:=StrToIntDef(Edit1.Text,1);Edit1.Text:=IntToStr(n);
For a:=1 to n do
begin ZbirDelioca(a,b);
ZbirDelioca(b,s);
If (s=a)and(a<b) then Memo1.Lines.Add(Format('%5d%5d',[a,b]));
end;
end;
procedure TForm1.ZbirDelioca(b:integer;var s:integer);
var d:integer;
begin s:=1;
end;
Збир делилаца можемо одредити и помоћу рекурентне процедуре:
procedure TForm1.ZbirDelioca(b,d:integer;var s:integer);
begin If d<2 then s:=1
else begin ZbirDelioca(b,d-1,s);
If b mod d=0 then s:=s+d;
end;
end;
Треба променити и позиве ове процедуре из процедуре Button1Click у:
ZbirDelioca(a,a div 2,b);
ZbirDelioca(b,b div 2,s);
4.8. Саставити програм који декадни број претвара у бинарни или обрнуто.
Креираћемо форму као на слици, а затим ћемо дефинисати понашања једног и другог едита
на притисак неког тастера на тастатури процедурама Edit1KeyPress и Edit2KeyPress:
If not (key in ['0','1',#8,#128]) then key:=#27
end;
end;
Пошто не смемо дефинисати процедуру којаби на промену садржаја једног едита
брисала садржај другог (јер би то проузроковало прекид програма Stack overflow) дефинисаћемо да се садржај
једног едита брише када се у курсор постави у други (догађај OnEnter):
procedure TForm1.Edit1Enter(Sender: TObject);
begin Edit2.Clear;
end;
begin Edit1.Clear;
end;
Двокликом прво на један, а затим и на други на тастер декларисаћемо и дефинисати процедуре Button1Click и
Button2Click:
var a:string;
b,s,i:integer;
begin a:=Edit1.Text;
s:=1;b:=0;
For i:=Length(a) downto 1 do
begin b:=b+StrToInt(a[i])*s;
s:=s*2;
end;
end;
var a:string;
b:integer;
begin b:=StrToIntDef(Edit2.Text,0);
a:='';
While b>0 do
begin a:=IntToStr(b mod 2)+a;
b:=b div 2;
end;
Edit1.Text:=a;
end;
Превођење бинарног у декадни број можемо остварити и рекурзивном процедуром (мада се може приметити
да ово решење није донело неко значајно поједностављење програма) на следећи начин:
procedure TForm1.Dekadni(a:string;s:integer;var d:integer);
begin if length(a)=1
then d:=d+StrToInt(a)*s
else begin d:=d+StrToInt(a[Length(a)])*s;
dekadni(Copy(a,1,Length(a)-1),s*2,d);
end;
end;
var a:string;
d:integer;
d:=0;
dekadni(a,1,d);
Edit2.Text:=IntToStr(d);
end;
Превођење декадног у бинарни број можемо остварити и рекурзивном процедуром (мада се може приметити
да ово решење није донело неко значајно поједностављење програма) на следећи начин:
procedure TForm1.Binarni(b:integer;var a:string);
begin If b=0
then a:=''
else begin binarni(b div 2,a);
a:=a+IntToStr(b mod 2);
end;
end;
var a:string;
b:integer;
Binarni(b,a);
Edit1.Text:=a;
end;
4.9. Саставити програм који римски број претвара у арапски или обрнуто.
Креираћемо форму као на слици, а затим ћемо дефинисати понашања једног и другог едита
на притисак неког тастера на тастатури процедурама Edit1KeyPress и Edit2KeyPress:
If not (key in ['I','V','X','L','C','D','M',#8,#128])
then key:=#27
end;
end;
Пошто не смемо дефинисати процедуру која би на промену садржаја једног едита брисала садржај другог (јер
би то проузроковало прекид програма са грешком Stack overflow) дефинисаћемо да се садржај једног едита
брише када се у курсор постави у други (догађај OnEnter):
begin Edit2.Clear;
end;
begin Edit1.Clear;
end;
Двокликом прво на један, а затим и на други на тастер декларисаћемо и дефинисати процедуре Button1Click и
Button2Click:
var a:string;
If length(a)>0 then
begin a:=Arapski(a);
If a=' '
then ShowMessage('Greska u unosu broja')
else Edit2.Text:=a;
end;
end;
var a:string;
b:integer;
If (b>3999)or(b<1) then b:=3999;
Rimski(b,0,a);
Edit1.Text:=a;
end;
Рекурзивном процедуром ћемо арапски број претворити у римски:
procedure TForm1.Rimski(a,c:integer;var r:string);
var b:integer;
c1,c2,c3:string;
begin If a>0 then
begin c:=c+1;

case c of
1 : begin c1:='I';c2:='V';c3:='X';
end;
2 : begin c1:='X';c2:='L';c3:='C';
end;
3 : begin c1:='C';c2:='D';c3:='M';
end;
4 : begin c1:='M';c2:=' ';c3:=' ';
end;
end;
case a mod 10 of
1 : r:=c1+r;
2 : r:=c1+c1+r;
3 : r:=c1+c1+c1+r;
4 : r:=c1+c2+r;
5 : r:=c2+r;
6 : r:=c2+c1+r;
7 : r:=c2+c1+c1+r;
8 : r:=c2+c1+c1+c1+r;
9 : r:=c1+c3+r;
end;
Rimski(a div 10,c,r);
end;
end;
Функцијом ћемо римски број претворити у арапски:
function TForm1.Arapski(a:string):string;
var i,b:integer;
g:boolean;
begin g:=false;b:=0;i:=0;
Repeat i:=i+1;
case a[i] of
'M':If b mod 1000=0 then
If b<3000 then b:=b+1000 else g:=true
else If b mod 1000=100 then b:=b+800 else g:=true;
'C':If b mod 100=0 then
If(b mod 1000<300)or(b mod 1000>400)and(b mod 1000<800)
then b:=b+100 else g:=true
'X':If b mod 10=0 then
If(b mod 100<30)or(b mod 100>40)and(b mod 100<80)
'D':If b mod 1000=0 then b:=b+500
'L':If b mod 100=0 then b:=b+50
'V':If b mod 10=0 then b:=b+5
'I':If(b mod 10<3)or(b mod 10>4)and(b mod 10<8)
else g:=true;
end;
Until i=length(a);
if g then arapski:=' ' else arapski:=IntToStr(b);
end;
4.10. Саставити програм који исписује Паскалов троугао до реда n.

Креираћемо форму као на слици, а затим двокликом на едит декларисати и дефинисати процедуру Edit1Change:
begin Memo1.Clear;
end;
Дефинисаћемо понашање едита на притисак неког тастера на тастатури процедуром Edit1KeyPress:
end;
Двокликом на тастер ОДРЕДИ декларисати и дефинисати процедуру
Button1Click:
var n,p:integer;
begin p:=StrToIntDef(Edit1.Text,0);
Edit1.Text:=IntToStr(p);
For n:=0 to p do
Memo1.Lines.Add(Red(n));
end;
function TForm1.Red(n:integer):string;
var k:integer;
a:string;
begin a:='';
For k:=0 to n do
a:=a+IntToStr(Trunc(BK(n,k)))+' ';
red:=a;
end;
function TForm1.BK(n,k:integer):real;
var i:integer;
b:real;
begin b:=1;
For i:=1 to k do
b:=b*(n-i+1)/i;
bk:=b;
end;
Функцију за одређивањебиномног коефицијента можемо написати и као рекурзивну:
begin If k=0
then BK:=1
else BK:=BK(n,k-1)*(n-k+1)/k;
end;
Задатак се може решити и овако:
var n,p:integer;
begin p:=StrToIntDef(Edit1.Text,0);
Edit1.Text:=IntToStr(p);
For n:=0 to p do
Memo1.Lines.Add(Red(n));
end;
function TForm1.Red(n:integer):string;
var k:integer;
a:string;
begin a:='';
For k:=0 to n do
a:=a+Format('%1.0f',[BK(n,k)])+' ';
red:=a;
end;
begin bk:=Fakt(n)/(Fakt(k)*Fakt(n-k));
end;
function TForm1.Fakt(n:integer):real;
var f:real;
i:integer;
begin f:=1;
For i:=1 to n do
f:=f*i;
fakt:=f;
end;
Функција за одређивање факторијела може бити и рекурзивна:
function TForm1.Fakt(n:integer):real;
begin If n=0
then fakt:=1
else fakt:=fakt(n-1)*n;
end;

4.11. Саставити програм који са тастатуре прихвата n бројева, а затим одређује број са
највећим и број са најмањим збиром цифара и њихове редне бројеве.
Креираћемо форму као на слици, а затим ћемо двокликом на први едит декларисати и
дефинисати процедуру Edit1Change:
begin Memo1.Clear;Edit2.Clear;
Edit3.Clear;Edit4.Clear;
max:=0;min:=maxint;
end;
Променљиве max и min декларисаћемо као глобалне јер се користе у различитим
процедурама, а треба да чувају своју вредност. Почетна вредност прве променљиве је 0
јер је то најмањи могући збир цифара неког броја, па када се било који број упише он ће
бити са већим збиром цифара и задатак ће увек имати коректно решење (замислимо да
смо за почену вредност узели 20, а може се десити да приликом уноса бројева не унесемо ниједан број са више
од две цифре, тј највећи могући збир цифара унетих бројева је 18, па се никада неће десити да унети број има
већи збир цифара од 20 и ниједан број се неће исписати као решење задатка што није коректно). Друга
променљива има почетну вредност maxint (највећи цео број) јер било који уписани број има мањи збир цифара
и задатак ће увек имати коректно решење. Дефинисаћемо понашање прва два едита на притисак неког тастера
на тастатури процедурама Edit1KeyPress и Edit2KeyPress:
end;
end;
Ове две процедуре можемо заменити једном нешто компликованијом:
begin If key=#13
then If sender=edit1
then Button1.Click
else Button2.Click
else If not (key in ['0'..'9',#8,#128]) then key:=#27
end;
Edit1Change(sender);
Edit1.Enabled:=false;Button1.Enabled:=false;
Edit2.Enabled:=true;Button2.Enabled:=true;
Edit2.SetFocus;
end;
Двокликом на тастер ЗАПАМТИ декларисати и дефинисати процедуру Button2Click:
var b,z:integer;
Memo1.Lines.Add(Edit2.Text);
n:=n-1;z:=ZbirCifara(b);
If max<z // одређивање броја са највећим збиром цифара
then begin max:=z;
end;
If min>z // одређивање броја са најмањим збиром цифара
then begin min:=z;
end;
If n=0 // крај уноса бројева јер су сви унешени
then begin Edit2.Enabled:=false;Button2.Enabled:=false;
Edit1.SetFocus;
end
else begin Edit2.Clear;Edit2.SetFocus;
end;
end;
Декларисаћемо и дефинисати функцију која одређује збир цифара унетог броја:
function TForm1.ZbirCifara(a:integer):integer;
var z:integer;
begin z:=0;
Repeat z:=z+a mod 10;
a:=a div 10;
until a=0;
zbircifara:=z;
end;
Ова функција може бити и рекурзивна:
begin If a=0
then zbircifara:=0
else zbircifara:=ZbirCifara(a div 10)+a mod 10;
end;
Ако два уписана броја имају исти збир и то је најмањи или највећи збир цифара као резултат ће се исписати
онај који је први унет. Заменом релације < релацијом <= и релације > релацијом >= исписаће се последњи унети
број што је једнако оправдано. Коректније би било да се испишу сви бројеви који имају исти, највећи или
најмањи збир цифара, али то би било јако компликовано извести са овим нивоом знања програмирања.
4.12. Уписују се бројеви све док се не упише 0. Саставити програм који одређује најмањи и
највећи уписани број и њихове редне бројеве и аритметичку средину уписаних бројева.
Креираћемо форму као на слици, а затим ћемо дефинисаћемо понашање првог едита на
притисак неког тастера на тастатури процедуром Edit1KeyPress:
begin If key=#13
then Button1.Click
else If not (key in ['0'..'9',#8,#128]) then key:=#27
end;
Двокликом на тастер ЗАПАМТИ декларисати и дефинисати процедуру Button1Click:
var b:integer;
If b=0
then begin Edit1.Enabled:=false;Button1.Enabled:=false;
Button2.Enabled:=true;Button2.SetFocus;
end
else begin Memo1.Lines.Add(Edit1.Text);
n:=n+1;ars:=ars+b;
Edit2.Text:=Format('%1.5f',[ars/n]);
If max<b then // odredjivanje najveceg broja
begin max:=b;
end;
If min>b then // odredjivanje najmanjeg broja
begin min:=b;
end;
Edit1.Clear;Edit1.SetFocus;
end;
end;
Двокликом на тастер НОВИ УПИС декларисати и дефинисати процедуру Button2Click:
max:=0;min:=maxint;
asr:=0;n:=0;

Button2.Enabled:=false;Button1.Enabled:=true;
Edit1.Enabled:=true;Edit1.SetFocus;
end;
Двокликом на тастер форму декларисати и дефинисати процедуру FormCreate која треба да постави почетне
вредности глобалних променљивих max, min, asr и n:
procedure TForm1.FormCreate(Sender: TObject);
begin max:=0;min:=maxint;
asr:=0;n:=0;
end;
Други начин да се ово исто уради је предефинисање вредности глобалних променљивих прилоком њихове
декларације (на програмеру је да одлучи који начин ће користити у свом програму) на следећи начин:
var
Form1: TForm1;
max:integer=0;
min:integer=maxint;
asr:integer=0;
n:integer=0;
Претходна два задатка решена су без коришћења типа низ и предности које он доноси. Следе
задаци који ће бити решавани са променљивама типа низ. Формирање низа може се остварити на три
начина: директним уписом преко тастатуре, генерисањем бројева помоћу функције Random или
преузимањем података из датотеке (мада се и та датотека мора некако попунити). У зависности од
изабраног начина формирања низа форма може бити дизајнирана на два начина: са делом за унос
елемената низа или без тог дела. Урадићемо први задатак у обе варијанте, а остале ћемо решавати
само случајним генерисањем елемената низа.
4.13. Саставити програм који формира низ са највише 100 троцифрених бројева, а затим
одређује збир непарних и аритметичку средину парних елемената низа
Форма за унос елемената помоћу тастатуре Форма за случајно генерисање елемената
Да би се лакше прешло из једног решења на

друго из прве форме је избрисан други едит,
редослед осталих компоненти на форми је
остао потпуно исти. Готово све процедуре ће
бити исте (можда неке мало модификоване,
али сасвим мало) осим процедуре којом ће се
формирати елементи низа, зато их нећемо
писати два пута, већ ће, у погодном тренутку
бити напоменуте само разлике које треба
увести. Задатак ће бити решен онако како би
кориснику апликације било најједноставније.
Најпре ћемо дефинисати нови тип података - низ у делу за дефиниције типова (на самом почетку јунита):
type
niz=array[1..100] of integer;
TForm1 = class(TForm)
...
Затим ћемо декларисати глобалне променљиве n - број елемената низа и k - бројач елемената низа које су цели
бројеви и a - променљива типа низ у делу за декларације:
var
Form1: TForm1;
n,k:integer;
a:niz;
Сада ћемо, двокликом на први едит, декларисати и дефинисати процедуру Edit1Change којом се поставља
почетно стање компоненти на форми (бришу се резултати претходног тестирања):
begin Memo1.Clear;Edit2.Clear;Edit3.Clear;
Edit4.Clear;Edit5.Clear;Edit6.Clear;
end;
Затим ћемо дефинисати понашање првог и другог едита на притисак неког тастера на тастатури дркларисањем
и дефиницијом процедуре Edit1KeyPress:
begin If key=#13
then Button1.Click
else Button2.Click
else If not (key in ['0'..'9',#8,#128]) then key:=#27;
end;
Двокликом на први тастер декларисаћемо и дефинисати процедуру за одређивање броја елемената низа:
If n>100 then n:=100;
k:=0;Edit2.SetFocus;
end;
Следећа је процедура која омогућава унос елемената низа помоћу тастатуре. Декларисаћемо је и дефинисати
двокликом на други тастер:
begin k:=k+1;
a[k]:=StrToIntDef(Edit2.Text,100);
If a[k]<100 then a[k]:=100;
Edit2.Text:=IntToStr(a[k]);
Memo1.Lines.Add(IntToStr(k)+'. '+Edit2.Text);
If k<n
then begin Edit2.Clear;Edit2.SetFocus;
end
else begin Edit2.Enabled:=false;Button2.Enabled:=false;
end;
end;
Ако желимо да се низ генерише на случајан начин ову процедуру ћемо заменити следећом:
begin Randomize;
While k<n do
begin k:=k+1;
a[k]:=Random(900)+100;
Memo1.Lines.Add(IntToStr(k)+'. '+IntToStr(a[k]));
end;
Button2.Enabled:=false;
Button3.Enabled:=true;
Button3.SetFocus;
end;
Из процедуре Edit1Change треба избрисати наредбу Edit2.Clear; а у процедури Button1Click избрисати наредбе
Edit2.Enabled:=true; и Edit2.SetFocus; и додати наредбу Button2.SetFocus;. У обе верзије програма иста је радна
процедура Button3Click у којој се одређују тражени резултати:
var par,nep,zp,zn,i:integer;
begin par:=0;zp:=0;
nep:=0;zn:=0;
For i:=1 to n do
If Odd(a[i])
then begin nep:=nep+1;zn:=zn+a[i]
end
else begin par:=par+1;zp:=zp+a[i]
end;
Edit3.Text:=IntToStr(nep);
Edit4.Text:=IntToStr(zn);
Edit5.Text:=IntToStr(par);
If par>0
then Edit6.Text:=Format('%1.5f',[zp/par])
else Edit6.Text:='0';
end;

4.14. Саставити програм који формира низ од 100 природних бројева, а затим одређује редни
број елемента који има највећи збир цифара, у случају да више елемената има исти збир
цифара исписује се најмањи.
Дизајнираћемо форму као на слици, дефинисати тип низ и глобалне променљиве као и
стандардне процедуре за формирање низа:
type
...
var
Form1: TForm1;
n,k:integer;
a:niz;
end;
begin If key=#13
then Button1.Click
end;
If n>100 then n:=100;
Edit1.Enabled:=false;
Button2.SetFocus;
end;
begin Randomize;
k:=0;
While k<n do
begin k:=k+1;
a[k]:=Random(900)+100;
end;
Button3.SetFocus;
end;
Декларисаћемо и дефинисати процедуру Button3Click која је специфична за овај задатак:
var i,j,nz,zc:integer;
begin j:=1;nz:=ZbirCifara(a[j]);
For i:=2 to 100 do
begin zc:=ZbirCifara(a[i]);
If (nz<zc)or(nz=zc)and(a[j]>a[i])
then begin nz:=zc;j:=i;
end;
end;
Edit2.Text:=IntToStr(nz);
Edit3.Text:=IntToStr(a[j]);
Edit4.Text:=IntToStr(j);
end;
И функцију за израчунавање збира цифара која не мора бити рекурзивна, али је овако ефектније решење:
begin If a=0
then zbircifara:=0
else zbircifara:=ZbirCifara(a div 10)+a mod 10;
end;
4.15. Саставити програм који формира низ од 100 природних бројева, а затим одређује редни
број највећег и најмањег елемента, у случају да има више једнаких елемената исписује се
елемент са најмањим редним бројем.
type
...
var
Form1: TForm1;
n,k:integer;
a:niz;
Edit5.Clear;
end;
begin If key=#13
then Button1.Click
end;
If n>100 then n:=100;
Button2.SetFocus;
end;
begin Randomize;
k:=0;
While k<n do
begin k:=k+1;
a[k]:=Random(900)+100;
end;
Button3.SetFocus;
end;
Декларисаћемо и дефинисати процедуру Button3Click која је специфична за овај задатак. Користимо методу
"лажне претпоставке" (ово је често коришћена метода, позната и под разним другим именима, а састоји се у
следећем: претпостављамо да је први елемент низа највећи, а затим га упоређујемо са свим осталим
елеметима низа и кад год наиђемо на неки већи од њега проглашавамо га највећим; исто тако и за најмањи,
претпостављамо да је први најмањи, а затим га упоређујемо са свим осталим елементима низа и кад год
наиђемо на неки мањи од њега проглашавамо га најмањим):
var i,max,min:integer;
begin max:=1;min:=1;
For i:=2 to n do
If a[i]>a[max]
then max:=i
else If a[i]<a[min] then min:=i;
Edit2.Text:=IntToStr(a[max]);
Edit3.Text:=IntToStr(max);
Еdit4.Text:=IntToStr(a[min]);
Edit5.Text:=IntToStr(min);
end;

4.16. Саставити програм који формира низ од највише 100 троцифрених бројева, а затим
одређује аритметичку средину низа и редни број елемента низа који јој је најближи, у
случају да има више елемената исписује се елемент са најмањим редним бројем.
type
...
var
Form1: TForm1;
n,k:integer;
a:niz;
end;
begin If key=#13
then Button1.Click
end;
If n>100 then n:=100;
Button2.SetFocus;
end;
begin Randomize;
k:=0;
While k<n do
begin k:=k+1;
a[k]:=Random(900)+100;
end;
Button3.SetFocus;
end;
var i,z,rb:integer;
begin z:=0;
For i:=1 to n do z:=z+a[i];
Edit2.Text:=Format('%1.5f',[z/n]);
rb:=1;
For i:=2 to n do
If Abs(a[i]-z/n)<Abs(a[rb]-z/n) then rb:=i;
Edit3.Text:=IntToStr(rb);
Edit4.Text:=IntToStr(a[rb]);
end;
Опис формата '%1.5f' код исписа аритметичке средине низа није коректан, правилно би било дефинисати опис
са '%9.5f' (три целобројне цифре, децимална тачка и пет децимала то је девет места за испис броја), али се
може прихватити будући да смо само хтели да испис има 5 децимала. Целобројни део ће се и онако увек
исписивати без заокругљења тако да не утиче на правилан испис резултата. Можда би се прегледност решења
повећала увођењем посебне променљиве за аритметичку средину и најкраће растојање, али је и овакво решење
сасвим солидно и програмерски оправдано (јер се не троши меморија за још две реалне променљиве).
одређује број парних и њихов збир и аритметичку средину непарних елемената низа.
type
...
var
Form1: TForm1;
n,k:integer;
a:niz;
Edit5.Clear;
end;
begin If key=#13
then Button1.Click
end;
If n>100 then n:=100;
Button2.SetFocus;
end;
begin Randomize;
k:=0;
While k<n do
begin k:=k+1;
a[k]:=Random(900)+100;
end;
Button3.SetFocus;
end;
var i,nep,zp,zn:integer;
begin zp:=0;zn:=0;nep:=0;
For i:=1 to n do
If Odd(a[i])
then begin zn:=zn+a[i];
nep:=nep+1;
end
else zp:=zp+a[i];
If nep>0
then Edit2.Text:=Format('%1.5f',[zn/nep])
else Edit2.Text:='0';
Edit3.Text:=IntToStr(n-nep);
Edit4.Text:=IntToStr(zp);
Edit1.Enabled:=true;
Edit1.SetFocus;
end;

4.18. Саставити програм који формира низ од највише 100 троцифрених бројева, а затим га
уређује у неопадајући или нерастући поредак.
Дизајнираћемо форму као на слици, дефинисати тип низ и глобалне променљиве
као и стандардне процедуре за формирање низа:
type
...
var
Form1: TForm1;
n,k:integer;
a:niz;
begin Memo1.Clear;Memo2.Clear;
end;
begin If key=#13
then Button1.Click
end;
If n>100 then n:=100;
Button2.SetFocus;
end;
begin Randomize;
k:=0;
While k<n do
begin k:=k+1;
a[k]:=Random(900)+100;
end;
Button4.Enabled:=true;Button5.Enabled:=true;
end;
Декларисаћемо и дефинисати процедуре Button3Click, Button4Click и Button5Click које су специфичне:
var i,j,p:integer;
begin For i:=1 to n-1 do
For j:=i+1 to n do
If a[i]>a[j]
then begin p:=a[i];a[i]:=a[j];a[j]:=p;
end;
Memo2.Clear;
For i:=1 to n do
Memo2.Lines.Add(IntToStr(i)+'. '+IntToStr(a[i]));
end;
var i,j,p:integer;
For j:=i+1 to n do
If a[i]<a[j]
end;
Memo2.Clear;
For i:=1 to n do
end;
begin Button3.Enabled:=false;Button4.Enabled:=false;
end;
Занимљиво је и овакво решење истог задатка:
begin If sender=button3
then UrediNiz(0)
else If sender=button4
then UrediNiz(1)
else begin Button3.Enabled:=false;Button4.Enabled:=false;
end;
end;
procedure TForm1.UrediNiz(tip:integer);
var i,j,p:integer;
For j:=i+1 to n do
If (a[i]>a[j])and(tip=0)or(a[i]<a[j])and(tip=1)
end;
Memo2.Clear;
For i:=1 to n do
end;
4.19. Саставити програм који формира низ од највише 100 двоцифрених бројева, а затим од
тог низа формира нови низ чији су сви елементи различити.
type
...
var
Form1: TForm1;
n,k:integer;
a,b:niz;
Edit5.Clear;
end;
begin If key=#13
then Button1.Click
end;
If n>100 then n:=100;
end;
begin Randomize;
k:=0;
While k<n do
begin k:=k+1;a[k]:=Random(90)+10;
end;

Button3.SetFocus;
end;
var i,j:integer;
dodaj:boolean;
begin i:=1;k:=0;
While i<=n do
begin dodaj:=true;
For j:=1 to i-1 do
If a[i]=a[j] then dodaj:=false;
If dodaj then begin k:=k+1;b[k]:=a[i];
end;
i:=i+1;
end;
For i:=1 to k do
Memo2.Lines.Add(IntToStr(i)+'. '+IntToStr(b[i]));
end;
4.20. Саставити програм који формира низ од највише 100 природних бројева, а затим
неуређујући низ исписује к највећих.
type
...
var
Form1: TForm1;
n,k:integer;
a,b:niz;
begin Memo1.Clear;Memo2.Clear;Edit2.Clear;
end;
begin If key=#13
then Button1.Click
else Button3.Click
end;
If n>100 then n:=100;
end;
begin Randomize;
k:=0;
While k<n do
begin k:=k+1;
a[k]:=Random(1000);
end;
end;
Измене у претходним процедурама су минималне. Декларисаћемо и дефинисати процедуре Edit2Change,
Button3Click, Button4Click и Button5Click која је специфична за овај задатак:
begin Memo2.Clear;
end;
var i,j,p:integer;
dodaj:boolean;
begin k:=StrToIntDef(Edit2.Text,10);
If k>n then k:=n;
Edit2.Text:=IntToStr(k);
For i:=1 to k do b[i]:=a[i]; // првих к елемената низа а формира низ б
For i:=k+1 to n do // проверавамо да ли има већих у остатку низа а
begin dodaj:=false;j:=1;p:=1;
While j<=k do
begin If a[i]>b[j] // ако је већи елемент у остатку низа а
then begin dodaj:=true; // памтимо да треба додати елемент
If b[j]<b[p] then p:=j; // тражи се најмањи у б
end;
j:=j+1;
end;
If dodaj
then begin for j:=p to k-1 do b[j]:=b[j+1]; // брише најмањи у б
b[k]:=a[i]; // додаје се нови елемент на крај низа б
end;
end;
For i:=1 to k do
Memo2.Lines.Add(IntToStr(i)+'. '+IntToStr(b[i]));
end;
Button3.Enabled:=true;Edit2.Enabled:=true;Edit2.SetFocus;
end;
Button1.Enabled:=true;Edit1.Enabled:=true;Edit1.SetFocus;
end;
Процедура Button5Click је нешто компликованија од до садашњих јер је и проблем који треба да сложенији
зато је треба пажљиво проучити и разјаснити, додати коментари су добра основа за то.
4.21. Саставити програм који формира низ од највише 100 троцифрених бројева, а затим из
низа издваја најдужи растући подниз.
type
...
var
Form1: TForm1;
n,k:integer;
a,b:niz;
end;
begin If key=#13
then Button1.Click
end;
If n>100 then n:=100;

end;
begin Randomize;
k:=0;
While k<n do
end;
Button3.SetFocus;
end;
var i,p,q,np,pp:integer;
begin np:=0;pp:=1;p:=0;q:=1;
For i:=2 to n do
If a[i-1]<a[i]
then p:=p+1
else begin If np<p
then begin np:=p;pp:=q;
end;
p:=0;q:=i;
end;
For i:=pp to pp+np do
Memo2.Lines.Add(IntToStr(i-pp+1)+'. '+IntToStr(a[i]));
end;
4.22. Саставити програм који формира два низа са по н (н<=100) троцифрених бројева, а
затим од њих формира трећи низ узимајући парне елементе из првог и непарне
елементе из другог низа.
Дизајнираћемо форму као на слици, дефинисати тип низ и глобалне
променљиве као и стандардне процедуре за формирање низа:
type
...
var
Form1: TForm1;
n,k:integer;
a,b:niz;
c:array[1..200] of integer;
begin Memo1.Clear;Memo2.Clear;Memo3.Clear;
end;
begin If key=#13
then Button1.Click
end;
If n>100 then n:=100;
end;
begin Randomize;
k:=0;
While k<n do
begin k:=k+1;
a[k]:=Random(900)+100;
b[k]:=Random(900)+100;
Memo2.Lines.Add(IntToStr(k)+'. '+IntToStr(b[k]));
end;
Button3.SetFocus;
end;
var i:integer;
begin k:=0;
For i:=1 to n do
begin If not Odd(a[i])
then begin k:=k+1;c[k]:=a[i];
end;
If Odd(b[i])
then begin k:=k+1;c[k]:=b[i];
end;
end;
For i:=1 to k do
Memo3.Lines.Add(IntToStr(i)+'. '+IntToStr(c[i]));
end;
неуређујући га исписује редне бројеве елемената од најмањег до највећег.
type
...
var
Form1: TForm1;
n,k:integer;
a,b:niz;
end;
begin If key=#13
then Button1.Click
end;
If n>100 then n:=100;
end;
begin Randomize;
k:=0;
While k<n do
Memo1.Lines.Add(Format('%2d',[k])+'. '+IntToStr(a[k]));
end;
Button2.Enabled:=false;Button3.Enabled:=true;Button3.SetFocus;
end;

Један од начина да се реши овај задатак је тражити најмањи елемент низа и његов редни број сместити у нови
низ, а на његово место ставити 1000, поступак понављамо све до сви елементи првог низа не постану исти. Ово
ћемо урадити у процедури, при чему ће почетни низ бити улазни параметар процедуре да се не би изгубиле
вредности елемената низа. Декларисаћемо и дефинисати процедуре Button3Click и Indeksi које су специфична
за овај задатак:
var i:integer;
begin k:=0;Odredi(a,b);
For i:=1 to n do
Memo2.Lines.Add(Format('%2d',[b[i]])+'. '+IntToStr(a[b[i]]));
end;
procedure TForm1.Odredi(a:niz;var b:niz);
var i,p:integer;
begin While k<n do
begin p:=1;
For i:=2 to n do
If a[i]<a[p] then p:=i;
k:=k+1;b[k]:=p;a[p]:=1000;
end;
end;
Задатак се врло лепо може решити и уз помоћ скупова. Тражи се најмањи елемент чији редни број се не налази
у скупу индекса и када се нађе његов редни број се смести у нови низ и дода у скуп индекса. Ево решења:
var i,p:integer;
si:set of 1..100;
begin k:=0;si:=[];
While k<n do
begin p:=0;
Repeat p:=p+1;
until not(p in si);
For i:=1 to n do
If not(i in si)and(a[i]<a[p]) then p:=i;
k:=k+1;b[k]:=p;si:=si+[p];
end;
For i:=1 to n do
end;
Још једно решење за које се може рећи да задовољава у слободнијем тумачењу услова задатака је формирати
низ чије су вредности индекси првог низа, а затим новоформирани низ уредити у неопадајући. Ево и оваквог
решења:
var i,ј,p:integer;
begin For i:=1 to n do b[i]:=i;
For i:=1 to n-1 do
For j:=i+1 to n do
If a[b[i]]>a[b[j]]
then begin p:=b[i];b[i]:=b[j];b[j]:=p;
end;
For i:=1 to n do
end;
Вероватно има још лепих решења овог (као и сваког другог) задатка. Читаоцима ових редова оставља се на
вољу да истражују и пронађу бар још једно лепо решење.
Има још пуно лепих и карактеристичних задатака са једнодимензионалним низовима, али не
могу се баш сви урадити и сервирати читаоцима, зато сада прелазимо на нешто сасвим ново, на
групу задатака са дводимензионалним низовима да се упознамо и са начином рада са њима и неким
лепим начинима размишљања у две димензије.
4.24. Саставити програм који формира дводимензионални низ 10 x 10 двоцифрених бројева, а
затим одређује аритметичку средину и број елемената већих од ње.
Дизајнираћемо форму као на слици, затим ћемо дефинисати тип низ и глобалне
променљиве:
type
niz=array[1..100,1..100] of integer;
...
var
Form1: TForm1;
a:niz;
Да би се извршио програм није потребна никаква акција корисника, зато ћемо у
процедури FormCreate симулирати притисак тастера:
begin Button1.Click;
end;
Дефинисаћемо сада процедуру Button1Click као реакцију на притисак тастера да бисмо омогућили кориснику
да више пута изврши програм без обавезе да га поново стартује:
var i,j,n:integer;
asr:real;
red:string;
begin Randomize; // Формирање дводимензионалног низа
Memo1.Clear;
red:='1 2 3 4 5 6 7 8 9 10';
Memo1.Lines.Add(Format('%43s',[red]));
For i:=1 to 10 do
begin red:=Format('%2d',[i])+' ';
For j:=1 to 10 do
begin a[i,j]:=Random(90)+10;
red:=red+Format('%4d',[a[i,j]]);
end;
Memo1.Lines.Add(red);
end;
n:=0;asr:=0; // Одређивање аритметичке средине и броја већих од од ње
For i:=1 to 10 do
For j:=1 to 10 do
asr:=asr+a[i,j]/100;
Edit1.Text:=Format('%7.2f',[asr]);
For i:=1 to 10 do
For j:=1 to 10 do
If a[i,j]>asr then n:=n+1;
Edit2.Text:=Format('%4d',[n]);
end;

затим одређује збирове елемената по колонама, по редовима и по дијагоналама.
Дизајнираћемо форму као на слици, затим ћемо дефинисати тип низ и
глобалне променљиве:
type
...
var
Form1: TForm1;
a:niz;
Да би се извршио програм није потребна никаква акција корисника, зато ћемо
у процедури FormCreate симулирати притисак тастера:
end;


var i,j,r,k:integer;
red:string;
begin Randomize;
Memo1.Clear;
red:='1 2 3 4 5 6 7 8 9 10';
For i:=1 to 10 do
For j:=1 to 10 do
end;
end;
For i:=1 to 10 do
begin r:=0;k:=0;
For j:=1 to 10 do
begin r:=r+a[i,j];k:=k+a[j,i];
end;
Edit1.Text:=Edit1.Text+Format('%4d',[r]);
Edit2.Text:=Edit2.Text+Format('%4d',[k]);
end;
end;

затим одређује збир елемената испод главе и збир елемената изнад споредне дијагонале.
Дизајнираћемо форму као на слици, затим ћемо дефинисати тип низ и глобалне
променљиве:
type
...
var
Form1: TForm1;
a:niz;
Да би се извршио програм није потребна никаква акција корисника, зато ћемо у
процедури FormCreate симулирати притисак тастера:
end;
var i,j,g,s:integer;
red:string;
begin Randomize;Memo1.Clear;
red:='1 2 3 4 5 6 7 8 9 10';
For i:=1 to 10 do
For j:=1 to 10 do
end;
end;
g:=0;s:=0;
For i:=2 to 10 do
For j:=1 to i-1 do g:=g+a[i,j];
For i:=1 to 9 do
For j:=1 to 10-i do s:=s+a[i,j];
Edit1.Text:=IntToStr(g);
end;

Funkcije Procedure Nizovi

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Funkcije Procedure Nizovi

Uploaded by

Copyright:

Available Formats

Програмирање није само написати програм који решава одређени проблем.

Програмирање је више од тога, много више. Програмирање је уметност.

4.1. Саставити програм који одређује n-ти степен уписног броја.

Програмирање - први кораци 2

4.2. Саставити програм који одређује факторијел уписаног броја.

Исто, са процедуром. Двокликом на тастер ОДРЕДИ декларисати и дефинисати процедуру Button1Click:

4.3. Саставити програм који одређује све Армстронгове бројеве до n.

Програмирање - први кораци 6

4.6. Саставити програм који одређује све савршене бројеве до n.

4.7. Саставити програм који одређује парове пријатељских бројева до n.

Програмирање - први кораци 12

4.10. Саставити програм који исписује Паскалов троугао до реда n.

Програмирање - први кораци 14

Програмирање - први кораци 16

Да би се лакше прешло из једног решења на

Програмирање - први кораци 18

Програмирање - први кораци 20

Програмирање - први кораци 22

Програмирање - први кораци 24

Програмирање - први кораци 26

Програмирање - први кораци 28

4.25. Саставити програм који формира дводимензионални низ 10 x 10 двоцифрених бројева, а

Програмирање - први кораци 30

procedure TForm1.Button1Click(Sender: TObject);

4.26. Саставити програм који формира дводимензионални низ 10 x 10 двоцифрених бројева, а

You might also like