Funkcije

Šta su funkcije?

Funkcije u Pascalu predstavljaju blok koda koji je dizajniran da obavlja određenu

operaciju ili izračunavanje. Ono što čini funkcije posebnim je njihova sposobnost da
vraćaju vrednost, bilo kojeg tipa podatka. Funkcije često olakšavaju kodiranje, čineći
ga modularnim i lako čitljivim.

Kako se implementiraju funkcije?

Da biste implementirali funkciju, koristite ključnu reč function, naziv funkcije, listu
parametara (ako postoje), i tip podatka koji funkcija vraća. Tijelo funkcije sadrži logiku
operacije, a rezultat se označava pomoću rečenice Result.

function Saberi(a, b: Integer): Integer;

begin

Result := a + b;

end;

U ovom primjeru, funkcija Saberi prima dva cijela broja i vraća njihov zbir.

Kako funkcije funkcionišu?

Kada pozovete funkciju, prosljeđujete joj određene vrijednosti (argumente), a funkcija

ih koristi unutar svog tijela za izračunavanje rezultata. Rezultat se potom može
koristiti u ostatku programa.

var rezultat: Integer;

begin

rezultat := Saberi(3, 5);

// Rezultat će biti 8 jer je 3 + 5

end;

Zašto su nam potrebne funkcije?

 1. Modularnost: Funkcije omogućavaju razbijanje koda na manje, samostalne
dijelove, čineći ga lakšim za održavanje.
2. Ponovna upotreba koda: Logika unutar funkcija može se koristiti na
različitim mijestima u programu.
3. Čitljivost koda: Svaka funkcija ima jasno definisanu svrhu, poboljšavajući
čitljivost i razumijevanje koda.

Procedure: Kako se Razlikuju od Funkcija

Procedure su slične funkcijama, ali se razlikuju po tome što ne vraćaju nikakvu

vrijednost. Koriste se za izvođenje operacija ili radnji bez potrebe da vrate rezultat.

procedure Pozdravi(ime: String);

begin

Writeln('Dobar dan, ', ime, '!');

end;

U ovom primjeru, procedura Pozdravi ispisuje pozdravnu poruku, ali ne vraća nikakav
rezultat.

Primjeri Zadataka:

1. Funkcija za proveru parnosti:

function JeParan(broj: Integer): Boolean;

begin
Result := (broj mod 2 = 0);
end; function JeParan(broj: Integer): Boolean; begin Result := (broj mod 2 = 0); end;
Korišćenje funkcije:
var
rezultat: Boolean;
begin
rezultat := JeParan(7);
// Rezultat će biti False jer je 7 neparan
end; var rezultat: Boolean; begin rezultat := JeParan(7); // Rezultat će biti False jer je 7 neparan end;
2. Procedure za ispisivanje poruka:

pascalCopy code
procedure Pozdravi(ime: String); begin Writeln('Dobar dan, ', ime, '!'); end;
Korišćenje procedure:
pascalCopy code
begin Pozdravi('Ana'); // Ispisuje: Dobar dan, Ana! end;
Ovi primjeri ilustruju osnovne koncepte funkcija i procedura u Pascalu, ističući
njihovu ulogu, implementaciju i korisnost.

Šta je rekurzija?

Rekurzija je koncept u programiranju gdje funkcija može da poziva samu sebe. Ova
tehnika se često koristi za rješavanje problema koji se mogu podijeliti na manje slične
podprobleme. U Pascalu, rekurzivne funkcije su dio moćnog alata koji omogućava
elegantno rješavanje određenih problema.

Kako implementirati rekurzivne funkcije?

Rekurzivna funkcija se definiše slično kao i obična funkcija, ali sadrži poziv same sebe
unutar svog tijela. Važno je postaviti uslov zaustavljanja kako biste izbjegli
beskonačnu rekurziju.

function Faktorijel(n: Integer): Integer;

begin

if n <= 1 then

Result := 1

else

Result := n * Faktorijel(n - 1);

end;

U ovom primjeru, funkcija Faktorijel izračunava faktorijel broja korišćenjem rekurzije.

Ako je broj manji ili jednak 1, vraća 1; inače, množi broj sa rezultatom faktorijela za
broj manji za 1.

