Ez dugu ariketa errekurtsibo asko aurkituko gure programetan, baina interesgarria da kontzeptu hori lantzea azpiprogramak aktibatzen direnean zer gertatzen den ikasteko.
Egoera errekurtsiboak bizitzan eta naturan ematen dira eta jarraian adibide grafikoak erakusten dira:
iZenbaki zenbaki baten faktoriala kalkulatzen duen funtzio errekurtsiboa erakusten da jarraian. Faktorialaren kalkulu errekurtsiboa algoritmo honetan oinarritzen da:
iZenbaki! = iZenbaki * (iZenbaki - 1)!
/* 14-Jarduera_Faktorial-Errekurtsiboa: faktoriala errekurtsiboki */
#include ++stdio.h>
long int faktorialaKalkulatu(int iZbk)
{
if (iZbk == 1)
{
printf(" 1! badakit kalkulatzen, itzuli 1 modulu deitzaileari\n");
return 1;
}
else
{
printf("%3d! kalkulatzeko... %d! ezagutu behar dut\n", iZbk, iZbk - 1);
long int emaitza = iZbk * faktorialaKalkulatu(iZbk - 1);
printf("%3d! kalkulatu dut... %d! * %d eginez\n", iZbk, iZbk - 1, iZbk);
return emaitza;
}
}
int main()
{
int iDatua;
long int liEmaitza;
do
{
printf("Eman zenbaki osoa bere faktoriala kalkulatzeko (adibidez 6): ");
scanf("%d", &iDatua);
} while (iDatua ++= 0);
liEmaitza = faktorialaKalkulatu(iDatua);
printf("%d! = %ld\n", iDatua, liEmaitza);
return 0;
}
Fibonacciren segidaren adierazpen orokorra gogoratuz:
Hauxe da fniFibonacci funtzio errekurtsiboa:
{-------------------------FUNTZIO ERREKURTSIBOA-------------------------}
function fniFibonacci(iZbk: integer): integer ;
begin
if (iZbk = 0) or (iZbk = 1) then
fniFibonacci := iZbk
else
fniFibonacci := fniFibonacci(iZbk-1) + fniFibonacci(iZbk-2) ;
end ;
Teklatuaren bitartez iZenbat kopuru oso bat irakurri eta Fibonacci-ren lehen iZenbat zenbakiak pantailaratu. Hauxe da programa eta bere exekuzioaren irteera bat:
program FibonacciErrekurtsiboa ;
uses
crt ;
const
AZKENMUGA = 24 ; { integer datu-motak ez du gehiago ematen }
{-------------------------FUNTZIO ERREKURTSIBOA-------------------------}
function fniFibonacci(iZbk: integer): integer ;
begin
if (iZbk = 0) or (iZbk = 1) then
fniFibonacci := iZbk
else
fniFibonacci := fniFibonacci(iZbk-1) + fniFibonacci(iZbk-2) ;
end ;
{---------------------------PROGRAMA NAGUSIA---------------------------}
var
iZenbat, iKont: integer ;
cErantzuna: char ;
begin
writeln ;
repeat
repeat
write('Eman Fibonacci segidaren zenbaki kopurua (1 eta ', AZKENMUGA,' artekoa): ') ;
readln(iZenbat) ;
until (iZenbat >= 1) and (iZenbat <= AZKENMUGA) ;
writeln ;
for iKont:=1 to iZenbat do
begin
if (iKont = 1) or (iKont = 2) then
writeln(iKont:20, ' >>>>>> ', fniFibonacci(iKont-1))
else
writeln(iKont:20, ' -----> ', fniFibonacci(iKont-1)) ;
end ;
writeln ;
write('Amaitu nahi duzu? (B/E): ') ;
repeat
cErantzuna := readkey ;
writeln(cErantzuna) ;
cErantzuna := upcase(cErantzuna) ;
until (cErantzuna = 'B') or (cErantzuna = 'E') ;
writeln ;
writeln ;
until cErantzuna = 'B' ;
write('Programa bukatu da') ;
repeat until keypressed ;
end.
Goiko programa hobeto ulertzeko, aztertu ere FibonacciErrekurtsiboa_formatua.pas bertsioa non pantailan idazketa batzuk egiten diren, eta horiei esker programa exekutatzean ikus daiteke kodearen zein puntutan aurkitzen garen.
Programa bat daukagu fniBatuBiEtaGehitu5Gehiago izeneko funtzioari deitzen diona, honako hauek ikusi:
fniBatuBiEtaGehitu5Gehiago funtzioak bi parametro ditu, biak integer datu-motatakoak
fniBatuBiEtaGehitu5Gehiago funtzioaren bi parametroak sarrerakoak dira.
fniBatuBiEtaGehitu5Gehiago funtzioak irteera bakarra du eta integer datu-motatakoa da
fniBatuBiEtaGehitu5Gehiago funtzioari deia egitean esleipen bat idatziko da
fniBatuBiEtaGehitu5Gehiago funtzioaren deia adierazpen aritmetiko batean ager daiteke
fniBatuBiEtaGehitu5Gehiago funtzioaren deia beste azpiprograma baten uneko parametroa izan daiteke
fniBatuBiEtaGehitu5Gehiago funtzioak emaitza itzuliko dio programa nagusiari, emaitza den balio hori itzultzeko fniBatuBiEtaGehitu5Gehiago etiketa erabiliko du
program FaktorialaKalkulatzen ;
function fnliFaktoriala(iZbk:integer) : longint ;
var
k : integer ;
liMetatua : longint ;
begin
liMetatua := 1 ;
for k:=1 to iZbk do
begin
liMetatua := liMetatua*k ;
WriteLn(k, ' ---> ', liMetatua) ;
end ;
fnliFaktoriala := liMetatua ;
end ;
var
liEmaitza : longint ;
iDatua : integer ;
begin
repeat
write('Eman zenbaki osoa: ') ;
readln(iDatua) ;
until iDatua > 0 ;
liEmaitza := fnliFaktoriala(iDatua) ;
writeln(iDatua, '! = ', liEmaitza) ;
readln ;
end.
Programa horretan fnliFaktoriala() funtzioari dei bakar bat egiten zaio, programa nagusian liEmaitza aldagaiari balioa ematen zaio baino lehenago iDatua aldagaiaren balioa teklatuaren bitartez irakurri dugu. fnliFaktoriala() funtzioaren kodifikazioan FOR-DO egitura bat behar dugu eta hura kontrolatzeko k aldagaia behar dugu, faktoriala kalkulatzen duen liMetatua aldagaia beharko dugu ere.
fnliFaktoriala() funtzioak programa nagusiari emaitza itzultzeko fnliFaktoriala etiketa erabili behar da derrigorrez, bestela liMetatua aldagaiak faktorialaren balioa gordeko du baina programa nagusiari ez zaio inolaz ere helduko.
iZenbaki zenbaki baten faktoriala kalkulatzen duen funtzio errekurtsiboa erakusten da jarraian. Faktorialaren kalkulu errekurtsiboa algoritmo honetan oinarritzen da:
iZenbaki! = iZenbaki * (iZenbaki - 1)!
program FaktorialErrekurtsiboa ;
function fnliFaktoriala(iZbk:integer) : longint ;
begin
writeln('Dei errekurtsiboa baino lehen ---> ', iZbk) ;
if iZbk = 1 then
fnliFaktoriala := 1
else
fnliFaktoriala := iZbk * fnliFaktoriala(iZbk - 1) ;
writeln ('Dei errekurtsiboa eta gero ------> ', iZbk) ;
end ;
var
liEmaitza : longint ;
iDatua : integer ;
begin
repeat
write('Eman zenbaki osoa: ') ;
readln(iDatua) ;
until iDatua > 0 ;
liEmaitza := fnliFaktoriala(iDatua) ;
writeln(iDatua, '! = ', liEmaitza) ;
readln ;
end.
Ordenadoreak letra bat pentsatuko du eta guk asmatu beharko dugu
A eta Z bitartean dagoen letra bat aukeratuko du ordenadoreak eta ezezaguna den letra hori guk asmatuko dugu. Egiten dugun saiakera bakoitzeko, programak informazioa emango digu esanez letra ezezaguna zein tartetan dagoen.
Ordenadoreak letra bat aukeratuko du, A eta Z bitartean dagoen letra bat aukeratuko du. Horretarako, random() funtzio estandarra erabiliko du (randomize prozedurarekin batera). programak aukeratzen duen letra cAsmatzeko aldagaian gordeko da
Ezezaguna den letraren heina [A, Z] da hasieran, behemuga A eta goimuga Z. Beraz, cProposatutakoTxikiena:='A' eta cProposatutakoHandiena:='Z'
Errepikatu letra asmatu arte edo 5 saiakera egin arte:
Teklatuaren bitartez irakurriz, soluzio bat proposatuko diogu programari. Nahi dugun soluzioa proposatuko diogu programari, modurik eraginkorrena da tartearen erdiko letra proposatzea programari: M lehen saiakeran, G edo T bigarren saiakeran...
Gure proposamenaren arabera, programak bi aukera izango ditu eta honela jokatuko du:
Proposatutako letra eta programak asmatutakoa bat datoz, letra asmatu dugunez begiztatik irten
Proposatutako letra eta programak asmatutakoa ez datoz bat, ez dugunez letra asmatu beste saiakera bat emango digu programak (5 saiakeraren muga ez badugu oraindik gainditu). Hurrengo saiakeraran erakutsiko digun tartea egokituko du programak, honelaxe:
Proposatu diogun letra programarena baino handiagoa bada (tartearen cProposatutakoHandiena aldatu eta 3. urratsaren hasierara itzuli saiakera berri bat egiteko)
Proposatu diogun letra programarena baino txikiagoa bada (tartearen cProposatutakoTxikiena aldatu eta 3. urratsaren hasierara itzuli saiakera berri bat egiteko)
Emaitza erakutsi, begiztatik irteteko aukerak:
Letra asmatu diogu programari, zorionak eta iSaiakera erakutsi
Saiakerak 5 baino gehiago izan dira, cAsmatzeko aldagaiaren edukia erakutsi
Zergatik 5 saiakera?
A-ren eta Z-ren artean 26 karaktere. Urrats bakoitzean,
karaktere guztietatik erdiak baztertzen dira. Beraz:
log2(26)=4,70044
logaritmo (2 oinarrian) 26 zenbakiarena 4,70044 da
Eskatzen den ariketaren hurbilpen hau LetraAsmatu_hasiera.pas abiapuntutzat har daiteke. Hau da eskatzen den LetraAsmatu.pas iturburu-programa bat. Zein da zurea?
Hona hemen programaren kodifikazioa non, mesedez, pantaila-irteeran agertzen diren koloreei jaramonik ez diezuen egin behar. Aldiz, oso interesgarria da boAsmatua aldagai boolear laguntzilearen erabilera. Ikusi ere random(), chr(), ord(), pred() eta succ() funtzioek programari egiten dioten ekarpena:
{
'A' eta 'Z' arteko letra bat programak aukeratuko du,
letra hori guk asmatuko dugu erantzun hauek emanez:
00000000011111111112222222
12345678901234567890123456
ABCDEFGHIJKLMNOPQRSTUVWXYZ
M 1. saikera
G T 2. saikera
D J P W 3. saikera
B F R Y 4. saikera
5. saikera
---------------------------------------
Zergatik 5 saiakera?
log2(26)=4.7
logaritmo 2 oinarrian 26 zenbakiarena 4.7 da
A eta Z artean 26 karaktere
}
program LetraAsmatu;
uses
crt;
const
iSAIAKERAKOPURUMAXIMOA = 5;
var
cLetra, cAsmatzeko, cProposatutakoTxikiena, cProposatutakoHandiena, cItxaron: char;
iEsparrua, iAleatorioa, iSaiakera: integer;
boAsmatua: boolean;
begin
clrscr;
writeln;
writeln('''A'' eta ''Z'' arteko letra bat aukeratuko du konputagailuak eta');
writeln('ea letra hori asmatzeko gai zaren. Zure proposamenak egitean');
writeln('"Bilaketa Bitarra" deitzen den estrategia erabil ezazu');
writeln;
writeln;
writeln('Aurrera egiteko tekla bat sakatu!');
writeln;
writeln;
cItxaron := readkey;
writeln(cItxaron);
clrscr;
writeln('//////////////////////////////////////');
writeln;
randomize;
iEsparrua := ord('Z') - ord('A') + 1;
iAleatorioa := random(iEsparrua);
(* *) writeln('iAleatorioa=', iAleatorioa);
cAsmatzeko := chr(iAleatorioa + ord('A')); (* 0-A, 1-B, 2-C, ... 24-Y, 25-Z *)
(* *) writeln('cAsmatzeko=', cAsmatzeko);
writeln;
boAsmatua := FALSE;
iSaiakera := 1;
cProposatutakoTxikiena := 'A';
cProposatutakoHandiena := 'Z';
repeat
repeat
writeln('Saiakera=', iSaiakera, ' Zein da ezkutatu dugun letra maiuskula? ');
// kolorerik gabe
write(' ', cProposatutakoTxikiena, '..', cProposatutakoHandiena,' alfabetoko letra bat eman, eta ea asmatzen duzun: ');
// koloreekin
{
write(' ');
textcolor(Cyan);
write(cProposatutakoTxikiena);
textcolor(LightGray);
write('..');
textcolor(Cyan);
write(cProposatutakoHandiena);
textcolor(LightGray);
write(' alfabetoko letra bat eman, eta ea asmatzen duzun: ');
}
readln(cLetra);
cLetra := upcase(cLetra);
if (cLetra < cProposatutakoTxikiena) or (cLetra > cProposatutakoHandiena) then
begin
// kolorerik gabe
writeln('Datua ''', cProposatutakoTxikiena, ''' eta ''', cProposatutakoHandiena, ''' artekoa, mesedez!');
// koloreekin
{
write('Datua ');
textcolor(Red);
write('''', cProposatutakoTxikiena, '''');
textcolor(LightGray);
write(' eta ');
textcolor(Red);
write('''', cProposatutakoHandiena, '''');
textcolor(LightGray);
writeln(' artekoa, mesedez!');
}
end;
until (cLetra >= cProposatutakoTxikiena) and (cLetra <= cProposatutakoHandiena);
if cLetra=cAsmatzeko then
begin
boAsmatua := TRUE;
writeln;
// kolorerik gabe
writeln('OSO ONDO!');
// koloreekin
{
textcolor(Green);
writeln('OSO ONDO!');
textcolor(LightGray);
}
end
else
begin
iSaiakera := iSaiakera + 1;
// kolorerik gabe
write('EZ, EZ DUZU ASMATU! ');
// koloreekin
{
textcolor(Red);
write('EZ, EZ DUZU ASMATU! ');
textcolor(LightGray);
}
if cAsmatzeko < cLetra then
begin
cProposatutakoTxikiena := cProposatutakoTxikiena; {esleipen hau soberan egon daiteke}
cProposatutakoHandiena := pred(cLetra);
// kolorerik gabe
writeln('Saiatu bilatzen ''', cProposatutakoTxikiena, ''' eta ''', cProposatutakoHandiena, ''' bitartean');
// koloreekin
{
write('Saiatu bilatzen ');
textcolor(Cyan);
write('''', cProposatutakoTxikiena, '''');
textcolor(LightGray);
write(' eta ');
textcolor(Cyan);
write('''', cProposatutakoHandiena, '''');
textcolor(LightGray);
writeln(' bitartean');
}
end;
if cAsmatzeko > cLetra then
begin
cProposatutakoHandiena := cProposatutakoHandiena; {esleipen hau soberan egon daiteke}
cProposatutakoTxikiena := succ(cLetra);
// kolorerik gabe
writeln('Saiatu bilatzen ''', cProposatutakoTxikiena, ''' eta ''', cProposatutakoHandiena, ''' bitartean');
// koloreekin
{
write('Saiatu bilatzen ');
textcolor(Cyan);
write('''', cProposatutakoTxikiena, '''');
textcolor(LightGray);
write(' eta ');
textcolor(Cyan);
write('''', cProposatutakoHandiena, '''');
textcolor(LightGray);
writeln(' bitartean');
}
end;
writeln;
end;
until (iSaiakera > iSAIAKERAKOPURUMAXIMOA) or boAsmatua;
if boAsmatua then
begin
writeln(iSaiakera, ' saiakera egin ondoren asmatu duzu');
end
else
begin
writeln('Saiakerak agortu dituzu eta ez duzu asmatu');
write('Asmatu beharreko letra hau izan da: ');
// kolorerik gabe
writeln(cAsmatzeko);
// koloreekin
{
textcolor(Red);
writeln(cAsmatzeko);
textcolor(LightGray);
}
end;
writeln;
writeln('//////////////////////////////////////');
readln;
end.
00000000011111111112222222
12345678901234567890123456
ABCDEFGHIJKLMNOPQRSTUVWXYZ
M 1. saikera
G T 2. saikera
D J P W 3. saikera
B F R Y 4. saikera
5. saikera
0 eta 100 bitartean dagoen zenbaki osoa pentsatuko dugu eta ordenagailuak galdera batzuk eginez zenbaki hori asmatuko digu. Saiakera bakoitzeko, ordenagailuari informazioa emango diogu esanez zenbaki ezezaguna zein tartetan dagoen.
Zenbaki oso bat pentsatu dugu, hots, 0 eta 100 bitartean dagoen zenbaki osoa pentsatu dugu
Ezezaguna den zenbakiaren heina [0, 100] da hasieran, behemuga 0 eta goimuga 100. Beraz, iBehemuga:=0 eta iGoimuga:=100
Errepikatu zenbakia asmatu arte edo 7 saiakera egin arte:
Programak proposatuko digun soluzioa kalkulatuko du, soluzioa: baligarria den heinaren erdia. Beraz, iSoluzioa := (iBehemuga + iGoimuga) div 2
Programak galdetuko digu proposatu duen soluzioa egokia den ala ez, aukerak:
B, bai, proposatu digun zenbakia guk pentsatu duguna izan da (begiztatik irten)
H, ez, proposatu digun zenbakia ez da guk pentsatutakoa, proposatu digun zenbakia gurea baino handiagoa da (heinaren iGoimuga aldatu eta 3. urratsaren hasierara itzuli saiakera berri bat egiteko)
T, ez, proposatu digun zenbakia ez da guk pentsatutakoa, proposatu digun zenbakia gurea baino txikiagoa da (heinaren iBehemuga aldatu eta 3. urratsaren hasierara itzuli saiakera berri bat egiteko)
Emaitza erakutsi, begiztatik irteteko aukerak:
Gure erantzuna B izan denez, ordenagailuak gure zenbakia asmatu du: iSoluzioa erakutsi
Saiakerak 7 baino gehiago izan dira, horrek esan nahi du ez dugula zuzen jokatu eta gure erantzunetan gezurra esan diogula programari
Zergatik 7 saiakera?
0-tik 100-ra, biak barne, 101 aukera. Urrats bakoitzean,
aukera guztietatik erdiak baztertzen dira. Beraz:
Eskatzen den ariketaren hurbilpen hau ZenbakiaAsmatu_hasiera.pas abiapuntutzat har daiteke. Hona hemen... ...iturburu-programa, eta... ...beste iturburu-programa bat da. Ikusten denez, soluzio bakarra ez dago, zein da zurea?
Antzeko algoritmoa aplikatzen da 6. astea | letra bat asmatzen ariketan, non makinak letra bat aukeratzen duen eta guk asmatu behar dugun, LetraAsmatu.pas programaren kodea ikusteko klik egin hemen.
Leonardo Pisano (Pisa, Italia, 1170-1250), Leonardo Bonacci, Leonardo Fibonacci edo Fibonacci moduan ezaguna, Italiar matematikaria izan zen, Erdi Aroko ezagunetarikoa. Ezaguna da batez ere bi aurkikuntzengatik:
Hindu-arabiar zenbaki sistema Europan sartu zuen eta berau erabiltzeko bideak jarri zituen XIII. mendeko "Liber Abaci" liburuaren bitartez
Fibonacciren zenbakiak deskribatu zituen liburu berean, nahiz eta berak ez zituen aurkitu baizik eta adibide moduan jarri
Fibonacciren sekuentziako lehen zenbakia 0 da, Fibonacci-ren bigarren zenbakia 1 da, eta hirugarren zenbakia lortzeko aurreko biak batuko dira, horregatik Fibonacciren hirugarren zenbakia 1 da, laugarren zenbakia 2 izango da, bosgarrena 3, ...
Ondorengoa da Fibonacciren segidaren adierazpen orokorra:
Fibonacciren zenbakiak grafikoki adieraztean honako blokeen sorta eta espirala lortzen dira:
Fibonacciren sekuentziako bi zenbaki hartuz eta zatiketa eginez, urrezko zenbakia edo jainkozko proportzioa edo urrezko proportzioa edo zerutiar zenbakia lortzen da:
Fibonacciren sekuentzia sarritan agertzen da naturan. Izan ere, naturan hazkundea gertatzen denean Fibonacciren sekuentziaren arabera ematen da:
Eskatzen den programa (prozedura bat eta funtzio bat)
Programa bakarra izan arren programak bi zati izango ditu. Lehen zatian prozedura bati dei egingo zaio eta programaren bigarren zatian funtzio bati dei egingo zaio.
Programaren prozedura eta programaren funtzioa jarraian deskribatzen dira eta azpiprograma bakoitzaren kodea falta da. Ikaslearen lana da azpiprogramen kodeak bukatzea eta programaren emaitzak ulertzea.
Hau garrantzitsua da
Ez ahaztu, edozein ariketa programatzerakoan beti Programa Nagusitik hasiko garela, eta Programa Nagusia bukatzean jarraituko dugula azpiprograma guztien kodea idazten. Horregatik, bi adibide hauetan Programa Nagusiak ematen dira eta eskatzen da garatzea bakoitzari dagokion azpiprograma.
Lehen zatia. Fibonacciren sekuentzia osatuko duten zenbakien iZenbat kopurua teklatuz irakurri programa nagusian eta prozedura batek ondoko taularen pantailaraketa egin dezala FOR-DO egitura bat erabiliz, prozeduraren izena FibonaccirenSekuentziaPantailaratu izan daiteke.
Hona hemen kodifikazioa non programa nagusia ematen den eta prozedura falta den:
{ iKopurua (3 eta 24 artekoa) teklatuz irakurri eta Fibonacci zenbakien }
{ sekuentziaren horrenbeste elementu pantailaratuko dira 0-tik hasita }
program FibonacciSekuentzia_prozedura ;
const (* integer-ekin muga 23 da *)
ZENBAKIKOPURUMAX = 23 ; (* longint-ekin muga 47 da *)
{ prozeduraren kodea hemen hasten da }
procedure FibonaccirenSekuentziaPantailaratu...
{ prozeduraren kodea hemen amaitzen da }
{ ---------------------------------PROGRAMA NAGUSIA--------------------------------- }
var
iKopurua : integer ;
begin
writeln ;
writeln ;
repeat
writeln('Fibonacci zenbakien kopurua eman (3 eta ', ZENBAKIKOPURUMAX,' artekoa)') ;
write('eta 0-tik hasita Fibonacciren segida erakutsiko da: ') ;
readln(iKopurua) ;
until (iKopurua >= 3) and (iKopurua <= ZENBAKIKOPURUMAX) ;
FibonaccirenSekuentziaPantailaratu(iKopurua) ;
writeln ;
write('Programa bukatu da, irteteko RETURN sakatu') ;
readln ;
end.
Programaren lehen zatiko irteera bat hau izan daiteke:
Bigarren zatia. Prozesu errepikakor bat izango da eta bertatik irteteko b edo B erantzun beharko da, bestela programa nagusian iMuga teklatuz irakurriko da eta funtzio batek kalkulatuko du 0-tik hasita zenbat Fibonacciren zenbaki dauden. Horretarako, WHILE-DO egitura bat edo REPEAT-UNTIL egitura bat erabiliko da fniFibonacciZenbakienKopuruaKalkulatu izeneko funtzioan.
Hona hemen kodifikazioa non programa nagusia ematen den eta funtzioa falta den:
{ iMuga teklatuz irakurri eta Fibonacci zenbakien kopurua kalkulatu }
program FibonacciKopurua_funtzioa ;
const
AZKENMUGA = 28000 ;
{ funtzioaren kodea hemen hasten da }
function fniFibonacciZenbakienKopuruaKalkulatu...
{ funtzioaren kodea hemen amaitzen da }
{ ---------------------------------PROGRAMA NAGUSIA--------------------------------- }
var
iMuga, iKopurua : integer ;
cErantzuna : char ;
begin
writeln ;
writeln ;
repeat
repeat
write('Eman azken muga (0 eta ', AZKENMUGA,' artekoa): ') ;
readln(iMuga) ;
until (iMuga >= 0) and (iMuga <= AZKENMUGA) ;
iKopurua := fniFibonacciZenbakienKopuruaKalkulatu(iMuga) ;
writeln('Emaitza, Fibonacci zenbakien kopurua ------> ', iKopurua) ;
write('Amaitu nahi duzu? (B/E): ') ;
repeat
readln(cErantzuna) ;
cErantzuna := upcase(cErantzuna) ;
until (cErantzuna = 'B') or (cErantzuna = 'E') ;
writeln ;
until cErantzuna = 'B' ;
write('Programa bukatu da, irteteko RETURN sakatu') ;
readln ;
end.
Programaren bigarren zatiko irteera bat hau izan daiteke:
Balizko emaitzaren iturburu-programa hau izan daiteke... laster argitaratuko da
Goiko bi programa horiek bukatu ondoren, saiatu zaitez bi ariketak programa bakar batean biltzen, hots, funtzionalitate guztiak betetzen dituen Programa Nagusi berria idatzi eta bi azpiprogramen kodea inportatu.
zenbaki konbinatorioa, kopuru osoa da eta hura lortzeko m eta n zenbaki osoak eta positiboak ezagutu behar dira. Jakinik ere, zenbaki negatiboen faktoriala definiturik ez dagoelako datuek baldintza hau betetzen dutela: m>=n.
Ikusita daukagun ondoko programa honek ZenbakiKonbinatorioaMonolitikoa.pas zenbaki konbinatorioa kalkulatzen du, baina aintzat hartu beharra dago programak inolako barne antolaketarik ez duelako faktorialaren kalkulua hiru aldiz egiten duela:
Aurreko programaren beste bertsio bat ondoko irudian erakusten da, non programa nagusian datuak irakurri eta gero EmaitzaKalkulatu()izeneko prozedurari deia egiten zaion. Prozedura horren barruan hiru faktorialak kalkulatuko dira:
Aurrekoa ikusita, prozeduraren barruan faktorialak kalkulatzen duen programa egizu. Beraz, ZenbakiKonbinatorioaProzeduraz.PAS programa idatz ezazu, hauek izanik hiru azpiprogramen deskribapenak eta definizioak.
1. DatuakHartu()prozedura barruan bi ReadLn() egin ondoren irakurritako bi balioak programa nagusira bidaltzen dira. Hauxe litzateke DatuakHartu()prozeduraren definizioa:
DatuakHartu() prozedura,
sarrera: sarrerarik ez dago
irteera: bi irteera, biak Integer datu-motakoak
2. EmaitzaKalkulatu()prozedura barruan hiru aldiz kalkulatzen da faktoriala, horregatik programa hori beste modu batez plantea daiteke: faktoriala lortzeko gai den funtzio bat erabili eta funtzioari hiru dei egin. Hauxe litzateke EmaitzaKalkulatu()prozeduraren definizioa:
EmaitzaKalkulatu() prozedura,
sarrera: bi sarrera, Integer datu-motako bi sarrera
irteera: irteera bakarra, LongInt datu-motakoa
3. fniFaktoriala()funtzioak zenbaki oso baten faktoriala kalkulatu eta itzultzen du. Hauxe litzateke fniFaktoriala() funtzioaren definizioa:
