sakontzeko etiketadun mezuak erakusten. Erakutsi mezu guztiak
sakontzeko etiketadun mezuak erakusten. Erakutsi mezu guztiak

2024(e)ko apirilaren 11(a), osteguna

11. astea | itsas-guda (II)






Itsas-bataila

11. astea | itsas-guda (II) programa 10. astea | itsas-bataila (II) bezalakoa da, baina 6x6 taulako elementuak erregistroak izango dira. Horrela lau datu hauek gorde ahalko dira posizio bakoitzeko:

type
   trdPuntua = record
                     cLetra: char;       { K, D, P edo X }
                   iKolorea: integer;    { letraren kolorea }
                    iHondoa: integer;    { letraren hondoaren kolorea }
                  boHartuta: boolean;    { hasieran FALSE eta puntua aukeratzean TRUE }
               end;
   tardItsasoa = array[1..6, 'A'..'F'] of trdPuntua; 

Gogoratu taularen errenkadak izendatzeko zenbaki osoak erabiliko direla (1-etik 6-ra), eta taularen zutabeak izendatzeko karaktereak erabiliko direla (A-tik F-ra)

Ordenadoreak etsaien armada kokatuko du 6x6 itsasoan, eta etsaien armada hori hondoratu beharko dugu gehienez 19 jaurtiketa erabiliz. Etsaien armada sei itsasontziz osaturik dago:

  • 2 korazatu, armadako itsasontzi handienak dira (bakoitzak 3 zati)
  • 3 destruktore, armadako itsasontzi ertainak dira (bakoitzak 2 zati) 
  • 1 itsaspeko, armadako itsasontzi txikiena da (1 zati)

Hondoratu behar dugun etsaien armada 6x6 itsasoan kokatzeko, bi dimentsiotako array bat erabiliko dugu, hots, karaktereen array bat. Korazatua adierazteko K idatziko dugu, destruktorea adierazteko D idatziko dugu, itsaspekoa adierazteko P idatziko dugu, ura adierazteko, u idatziko dugu, eta, gainerako toki guztietan X idatzirik egongo da. Adibidez:


Baina bataila hasi aurretik, ikus dezagun etsaien ontziteriak har ditzaken kokapen posibleak zeintzuk diren. Horretarako, programa bat idatziko dugu eta bere helburu bakarra EtsaienArmadaGuztiakKokatu delako prozedurari dei egitea da. Dakigunez, EtsaienArmadaGuztiakKokatu prozedura itsasoarena unitatean garaturik dago.

Guztira 10 kokapen desberdin direlako EtsaienArmadaGuztiakErakutsi prozedurak pantailaratuko ditu for-to-do agindu baten bitartez.

Lehendik programaturik dagoen unitate bat erabiliko dugu, itsasoarena izeneko unitatea hain zuzen ere. Unitate horren iturburu-programa ez daukagu, baina bere interfazea ezagutzen dugu. Hori dela eta, guk idatziko dugun programan itsasoarena unitatearen ondoko konstante, datu-mota eta azpiprogra erabil ditzakegu: 

unit itsasoarena; 

interface        (* ----------------------------- interfazearen hasiera ----- *)

   const
      KOKAPENKOPURUA = 10;
   type
      trdPuntua = record
                        cLetra: char;      { K, D, P edo X }
                      iKolorea: integer;   { letraren kolorea }
                       iHondoa: integer;   { letraren hondoaren kolorea }
                     boHartuta: boolean;   { hasieran FALSE eta puntua aukeratzean TRUE }
                  end;
      tardItsasoa = array[1..6, 'A'..'F'] of trdPuntua;
   function fncSuEgin(iErrenkada: integer;cZutabea: char): char;{ K, D, P edo X }
   procedure EtsaienArmadaHasieratu;
   procedure EtsaienArmadaErakutsi;
   procedure EtsaienArmadaKokatu;           // 10 kokapen artean bat aukeratzen da
   procedure EtsaienArmadaGuztiakKokatu;
   
                 (* ----------------------------- interfazearen amaiera ----- *)

implementation   (* ------------------------- inplementazioaren hasiera ----- *)

   ...

end.             (* --------- inplementazioaren eta unitatearen amaiera ----- *)  

Interfazean adierazten dira unitateak bezero-programarekin partekatuko dituen elementuak: konstanteak, datu-motak, funtzioak, prozedurak eta abar. Adibide honetan, konstantea eta datu-mota bat partekatzeaz gain funtzio bat eta lau prozedura partekatzen dira.

Interfazearen datu-motaren azalpena:

  • tardItsasoa datu-motak itsasoa ereduztatzen du, 6x6 itsaso zati horretan burutuko da bataila. Errenkadak izendatzeko zenbakizko indizeak erabiliko dira (1-etik 6-ra) eta zutabeak izendatzeko letrak erabiliko dira (A-tik F-ra)

Interfazearen bost azpiprogramen azalpenak:

  • fncSuEgin funtzioak 6x6 arrayaren koordenatuak hartuko ditu eta posizio horren karakterea itzuliko du (K, D, P edo X)
  • EtsaienArmadaHasieratu prozedurak 6x6 itsasoan X markak idatziko ditu
  • EtsaienArmadaKokatu prozedurak 6x6 itsasoan K, D eta P markak idatziko ditu
  • EtsaienArmadaErakutsi prozedurak 6x6 itsasoaren edukia pantailaratuko du. Honi esker gure programa-bezerotik posible zaigu jakitea etsaien ontziteria non dagoen, baina prozedura honi dei egiten badiogu itsas-bataila galdu dugulako izango da
  • EtsaienArmadaGuztiakErakutsi prozedurak 6x6 itsasoaren edukia pantailaratuko du, guztira 10 kokapen desberdin definitu dira itsasoarena unitatean


Aurreko bost azpiprograma horiek gure programatik aktiba ditzakegu. Horretarako, uses klausulari esker itsasoarena unitatea behar-beharrekoa zaigula adieraziko dugu gure iturburu-programaren hasieran:

program ItsasGudak;

uses
   crt, itsasoarena;
const
   ARMADA_OSOA = 13;
   JAURTIK_MAX = 22;
   
type
   tsJaurtiketa = string[2]; 

Hori dela eta, gure bezero-programak EtsaienArmadaKokatu prozedurari deia egitean etsaien armadaren kokapen zehatz bat gertatuko da (10 kokapen posibleetatik bat) eta jokoa hasi ahalko da. Jakin badakigu etsaien armadak 6 ontzi izango dituela eta bi ontziren artean beti ura dagoela; esate baterako, ondoko irudian erakusten den kokapena ez da itsasarena unitateak emandakoa kokapena desegokia delako:

Erroreak daudelako, goiko irudia ez du eman EtsaienArmadaKokatu prozedurak

ItsasGudak.pas bezero-programak itsasoarena eta crt unitateak beharko dituela dakigu. Bere programa nagusia ondoko hau izan daiteke, non aboJaurtiketaErrepikaturik bezalako 6x6 array karraturen beharrik ez daukagun:

{ -----------------------Programa Nagusia-------------------------- }
var
   iErrenkada, iJaurtiKont, iOntziZatiak, iUrKont: integer;
   cZutabea: char;
   ardItsasoarenEgoera: tardItsasoa;
   sJaurtiketa: tsJaurtiketa;
   boJaurtiketaEgokia: boolean;
   boErrepikatuGabea: boolean;
   cEmaitza: char;
     
begin
   clrscr;
   writeln;
   
   writeln('///////////////////////////////////////////////////////////////////');
   writeln;
   writeln('Garaile ateratzeko, gehienez ', JAURTIK_MAX, ' jaurtiketa dituzu');
   writeln;
   
   EtsaienArmadaHasieratu;   (* unitatean garaturik *)
   EtsaienArmadaKokatu;      (* unitatean garaturik *)
   // EtsaienArmadaErakutsi;
   
   writeln('Gudaren hasieran itsasoaren egoera hauxe da:');
   writeln;
   ItsasoarenEgoeraHasieratu(ardItsasoarenEgoera);   (* hasieran cLetra denak "X" eta boHartuta denak "FALSE" *)
   ItsasoaErakutsi(ardItsasoarenEgoera);
   
   writeln; 
   writeln('ARMISTIZIOA:');
   writeln('Amore eman eta bataila galdutzat jotzen baduzu, etsaien armada ikus dezakezu.');
   writeln('Garaitu zaituen etsaien armadaren kokapena ikusi nahi duzu, "AR" erantzun. ');
   writeln;
   
   iUrKont := 0;
   iOntziZatiak := 0;
   iJaurtiKont := 0;
   repeat
      if iUrKont >= 6 then
      begin
         TextColor(Blue);
         writeln('Jaurtiketa okerrak askotan egin dituzu, armistizioa eskatzerik daukazu!!!');
         TextColor(Black);
      end;
      
      iJaurtiKont := iJaurtiKont + 1;
      boJaurtiketaEgokia := FALSE;
      repeat
         repeat
            write(iJaurtiKont:3, '. jaurtiketa egin (adibidez 3C koordenatuak, armistizioa eskatzeko "AR"): ');
            readln(sJaurtiketa);
            sJaurtiketa := upcase(sJaurtiketa);
            boJaurtiketaEgokia := fnboJaurtiketaAztertu(sJaurtiketa);
         until boJaurtiketaEgokia;
         
         boErrepikatuGabea := fnboErrepikatuGabea(sJaurtiketa, ardItsasoarenEgoera);
      until boErrepikatuGabea;
      
      if sJaurtiketa <> 'AR' then
      begin
         val(sJaurtiketa[1], iErrenkada);
         //writeln('iErrenkada = ', iErrenkada);
         cZutabea := sJaurtiketa[2];
         
         cEmaitza := fncSuEgin(iErrenkada, cZutabea);   (* unitatean garaturik *)
         
         case cEmaitza of    { K, D, P edo X }
            'K': begin
                    writeln(iErrenkada:3, cZutabea, ' ---> K, korazatua');
                    iOntziZatiak := iOntziZatiak + 1;
                    ardItsasoarenEgoera[iErrenkada,cZutabea].cLetra := 'K';
                    ardItsasoarenEgoera[iErrenkada,cZutabea].boHartuta := TRUE;
                 end;
            'D': begin
                    writeln(iErrenkada:3, cZutabea, ' ---> D, destruktorea');
                    iOntziZatiak := iOntziZatiak + 1;
                    ardItsasoarenEgoera[iErrenkada,cZutabea].cLetra := 'D';
                    ardItsasoarenEgoera[iErrenkada,cZutabea].boHartuta := TRUE;
                 end;
            'P': begin
                    writeln(iErrenkada:3, cZutabea, ' ---> P, itsaspekoa');
                    iOntziZatiak := iOntziZatiak + 1;
                    ardItsasoarenEgoera[iErrenkada,cZutabea].cLetra := 'P';
                    ardItsasoarenEgoera[iErrenkada,cZutabea].boHartuta := TRUE;
                 end;
            'X': begin
                    writeln(iErrenkada:3, cZutabea, ' ---> URA');
                    ardItsasoarenEgoera[iErrenkada,cZutabea].cLetra := 'u';
                    ardItsasoarenEgoera[iErrenkada,cZutabea].boHartuta := TRUE;
                    iUrKont := iUrKont + 1;
                 end;
         end;
         
         writeln((JAURTIK_MAX-iJaurtiKont):4, ' jaurtiketa geratzen d(ir)a');
         writeln;
         ItsasoaErakutsi(ardItsasoarenEgoera);
         writeln;
      end; 
   until (iOntziZatiak = ARMADA_OSOA) or
         (iJaurtiKont = JAURTIK_MAX) or
         (sJaurtiketa = 'AR');
   
   writeln;
   
   if sJaurtiketa = 'AR' then
   begin
      writeln('ARMISTIZIOA, garaile atera diren etsaien ontziteria:');
      writeln;
      EtsaienArmadaErakutsi;   (* unitatean garaturik *)
   end
   else
   begin
      if (iOntziZatiak = ARMADA_OSOA) and (iJaurtiKont <= JAURTIK_MAX) then
      begin
         writeln(iJaurtiKont, ' jaurtiketekin etsaien armada osoa hondoratu dugunez, gerra irabazi duzu!!!');
      end
      else
      begin
         writeln(iJaurtiKont, ' jaurtiketa ondoren itsas-bataila galdu duzu!!!');
         writeln('Garaitu zaituen etsaien ontziteria:');
         writeln;
         EtsaienArmadaErakutsi;   (* unitatean garaturik *)
      end;
   end;
   
   writeln;
   writeln('///////////////////////////////////////////////////////////////////');
   
   writeln;
   repeat until keypressed;
end.

ardItsasoarenEgoera karaktereen array horretan itsas-batailaren egoera gordeko dugu uneoro. Bataila hasi aurretik ItsasoarenEgoeraHasieratu prozedurak 6x6 arrayaren elementu guztien cLetra eremua X karakterez betetzen ditu, FALSE konstantez boHartuta eremuak betetzen ditu, iKolorea eremu guztiak beltzez eta iHondoa eremu guztiak grisez betetzen ditu.

Etsaien armada hondoratu nahian, 6x6 itsasoko koordenatu pare bat hautatzeko aukera izango dugu (5D bezalako karaktere-katea) eta koordenatu horiek fncSuEgin funtzioari pasatuz, honek jaurtiketaren emaitza itzuliko digu, eta, ondorioz ItsasoarenEgoeraHasieratu prozedurak bete dituen X guztietatik bat ordeztuko dugu. Arrayaren posizio horretako balio berria, honako hauetatik bat izango da:

  • u ura, gure jaurtiketak huts egin du
  • K korazatua, gure jaurtiketak korazatu baten zatia suntsitu du 
  • D destruktorea, gure jaurtiketak destruktore baten zatia suntsitu du 
  • P itsaspekoa, gure jaurtiketak itsaspekoa suntsitu eta hondoratu du 

Etsaien armadak 3+3+2+2+2+1=13 zatiz osaturik dago, eta guztiak suntsitu arte itsas-bataila ez da bukatuko eta garaile aterako gara 19 jaurtiketa behar izan badugu (19 jaurtiketa edo gutxiago beharko dira itsas-bataila irabazteko). Dagozkigun 19 jaurtiketak agortzean, batailaren galtzaileak gu izango gara eta programa bukatuko da. Baina 19. jaurtiketa egin baino lehenago, bataila galdutzat jotzen badugu, armistizioa eskatu ahalko dugu (AR koordenatuak sartuz) eta etsaien ontziteria pantailaratu ondoren programa bukatuko da.






  • ItsasGudak.pas   bezero-programaren iturburu-kodea
  • itsasoarena.pas   unitatearen iturburu-kodea, hau konpilatzean:
    • itsasoarena.ow   unitatearen objektu-kodea lortzen da (itsasoarena.pas konpilatu ondoren)
    • itsasoarena.ppw   unitate konpilatua lortzen da (itsasoarena.pas konpilatu ondoren)
  • ItsasGudak.exe   programa exekutagarria fitxategi hauekin lor daiteke:
    • ItsasGudak.pas
    • itsasoarena.ow
    • itsasoarena.ppw
 

 

11. astea | itsas-guda (I)






Itsas-guda

11. astea | itsas-guda (I) programa 10. astea | itsas-bataila (I) bezalakoa da, baina 6x6 taulako elementuak erregistroak izango dira. Horrela lau datu hauek gorde ahalko dira posizio bakoitzeko:

type
   trdPuntua = record
                     cLetra: char;       { K, D, P edo X }
                   iKolorea: integer;    { letraren kolorea }
                    iHondoa: integer;    { letraren hondoaren kolorea }
                  boHartuta: boolean;    { hasieran FALSE eta puntua aukeratzean TRUE }
               end;
   tardItsasoa = array[1..6, 'A'..'F'] of trdPuntua; 

Gogoratu taularen errenkadak izendatzeko zenbaki osoak erabiliko direla (1-etik 6-ra), eta taularen zutabeak izendatzeko karaktereak erabiliko direla (A-tik F-ra)

Ordenadoreak etsaien armada kokatuko du 6x6 itsasoan, eta etsaien armada hori hondoratu beharko dugu gehienez 19 jaurtiketa erabiliz. Etsaien armada sei itsasontziz osaturik dago:

  • 2 korazatu, armadako itsasontzi handienak dira (bakoitzak 3 zati)
  • 3 destruktore, armadako itsasontzi ertainak dira (bakoitzak 2 zati) 
  • 1 itsaspeko, armadako itsasontzi txikiena da (1 zati)

Hondoratu behar dugun etsaien armada 6x6 itsasoan kokatzeko, bi dimentsiotako array bat erabiliko dugu, hots, karaktereen array bat. Korazatua adierazteko K idatziko dugu, destruktorea adierazteko D idatziko dugu, itsaspekoa adierazteko P idatziko dugu, ura adierazteko, u idatziko dugu, eta, gainerako toki guztietan X idatzirik egongo da. Adibidez:


Baina bataila hasi aurretik, ikus dezagun etsaien ontziteriak har ditzaken kokapen posibleak zeintzuk diren. Horretarako, programa bat idatziko dugu eta bere helburu bakarra EtsaienArmadaGuztiakKokatu delako prozedurari dei egitea da. Dakigunez, EtsaienArmadaGuztiakKokatu prozedura itsasoarena unitatean garaturik dago.

Guztira 10 kokapen desberdin direlako EtsaienArmadaGuztiakErakutsi prozedurak for-to-do agindu baten bitartez, iterazio bakoitzean hiru dei egingo ditu: EtsaienArmadaHasieratu prozedurari, NgarrenKokapena prozedurari eta EtsaienArmadaKokatu prozedurari. Hirurak itsasoarena unitatean garaturik daude.

Lehendik programaturik dagoen unitate bat erabiliko dugu, itsasoarena izeneko unitatea hain zuzen ere. Unitate horren iturburu-programa ez daukagu, baina bere interfazea ezagutzen dugu. Hori dela eta, guk idatziko dugun programan itsasoarena unitatearen ondoko konstanteak, ondoko datu-mota eta ondoko azpiprograak erabil ditzakegu:  

unit itsasorena; 

interface        (* ----------------------------- interfazearen hasiera ----- *)

   const
      KOKAPENKOPURUA = 10;
   type
      trdPuntua = record
                        cLetra: char;       { K, D, P edo X }
                      iKolorea: integer;    { letraren kolorea }
                       iHondoa: integer;    { letraren hondoaren kolorea }
                     boHartuta: boolean;    { hasieran FALSE eta puntua aukeratzean TRUE }
               end;
      tardItsasoa = array[1..6, 'A'..'F'] of trdPuntua;
   procedure KoloreakErakutsi;
   function fncSuEgin(iErrenkada: integer;cZutabea: char): char;{ K, D, P edo X }
   procedure EtsaienArmadaHasieratu;
   procedure EtsaienArmadaErakutsi;
   procedure EtsaienArmadaKokatu;           // 10 kokapen artean bat aukeratzen da
   procedure EtsaienArmadaGuztiakKokatu;
   
                 (* ----------------------------- interfazearen amaiera ----- *)

implementation   (* ------------------------- inplementazioaren hasiera ----- *)

   ...

end.             (* --------- inplementazioaren eta unitatearen amaiera ----- *)  

Interfazean adierazten dira unitateak bezero-programarekin partekatuko dituen elementuak: konstanteak, datu-motak, funtzioak, prozedurak eta abar. Adibide honetan, konstantea eta datu-motak partekatzeaz gain funtzio bat eta lau prozedura partekatzen dira.

Interfazearen datu-motaren azalpena:

  • tardItsasoa datu-motak itsasoa ereduztatzen du, 6x6 itsaso zati horretan burutuko da bataila. Errenkadak izendatzeko zenbakizko indizeak erabiliko dira (1-etik 6-ra) eta zutabeak izendatzeko letrak erabiliko dira (A-tik F-ra)

Interfazearen bost azpiprogramen azalpenak:

  • fncSuEgin funtzioak 6x6 arrayaren koordenatuak hartuko ditu eta posizio horren karakterea itzuliko du (K, D, P edo X)
  • EtsaienArmadaHasieratu prozedurak 6x6 itsasoan X markak idatziko ditu
  • EtsaienArmadaKokatu prozedurak 6x6 itsasoan K, D eta P markak idatziko ditu
  • EtsaienArmadaErakutsi prozedurak 6x6 itsasoaren edukia pantailaratuko du. Honi esker gure programa-bezerotik posible zaigu jakitea etsaien ontziteria non dagoen, baina prozedura honi dei egiten badiogu itsas-bataila galdu dugulako izango da
  • EtsaienArmadaGuztiakErakutsi prozedurak 6x6 itsasoaren edukia pantailaratuko du, guztira 10 kokapen desberdin definitu dira itsasoarena unitatean

Bost azpiprograma horiek gure programatik aktiba ditzakegu. Horretarako, uses klausulari esker itsasoarena unitatea behar-beharrekoa zaigula adieraziko dugu gure iturburu-programaren hasieran. Dena den EtsaiakNonDaude programan azpiprograma bakarra erabiliko dugu, EtsaienArmadaGuztiakErakutsi prozedura:

program EtsaiakNonDaude;

uses
   crt, itsasoarena;

Hori dela eta, gure bezero-programak EtsaienArmadaGuztiakErakutsi prozedurari dei egitean etsaien armadaren kokapen guztiak zeintzuk izan daitezkeen erakutsiko ditu pantailan. Orotara 10 kokapen desberdinetatik hona hemen lehen laurak:

EtsaienArmadaGuztiakErakutsi prozedurak pantailaratzen duenaren zati bat


EtsaiakNonDaude.pas bezero-programak itsasoarena eta crt unitateak beharko dituela dakigu. Horrez gain, bezero-programan  KoloreakErakutsi garatu da. Hona hemen EtsaiakNonDaude.pas bezero-programaren hasiera eta programa nagusia:

program EtsaiakNonDaude;

uses
   crt, itsasoarena;

procedure KoloreakErakutsi;
begin
   write('textCOLOR ':22);
   writeln('textBACKGROUND ':22);
   ...
end;
   
{ -----------------------Programa Nagusia-------------------------- }

begin
   clrscr;
   writeln;
   
   KoloreakErakutsi;
   
   writeln;
   writeln('///////////////////////////////////////////////////////////////////');
   writeln;
   writeln('Guztira ', KOKAPENKOPURUA, ' kokapen desberdin definitu dira.');
   writeln;
   
   EtsaienArmadaGuztiakKokatu;
   
   writeln('///////////////////////////////////////////////////////////////////');
   
   writeln;
   repeat until keypressed;
end.
 



  • EtsaiakNonDaude.pas   bezero-programaren iturburu-kodea
  • itsasoarena.pas   unitatearen iturburu-kodea, hau konpilatzean:
    • itsasoarena.ow   unitatearen objektu-kodea lortzen da (itsasoarena.pas konpilatu ondoren)
    • itsasoarena.ppw   unitate konpilatua lortzen da (itsasoarena.pas konpilatu ondoren)
  • EtsaiakNonDaude.exe   programa exekutagarria fitxategi hauekin lor daiteke:
    • EtsaiakNonDaude.pas
    • itsasoarena.ow
    • itsasoarena.ppw
 

 

2024(e)ko martxoaren 21(a), osteguna

10. astea | itsas-bataila (II)






Itsas-bataila

Itsas-batailaren jokoa programatuko dugu. Bi dimentsioatako 6x6 taula batean gertatuko dira ekintza guztiak, taularen errenkadak izendatzeko zenbaki osoak erabiliko dira (1-etik 6-ra), eta taularen zutabeak izendatzeko karaktereak erabiliko dira (A-tik F-ra)

Ordenadoreak etsaien armada kokatuko du 6x6 itsasoan, eta etsaien armada hori hondoratu beharko dugu gehienez 19 jaurtiketa erabiliz. Etsaien armada sei itsasontziz osaturik dago:

  • 2 korazatu, armadako itsasontzi handienak dira (bakoitzak 3 zati)
  • 3 destruktore, armadako itsasontzi ertainak dira (bakoitzak 2 zati) 
  • 1 itsaspeko, armadako itsasontzi txikiena da (1 zati)

Hondoratu behar dugun etsaien armada 6x6 itsasoan kokatzeko, bi dimentsiotako array bat erabiliko dugu, hots, karaktereen array bat. Korazatua adierazteko K idatziko dugu, destruktorea adierazteko D idatziko dugu, itsaspekoa adierazteko P idatziko dugu, ura adierazteko, u idatziko dugu, eta, gainerako toki guztietan X idatzirik egongo da. Adibidez:


Lehendik programaturik dagoen unitate bat erabiliko dugu, itsas_w izeneko unitatea hain zuzen ere. Unitate horren iturburu-programa ez daukagu, baina bere interfazea ezagutzen dugu. Hori dela eta, guk idatziko dugun programan itsas_w unitatearen ondoko datu-mota erabil dezakegu eta ondoko azpiprogramen deiak egin ditzakegu: 

unit itsas_w ; 

interface        (* ----------------------------- interfazearen hasiera ----- *)

   type tacItsasoa = array[1..6, 'A'..'F'] of char ;
   procedure EtsaienArmadaHasieratu ;
   procedure EtsaienArmadaKokatu ;
   procedure EtsaienArmadaErakutsi ;
   function fncSuEgin(iErrenkada: integer;
                        cZutabea: char): char ;   { K, D, P edo X }
   procedure EtsaienArmadaGuztiakKokatu ;
   
                 (* ----------------------------- interfazearen amaiera ----- *)

implementation   (* ------------------------- inplementazioaren hasiera ----- *)

   ...

end.             (* --------- inplementazioaren eta unitatearen amaiera ----- *) 

Interfazean adierazten dira unitateak bezero-programarekin partekatuko dituen elementuak: konstanteak, datu-motak, funtzioak, prozedurak eta abar. Adibide honetan, datu-mota bat partekatzeaz gain funtzio bat eta lau prozedura partekatzen dira.

Interfazearen datu-motaren azalpena:

  • tacItsasoa datu-motak itsasoa ereduztatzen du, 6x6 itsaso zati horretan burutuko da bataila. Errenkadak izendatzeko zenbakizko indizeak erabiliko dira (1-etik 6-ra) eta zutabeak izendatzeko letrak erabiliko dira (A-tik F-ra)

Interfazearen bost azpiprogramen azalpenak:

  • fncSuEgin funtzioak 6x6 arrayaren koordenatuak hartuko ditu eta posizio horren karakterea itzuliko du (K, D, P edo X)
  • EtsaienArmadaHasieratu prozedurak 6x6 itsasoan X markak idatziko ditu
  • EtsaienArmadaKokatu prozedurak 6x6 itsasoan K, D eta P markak idatziko ditu
  • EtsaienArmadaErakutsi prozedurak 6x6 itsasoaren edukia pantailaratuko du. Honi esker gure programa-bezerotik posible zaigu jakitea etsaien ontziteria non dagoen, baina prozedura honi dei egiten badiogu itsas-bataila galdu dugulako izango da
  • EtsaienArmadaGuztiakErakutsi prozedurak 6x6 itsasoaren edukia pantailaratuko du, guztira 16 kokapen desberdin definitu dira itsas_w unitatean

Bost azpiprograma horiek gure programatik aktiba ditzakegu. Horretarako, uses klausulari esker itsas_w unitatea behar-beharrekoa zaigula adieraziko dugu gure iturburu-programaren hasieran:

program ItsasBatailak_w ;

uses
   crt, itsas_w ;
const                     (* 2 korazatu, 3 destruktore eta 1 itsaspeko *)
   ARMADA_OSOA = 13 ;     (* 2x3 + 3x2 + 1 = 13 *)
   JAURTIK_MAX = 19 ;  
type  
   tsJaurtiketa = string[2] ;

Hori dela eta, gure bezero-programak EtsaienArmadaKokatu prozedurari deia egitean etsaien armadaren kokapen zehatz bat gertatuko da (16 kokapen posibleetatik bat) eta jokoa hasi ahalko da. Jakin badakigu etsaien armadak 6 ontzi izango dituela eta bi ontziren artean beti ura dagoela; esate baterako, ondoko irudian erakusten den kokapena ez da itsas_w unitateak emandakoa kokapena desegokia delako:

Erroreak daudelako, goiko irudia ez du eman EtsaienArmadaKokatu prozedurak


ItsasBatailak_w.pas bezero-programak itsas_w eta crt unitateak beharko dituela dakigu. Baina, zer gertatuko litzateke  bezero-programak deklaratu eta garatuko balu unitatearen interfazeko funtzioa edo prozeduraren bat? Honako hau galdetzen da: EtsaienArmadaKokatu prozedura unitatean garaturik dago (bezero-programaren erabiltzaileak jakin ez dezan etsaien ontziteria non dagoen), bezero-programak EtsaienArmadaKokatu prozedura berri bat idatz dezake? Bai idatz dezake, errorerik ez dago ez sintaxian ez exekuzioan.

Aurreko erantzunak beste galdera bat sorarazten du: baldin eta EtsaienArmadaKokatu bi prozedura badaude (bat unitatekoa eta bestea bezero-programakoa), zein aktibatuko da bezero-programa exekutatzean? Bezero-programakoa, hots, bezero-programako EtsaienArmadaKokatu prozedura piztuko da eta unitateko EtsaienArmadaKokatu prozedura ez balego bezala da. Ondorioz, unitatean garaturik dagoen zerbait bezero-programan garatzen bada, azken honek "estaltzen" du unitatekoa.

ItsasBatailak_w.pas bezero-programak itsas_w eta crt unitateak beharko ditu eta bere programa nagusia ondoko hau izan daiteke, non aboJaurtiketaErrepikaturik array karratuan egindako jaurtiketak gordetzen ditugun (boolearren 6x6 array bat da) :

{ -----------------------Programa Nagusia-------------------------- }
var
   iErrenkada, iJaurtiKont, iOntziZatiak, iUrKont: integer ;
   cZutabea: char ; 
   acItsasoarenEgoera: tacItsasoa ;
   aboJaurtiketaErrepikaturik: tboJaurtiketenHistoria ; 
   sJaurtiketa: tsJaurtiketa ; 
   boJaurtiketaEgokia, boErrepikatuGabea: boolean ;
   cEmaitza: char ;
     
begin
   clrscr ;
   writeln ;
   
   writeln('///////////////////////////////////////////////////////////////////') ;
   writeln ;
   writeln('Garaile ateratzeko, gehienez ', JAURTIK_MAX, ' jaurtiketa dituzu') ;
   writeln ;  
  
   EtsaienArmadaHasieratu ;    (* unitatean garaturik *)  
   EtsaienArmadaKokatu ;       (* unitatean garaturik *)

   JaurtiketenHistoriaHasi(aboJaurtiketaErrepikaturik) ;    (* hasieran denak "FALSE" *)
   ItsasoarenEgoeraHasieratu(acItsasoarenEgoera) ;          (* hasieran denak "X" *)
   ItsasoaErakutsi(acItsasoarenEgoera) ;
   
   writeln ;      
   writeln('ARMISTIZIOA:') ;
   writeln('Amore eman eta bataila galdutzat jotzen baduzu, etsaien armada ikus dezakezu.') ;
   writeln('Garaitu zaituen etsaien armadaren kokapena ikusi nahi duzu, "AR" erantzun. ') ;
   writeln ;
   
   iUrKont := 0 ;
   iOntziZatiak := 0 ;
   iJaurtiKont := 0 ;
   repeat
      if iUrKont >= 6 then
      begin
         TextColor(LightCyan) ;
         writeln('Jaurtiketa okerrak askotan egin dituzu, armistizioa eskatzerik daukazu!!!') ;
         TextColor(White) ;
      end ;   
      
      iJaurtiKont := iJaurtiKont + 1 ; 
      boJaurtiketaEgokia := FALSE ;   
      repeat
         repeat
            write(iJaurtiKont:3, '. jaurtiketa egin (adibidez 3C koordenatuak, armistizioa eskatzeko "AR"): ') ;
            readln(sJaurtiketa) ;
            sJaurtiketa := upcase(sJaurtiketa) ;
            boJaurtiketaEgokia := fnboJaurtiketaAztertu(sJaurtiketa) ;     
         until boJaurtiketaEgokia ;
         
         boErrepikatuGabea := fnboErrepikatuGabea(sJaurtiketa, aboJaurtiketaErrepikaturik) ;
      until boErrepikatuGabea ;
      
      if sJaurtiketa <> 'AR' then
      begin
         val(sJaurtiketa[1], iErrenkada) ;
         //writeln('iErrenkada = ', iErrenkada) ;
         cZutabea := sJaurtiketa[2] ;
    
         cEmaitza := fncSuEgin(iErrenkada, cZutabea) ;    (* unitatean garaturik *) 
      
         case cEmaitza of    { K, D, P edo X }         
            'K': begin
                    writeln(iErrenkada:3, cZutabea, ' ---> K, korazatua') ;
                    iOntziZatiak := iOntziZatiak + 1 ;
                    acItsasoarenEgoera[iErrenkada,cZutabea] := 'K' ;
                    aboJaurtiketaErrepikaturik[iErrenkada,cZutabea] := TRUE ;
                 end ;
            'D': begin
                    writeln(iErrenkada:3, cZutabea, ' ---> D, destruktorea') ;
                    iOntziZatiak := iOntziZatiak + 1 ;
                    acItsasoarenEgoera[iErrenkada,cZutabea] := 'D' ;
                    aboJaurtiketaErrepikaturik[iErrenkada,cZutabea] := TRUE ;
                 end ;      
            'P': begin
                    writeln(iErrenkada:3, cZutabea, ' ---> P, itsaspekoa') ;
                    iOntziZatiak := iOntziZatiak + 1 ;
                    acItsasoarenEgoera[iErrenkada,cZutabea] := 'P' ;
                    aboJaurtiketaErrepikaturik[iErrenkada,cZutabea] := TRUE ;
                 end ;      
            'X': begin
                    writeln(iErrenkada:3, cZutabea, ' ---> URA') ;
                    acItsasoarenEgoera[iErrenkada,cZutabea] := 'u' ;
                    aboJaurtiketaErrepikaturik[iErrenkada,cZutabea] := TRUE ;
                    iUrKont := iUrKont + 1 ;
                 end ;      
         end ;
         
         writeln((JAURTIK_MAX-iJaurtiKont):4, ' jaurtiketa geratzen d(ir)a');
         writeln ;
         ItsasoaErakutsi(acItsasoarenEgoera) ;
         writeln ;
      end ;       
   until (iOntziZatiak = ARMADA_OSOA) or
         (iJaurtiKont = JAURTIK_MAX) or
         (sJaurtiketa = 'AR') ;
   
   writeln ;
   
   if sJaurtiketa = 'AR' then
   begin
      writeln('ARMISTIZIOA, garaile atera diren etsaien ontziteria:') ;
      writeln ;
      EtsaienArmadaErakutsi ;    (* unitatean garaturik *) 
   end
   else
   begin
      if (iOntziZatiak = ARMADA_OSOA) and (iJaurtiKont <= JAURTIK_MAX) then
      begin
         TextColor(LightGreen) ;
         writeln(iJaurtiKont, ' jaurtiketekin etsaien armada osoa hondoratu duzunez, gerra irabazi duzu!!!') ;
         TextColor(White) ;
      end
      else
      begin
         TextColor(LightRed) ;
         writeln(iJaurtiKont, ' jaurtiketa ondoren itsas-bataila galdu duzu!!!') ;
         TextColor(White) ;
         writeln('Garaitu zaituen etsaien ontziteria:') ;
         writeln ;
         EtsaienArmadaErakutsi ;    (* unitatean garaturik *)
      end ;
   end ;
       
   writeln ;
   writeln('///////////////////////////////////////////////////////////////////') ;
   
   writeln ;
   repeat until keypressed ;
end.

acItsasoarenEgoera karaktereen array horretan itsas-batailaren egoera gordeko dugu uneoro. Bataila hasi aurretik ItsasoarenEgoeraHasieratu prozedurak X karakterez betetzen du 6x6 arraya. Etsaien armada hondoratu nahian, 6x6 itsasoko koordenatu pare bat hautatzeko aukera izango dugu (5D bezalako karaktere-katea) eta koordenatu horiek fncSuEgin funtzioari pasatuz, honek jaurtiketaren emaitza itzuliko digu, eta, ondorioz ItsasoarenEgoeraHasieratu prozedurak bete dituen X guztietatik bat ordeztuko dugu. Arrayaren posizio horretako balio berria, honako hauetatik bat izango da:

  • u ura, gure jaurtiketak huts egin du
  • K korazatua, gure jaurtiketak korazatu baten zatia suntsitu du 
  • D destruktorea, gure jaurtiketak destruktore baten zatia suntsitu du 
  • P itsaspekoa, gure jaurtiketak itsaspekoa suntsitu eta hondoratu du 


Etsaien armadak 3+3+2+2+2+1=13 zatiz osaturik dago, eta guztiak suntsitu arte itsas-bataila ez da bukatuko eta garaile aterako gara 19 jaurtiketa behar izan badugu (19 jaurtiketa edo gutxiago beharko dira itsas-bataila irabazteko). Dagozkigun 19 jaurtiketak agortzean, batailaren galtzaileak gu izango gara eta programa bukatuko da. Baina 19. jaurtiketa egin baino lehenago, bataila galdutzat jotzen badugu, armistizioa eskatu ahalko dugu (AR koordenatuak sartuz) eta etsaien ontziteria pantailaratu ondoren programa bukatuko da.

Ikusi balizko exekuzio bat, non 16 jaurtiketan ura egin ondoren, amore eman eta armistizioa eskatzea erakabi dugun. Ondorioz, programa amaitu aurretik etsaien armadaren kokapena erakusten da:






    Windows:
  • ItsasBatailak_w.pas   bezero-programaren iturburu-kodea
  • itsas_w.pas   unitatearen iturburu-kodea, hau konpilatzean:
    • itsas_w.ow   unitatearen objektu-kodea lortzen da (itsas_w.pas konpilatu ondoren)
    • itsas_w.ppw   unitate konpilatua lortzen da (itsas_w.pas konpilatu ondoren)
  • ItsasBatailak_w.exe   programa exekutagarria fitxategi hauekin lor daiteke:
    • ItsasBatailak_w.pas
    • itsas_w.ow
    • itsas_w.ppw
    Windows:
  • ItsasBatailak_w.zip   unitate konpilatua eta bezero-programaren iturburu-kodea (itsas_w.ow eta itsas_w.ppw gehi ItsasBatailak_w.pas)
 

    Mac:
  • ItsasBatailak.pas   bezero-programaren iturburu-kodea
  • itsas.pas   unitatearen iturburu-kodea
  • itsas.o   unitatearen objektu-kodea
  • itsas.ppu   unitate konpilatua
  • ItsasBatailak   programa exekutagarria (goiko fitxategiekin lor daiteke)


 

10. astea | itsas-bataila (I)






Itsas-bataila

Itsas-batailaren jokoa programatuko dugu. Bi dimentsioatako 6x6 taula batean gertatuko dira ekintza guztiak, taularen errenkadak izendatzeko zenbaki osoak erabiliko dira (1-etik 6-ra), eta taularen zutabeak izendatzeko karaktereak erabiliko dira (A-tik F-ra)

Ordenadoreak etsaien armada kokatuko du 6x6 itsasoan, eta etsaien armada hori hondoratu beharko dugu gehienez 19 jaurtiketa erabiliz. Etsaien armada sei itsasontziz osaturik dago:

  • 2 korazatu, armadako itsasontzi handienak dira (bakoitzak 3 zati)
  • 3 destruktore, armadako itsasontzi ertainak dira (bakoitzak 2 zati) 
  • 1 itsaspeko, armadako itsasontzi txikiena da (1 zati)

Hondoratu behar dugun etsaien armada 6x6 itsasoan kokatzeko, bi dimentsiotako array bat erabiliko dugu, hots, karaktereen array bat. Korazatua adierazteko K idatziko dugu, destruktorea adierazteko D idatziko dugu, itsaspekoa adierazteko P idatziko dugu, ura adierazteko, u idatziko dugu, eta, gainerako toki guztietan X idatzirik egongo da. Adibidez:


Baina bataila hasi aurretik, ikus dezagun etsaien ontziteriak har ditzaken kokapen posibleak zeintzuk diren. Horretarako, programa bat idatziko dugu eta bere helburu bakarra EtsaienArmadaGuztiakKokatu delako prozedurari dei egitea da. Dakigunez, EtsaienArmadaGuztiakKokatu prozedura itsas_w unitatean garaturik dago.

Guztira 16 kokapen desberdin direlako EtsaienArmadaGuztiakErakutsi prozedurak for-to-do agindu baten bitartez, iterazio bakoitzean bi dei egingo ditu: EtsaienArmadaHasieratu prozedurari eta EtsaienArmadaKokatu prozedurari. Hirurak itsas_w unitatean garaturik daude.

Lehendik programaturik dagoen unitate bat erabiliko dugu, itsas_w izeneko unitatea hain zuzen ere. Unitate horren iturburu-programa ez daukagu, baina bere interfazea ezagutzen dugu. Hori dela eta, guk idatziko dugun programan itsas_w unitatearen ondoko datu-mota erabil dezakegu eta ondoko azpiprogramen deiak egin ditzakegu:  

unit itsas_w ; 

interface        (* ----------------------------- interfazearen hasiera ----- *)

   type tacItsasoa = array[1..6, 'A'..'F'] of char ;
   function fncSuEgin(iErrenkada: integer;
                        cZutabea: char): char ;   { K, D, P edo X }
   procedure EtsaienArmadaHasieratu ;   
   procedure EtsaienArmadaErakutsi ;   
   procedure EtsaienArmadaKokatu ;
   procedure EtsaienArmadaGuztiakKokatu ;
   
                 (* ----------------------------- interfazearen amaiera ----- *)

implementation   (* ------------------------- inplementazioaren hasiera ----- *)

   ...

end.             (* --------- inplementazioaren eta unitatearen amaiera ----- *)  

Interfazean adierazten dira unitateak bezero-programarekin partekatuko dituen elementuak: konstanteak, datu-motak, funtzioak, prozedurak eta abar. Adibide honetan, datu-mota bat partekatzeaz gain funtzio bat eta lau prozedura partekatzen dira.

Interfazearen datu-motaren azalpena:

  • tacItsasoa datu-motak itsasoa ereduztatzen du, 6x6 itsaso zati horretan burutuko da bataila. Errenkadak izendatzeko zenbakizko indizeak erabiliko dira (1-etik 6-ra) eta zutabeak izendatzeko letrak erabiliko dira (A-tik F-ra)

Interfazearen bost azpiprogramen azalpenak:

  • fncSuEgin funtzioak 6x6 arrayaren koordenatuak hartuko ditu eta posizio horren karakterea itzuliko du (K, D, P edo X)
  • EtsaienArmadaHasieratu prozedurak 6x6 itsasoan X markak idatziko ditu
  • EtsaienArmadaKokatu prozedurak 6x6 itsasoan K, D eta P markak idatziko ditu
  • EtsaienArmadaErakutsi prozedurak 6x6 itsasoaren edukia pantailaratuko du. Honi esker gure programa-bezerotik posible zaigu jakitea etsaien ontziteria non dagoen, baina prozedura honi dei egiten badiogu itsas-bataila galdu dugulako izango da
  • EtsaienArmadaGuztiakErakutsi prozedurak 6x6 itsasoaren edukia pantailaratuko du, guztira 16 kokapen desberdin definitu dira itsas_w unitatean

Bost azpiprograma horiek gure programatik aktiba ditzakegu. Horretarako, uses klausulari esker itsas_w unitatea behar-beharrekoa zaigula adieraziko dugu gure iturburu-programaren hasieran. Dena den EtsaiakNon_w programan azpiprograma bakarra erabiliko dugu, EtsaienArmadaGuztiakErakutsi prozedura:

program EtsaiakNon_w ;

uses
   crt, itsas_w ;

Hori dela eta, gure bezero-programak EtsaienArmadaGuztiakErakutsi prozedurari dei egitean etsaien armadaren kokapen guztiak zeintzuk izan daitezkeen erakutsiko ditu pantailan. Orotara 16 kokapen desberdinetatik hona hemen lehen laurak:

EtsaienArmadaGuztiakErakutsi prozedurak pantailaratzen duenenaren zati bat


EtsaiakNon_w.pas bezero-programak itsas_w eta crt unitateak beharko dituela dakigu. Baina, zer gertatuko litzateke  bezero-programak deklaratu eta garatuko balu unitatearen interfazeko funtzioa edo prozeduraren bat? Honako hau galdetzen da: EtsaienArmadaGuztiakKokatu prozedura unitatean garaturik dago (bezero-programaren erabiltzaileak jakin ez dezan etsaien ontziteria non egon daitekeen), bezero-programak EtsaienArmadaGuztiakKokatu prozedura berri bat idatz dezake? Bai idatz dezake, errorerik ez dago ez sintaxian ez exekuzioan.

Aurreko erantzunak beste galdera bat sorarazten du: baldin eta EtsaienArmadaGuztiakKokatu bi prozedura badaude (bat unitatekoa eta bestea bezero-programakoa), zein aktibatuko da bezero-programa exekutatzean? Bezero-programakoa, hots, bezero-programako EtsaienArmadaGuztiakKokatu prozedura piztuko da eta unitateko EtsaienArmadaGuztiakKokatu prozedura ez balego bezala da. Ondorioz, unitatean garaturik dagoen zerbait bezero-programan garatzen bada, azken honek "estaltzen" du unitatekoa.

EtsaiakNon_w.pas bezero-programak itsas_w eta crt unitateak beharko ditu jarraian ikusten den bezala:

program EtsaiakNon_w ;

uses
   crt, itsas_w ;

{ -----------------------Programa Nagusia-------------------------- }

begin
   clrscr ;
   writeln ;
   
   writeln('///////////////////////////////////////////////////////////////////') ;
   writeln ;
   writeln ;
     
   EtsaienArmadaGuztiakKokatu ;
    
   writeln ;
   writeln ;
   writeln('///////////////////////////////////////////////////////////////////') ;
   
   writeln ;
   repeat until keypressed ;