Kako rekurzija funkcioniše?

1. Poziv funkcije: Kada rekurzivna funkcija bude pozvana, obavlja određene

operacije i može ponovo pozvati samu sebe.
2. Novi kontekst: Svaki put kada se funkcija pozove, stvara se novi kontekst
izvršavanja, sa sopstvenim parametrima i promenljivama.
3. Uslov zaustavljanja: Postavljanjem uslova zaustavljanja, osiguravamo da
rekurzija stane nakon određenog broja koraka. U suprotnom, može doći do
beskonačne rekurzije.
Zašto koristiti rekurziju?

1. Elegantnost koda: Rekurzivni pristup može biti elegantan i čist, posebno

kada se rešavaju problemi koji se lako dijele na manje djelove.
2. Praktičnost: Kod nekih problema, rekurzivna implementacija može biti
jednostavnija za razumevanje i održavanje od iterativnih pristupa.

Primer zadatka sa rekurzijom:

Fibonačijev niz:

function Fibonaci(n: Integer): Integer;

begin
if n <= 1 then
Result := n
else
Result := Fibonaci(n - 1) + Fibonaci(n - 2);
end; function Fibonaci(n: Integer): Integer; begin if n <= 1 then Result := n else Result := Fibonaci(n - 1) +
Fibonaci(n - 2); end;

Fibonačijev niz je niz brojeva gde svaki broj predstavlja zbir prethodna dva. U ovom
primeru, funkcija Fibonaci rekurzivno izračunava n-ti član Fibonačijevog niza.

var
rezultatFib: Integer;
begin
rezultatFib := Fibonaci(5);
// RezultatFib će biti 5 jer je peti član Fibonačijevog niza 5
end; var rezultatFib: Integer; begin rezultatFib := Fibonaci(5); // RezultatFib će biti 5 jer je peti član
Fibonačijevog niza 5 end;

Rekurzija može biti moćan alat u rešavanju određenih problema, ali je važno koristiti
je pažljivo kako biste izbegli beskonačne petlje i postavili odgovarajuće uslove
zaustavljanja.

Ispis broja permutacija niza

program PermutationGenerator;

procedure Swap(var a, b: char);

var
temp: char;
begin
temp := a;
a := b;
b := temp;
end;
procedure GeneratePermutations(chars: string; start, n: integer);
var
i: integer;
begin
if start = n then
writeln(chars)
else
begin
for i := start to n do
begin
Swap(chars[start], chars[i]);
GeneratePermutations(chars, start + 1, n);
Swap(chars[start], chars[i]); // backtrack
end;
end;
end;

var
inputChars: string;

begin
writeln('Permutation Generator');
writeln('---------------------');

write('Enter a string of characters: ');

readln(inputChars);

if Length(inputChars) < 1 then

begin
writeln('Please enter a non-empty string.');
Exit;
end;

writeln('---------------------');
writeln('Permutations:');
GeneratePermutations(inputChars, 1, Length(inputChars));
end.

Zadaci

1. Faktorijel
Napiši program koji računa faktorijel nekog broja! (6!=1*2*3*4*5*6=720)

2. Obrnuta Poezija
Mali Albert je jako talentovano dijete za poeziju, to je primijetio i njegov učitelj. Kako je Albert
postajao sve bolji i bolji u recitovanju, dobri učitelj je htio da mu zada izazovnije tekstove za
recitovanje, no učitelj je nažalost polu-disleksičan. Pomozi Albertovom učitelju tako što češ napraviti
program koji datu rečenicu pretvori u „obrnutu poeziju“ tako što ćeš samo riječi pojedinačno napisati
unatraške dok će raspored riječi ostati nepromijenjen! (npr. Crna svinja  anrC ajnivs)

3. Euklidov Algoritam
Napiši program koji računa NZD(najveći zajednički sadržilac) dva broja! (najveci broj koji dijeli neka
dva broja npr. NZD(16,20)=4)

4. Nemušti jezik
Profesorica istorije je prije bila jako uspješna u vođenju časa, no zadesila se u saobraćajnoj nesreći u
kojoj je preživjela, ali joj se poremetio govorni centar u mozgu. Naime, ona je savršeno svjesna svega
ali kada izgovara rečenice permutuje mnoga slova tako da učenici ništa ne mogu razumjeti. Zbog toga
joj prijeti otkaz. Međutim, ona ima sreće što ima tako brižne učenike, koji ju jako cijene i poštuju, i
koji su odlučili da naprave mašinu koja će prevoditi istoričarkine nebuloze kako ona ne bi dobila
otkaz. Pomozi dobrim učenicima da pomognu svojoj profesorici da ne izubi posao tako što ćeš
napraviti program koji provjeraca da li su dva unesena stringa ambigrami ili nisu (npr. Ja sam Matej 
Mj tej aasma)

Rjesenja

1. Faktorijel
program RecursiveFactorialCalculator;

function CalculateFactorial(n: Integer): Integer;

begin

if n = 0 then
CalculateFactorial := 1
else

CalculateFactorial := n * CalculateFactorial(n - 1);

end;

var
num: Integer;

begin
writeln('Recursive Factorial Calculator');
 writeln('--------------------------------');

write('Enter a non-negative integer: ');

readln(num);

if num < 0 then

writeln('Factorial is not defined for negative numbers.')
else
writeln('Factorial of ', num, ' is: ', CalculateFactorial(num));
end.

2. Obrnuta Poezija
program ObrnutaPoezija;

function RijecNaopacke(rijec: string): string;

var
i: integer;
begin
Result := '';
for i := Length(rijec) downto 1 do
Result := Result + rijec[i];
end;

procedure NapraviObrnutuPoeziju;
var
unos, obrnutaRecenica, trenRijec: string;
i: integer;
begin
writeln('Generator Obrnute Poezije');
writeln('------------------------');

write('Unesi recenicu: ');

readln(unos);

obrnutaRecenica := '';
trenRijec := '';

for i := 1 to Length(unos) do
begin
if unos[i] = ' ' then
begin
obrnutaRecenica := obrnutaRecenica + RijecNaopacke(trenRijec) + ' ';
trenRijec := '';
end
else
trenRijec := trenRijec + unos[i];
end;

obrnutaRecenica := obrnutaRecenica + RijecNaopacke(trenRijec);

 writeln('Poezija naopacke: ', obrnutaRecenica);
end;

begin
NapraviObrnutuPoeziju;
readln;
end.

3. Euklidov Algoritam

program EuklidovAlgoritam;

function EuklidNZD(a, b: Integer): Integer;

begin
while b <> 0 do
begin

a := a mod b;
a := a + b;
b := a - b;
a := a - b;
end;

EuclidsGCD := a;
end;

var
num1, num2: Integer;

begin
writeln('Euklidov Algoritam (NZD Kalkulator)');
writeln('-----------------------------------');

write('Unesi prvi broj: ');

readln(num1);
write('Unesi drugi broj: ');
readln(num2);

writeln('The GCD of ', num1, ' and ', num2, ' is: ', EuklidNZD(num1, num2));
readln;
end.

4. Nemušti jezik
program SimpleAnagramChecker;

function AreAnagrams(str1, str2: string): boolean;

var
i, j: Integer;
 temp: Char;
begin
if Length(str1) <> Length(str2) then
begin
Result := False;
Exit;
end;

for i := 1 to Length(str1) - 1 do
for j := 1 to Length(str1) - i do
if str1[j - 1] > str1[j] then
begin
temp := str1[j - 1];
str1[j - 1] := str1[j];
str1[j] := temp;
end;

for i := 1 to Length(str2) - 1 do
for j := 1 to Length(str2) - i do
if str2[j - 1] > str2[j] then
begin
temp := str2[j - 1];
str2[j - 1] := str2[j];
str2[j] := temp;
end;

Result := str1 = str2;

end;

var
str1, str2: string;

begin
writeln('Simple Anagram Checker');
writeln('----------------------');

write('Unesi prvi string: ');

readln(str1);
write('Unesi drugi string: ');
readln(str2);

if AreAnagrams(str1, str2) then

writeln('Uneseni stringovi su anagrami.')
else
writeln('Uneseni stringovi nisu anagrami.');
readln;
end.