Informatika | 2023-24 | 32-azp2: otsaila 2024

2024(e)ko otsailaren 29(a), osteguna

Errekurtsibitatea zertan den

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

program FaktorialErrekurtsiboaAzaltzen ;

function fnliFaktorialaKalkulatu(iZbk: integer) : longint  ;
begin
   if iZbk = 1 then
   begin
      WriteLn('1! badakit kalkulatzen, itzuli 1 modulu deitzaileari') ;
      fnliFaktorialaKalkulatu := 1 ;
   end
   else
   begin
      writeln(iZbk, '! kalkulatzeko ', iZbk-1, '! ezagutu behar dut') ;
      fnliFaktorialaKalkulatu := iZbk * fnliFaktorialaKalkulatu(iZbk - 1) ;
      writeln(iZbk, '! kalkulatu dut ', iZbk-1, '! * ', iZbk, ' eginez') ;
   end ;
end ;


var
  liEmaitza : longint ;
  iDatua : integer ;

begin
   repeat
      write('Eman zenbaki osoa: ') ;
      readln(iDatua) ;
   until iDatua > 0 ;
   liEmaitza := fnliFaktorialaKalkulatu(iDatua) ;
   writeln(iDatua, '! = ', liEmaitza) ;
   readln ;
end.

FaktorialErrekurtsiboa.pas programa hartu eta zuk zeuk exekutatu.

Fibonacciren segidaren adierazpen orokorra gogoratuz:

$F_{n}={\begin{cases}0&n=0{\mbox{ bada}}\\1&n=1{\mbox{ bada}}\\F_{n-1}+F_{n-2}&n>1{\mbox{ bada}}\\\end{cases}}$

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.

2024(e)ko otsailaren 26(a), astelehena

6. ASTEA | etxerako lana

6. astea (2024/03/28) etxean egitekoa

6. astea | zenbaki edo letra sorta baten maximoa blog-artikuluko programak laborategian azaldu dira, haiek berreskuratu eta moldatu ondoko hauek lortze aldera:

ZenbakiSortaBatenMinimoa_1.pas minimoa kalkulatzeko iZenbat irakurri, emaitza izango den iMinimoa hasieratu eta FOR batean iZenbat iterazio egin balio minimoa lortzeko
ZenbakiSortaBatenMinimoa_2.pas minimoa kalkulatzeko iZenbat irakurri, FOR-etik kanpo emaitza izango den iMinimoa kalkulatu eta FOR batean iZenbat-1 iterazio egin balio minimoa lortzeko
LetraSortaBatenMaximoa.pas maximoa kalkulatzeko iZenbat irakurri, emaitza izango den iMaximoa hasieratu eta FOR batean iZenbat iterazio egin balio maximoa lortzeko

6. astea | ReadKey funtzioa blog-artikulua birpasatu

Autoebaluazioa:

Autoebaluazioa: hainbat aukerako menu bat. Azken asteetako hiru ariketa hauek ondo menperatu ondoren, hirurak programa bakar batean bildu:

6. astea | letrarik hurbilena ariketa programatu
6. astea | Fibonacci zenbakiak ariketa hau egiteko zenbaki osoak erabili
5. astea | Newton-en hurbilketa-metodoa ariketa garrantzitsua da beste ariketa batzuen oinarria delako: ax²+bx+c parabolaren erroak kalkulatu Newton-Raphsonen metodoari esker artikulu horren bukaeran ematen da soluzio hau NewtonEdozeinParabola.pas (programa horretan, Fibonacciren bezala, iterazio baten emaitza hurrengo iterazioareko datua da). Begiratu ere x³=n ekuazioaren soluzioa 5. astea | Newton-en metodoa, erro karratua eta erro kuboa artikulua aztertuz

Hauxe da eskatzen den programaren irteera bat:

Hementxe adibide bat:

program AukerakMenuBatezHautatzen;
uses
  crt;
var
  cAukera, cItxoin: char;
  rEragigai1, rEragigai2: real;