end.
 



    Windows:
  • EtsaiakNon_w.pas   bezero-programaren iturburu-kodea
  • itsas_w.pas   unitatearen iturburu-kodea, hau konpilatzean:
    • itsas_w.ow   unitatearen objektu-kodea lortzen da (itsas_w.pas konpilatu ondoren)
    • itsas_w.ppw   unitate konpilatua lortzen da (itsas_w.pas konpilatu ondoren)
  • EtsaiakNon_w.exe   programa exekutagarria fitxategi hauekin lor daiteke:
    • EtsaiakNon_w.pas
    • itsas_w.ow
    • itsas_w.ppw
    Windows:
  • EtsaiakNon_w.zip   unitate konpilatua eta bezero-programaren iturburu-kodea (itsas_w.ow eta itsas_w.ppw gehi EtsaiakNon_w.pas)
 

    Mac:
  • EtsaiakNon.pas   bezero-programaren iturburu-kodea
  • itsas.pas   unitatearen iturburu-kodea
  • itsas.o   unitatearen objektu-kodea
  • itsas.ppu   unitate konpilatua
  • EtsaiakNon   programa exekutagarria (goiko fitxategiekin lor daiteke)


 

Konpiladorea eta estekatzailea






Aurrekariak

Dakigunez ordenadore baten funtzionamendua programa batek gidatzen du. Baina, defini dezagun programa bat zer den informatikaren arloan:

Programa: Ordenagailu bati programazio-lengoaia batean idatzita ematen zaion agindu-segida, lan jakin bat egiteko behar diren oinarrizko eragiketak ordenagailuak exkutatzeko moduan zehatz-mehatz azaltzen dituena. 

Baina ez dugu ahaztu behar ordenagailua makina digitala dela eta exekuta dezakeen programa berari dagokion makina-kodean idatzirik eman behar zaiola.

Makina-kode: makina-kodea edo makina-programa ordenadoreak ulertzen duen agindu-multzoa da. Ordenagailuaren PUZak (prozesatzeko unitate zentralak) zuzenean, itzulpenik gabe, exekuta dezakeen agindu-multzoa. Agindu horiek sistema bitarrean adierazten dira eta bakoitzak eragiketa aritmetiko edo logiko bat adierazten du. Ordenagailu batetik bestera alda daiteke. 

Modu beretsuan, ez dugu ahaztu behar guk goi-mailako lengoaiaren bat erabiliko dugula programa idazteko eta horregatik gure programa "itzuli" beharko dela ordenadoreak exekuta dezan. Hori dela eta, guk idatzitako programari iturburu-programa esaten zaio, hauxe da bere definizioa.

Iturburu-programa: iturburu-programa edo iturburu-kodea goi-mailako lengoaian idatzitako sententzia eta aginduen multzoa da. Ordenagailuak exekutatu ahal izateko konpiladore, mihiztatzaile edo interpretatzaileen bidez makina-lengoaiara bihurtu behar dena, hots, iturburu-programa itzuli beharra dago ordenadoreak exekuta dezan. 

Eskematikoki:

Iturburu-programa itzuli beharra dagoela eta, goi-mailako lengoaian bi motatakoak izan daitezke: Interpretatuak eta Konpilatuak. Goi-mailako lengoaia interpretatuetan interpretatzaile bat aplikatzen zaio programari makina-kodea lortzeko. Goi-mailako lengoaia konpilatuetan programaren itzultzaile lana konpiladoreak egingo du.

Interpretatzaile: Goi-mailako lengoaia itzultzeko programa orokorra da, aginduak irakurri ahala aztertu eta exekutatzen dituena. Goi-mailako lengoaia interpretatuen adibideak: Python, PHP, Perl, MATLAB, Ruby, JavaScript, ... 

Konpiladore: Goi-mailako lengoaian idatzitako programa oso bat hartu eta itzuli edo konpilatzen duen programa da. Goi-mailako lengoaia konpilatuen adibideak: Pascal, C, C++, ... 

Informatikaren arloan konpilatzea iturburu-programa bat itzultzea da, ordenadore baten makina-kodera itzultzea alegia. Konpilatze prozesuak fase desberdinak ditu eta horiekin ez da programa exekutagarria lortzen, konpilatzeari beste estekatzea gehitu behar baitzaio.

Konpilatzearen faseak ondoko irudian erakusten dira:

Non bost fase hauek desberdintzen diren:

  1. Analisi lexikala: Lexikoaren analisia, hitzen analisia, lehenengo fasea da; hemen iturburu-programa ezkerretik eskuinera irakurtzen da eta osagai lexikoetan (tokenak) biltzen da, esanahi bat duten karaktere-sekuentziak direnak. Gainera, zuriune guztiak, lerro zuriak, iruzkinak eta beharrezkoa ez den gainerako informazioa iturburu-programatik ezabatzen da. Lengoaiaren sinboloak (hitz gakoak, eragileak, etab.) behar bezala idatzi direla ere egiaztatzen da. Adibidez, fase honetan aurkitzen dira ";" baten falta, edo ">=" ordez "=>" idatzi dela, edo aldagai baten etiketa okerra, edo etiketa bera bikoiztuta dagoela
  2. Analisi sintaktikoa: Fase honetan, tokenak edo osagai lexikoak hierarkikoki biltzen dira gramatika-esaldietan, eta horiek konpiladoreak erabiltzen ditu bere irteera sintetizatzeko. Aurreko fasetik lortutakoa sintaktikoki zuzena den egiaztatzen da (lengoaiaren gramatikaren araberakoa da). Oro har, iturburu-programaren esaldi gramatikalak analisi sintaktikoko zuhaitz baten bidez adierazten dira. Adibidez, fase honetan parekatzen dira adierazpen desberdinen parentesi bikoteak edo begin-end bikoteak
  3. Analisi semantikoa: Analisi semantikoaren faseak iturburu-programa berrikusten du akats semantikoak aurkitzen saiatzeko, eta datu-motei buruzko informazioa biltzen du kodea sortzeko ondorengo faserako. Analisi semantikoaren zeregin garrantzitsu bat datu-motak egiaztatzea da. Hemen, konpiladoreak operadore bakoitzak iturburu-lengoaiaren espezifikazioagatik baimendutako operandoak dituen egiaztatuko du. Adibidez, integer datu-motako aldagai bati zenbaki erreal ezingo zaio esleitu, edo div operadore aritmetikoa ezin zaio zenbaki erreal bati aplikatu
  4. Kodearen sortzea: Sintesi-fasea honetan iturburu-programaren baliokidea den objektu-kodea sortzean datza. Iturburu-programak analisi-akatsik ez duenean bakarrik sortzen da objektu-kodea; horrek ez du esan nahi programa behar bezala exekutatuko denik, programa batek kontzeptu-akatsak edo gaizki kalkulatutako esamoldeak izan baititzake
  5. Kodearen optimizatzea: Kodea optimizatzeko fasea bitarteko kodea hobetzean datza, exekutatzeko makina-kode azkarragoa izan dadin. Alde handia dago konpiladoreek exekutatzen duten kode-optimizazioaren kopuruan. Optimizazio handia egiten dutenetan, "Konpiladore optimizatzaileak" deituak, konpiladorearen denboraren zati esanguratsu bat fase honetan luzatzen da. Hala ere, optimizazio sinple batzuk nabarmen hobetzen dute objektu-programa gauzatzeko denbora, konpilazioa gehiegi atzeratu gabe

Objektu-kodea eta objektu-programa aipatu dira goian, izan ere konpilatzearen emaitza .obj luzapena, edo .o luzapena, edo .ow luzapena, edo .ppw luzapena duen fitxategi bat izango da eta fitxategi horri objektu-programa esaten zaio. Objektu-programaren fitxategi hau, makina-kodean idatzita egon arren ezin da exekutatu programa-liburutegien kodea falta zaiolako. Linker edo estekatzaile delako programak objektu-kodetik abiatuta .exe luzapeneko programa-exekutagarria lortuko du.



Estekatu aditzaren esanahia lotu edo elkartu da. Esan bezala, linker edo estekatzaile delako programak .obj objektu-kodetik abiatuta .exe luzapeneko programa-exekutagarria lortuko du, objektu-kodeari falta zaizkion programa-liburutegiak gehituz. Baina, programa-liburutegiaren eta estekatzailearen definizioak eman ditzagun.

Programa-liburutegi: Programatzaileen eskueran dauden prozedura edo programa prekonpilatuen multzoa. 

Iturburu-programa konpilatu ondoen lortzen den objektu-kodeari aurredefinituriko prozedura eta funtzioak falta zaizkio. Prozedura eta funtzio horiek programa-liburutegietan bildurik daude makina-kodean itzulirik. Estekatzaile delako programak objektu-kodea eta programa-liburutegiak lotu/elkartu egiten egiten ditu. 

Estekatzaile: Independenteki idatzi eta independenteki konpilatu programa edo moduluak elkarrekin lotu eta programa exekutagarri koherente bat eratzen duen programa. 

Eskematikoki:

Baina non aurkitzen dira .ow eta .ppw luzapeneko prekonpilatutako moduluak? Dev-Pas konpiladorearen kasuan, irudi honek adierazten digu modulu horiek estekatzaileak non bilatuko dituen; konpiladorea C:\Dev-Pas karpetan instalatu bada, unitate prekonpilatuak C:\Dev-Pas\units\rtl karpetan kokatuko dira:

Unitateen eta liburutegien direktorio horiek Dev-Pas konpilazio-ingurunea instalatzean ezartzen dira, behar izanez gero Options > Compiler options > Directories bidea jarraituz alda ditzakegu:


 

10. astea | mediana eta batezbestekoa


Gehienez 40 elementu gordetzeko gai den array batekin lan egingo dugu. Arrayaren elementuak zenbaki errealak izango dira.

Array zehatz honen datuek bi baldintza betetzen dituzte:

  1. Arrayaren datu guztiak desberdinak dira. Arraya betetzean, datua den zenbaki erreala arrayean gorde aurretik, frogatu beharra dago errepikaturik ez dela egongo. Horretarako, teoriako blogearen 9. astea | bilaketa sekuentzialaren aplikazio bat programara jo eta bertako BilaketaLineala izeneko funtzioa erabili gure behar izanetara egokituz, hots, beharko dituen moldapenak eginez
  2. Arrayaren datu guztiak ordenaturik daude. Arraya betetzean, datu berria dela frogatu ondoren, zein tokitan txertatuko den zehaztu beharra dago eta non txertatu dakiguka tartekaketaren algoritmoa aplikatu (gogoratu 10. astea | txertaketa array batean non elementu bat arrayaren posizio jakin batean tartekatzen den)

Zein da datuen rMed medianaren balioa? eta zein da datuen rBaBe batezbestekoaren balioa?

Mediana. Estatistikan, rMed mediana hainbat datu txikienetik handienera ordenaturik daudela, erdian dagoen datua da. Datu-kopurua bakoitia bada, denak ordenaturik daudela, rMed mediana erdiko datuak hartzen duen balioa da. Datu-kopurua bikoitia bada, datuak ordenaturik daudela, erdiko datu bi dagoenez, rMed mediana erdiko bi datu horien batezbestekoa dela esan daiteke (rMed aldagaiaren datu-mota real izango da).

Batezbestekoa. Batezbestekoaren balioa kalkulatzeko, rBaBe aldagaia erabiliko da (real datu-motakoa). Arrayak dituen balioen metekata egin ondoren, arrayaren elementu kopuruagatik zatiketa egingo da.









Arrayaren datu-mota eta arrayaren edukia

Arrayaren elementuak zenbaki errealak dira. Zehatzago hitz eginez, elementuen egitura hau da: 0 eta 9 arteko unitate bat, eta, 0 eta 9 arteko dezimal bat.

     program MedianaEtaBatezbestekoa ;
     const
        BEHEMUGA = 1 ;
        GOIMUGA = 40 ;
     type
        tarZenbakienSorta = array[BEHEMUGA..GOIMUGA] of real ;
     ...   

Arrayaren elementu guztiak desberdinak dira elkarrekiko, eta sailkaturik daude txikitik handira. Adibidez, hau izan daiteke 9 elementu dituen array baten edukia:

       balioak ===>     0.3   2.1   2.2   3.9   5.6   7.4   8.8   8.9   9.5
      indizeak ===>      1     2     3     4     5     6     7     8     9



Programa nagusia

Programa nagusian array bat (eta bere luzera efektiboa) daukagu eta eskatzen diren mediana eta batezbesteko aritmetikoa kalulatzen dira.

{ =============================programa nagusia============================ }
var
   arZenbakiak: tarZenbakienSorta ;
   iLuzera: integer ;
   rMed, rBaBe: real ;
begin
   writeln ;
   writeln ;
   
   randomize ;    (* ArrayaBete prozeduran random(10) funtzioa erabiltzen delako *)

   ArrayaBete_DesberdinakEtaOrdenaturik(arZenbakiak, iLuzera) ;
   writeln ;
   
   writeln('Arrayaren edukia: ') ;
   ArrayaIkusi(arZenbakiak, iLuzera) ;
   writeln ;

   rMed := fnrMedianaKalkulatu(arZenbakiak, iLuzera) ;
   writeln('Mediana = ', rMed:0:2) ;
   writeln ;

   rBaBe := fnrBatezbestekoaKalkulatu(arZenbakiak, iLuzera) ;
   writeln('Batezbestekoa = ', rBaBe:0:2) ;
   writeln ;
   
   writeln ;
   writeln('====================================================') ;
   writeln('RETURN sakatu amaitzeko ') ;
   writeln('====================================================') ;
   readln ;
end.



ArrayaBete_DesberdinakEtaOrdenaturik prozedura

Programaren eginkizun zailena ArrayaBete_DesberdinakEtaOrdenaturik prozedura honetan burutzen da, bere lana bikoitza da: 1) elementu desberdinak eta 2) ordenaturik gorde.

...
procedure ArrayaBete_DesberdinakEtaOrdenaturik(var arZenbakiak: tarZenbakienSorta;
                                                   var iLuzera: integer) ;
var
   iKont, iUnitatea, iDezimala, iNonDago, iNonTxertatu: integer ;
   rZbk: real ;
begin
   iLuzera := random(GOIMUGA) + 1 ;     (* 1 eta 40 arteko balioa *)
   
   for iKont:=BEHEMUGA to iLuzera do
   begin
      repeat
         iUnitatea := random(10) ;      (* 0 eta 9 arteko balioa *)
         iDezimala := random(10) ;      (* 0 eta 9 arteko balioa *)

         rZbk := iUnitatea*1.0 + iDezimala*0.1 ;

         iNonDago := fniZenbakiaBilatu(arZenbakiak, iLuzera, rZbk) ;
         
         if iNonDago <> 0 then
            writeln('iKont = ', iKont:2, ' -------- ', rZbk:0:1, ' ----errepikatuta---- ', iNonDago:2, ' ----posizioan--------') ;
            
      until iNonDago = 0 ;    (* errepikatu elementu berria izan arte *)

      iNonTxertatu := fniBerePosizioaAurkitu(arZenbakiak, iKont, rZbk) ;
      //writeln('iNonTxertatu = ', iNonTxertatu) ;  
      ZbkTartekatu(arZenbakiak, iKont, rZbk, iNonTxertatu) ;
   end ;
end ;
...

fniBerePosizioaAurkitu funtzioak bilaketa sekuentzialaren algoritmoa barneratzen du. Eta, ZbkTartekatu prozedurak elementu baten tartekataren algoritmoa barneratzen du.

Hona hemen MedianaEtaBatezbestekoa.pas programaren kodea eta bi exekuzioen balizko pantailaraketak:

Datu-kopurua bakoitia izatean
Datu-kopurua bikoitia izatean