begin
  repeat
    clrscr;
    write('Zenbaki errealekin lan eginez, lehenengo eragigaiaren balioa eman: ':74);
    readln(rEragigai1);
    write('Zenbaki errealekin lan eginez, bigarren eragigaiaren balioa eman:  ':74);
    readln(rEragigai2);

    writeln('============Menua============':40);
    writeln('             +   Batura lortzeko');
    writeln('             -   Kendura lortzeko');
    writeln('             *   Biderkadura lortzeko');
    writeln('             /   Zatiketa burutzeko');
    writeln;
    writeln('             i   Programatik irten');
    writeln('=============================':40);
    write('                 Zure aukera: ');
    cAukera := readkey;
    writeln(cAukera);
    writeln;

    case cAukera of
       '+' : writeln(rEragigai1:21:2, ' + ', rEragigai2:0:2, ' = ', rEragigai1+rEragigai2:0:2);
       '-' : writeln(rEragigai1:21:2, ' - ', rEragigai2:0:2, ' = ', rEragigai1-rEragigai2:0:2);
       '*','x','X' : writeln(rEragigai1:21:2, ' * ', rEragigai2:0:2, ' = ', rEragigai1*rEragigai2:0:2);
       '/' : writeln(rEragigai1:21:2, ' / ', rEragigai2:0:2, ' = ', rEragigai1/rEragigai2:0:2);
       'i', 'I' : writeln('Agur, ondo ibili!!!':30);
       else
          writeln('Eragiketa gaizki aukeratuta!':40);
    end;

    cItxoin := readkey;
    writeln(cItxoin);

  until (cAukera = 'i') or (cAukera = 'I');
end.

6. ASTEA | laborategi/mintegian egin dena

6. astea (2024/02/28) laborategi/mintegian egindakoa

Zerrenda pasatu dugu, deitutakoen artean 6 etorri dira (zehaztapen gehiago eGela zerbitzuan)

6. astea | alfabeto zati bat pantailaratu artikularen bitartez CHAR datu-mota landu dugu. Blogeko 6. astea | ReadKey funtzioa artikulua ikusi dugu ere

6. astea | zenbaki edo letra sorta baten maximoa artikularen bitartez maximoa (edo minimoa) zehazteko algoritmoa ikasi dugu. Eskatzen dena: algoritmoak ulertu, programak exekutatu eta emaitzak aztertu

6. astea | letrarik hurbilena ariketa planteatu eta egin dugu

6. astea | Fibonacci zenbakiak ariketa planteatu eta egin dugu. Hiru bertsio:

Fibonacciren hainbat zenbaki pantailan idatzi: iZenbat datua teklatuaren bitartez irakurri, Fibonacciren lehen bi zenbakiak FOR agindua baino lehen pantailaratu eta hurrengo zenbakiak banan-banan FOR aginduaren iterazio bakoitzean
Muga bat emanik Fibonacciren zenbakiak pantailan idatzi: iMuga datua teklatuaren bitartez irakurri, Fibonacciren lehen hiru zenbakiak WHILE agindua baino lehen pantailaratu eta hurrengo zenbakiak banan-banan WHILE aginduaren iterazio bakoitzean
Muga bat emanik Fibonacciren zenbakiak pantailan idatzi: iMuga datua teklatuaren bitartez irakurri, Fibonacciren lehen bi zenbakiak REPEAT agindua baino lehen pantailaratu eta hurrengo zenbakiak banan-banan REPEAT aginduaren iterazio bakoitzean

6. astea | Fibonacci zenbakiak

Fibonacciren zenbakiak: Leonardo de Pisak, Fibonacci izenez ere ezagutzen den XIII. mendeko matematikari italiarrak, Europan deskribatu zuen segida hau (komenigarria da aipatzea segida hori matematikari indiar batzuek deskribatu zutela K.a. 200. urtean). Aplikazio ugari ditu konputazio-zientzietan, matematikan eta jokoen teorian. Konfigurazio biologikoetan ere agertzen da, hala nola zuhaitzen adarretan, hostoetan, koniferoen pinaburuen konfigurazioan, molusku batzuen oskolaren egitura espiralean dago, untxien ugalketan eta DNAk forma organiko konplexuen hazkundea kodifikatzeko moduan.

Hona hemen Fibonacciren zenbakien adibide batzuk:

Ondorengoa da Fibonacciren segidaren adierazpen orokorra:

$F_{n}={\begin{cases}0&n=0{\mbox{ bada}}\\1&n=1{\mbox{ bada}}\\F_{n-1}+F_{n-2}&n>1{\mbox{ bada}}\\\end{cases}}$

Beraz, Fibonacciren sekuentzia honako hau da:

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, ...

Leonardo Pisano, Fibonacci, ezagutzeko artikulu bat "Fibonacci, el matemático que se puso a contar conejos y descubrió la secuencia divina" eta hemen Fibonacci-ren sekuentziaren adibide bat naturan:

Ariketa:

Teklatuaren bitartez N kopuru oso bat irakurri eta Fibonacci-ren lehen N zenbakiak pantailaratu. Fibonacci-ren lehen zenbakia 0 da, Fibonacci-ren bigarren zenbakia 1 da, eta hirugarren zenbakia lortzeko aurreko biak batuko dira, horregatik Fibonacci-ren hirugarren zenbakia 1 da, laugarren zenbakia 2 izango da, bosgarrena 3, ...

Beraz, Fibonacci-ren sekuentzia honako hau da:

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...

Programaren exekuzio batean N kopurua 9 balitz, bere irteera 0, 1, 1, 2, 3, 5, 8, 13, 21, izango litzateke.

Fibonacci-ren sekuentziako bi zenbaki hartuz eta zatiketa eginez, urrezko zenbakia edo jainkozko proportzioa edo urrezko proportzioa edo zerutiar zenbakia lortzen da:

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.

Lehen programaren irteera hau izan daiteke:

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.

Bigarren programaren irteera hau izan dadila, ikusi kalkuluak errepikatzen direla e edo E erantzuten den bitartean eta irteera gauzatzen da b edo B erantzutean:

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.

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.

6. astea | letrarik hurbilena

Erreferentzia izango den letra maiuskula bat teklatueren bitartez irakurri eta cErreferentzia aldagaian gorde.

Prozesu errepikakor bat hasi non cLetra maiuskula bat teklatuaz irakurriko den eta cErreferentzia aldagaiaren edukiarekin alderatuz, karaktere bien arteko distantzia alfabetoan kalkulatuko den. Iterazio bakoitzeko, gorde letrarik hurbilena cErreferentzia aldagaiaren edukiarekiko eta baita ere alfabetoko distantziarik hurbilena.

Azkenean, sartu diren karaktere guztietatik cErreferentzia aldagaiaren edukiarekiko karaktererik hurbilena erakutsi (erakutsi baita ere hurbilen den karaktere horren distantzia erreferentziarekiko).

Prozesu errepikakorretik irteteko cLetra aldagaiaren edukia irakurtzean cErreferentzia aldagaian gordetakoa sartu.

Ikusi LetrarikHurbilena.exe programa eta programa horren balizko irteera bat:

Jarraian eskatzen den bezala, programa bera berridatzi letra maiuskulak eta minuskulak onar ditzan:

6. astea | zenbaki edo letra sorta baten maximoa

Zenbaki osoen multzo batean zein da zenbakirik handiena?

Hainbat zenbaki teklatuaren bitartez irakurri eta guztien artean maximoa zehaztu. Hona hemen algoritmoa:

Zenbakien sorta batekin lan egingo dugu, zenbakien kopurua zehaztu
Sortaren lehen zenbakia irakurri
Lehen zenbaki hori maximoa da
Errepikatu zenbakien sorta amaitu arte:

Zenbaki berria irakurri
Zenbaki berria orain arteko maximoa baino handiagoa bada maximoaren balioa berritu

Maximoa erakutsi

Demagun iZenbakienKopurua kopuru osoa eta positiboa teklatuaren bitartez irakurriko dela, adibidez 5. Prozesu errepikakor batean 5-1=4 itzuli eman eta itzuliak kontrolatzeko k kontagailua erabili, 5-1=4 itzuliak amaitzean maximoaren balioa pantailaratu. Hau da algoritmotik eratorren taula:

k	iZbk	iMaximoa
–	8	8
2	11	11
3	4	11
4	23	23
5	17	23
		23

Algoritmotik programara jauzi egitean programazio-lengoaiaren elementuak aintzat hartuko dira eta jarraian baliokidean diren bi programa eskaintzen ditugu. Baliokideak izan arren bigarrena hobea da, lehen programak ez baitu algoritmoa zehatz-mehatz jarraitzen.

ZenbakiSortaBatenMaximoa_1.pas

Programa honek ez du goiko algoritmoa jarraitzen, zenbakiaren irakurketa guztiak prozesu errepikakorraren barruan egiten direlako. Horregatik iMaximoa aldagaiak hasieraketa berezi bat behar du derrigorrez:

{ Maximoaren hasieraketa berezia prozesu errepikakorra baino lehen }

program ZenbakiSortaBatenMaximoa_1 ;

uses
   crt ;
var
   iZenbakiKopurua, iZbk, iZenbatgarrena, iMaximoa, k : integer ;

begin
   clrscr ;
   writeln('Zenbaki positibo osoen sorta batean sartutako maximoa zehaztu') ;
   writeln('-------------------------------------------------------------') ;
   writeln ;
   
   repeat
      write('Zenbaki osoen kopuru eman: ') ;
      readln(iZenbakiKopurua) ;
   until iZenbakiKopurua > 0 ;
   
   iMaximoa := 0 ;     { maximoa bilatzen digulako, hasieraketa baliorik txikiena izan dadila; }
                       { hori dela eta, iMaximoa 0 delako, lehen itzulian iMaximoa aldatuko da }
   for k:=1 to iZenbakiKopurua do
   begin
      repeat
         write(k, '. zenbaki positiboa eman: ') ;
         readln(iZbk) ;
      until iZbk > 0 ;
      
      if iZbk > iMaximoa then      { oraintxe sartutakoa handiagoa denean }
      begin
         iMaximoa := iZbk ;
         iZenbatgarrena := k ;
         writeln('Une honetan, iMaximoa=', iMaximoa, ' eta iZenbatgarrena=', iZenbatgarrena) ;
      end ;
   end ;
   
   writeln ;
   writeln('Maximoa ', iMaximoa, ' izan da eta sortako ', iZenbatgarrena, '. izan da') ;
   
   repeat until keypressed ;
end.

ZenbakiSortaBatenMaximoa_2.pas

Goiko algoritmoa jarraituz, zenbakiaren lehen irakurketa prozesu errepikakorra baino lehen egiten delako iMaximoa aldagaiak hasieraketa berezerik ez du behar, iMaximoa hasiera iZbk izango delako:

{ Prozesu errepikakorra baino lehen maximoaren hasieraketa: iMaximoa:=iZbk; }

program ZenbakiSortaBatenMaximoa_2 ;

uses
   crt ;
var
   iZenbakiKopurua, iZbk, iZenbatgarrena, iMaximoa, k : integer ;

begin
   clrscr ;
   writeln('Zenbaki positibo osoen sorta batean sartutako maximoa zehaztu') ;
   writeln('-------------------------------------------------------------') ;
   writeln ;
   
   repeat
      write('Zenbaki osoen kopuru eman: ') ;
      readln(iZenbakiKopurua) ;
   until iZenbakiKopurua > 0 ;
   
   repeat
      write('Lehen zenbaki positiboa eman: ') ;
      readln(iZbk) ;
   until iZbk > 0 ;
   
   iMaximoa := iZbk ;              { lehen zenbakia iMaximoa da }
   iZenbatgarrena := 1 ;           { maximoaren posizioa 1 da   }
   for k:=2 to iZenbakiKopurua do
   begin
      repeat
         write(k, '. zenbaki positiboa eman: ') ;
         readln(iZbk) ;
      until iZbk > 0 ;
      
      if iZbk > iMaximoa then      { oraintxe sartutakoa handiagoa denean }
      begin
         iMaximoa := iZbk ;
         iZenbatgarrena := k ;
         writeln('Une honetan, iMaximoa=', iMaximoa, ' eta iZenbatgarrena=', iZenbatgarrena) ;
      end ;
   end ;
   
   writeln ;
   writeln('Maximoa ', iMaximoa, ' izan da eta sortako ', iZenbatgarrena, '. izan da') ;
   
   repeat until keypressed ;
end.

LetraSortaBatenMinimoa.pas

Zenbakiekin lan egin ordez karakterekin lan egingo bagenu, goiko algoritmoak berdin-berdin balio du. Jarraian ematen den programan ikusi larrien alfabetoko minimoa nola lortzen den:

{ Prozesu errepikakorra baino lehen minimoaren hasieraketa: cMinimoa:=cLetra; }

program LetraSortaBatenMinimoa ;

uses
   crt ;
var
   iLetraKopurua, iZenbatgarrena, k : integer ;
   cLetra, cMinimoa : char ;

begin
   clrscr ;
   writeln('Larrien alfabetoko letra sorta batean sartutako minimoa zehaztu') ;
   writeln('---------------------------------------------------------------') ;
   writeln ;
   
   repeat
      write('Zenbat letra sartuko duzu? kopuru osoa eta positiboa eman: ') ;
      readln(iLetraKopurua) ;
   until iLetraKopurua > 0 ;   
   
   repeat
      write('Lehen letra eman: ') ;
      readln(cLetra) ;
      cLetra := upcase(cLetra) ;
   until (cLetra >= 'A') and (cLetra <= 'Z') ;
   
   cMinimoa := cLetra ;             { lehen letra cMinimoa da  }
   iZenbatgarrena := 1 ;            { minimoaren posizioa 1 da }
   for k:=2 to iLetraKopurua do
   begin
      repeat
         write(k, '. letra eman: ') ;
         readln(cLetra) ;
         cLetra := upcase(cLetra) ;
      until (cLetra >= 'A') and (cLetra <= 'Z') ;
      
      if cLetra < cMinimoa then     { oraintxe sartutakoa txikiagoa denean }
      begin
         cMinimoa := cLetra ;
         iZenbatgarrena := k ;
         writeln('Une honetan, cMinimoa=', cMinimoa, ' eta iZenbatgarrena=', iZenbatgarrena) ;
      end ;
   end ;
   
   writeln ;
   writeln('Minimoa ', cMinimoa, ' izan da eta sortako ', iZenbatgarrena, '. izan da') ;
   
   repeat until keypressed ;
end.

Hauxe da programa horren balizko irteera bat:

Programaren aurreko irteeraren taula hauxe da:

k	cLetra	cMinimoa
–	W	W
2	K	K
3	P	K
4	G	G
5	H	G
6	M	G
		G

6. astea | alfabeto zati bat pantailaratu

Jarraian erakusten den AlfabetoLarriarenZatia.pas programaren bitartez, ondoko hauek ikasiko ditugu:

readkey funtzioa (crt unitatearen beharrezkoa da)
keypressed funtzioa (crt unitatearen beharrezkoa da)
clrscr prozedura (crt unitatearen beharrezkoa da)

Hauxe da AlfabetoLarriarenZatia.pas programa:

program AlfabetoLarriarenZatia ;
uses
   crt ;
var
   cLetra: char ;
   cLehenLetra: char ;
   cAzkenLetra: char ;
begin
   clrscr ;
   writeln ;
   writeln ;
   repeat
      write('''A'' eta ''Z'' arteko lehen letra bat eman: ') ;
      cLehenLetra := readkey ;
      writeln(cLehenLetra) ;
   until (cLehenLetra >= 'A') and (cLehenLetra <= 'Z') ;
   
   writeln ;
   repeat
      write('''', cLehenLetra, ''' eta ''Z'' arteko azken letra bat eman: ') ;
      cAzkenLetra := readkey ;
      writeln(cAzkenLetra) ;
   until (cAzkenLetra >= cLehenLetra) and (cAzkenLetra <= 'Z') ;
   
   writeln ;
   writeln('     Karakterea        Kodea') ;
   writeln('     ----------        -----') ;

   for cLetra:=cLehenLetra to cAzkenLetra do
   begin
      writeln(cLetra:15, ' -----> ', ord(cLetra)) ;
   end ;
   
   writeln('     ----------        -----') ;
   writeln('     Karakterea        Kodea') ;            
   
   writeln ;
   repeat until keypressed ;
   
   {
   writeln ;
   write('RETURN sakatu aurrera egiteko ') ;
   readln ;
   
   writeln ;
   repeat 
      writeln('keypressed = ', keypressed) ;
   until keypressed ;
   }
end.

Ondoko funtzio hauek ikas ditzagun ere:

upcase funtzioa
lowercase funtzioa
succ funtzioa
pred funtzioa
ord funtzioa
chr funtzioa

6. astea | ReadKey funtzioa

readkey funtzioak ez du parametrorik jasotzen, parametrorik ez duelako behar. Bere emaitza teklatuaren karaktere bat da. Hauek dira readkey funtzioaren ezaugarriak:

readkey funtzioak karaktere bat irakurtzeko balio du
Teklatua sakatu eta readkey funtzioak teklari dagokion karakterea CHAR datu-motako aldagai batean gordetzen du, hots, readkey funtzioak ez du RETURN beharrik
Teklaren karakterea jaso eta gero readkey funtzioak ez du karaktere hori pantailan erakusten
readkey funtzioa ez dago konpiladorearen muinean crt unitatean baizik, horregatik crt unitatea erabiliko dela adieraztea derrigorrezkoa da

Ikusi ere keypressed funtzio boolerra. Tekla bat sakatzean keypressed funtzio boolerrak TRUE itzuliko du. Horregatik programa honen bukaeran, exekuzioa gelditzeko ez dugu readln bat erabiltzen eta repeat until keypressed aginduagatik ordezkatu dugu. Programaren exekuzioa bukatzeko return teklan sakatu beharra dago readln jartzean, baina edozein tekla sakatzea nahikoa da repeat until keypressed agindua jartzean.

program readkey_funtzioa ;
uses
   crt;
var
   cKarak1, cKarak2 : char ;
begin
   clrscr ;
   writeln('Hasteko readln prozedurak karaktere bat') ;
   writeln('nola irakurtzen duen ikus dezagun') ;
   writeln('Lehenengo karakterea eman hurrengo lerroan: ') ;
   readln(cKarak1) ;        (* zein karaktere sartzen ari garen ikusten dugu  *)
                            (* RETURN baten bitartez baieztatu behar dugulako *)
 
   cKarak1 := lowercase(cKarak1) ;       (* string edo char bat minuskuletara *)
   write('Lehenengo karakterea =====>', cKarak1, '<=====') ;
 
   writeln ;
   writeln ;
   writeln('readkey funtzioaren txanda, funtzio hau') ;
   writeln('soilik karaktereekin erabil daiteke') ;
   writeln('Bigarren karakterea eman hurrengo lerroan: ') ;
   cKarak2 := readkey ;     (* sarrerako parametrorik ez daukan funtzio baten *)
                            (* deia, funtzioaren emaitza karaktere bat izanik *)
 
   cKarak2 := lowercase(cKarak2) ;       (* string edo char bat minuskuletara *)
   writeln('Bigarren karakterea =====>', cKarak2, '<=====') ;
 
   writeln ;
   writeln ;
   writeln ;
   writeln('==============================') ;
   writeln('Edozein tekla sakatu amaitzeko') ;
   writeln('==============================') ;
    
   repeat until keypressed ;    (* errepikatu edozein tekla sakatu arte *)
end.

Hona hemen ReadKey_funtzioa izeneko programaren exekuzio baten irudia:

2024(e)ko otsailaren 20(a), asteartea

5. ASTEA | etxerako lana

5. astea (2024/02/21) etxean egitekoa

Ziurtatu aurreko astean egindako ariketak menperatzen dituzula:

4. astea | FOR-DO bat beste FOR-DO baten barruan artikuluan ematen diren ariketak azaldu ditugu. Artikulu honekin batera honako hauek lotuta daude:

Ziurtatu aste honi dagozkion ariketa hauek menperatzen dituzula:

Laborategian azaldu den 4. astea | WHILE-DO eta REPEAT-UNTIL: Segida baten batukaria ariketa (batez ere WhileSegida3.pas programa eta RepeatSegida1.pas programa)
5. astea | batukari bat kalkulatzen ariketak (bat FOR bat da, baina bestea ez)
5. astea | biderkari bat kalkulatzen ariketak (bat FOR bat da, baina bestea ez). Biderkariaren bigarren programa, Biderkaria2.pas delakoa, AUTOEBALUAZIO ariketa bezala planteaturik dago
5. astea | Newton-en metodoa bigarren graduko edozein parabolarekin ariketa laborategian egin da while-do bitartez, zuk repeat-until egitura erabiliz berprograma ezazu
5. astea | Newton-en metodoa, erro karratua eta erro kuboa ariketa (aurrekoaren kasu berezi bat da, b=0 denean), AUTOEBALUAZIO ariketa bezala planteaturik dago

5. ASTEA | laborategi/mintegian egin dena

5. astea (2024/02/21) laborategi/mintegian egindakoa

Lehen kontrola egiten dugula zerrenda pasatu dugu. Deitutakoen 18 ikasleetatik 14 etorri dira (zehaztapen gehiago eGela zerbitzuan)

Blogeko 5. astea | batukari bat kalkulatzen artikuluan planteatzen diren bi ariketak egin ditugu:

Batukari1.pas kasuan batugaien kopurua datua denez for-to-do kontrol-egitura batekin programa daiteke
Batukari2.pas kasuan batugaien kopurua ezezaguna denez repeat-until edo while-do kontrol-egitura batekin programatu beharra dago

4. astea | WHILE-DO eta REPEAT-UNTIL: Segida baten batukaria ariketa laborategian azaltzeko denborarik ez dugu izan, ariketa interesgarria da WHILE-DO egitura eta REPEAT-UNTIL egitura alderatzen direlako

Ikasgelan azaldu den 5. astea | Newton-en hurbilketa-metodoa kalkulu-metodoaren haritik, ariketa bati ekin diogu. Hortaz, y=ax²+bx+c funtzioaren ariketari hasiera eman diogu eta ez dugu amaitzeko astirik izan baina oso bideratuta geratu da

2024(e)ko otsailaren 19(a), astelehena

5. astea | Newton-en metodoa funtzio esponentzialekin

Newton-Raphson hurbilketa-metodoa e^x-x³=0 ekuazioaren erro bat kalkulatzeko

Newton–Raphson metodoa (Newton-en metodo gisa ere ezagutzen dena) zenbakizko analisi-metodo bat da. Metodo honek funtzioen erro gero eta hobeak lortzen ditu, hau da, funtzioa zero egiten duen x balioa bilatzen du. Beste modu batez esanik, funtzioak OX ardatza mozten duen balioa (funtzioaren erroa) ematen du Newton–Raphson metodoak. Algoritmoa erroaren hurbilketa batekin hasten da eta urrats bakoitzean erroaren hurbilketa hobea lortzen du.

Aldagai bakarreko funtzio errealen kasuan honakoa da metodoa:

Izan bedi ƒ funtzioa x errealentzat definitua, eta izan bedi ƒ' bere deribatua. Erroaren hasierako hurbilketa bat behar dugu, x₀. Erroaren hurbilketa horretan oinarrituz hurbilketa hobea izango den x₁ honelaxe lortzen da:

Iterazioak eginez, n+1 hurbilketa n hurbilketan oinarritzen da formula honen arabera:

Formula horren zergatia geometrikoki adieraz daiteke. Hurrengo irudiko lerro urdina f(x) funtzioa da, eta lerro zuzen gorria f(x) funtzioaren tangentea (x_n, f(x_n)) puntuan:

Berde koloreko distantziari hobekuntza deitzen badiogu, orduan alfa angeluaren tangentea f(x_n)/hobekuntza litzateke, baina tangente hori f(x) funtzioaren deribatua (x_n, f(x_n))puntuan da, lerro zuzen gorriaren malda alfa angeluaren tangentea da. Horregatik:

tag(alfa)= f(x_n)/hobekuntza eta aldi berean tag(alfa)=malda= f'(x_n)
beraz f'(x_n)= f(x_n)/hobekuntza (non hobekuntza=x_n-x_n+1)

f'(x_n)= f(x_n)/(x_n-x_n+1) nondik x_n-x_n+1= f(x_n)/f'(x_n)

x_n+1= x_n- f(x_n)/f'(x_n)

e^x-x³=0 ekuazioaren erro bat kalkula dezagun Newton–Raphson metodoa aplikatuz:

f(x)=e^x-x³

f'(x)=e^x-3x²

Hurrengo irudian e^x-x³ funtzioaren itxura ikus daiteke:

Irudiaren gainean klik egin e^x-x³ funtzioa aztertzeko

Hau da ariketaren NewtonEsponentzialak.exe programa exekutagarria. Hurbilketa desberdinen araberako programaren bi irteera hauek erakusten dira jarraian:

Nahiz eta hasierako hurbilketa 0.98 izan, emaitza eskumako erroa 4.5364 da

Hasierako hurbilketa 1.2 bada, emaitza ezkerreko erroa 1.85718 da

5. astea | Newton-en metodoa funtzio trigonometrikoekin

Newton-Raphson hurbilketa-metodoa cos(x)-0.5x-2=0 ekuazioaren erro bat kalkulatzeko

Newton–Raphson metodoa (Newton-en metodo gisa ere ezagutzen dena) zenbakizko analisi-metodo bat da. Metodo honek funtzioen erro gero eta hobeak lortzen ditu, hau da, funtzioa zero egiten duen x balioa bilatzen du. Beste modu batez esanik, funtzioak OX ardatza mozten duen balioa (funtzioaren erroa) ematen du Newton–Raphson metodoak. Algoritmoa erroaren hurbilketa batekin hasten da eta urrats bakoitzean erroaren hurbilketa hobea lortzen du.

Aldagai bakarreko funtzio errealen kasuan honakoa da metodoa:

Izan bedi ƒ funtzioa x errealentzat definitua, eta izan bedi ƒ' bere deribatua. Erroaren hasierako hurbilketa bat behar dugu, x₀. Erroaren hurbilketa horretan oinarrituz hurbilketa hobea izango den x₁ honelaxe lortzen da:

Iterazioak eginez, n+1 hurbilketa n hurbilketan oinarritzen da formula honen arabera:

Formula horren zergatia geometrikoki adieraz daiteke. Hurrengo irudiko lerro urdina f(x) funtzioa da, eta lerro zuzen gorria f(x) funtzioaren tangentea (x_n, f(x_n)) puntuan:

Berde koloreko distantziari hobekuntza deitzen badiogu, orduan alfa angeluaren tangentea f(x_n)/hobekuntza litzateke, baina tangente hori f(x) funtzioaren deribatua (x_n, f(x_n))puntuan da, lerro zuzen gorriaren malda alfa angeluaren tangentea da. Horregatik:

tag(alfa)= f(x_n)/hobekuntza eta aldi berean tag(alfa)=malda= f'(x_n)
beraz f'(x_n)= f(x_n)/hobekuntza (non hobekuntza=x_n-x_n+1)

f'(x_n)= f(x_n)/(x_n-x_n+1) nondik x_n-x_n+1= f(x_n)/f'(x_n)

x_n+1= x_n- f(x_n)/f'(x_n)

cos(x)+0.5x-2=0 ekuazioaren erro bat kalkula dezagun Newton–Raphson metodoa aplikatuz:

f(x)=cos(x)+0.5x-2

f'(x)=-sin(x)+0.5

Hurrengo irudian cos(x)+0.5x-2 funtzioaren itxura ikus daiteke:

Irudiaren gainean klik egin cos(x)+0.5x-2 funtzioa aztertzeko

Hau da ariketaren NewtonTrigonometrikoak.exe programa exekutagarria. Hurbilketa desberdinen araberako programaren bi irteera hauek erakusten dira jarraian:

Hasierako hurbilketa 3.9 bada, emaitza 4.4734 erroa da

Hasierako hurbilketa 5.7 bada, emaitza 4.4734 erroa da

5. astea | Newton-en metodoa, erro karratua eta erro kuboa

Newton-en hurbilketa-metodoa √n eta ∛n kalkulatzeko

5. astea | Newton-en metodoa bigarren graduko edozein parabolarekin azaldutako ariketa erabiliko dugu zenbaki baten erro koadroa kalkulatzeko, baldin eta ax²+bx+c parabolaren koefizienteak egokiak badira.

ax²+bx+c parabola orokorraren koefizienteak hauek izanik:

a=1

b=0

c=-n

Ateratzen den ekuazioa x²-n=0 da (edo x²=n).
Ondorioz, x erroa n-ren erro karratua x=∓√n izango da.

Esate baterako, alboko irudian ikusten den bezala c=-2 denean, ekuazioa x²-2=0 da (edo x²=2). Horregatik x erroa, 2-ren erro karratua x=∓√2=∓1.4142 izango da.

Newton–Raphson metodoa (Newton-en metodo gisa ere ezagutzen dena) zenbakizko analisi-metodo bat da. Metodo honek funtzioen erro gero eta hobeak lortzen ditu, hau da, funtzioa zero egiten duen x balioa bilatzen du. Beste modu batez esanik, funtzioak OX ardatza mozten duen balioa (funtzioaren erroa) ematen du Newton–Raphson metodoak. Algoritmoa erroaren hurbilketa batekin hasten da eta urrats bakoitzean erroaren hurbilketa hobea lortzen du.

Aldagai bakarreko funtzio errealen kasuan honakoa da metodoa:

Izan bedi ƒ funtzioa x errealentzat definitua, eta izan bedi ƒ' bere deribatua. Erroaren hasierako hurbilketa bat behar dugu, x₀. Erroaren hurbilketa horretan oinarrituz hurbilketa hobea izango den x₁ honelaxe lortzen da:

Iterazioak eginez, n+1 hurbilketa n hurbilketan oinarritzen da formula honen arabera:

Formula horren zergatia geometrikoki adieraz daiteke. Hurrengo irudiko lerro urdina f(x) funtzioa da, eta lerro zuzen gorria f(x) funtzioaren tangentea (x_n, f(x_n)) puntuan:

Berde koloreko distantziari hobekuntza deitzen badiogu, orduan alfa angeluaren tangentea f(x_n)/hobekuntza litzateke, baina tangente hori f(x) funtzioaren deribatua (x_n, f(x_n))puntuan da, lerro zuzen gorriaren malda alfa angeluaren tangentea da. Horregatik:

tag(alfa)= f(x_n)/hobekuntza eta aldi berean tag(alfa)=malda= f'(x_n)
beraz f'(x_n)= f(x_n)/hobekuntza (non hobekuntza=x_n-x_n+1)

f'(x_n)= f(x_n)/(x_n-x_n+1) nondik x_n-x_n+1= f(x_n)/f'(x_n)

x_n+1= x_n- f(x_n)/f'(x_n)

n zenbaki erreal positibo baten erro koadroa kalkula dezagun. Hona hemen, Newton–Raphson metodotik eratorren formula:

x_n+1= x_n- f(x_n)/f'(x_n)

n ezaguna izanik x lortu: x = √n

x² = n

x²—n = 0

f(x) = x²—n

f'(x) = 2x

x_i+1= x_i- f(x_i)/f'(x_i)

x_i+1= x_i- (x_i²—n)/2x_i

Programaren zuzentasuna konprobatzeko sqrt() funtzio estandarra aplika daiteke.

n zenbaki erreal positibo baten erro kubikoa kalkula dezagun. Hona hemen, Newton–Raphson metodotik eratorrren formula:

Ikusi makusi... ...programa. Programaren zuzentasuna konprobatzeko logaritmoak hartu beharko dira:

x³ = n x = n^1/3 ln(x) = ln(n^1/3) x = exp(ln(n^1/3)) x = exp(1/3·ln(n))

Iturburu-programak argitaratu aurretik, lagungarria izan daitekeelako, har itzazu programa exekutagarriak eGela zerbitzuko Newton.exe delako karpetatik:

NewtonKarratua.exe
NewtonKuboa.exe