13. astea | kaosa sortzen (fitxategi ordenatu bat desordenatzen)

  kaosa sortzen  

Ariketa honen algoritmoa 11. astean ikusitako kaosa sortzen (array ordenatu bat desordenatzen) ariketan programatu zen berbera da. Orduan informazioa erregistroen array batean zegoen, eta orain erregistroen fitxategi batean.




Erregistroen fitxategi bat daukagu. Erregistroak hiru eremuz osaturik daude: kate bat, zenbaki oso bat eta zenbaki erreal bat. Erregistroen fitxategiaren datu batzuk konstante array batetik hartzen dira. Honako hau da erregistroen fitxategiaren datu-mota:

const
   iKOPURUMAX = 15;
type
   tsKate49 = string[49];
   trdFitxa = record
                 sIzenDeiturak: tsKate49;
                    byDeialdia: byte;      (* osoa, txikia eta positiboa *)
                         rNota: real;
              end ;
   tfrdFitxategi = file of trdFitxa ;

asIZENAK array konstantea da eta horretaz oinarriturik balioak hartuko ditu fitxategiak. Datuen asIZENAK array konstantea alfabetikoki ordenaturik dagoenez, fitxategia ordenaturik egongo da ere. Fitxategia desordenatzeko ardIkasleak eta ardKaotikoak array laguntzaileak erabiliko dira.  




Fitxategiaren edukia ardIkasleak arrayra igaro ondoren, nahasketa burutzen da ardKaotikoak arraya lortzeko. Behin ardKaotikoak arraya daukagula, bere edukia berriro fitxategian gordetzen da. Arrayaren nahasketa ZerrendaNahastu izeneko prozeduran burutzen da eta horretarako datu-mota berezi pare bat sortuko dugu, trdLaguntzaile erregistroa eta tardLaguntzaile arraya. Programaren gainerako tokietan erabilpenik ez dutenez, datu-mota espezifiko horiek ZerrendaNahastu prozedura barruan sortzen dira:

{ bi datu-mota berri sortzen dira, soilik prozedura honetan erabiliko direnak }
procedure ZerrendaNahastu(const ardIkasleak: tardIkasleak;
                                    iLuzera: integer;
                           var ardKaotikoak: tardIkasleak);
type
   trdLaguntzaile = record
                       rdIkaslea: trdFitxa;
                       boGordeta: boolean;
                    end;
   tardLaguntzaile = array[1..iKOPURUMAX] of trdLaguntzaile;
var
   ardLaguntzailea: tardLaguntzaile;
   ...

Fitxategi ordenatu bat desordenatzen duen programa hau izan daiteke:

program KaosaSortzenFitxategiBatean;
uses
   crt; 
const
   iZENBATIKASLE = 12; 
type
   tsKate49 = string[49];
   tasIzenenZerrenda = array[1..iZENBATIKASLE] of tsKate49;
   tarNotenZerrenda = array[1..iZENBATIKASLE] of real;
const
   asIZENAK: tasIzenenZerrenda = ('AGIRRE ROMERO, UNAI',              // 01
                                  'ANGULEMA CARAZO, JON ANDER',       // 02
                                  'BIKARREGI IGLESIAS, JULEN',        // 03
                                  'CANO RUIZ DE HEREDIA, JULIAN',     // 04
                                  'CORRAL EGIA, JOSEBA ANDONI',       // 05
                                  'DIAZ DE ULZURRUN, ROY, LEONOR',    // 06
                                  'EGIGUREN MARKINEZ, IRUNE',         // 07
                                  'ERKIAGA ANDONEGI, IKER',           // 08
                                  'FERNANDEZ FEITO, FELIX',           // 09
                                  'GARTZIA DE ALZA GIL, KATALIN',     // 10
                                  'HERRANZ MARTINEZ, REBECA',         // 11
                                  'IRAGORRI COTANO, MARTIN');         // 12
const
   arNOTAK: tarNotenZerrenda = (4.6,       // 01
                                3.2,       // 02
                                5.7,       // 03
                                4.8,       // 04
                                5.1,       // 05
                                6.1,       // 06
                                7.3,       // 07
                                7.6,       // 08
                                2.8,       // 09
                                9.2,       // 10
                                2.9,       // 11
                                8.5);      // 12                        
type
   trdIkasle = record
                  sNor: tsKate49;
                  rNota: real;
               end;
   tardIkasleak = array[1..iZENBATIKASLE] of trdIkasle;
   
   tsKateLuze = string[199];
   tfrdFitxategi = file of trdIkasle;
 
{ ikasleen izenak eta notak array konstanteetan daude }
procedure FitxategiaSortuEtaBete(sFitxIzen: tsKateLuze; iLuzera: integer);
var
   f: tfrdFitxategi;
   rdIkasleBat: trdIkasle;
   k: integer;
begin
   assign(f, sFitxIzen);
   rewrite(f);
   
   for k:=1 to iLuzera do
   begin
      rdIkasleBat.sNor := asIZENAK[k];
      rdIkasleBat.rNota := arNOTAK[k];
      write(f, rdIkasleBat);
   end;
   
   close(f);
end;
 
{ fitxategiaren edukia pantailaratu }
procedure FitxategiaIkusi(sFitxIzen: tsKateLuze);
var
   f: tfrdFitxategi;
   rdIkasleBat: trdIkasle;
begin
   assign(f, sFitxIzen);
   reset(f);
   
   while not eof(f) do
   begin
      read(f, rdIkasleBat);
      writeln(rdIkasleBat.sNor:57, rdIkasleBat.rNota:15:1);
   end;
   
   close(f);
end;

{ fitxategiaren edukia array batera eraman. iLuzera ez da behar ezaguna delako programa nagusian }
procedure FitxategiArray(sFitxIzen: tsKateLuze; var ardIkasleak: tardIkasleak);
var
   f: tfrdFitxategi;
   rdIkasleBat: trdIkasle;
   k: integer;
begin
   assign(f, sFitxIzen);
   reset(f);
   
   k := 0;
   while not eof(f) do
   begin
      read(f, rdIkasleBat);
      k := k + 1;
      ardIkasleak[k] := rdIkasleBat;
   end;
   
   close(f);
end;

{ arrayaren edukia fitxategian gorde }
procedure ArrayFitxategi(const ardKaotikoak: tardIkasleak; iLuzera: integer; sFitxIzen: tsKateLuze);
var
   f: tfrdFitxategi;
   rdIkasleBat: trdIkasle;
   k: integer;
begin
   assign(f, sFitxIzen);
   rewrite(f);
   
   for k:=1 to iLuzera do
   begin
      rdIkasleBat := ardKaotikoak[k];
      write(f, rdIkasleBat);
   end;
   
   close(f);
end;

{ arrayaren edukia pantailaratu }
procedure DatuakIkusi(const ardIkasleak: tardIkasleak; iLuzera: integer);
var
   k: integer;
begin
   for k:=1 to iLuzera do
   begin
      writeln(k:10, ' . ikaslea: ', ardIkasleak[k].sNor:40, ardIkasleak[k].rNota:10:1);
   end;
end;
 
{ bi datu-mota berri sortzen dira, soilik prozedura honetan erabiliko direnak }
procedure ZerrendaNahastu(const ardIkasleak: tardIkasleak;
                                    iLuzera: integer;
                           var ardKaotikoak: tardIkasleak);
type
   trdLaguntzaile = record
                       rdIkaslea: trdIkasle;
                       boGordeta: boolean;
                    end;
   tardLaguntzaile = array[1..iZENBATIKASLE] of trdLaguntzaile;
var
   ardLaguntzailea: tardLaguntzaile;
   k, iZbk: integer;
begin
   for k:=1 to iLUZERA do
   begin
      ardLaguntzailea[k].boGordeta := FALSE;
   end;
 
   randomize;
   for k:=1 to iLuzera do
   begin
      repeat
         iZbk := random(iLUZERA) + 1;
         //writeln('k=', k:2, '----------');
      until ardLaguntzailea[iZbk].boGordeta = FALSE;
       
      ardLaguntzailea[iZbk].boGordeta := TRUE;
      ardLaguntzailea[iZbk].rdIkaslea := ardIkasleak[k];
   end;
 
   for k:=1 to iLUZERA do
   begin
      ardKaotikoak[k] := ardLaguntzailea[k].rdIkaslea;
   end;
end;  
 
{ ---------------------------------- Programa Nagusia ---------------------------------- }
var
   sFitxIzen: tsKateLuze;
   ardIkasleak: tardIkasleak;
   iLuzera: integer;
   ardKaotikoak: tardIkasleak;
begin
   clrscr;
   writeln;
   writeln;
    
   repeat
      write('Zenbat ikasle dira? (1 eta ', iZENBATIKASLE, ' artean): ');
      readln(iLuzera);
   until (iLuzera >= 1) and (iLuzera <= iZENBATIKASLE);
   writeln;
   
   sFitxIzen := 'C:\Ikasleak.dat';
   FitxategiaSortuEtaBete(sFitxIzen, iLuzera);
   
   writeln('===Fitxategi ordenatuaren edukia===============================================');
   FitxategiaIkusi(sFitxIzen);
   writeln;
    
   FitxategiArray(sFitxIzen, ardIkasleak);
   
   writeln('---Array Laguntzailea Nahastu aurretik-----------------------------------------');
   DatuakIkusi(ardIkasleak, iLuzera);
   writeln;
    
   ZerrendaNahastu(ardIkasleak, iLuzera, ardKaotikoak);
    
   writeln('---Array Laguntzailea Nahastu ondoren------------------------------------------');
   DatuakIkusi(ardKaotikoak, iLuzera);
   writeln;
   
   ArrayFitxategi(ardKaotikoak, iLuzera, sFitxIzen);
   
   writeln('===Fitxategi desordenatuaren edukia============================================');
   FitxategiaIkusi(sFitxIzen);
   writeln;
   writeln;
 
   repeat until keypressed;
end.

 

11. astea | kaosa sortzen (array ordenatu bat desordenatzen)

  kaosa sortzen  

Erregistroen array bat daukagu. Erregistroak bi eremuz osaturik daude kate bat eta zenbaki bat. Erregistroen arrayaren datuak konstante diren bi arrayetatik hartzen dira. Erregistroen arrayaren datu-mota:

const
   iZENBATIKASLE = 10;
type
   tsKate49 = string[49];
   trdIkasle = record
                  sNor: tsKate49;
                  rNota: real;
               end;
   tardIkasleak = array[1..iZENBATIKASLE] of trdIkasle;

asIZENAK eta arNOTAK array konstanteak dira eta horietaz oinarriturik balioak hartuko ditu ardIkasleak arrayak zein alfabetikoki ordenaturik egongo da ere. ardIkasleak arrayaren elementuak posizioz nahastuz lortuko da emaitza den ardKaotikoak arraya.  




Nahasketa burutzen duen ZerrendaNahastu prozeduran datu-mota berezi pare bat sortuko dugu, trdLaguntzaile erregistroa eta tardLaguntzaile arraya. Programaren gainerako tokietan erabilpenik ez dutenez, datu-mota espezifiko horiek ZerrendaNahastu prozedura barruan sortzen dira:

{ bi datu-mota berri sortzen dira, soilik prozedura honetan erabiliko direnak }
procedure ZerrendaNahastu(const ardIkasleak: tardIkasleak;
                                    iLuzera: integer;
                           var ardKaotikoak: tardIkasleak);
type
   trdLaguntzaile = record
                       rdIkaslea: trdIkasle;
                       boGordeta: boolean;
                    end;
   tardLaguntzaile = array[1..iZENBATIKASLE] of trdLaguntzaile;
var
   ardLaguntzailea: tardLaguntzaile;
   ...

Array ordenatu bat desordenatzen duen programa hau izan daiteke:

program KaosaSortzenArrayBatean;
uses
   crt; 
const
   iZENBATIKASLE = 12; 
type
   tsKate49 = string[49];
   tasIzenenZerrenda = array[1..iZENBATIKASLE] of tsKate49;
   tarNotenZerrenda = array[1..iZENBATIKASLE] of real;
const
   asIZENAK: tasIzenenZerrenda = ('AGIRRE ROMERO, UNAI',              // 01
                                  'ANGULEMA CARAZO, JON ANDER',       // 02
                                  'BIKARREGI IGLESIAS, JULEN',        // 03
                                  'CANO RUIZ DE HEREDIA, JULIAN',     // 04
                                  'CORRAL EGIA, JOSEBA ANDONI',       // 05
                                  'DIAZ DE ULZURRUN, ROY, LEONOR',    // 06
                                  'EGIGUREN MARKINEZ, IRUNE',         // 07
                                  'ERKIAGA ANDONEGI, IKER',           // 08
                                  'FERNANDEZ FEITO, FELIX',           // 09
                                  'GARTZIA DE ALZA GIL, KATALIN',     // 10
                                  'HERRANZ MARTINEZ, REBECA',         // 11
                                  'IRAGORRI COTANO, MARTIN');         // 12
const
   arNOTAK: tarNotenZerrenda = (4.6,       // 01
                                3.2,       // 02
                                5.7,       // 03
                                4.8,       // 04
                                5.1,       // 05
                                6.1,       // 06
                                7.3,       // 07
                                7.6,       // 08
                                2.8,       // 09
                                9.2,       // 10
                                2.9,       // 11
                                8.5);      // 12                        
type
   trdIkasle = record
                  sNor: tsKate49;
                  rNota: real;
               end;
   tardIkasleak = array[1..iZENBATIKASLE] of trdIkasle;

{ ikasleen izenak eta notak array konstanteetan daude }
procedure DatuakBildu(var ardIkasleak: tardIkasleak; iLuzera: integer);
var
   k: integer;
begin
   for k:=1 to iLuzera do
   begin
      ardIkasleak[k].sNor := asIZENAK[k];
      ardIkasleak[k].rNota := arNOTAK[k];
   end;
end;

{ ikasleen izenak eta notak array konstanteetan daude }
procedure DatuakIkusi(const ardIkasleak: tardIkasleak; iLuzera: integer);
var
   k: integer;
begin
   for k:=1 to iLuzera do
   begin
      writeln(k:10, ' . ikaslea: ', ardIkasleak[k].sNor:40, ardIkasleak[k].rNota:10:1);
   end;
end;

{ bi datu-mota berri sortzen dira, soilik prozedura honetan erabiliko direnak }
procedure ZerrendaNahastu(const ardIkasleak: tardIkasleak;
                                    iLuzera: integer;
                           var ardKaotikoak: tardIkasleak);
type
   trdLaguntzaile = record
                       rdIkaslea: trdIkasle;
                       boGordeta: boolean;
                    end;
   tardLaguntzaile = array[1..iZENBATIKASLE] of trdLaguntzaile;
var
   ardLaguntzailea: tardLaguntzaile;
   k, iZbk: integer;
begin
   for k:=1 to iLUZERA do
   begin
      ardLaguntzailea[k].boGordeta := FALSE;
   end;

   randomize;
   for k:=1 to iLuzera do
   begin
      repeat
         iZbk := random(iLUZERA) + 1;
      until ardLaguntzailea[iZbk].boGordeta = FALSE;
      
      ardLaguntzailea[iZbk].boGordeta := TRUE;
      ardLaguntzailea[iZbk].rdIkaslea := ardIkasleak[k];
   end;

   for k:=1 to iLUZERA do
   begin
      ardKaotikoak[k] := ardLaguntzailea[k].rdIkaslea;
   end;
end;  

{ ---------------------------------- Programa Nagusia ---------------------------------- }
var
   ardIkasleak: tardIkasleak;
   iLuzera: integer;
   ardKaotikoak: tardIkasleak;
begin
   clrscr;
   
   repeat
      write('Zenbat ikasle dira? (1 eta ', iZENBATIKASLE, ' artean): ');
      readln(iLuzera);
   until (iLuzera >= 1) and (iLuzera <= iZENBATIKASLE);
   
   DatuakBildu(ardIkasleak, iLuzera);    { izenak eta notak ez dira parametro, konstante direlako }
   writeln;
   
   writeln('--Nahastu aurretik----------------------------------------------------------');
   DatuakIkusi(ardIkasleak, iLuzera);
   writeln;
   
   ZerrendaNahastu(ardIkasleak, iLuzera, ardKaotikoak);
   
   writeln('--Nahastu ondoren-----------------------------------------------------------');
   DatuakIkusi(ardKaotikoak, iLuzera);
   writeln;

   repeat until keypressed;
end.

 

11. astea | erregistroen bektore baten elementuak ezabatu

Elementuak ezabatu bi algoritmo desberdinez Ikasleen informazioa biltzen duen bektore bat daukagu. Ikasle bakoitzaren informazioa izena eta adina dira. Ikasleen izenak ez dira errepikatzen eta horregatik BektoreaDatuzBete prozedurak fniIkasleaBilatu funtzioa darabil konprobatzeko onartuko duen ikaslea benetan berria den. Bektorea datuz horniturik dagoenen bi ezabaketa egiten dira: Ikasle baten izenaren hasiera A bada, ikasle hori zerrendatik kenduko da (ez da array laguntzailerik erabiltzen) Ikasle bat gaztea denean, bere adina mediatik behera dagoelako, ikasle hori zerrendatik kenduko da (array laguntzaile bat erabiltzen da) Bukatu aurretik ikasle berri baten datuak zerrendara eramaten dira. Lehenik tokirik dagoela konprobatzen da, gero ikasle berriaren posizioa zein den eskatzen da eta, azkenean, ikasle berriaren datuak jaso ondoren, erregistro hori dagokion posizioan zerrendan txertatzen da.

program IzenakEtaAdinakKendu ;
const
  BEHEMUGA = 1 ;
  GOIMUGA = 25 ;
  
type
   tsKatea = string[15] ;
   trdIkaslea = record
                   sIzena: tsKatea ;
                   iAdina: integer ;
                end ;
   tardZerrenda = array[BEHEMUGA..GOIMUGA] of trdIkaslea ;
  
  
function fniIkasleaBilatu(const ardIkasgela: tardZerrenda; 
                                    iLuzera: integer;
                                     sGakoa: tsKatea) : integer ;
var
   k: integer ;
   boAurkitua: boolean ;
begin
   k := BEHEMUGA ;
   boAurkitua := FALSE ;
   while (k <= iLuzera) and not boAurkitua do
   begin
      if UpCase(ardIkasgela[k].sIzena) = UpCase(sGakoa) then
        boAurkitua := TRUE
      else
        k := k+1 ;
   end ;
 
   if boAurkitua then
     fniIkasleaBilatu := k
   else
     fniIkasleaBilatu := -1 ;    { -1 gezurrezko posizioa litzateke }
end ;
 
  
procedure BektoreaDatuzBete(var ardIkasgela: tardZerrenda;
                                var iLuzera: integer) ;
var
    k, iPosizioa: integer ;
    sNor: tsKatea ;
begin
   repeat
      write('Ikasleen kopurua eman: ') ;
      readln(iLuzera) ;
   until (iLuzera >= BEHEMUGA) and (iLuzera <= GOIMUGA) ;
  
   writeln ;
   writeln('Ikaslen izenak ez dira errepikatzen') ;
   writeln ;
    
   for k:=BEHEMUGA to iLuzera do
   begin
      repeat
         write('Eman ', k, '. ikaslearen izena: ') ;
         readln(sNor) ;
         iPosizioa := fniIkasleaBilatu(ardIkasgela, iLuzera, sNor) ;
         if iPosizioa <> -1 then
            writeln(sNor, ' izeneko ikaslerik badago ', iPosizioa, ' posizioan') ;
      until iPosizioa = -1 ;
       
      ardIkasgela[k].sIzena := sNor ;
      write('Eman ', k, '. ikaslearen adina: ') ;
      readln(ardIkasgela[k].iAdina) ;
   end ;
end ;
  
  
procedure BektorearenEdukiaIkusi(const ardIkasgela: tardZerrenda;
                                           iLuzera: integer) ;
var
    k: integer ;
begin
   for k:=BEHEMUGA to iLuzera do
   begin
      write(k, '. ikaslea: ', ardIkasgela[k].sIzena:15) ;
      writeln(ardIkasgela[k].iAdina:20, ' urte') ;
   end ;
end ;
  
 
procedure ElementuBatEzabatu(var ardIkasgela: tardZerrenda;
                                 var iLuzera: integer;
                                           k: integer) ;
var
   iIndizea: integer ;
begin
   for iIndizea:=k to iLuzera-1 do
   begin
      ardIkasgela[iIndizea] := ardIkasgela[iIndizea+1] ;
   end ;
   iLuzera := iLuzera - 1 ;
end ;
  
  
function fnboIzenarenHasiera_A_Da(const rdIkasleBat: trdIkaslea) : boolean ;
begin 
   if (rdIkasleBat.sIzena[1] = 'A') OR
      (rdIkasleBat.sIzena[1] = 'a') then
      fnboIzenarenHasiera_A_Da := TRUE
   else
      fnboIzenarenHasiera_A_Da := FALSE ;
end ;
  
 
function fnrBatezbestekoaKalkulatu(const ardIkasgela: tardZerrenda;
                                             iLuzera: integer) : real ;
var
    k: integer ;
    rMetagailua: real ;
begin
   rMetagailua := 0.0 ;
   for k:=BEHEMUGA to iLuzera do
   begin
      rMetagailua := rMetagailua + ardIkasgela[k].iAdina ;
   end ;
    
   fnrBatezbestekoaKalkulatu := rMetagailua/iLuzera ;
end ;
 
  
procedure IkasleGazteakEzabatu(var ardIkasgela: tardZerrenda;
                                   var iLuzera: integer;
                                rBatezBestekoa: real) ;
var
   ardLaguntzailea: tardZerrenda;
   iZenbatIkasle, k: integer;
begin
   iZenbatIkasle := 0 ;
   for k:=BEHEMUGA to iLuzera do
   begin
      if ardIkasgela[k].iAdina >= rBatezBestekoa then
      begin
         iZenbatIkasle := iZenbatIkasle + 1 ;
         ardLaguntzailea[iZenbatIkasle] := ardIkasgela[k] ;
      end ;
   end ;
 
   ardIkasgela := ardLaguntzailea ;
   iLuzera := iZenbatIkasle ;
end ;


procedure IkasleBatenDatuakJaso(var rdIkasleBat: trdIkaslea) ;
begin
   write('Eman ikaslearen izena: ') ;
   readln(rdIkasleBat.sIzena) ;
   write('Eman ikaslearen adina: ') ;
   readln(rdIkasleBat.iAdina) ;
end ;


procedure IkasleBatTxertatu(var ardIkasgela: tardZerrenda;
                                var iLuzera: integer;
                            const rdIkaslea: trdIkaslea;
                                       iNon: integer) ;
var
   k: integer ;
begin
   for k:=iLuzera downto iNon do
   begin
      ardIkasgela[k+1] := ardIkasgela[k] ;
   end ;
   ardIkasgela[iNon] := rdIkaslea ;
   iLuzera := iLuzera + 1 ;
end ;


{=============Programa nagusia eta programa nagusiko aldagaiak=============}
var
  ardIkasgela: tardZerrenda ;
  iLuzera, k: integer ;
  rBatezBestekoa: real ;
  iNon: integer ;
  rdIkasleBerria: trdIkaslea ;
begin
   writeln('------------------------------------------------') ;
   writeln ;
   BektoreaDatuzBete(ardIkasgela, iLuzera) ;
   writeln ;
   BektorearenEdukiaIkusi(ardIkasgela, iLuzera) ;
 
   k := BEHEMUGA ;           (* for k:=BEHEMUGA to iLuzera do *)
   while k <= iLuzera do     (* txarto egongo litzateke *) 
   begin
      if fnboIzenarenHasiera_A_Da(ardIkasgela[k]) then
         ElementuBatEzabatu(ardIkasgela, iLuzera, k)
      else
         k := k+1 ;
   end ;
  
   writeln ;
   writeln('Izenaren hasiera A denean ikasleak zerrendatik kendu ostean:') ;
   BektorearenEdukiaIkusi(ardIkasgela, iLuzera) ;
  
   writeln ;
   rBatezBestekoa := fnrBatezbestekoaKalkulatu(ardIkasgela, iLuzera) ;
   writeln('BatezBestekoa = ', rBatezBestekoa:0:3);
     
   IkasleGazteakEzabatu(ardIkasgela, iLuzera, rBatezBestekoa) ;
     
   writeln('Mediatik beherako adina duten ikasleak zerrendatik kendu ostean:') ;
   BektorearenEdukiaIkusi(ardIkasgela, iLuzera) ;  
     
   writeln ;
   writeln('Ikasle berri baten datuak zerrendan gorde:') ;
   if iLuzera < GOIMUGA then
   begin
      repeat
         write('Eman ikasle berriaren posizioa zerrendan (') ;
         write(BEHEMUGA, ' eta ', iLuzera, ') artekoa: ') ;
         readln(iNon) ;
      until (iNon >= BEHEMUGA) and (iNon <= iLuzera) ;

      IkasleBatenDatuakJaso(rdIkasleBerria) ;
      IkasleBatTxertatu(ardIkasgela, iLuzera, rdIkasleBerria, iNon) ;
      BektorearenEdukiaIkusi(ardIkasgela, iLuzera) ;
   end
   else
   begin
      writeln('Zerrenda beterik dago, ezin da ikasle berririk sartu.') ;
   end ;

   writeln ;
   writeln ;
   writeln('Amaituta!----------------------------------------') ;
   readln ;
end. { Programaren bukaera }

 

11. astea | erregistroen bi bektore nahastu bektore bakar batean

Erregistroen bi bektore nahastu bakarra lortuz Laborategiko gelan, gehienez, 25 ikasle izango dira. Ikasleen datuak bi bektoretan biltzen dira, bektore bat lehen azterketari dagokio eta beste bektorea bigarren azterketari dagokio. Bektoreen elementuak kateak dira, eta bertan izena eta zenbaki bat daude / batez banaturik aurkitzen direlarik, zenbakien kopuru maximoa 9.9 izango eta minimoa 0.0 izango da. Datuak teklatuaren bitartez ematen dira eta ikasleen posizioak bektoretan zaindu behar dira berdinak izan daitezan, hurrengo adibidean erakusten den bezala: Josu ikaslea lehena da abiapuntuko array bietan. asAzterketa1 eta asAzterketa2 abiapuntuko bektoreak dira eta ardAzterketak bektorea da lortu behar dena. Hona hemen datuen adibide bat: asAzterketa1 ‘Josu/6.1’ ‘Ane/7.6’ ‘Mikel/2.7’ 1 2 3 asAzterketa2 ‘Josu/6.9’ ‘Ane/5.4’ ‘Mikel/6.3’ 1 2 3 iLuzera 3 ardAzterketak ‘Josu’ ‘Josu’ ‘Ane’ ‘Ane’ ‘Mikel’ ‘Mikel’ 6.1 6.9 7.6 5.4 2.7 6.3 1 2 3 4 5 6 iZenbat 6 ardAzterketak bektorea lortu ondoren zenbait operazio egingo dira. Hona hemen erabilgarri dauzkazun programa nagusia eta azpiprogramen goiburukoak: program ErregistroenBiArrayNahasten_1 ; const    BEHEMUGA = 1 ;    GOIMUGA1 = 25 ; type    tsKatea = string[30] ;    tasAzterketa = array[BEHEMUGA..GOIMUGA1] of tsKatea ; procedure DatuakSartu(var asAzterketa: tasAzterketa;                           VAR iLuzera: integer) ; begin end ; procedure DatuakIkusi(const asAzterketa: tasAzterketa;                                 iLuzera: integer) ;  begin end ; { =================================================================== } var    asAzterketa1, asAzterketa2: tasAzterketa ;    iLuzera: integer ; begin    writeln('1. azterketa:') ;    DatuakSartu(asAzterketa1, iLuzera) ;    writeln ;    writeln('1. azterketaren ') ;    DatuakIkusi(asAzterketa1, iLuzera) ;    writeln ;    writeln('2. azterketa:') ;    DatuakSartu(asAzterketa2, iLuzera) ;   (* datuak egoki sartzera  *)    writeln ;                              (* guztiz behartuta gaude *)    writeln('2. azterketaren ') ;    DatuakIkusi(asAzterketa2, iLuzera) ;    writeln ;    { hemen idatzi ariketan eskatzen dena }    writeln('Programa amaitzera doa.') ;    readln ; end. Ariketa honen enuntziatu inprimagarria hemendik hartu, ariketaren planteamendua eta lehen urratsak programa-iturburu honetan daude ErregistroenBiArrayNahastenEMATEKOA.PAS. Honako hauek egin: ardAzterketak arrayarekin lan eginez, ikasgelako ikasle baten izena eman (Ane adibidez) eta kalifikazioa orokorra erakutsi (bere noten batezbesteko aritmetikoa) ardAzterketak arrayarekin lan eginez, lehen azterketako kalifikazioetatik lortzen den batezbesteko aritmetikoa kalkulatu ardAzterketak arrayarekin lan eginez, bigarren azterketako kalifikazioetatik lortzen den batezbesteko aritmetikoa kalkulatu ardAzterketak arrayarekin lan eginez, nork lortu du notarik onena eta zein azterketan gertatu da ardAzterketak arrayarekin lan eginez, ikasgelako ikasle baten izena eman (Ane adibidez) eta aurkitzen bada bere kalifikazioak aldatu ardAzterketak arrayarekin lan eginez, ikasgelako ikasle baten izena eman (Ane adibidez) eta aurkitzen bada arraytik ezabatu ardAzterketak arrayarekin lan eginez, ikasle aprobatuen zerrenda erakutsi pantailan (ikasle bat aprobatuko du bere nota biren batezbesteko artrmetikoa 5.0 edo handiagoa bada) ardAzterketak arrayarekin lan eginez, arraya ordenatu/sailkatu ikasleen izenen arabera ardAzterketak arrayarekin lan eginez, ... Ariketa honek begi bistako hobekuntza du datuak ematerako prozeduretan: bigarren azterketako asAzterketa2 bektorea betetzean lehen azterketako asAzterketa1 bektorearen informazioa aintzat hartu, adibidez  prozedura DatuakSartuAurrekoakAintzatHarturik(asAzterketa1, iLuzera, asAzterketa2) idatziz non hiru parametroen jokamoldea sarrera-sarrera-irteera den. program ErregistroenBiArrayNahasten_1 ; const    BEHEMUGA = 1 ;    GOIMUGA1 = 25 ; type    tsKatea = string[30] ;    tasAzterketa = array[BEHEMUGA..GOIMUGA1] of tsKatea ; procedure LehenArrayarenDatuakSartu(var asAzterketa: tasAzterketa;                                         var iLuzera: integer) ;  begin end ; procedure DatuakIkusi(const asAzterketa: tasAzterketa;                                 iLuzera: integer) ; begin end ; procedure DatuakSartuAurrekoakAintzatHarturik(const asAzterketa1: tasAzterketa;                                                          iLuzera: integer;                                                 var asAzterketa2: tasAzterketa) ;  begin end ; { --------------------------------------------------------------------------------------------------------------------------------- } var    asAzterketa1, asAzterketa2: tasAzterketa ;    iLuzera: integer ; begin    writeln('1. azterketa:') ;    LehenArrayarenDatuakSartu(asAzterketa1, iLuzera) ;    writeln ;    writeln('1. azterketaren ') ;    DatuakIkusi(asAzterketa1, iLuzera) ;    writeln ;    DatuakSartuAurrekoakAintzatHarturik(asAzterketa1, iLuzera,  asAzterketa2) ;      writeln('2. azterketaren ') ;    DatuakIkusi(asAzterketa2, iLuzera) ;    writeln ;    { hemen idatzi ariketan eskatzen dena }    writeln('Programa amaitzera doa.') ;    readln ; end.

Erregistroen bi bektore nahastu (emaitza) Ariketa gehienetan bezala, ariketa honek emaitza bakarra ez du, jarraian bi soluzio ematen dira. Soluzio biren arteko aldea hasierako arrayak betetzean datza. Lehen soluzioan, azterketa biren arrayak betetzeko DatuakSartu prozedura beraren bitartez egiten da.  Bigarren soluzioan, lehen azterketaren arraya betetzeko LehenArrayarenDatuakSartu prozedura erabiltzen da zein DatuakSartu prozedura bezalakoa den; baina bigarren azterketaren arraya betetzeko, ez da DatuakSartu prozedura aplikatzen DatuakSartuAurrekoakAintzatHarturik prozedura baizik, zein LehenArrayarenDatuakSartu prozeduran emaniko datuetan oinarritzen den. Hona hemen bi soluzioak: ErregistroenBiArrayNahasten1.pas ErregistroenBiArrayNahasten2.pas

Hauxe da laborategian programatu dugun emaitza:

 emaitza laster...  




 

11. astea | NxM taula erregistroekin

 emaitza laster...

11. astea | erregistroen bektore bat lortu

Laborategiko gela batean, gehienez, 25 ikasle izango dira. Ikasleen datuak bektore batean biltzen dira. Bektorearen elementuak kateak izanik bertan izena eta zenbaki bat daude koma batez banaturik, honela adibidez:

Lehen zeregina erregistroen bektore baliokidea lortzea da, bektore hau hain zuzen ere:

Horretarako, ezinbestekoa da datu-motak era egokian definitzea. Ondoko irudian erakusten da programatzaile batek egindako datu-mota definizioa:

---

Ikasle baten bilaketa egin hasierako bektorean (karaktere kateak gordetzen dituen bektorean), eta ondoren ikasle baten bilaketa egin bukaerako bektorean (erregistroak gordetzen dituen bektorean). Ariketa honen enuntziatu inprimagarria hemendik hartu eta hauxe da programa ErregistroenBektoreBatLortu.PAS.



Programa hori abiapuntuz harturik funtzionalitate gehiago gehituko dizkiozu: bektore berria ordenatu noten arabera, bektore berria ordenatu izenen arabera, elementu bat kendu bektore berritik, elementu bat txertatu bektore berrian...



 

11. astea | erregistroen array bat

Ikasgelako ikasle kopuru maximoa 80 izanik, bildu array batean ikasleen informazio hau:

 

Hona hemen balizko soluzio bat:

program ErregistroenArrayBat ;

const
   BEHEMUGA = 1 ;
   GOIMUGA = 25 ;
   
type
   tsKate39 = string[39] ;
   tsKate99 = string[99] ;
   
   trdIkasle = record
                  sIzena   : tsKate39 ;
                  rNota    : real ;
                  sHelbidea: tsKate99 ;
                  byAdina  : byte ;
               end ;

   tardGela = array[BEHEMUGA..GOIMUGA] of trdIkasle ;


procedure IkasleBatHartu(var rdIkasle: trdIkasle) ;
begin
   write('Ikaslearen izena eman: ':30) ;
   readln(rdIkasle.sIzena) ;
   write('Ikaslearen nota eman: ':30) ;
   readln(rdIkasle.rNota) ;
   write('Ikaslearen helbidea eman: ':30) ;
   readln(rdIkasle.sHelbidea) ;
   write('Ikaslearen adina eman: ':30) ;
   readln(rdIkasle.byAdina) ;
end ;


procedure ArrayaBete(var ardGela: tardGela; var iLuzera: integer) ;
var
   k: integer ;
begin
   repeat
      write('Zenbat ikasle dira? ') ;
      readln(iLuzera) ;
   until (iLuzera >= BEHEMUGA) and (iLuzera <= GOIMUGA) ;
   
   for k:=BEHEMUGA to iLuzera do
   begin
      writeln(k, '. ikaslearen datuak hartzen.') ;
      IkasleBatHartu(ardGela[k]) ;
      writeln ;
   end ;
end ;


procedure IkasleBatErakutsi(const rdIkasle: trdIkasle) ;
begin
   writeln('Ikaslearen izena: ':25, rdIkasle.sIzena) ;
   writeln('Ikaslearen nota: ':25, rdIkasle.rNota:0:2) ;
   writeln('Ikaslearen helbidea: ':25, rdIkasle.sHelbidea) ;
   writeln('Ikaslearen adina: ':25, rdIkasle.byAdina) ;
end ;


procedure ArrayaIkusi(const ardGela: tardGela; iLuzera: integer) ;
var
   k: integer ;
begin
   for k:=BEHEMUGA to iLuzera do
   begin
      IkasleBatErakutsi(ardGela[k]) ;
      writeln ;
   end ;
end ;

{ ------------------- PROGRAMA NAGUSIA ------------------- }

var
   ardGela: tardGela ;
   iLuzera: integer ;    

begin
   writeln('//////////////////////////////////////') ;
   writeln ;
	
   writeln('Gelako datuak jaso.') ;
   ArrayaBete(ardGela, iLuzera) ;
   writeln ;
   
   writeln('Gelako datuak ikusi.') ;
   ArrayaIkusi(ardGela, iLuzera) ;
   writeln ;
   
   writeln('Lehen ikaslearen adina ', ardGela[BEHEMUGA].byAdina, ' da.') ;
   writeln('Azken ikaslearen izena ', ardGela[iLuzera].sizena, ' da.') ;

   writeln ;
   writeln('//////////////////////////////////////') ;
   readln ;
end.

RECORD datu-mota

DEFINIZIOA RECORD edo erregistro datu-mota, ataletan antolatzen den datu-mota egituratua da. Erregistro batek dituen elementuak eremuak deitzen dira eta eremuen datu-mota desberdinak izan daitezke elkarrekiko, erregistroaren elementu kopurua finitua da eta eremu bakoitzaren atzipena identifikadore baten bitartez gauzatzen da.

ESKEMA

DATU-MOTA SORTZEN Erregistro datu-mota bat deklaratzean, eremuak izendatzeko identifikadorea erabaki behar da eta eremu bakoitza zein datu-motatakoa izango den. Eskeman erakusten den rdIkaslea delako aldagaia lortzeko, aurretik deklarazio hau egin beharko da: ...         type trdIkasle = record sIzena: string[39] ; rNota: real ; sHelbidea: string[99] ; byAdina: byte ; end ; var rdIkaslea: trdIkasle ; rdIrakaslea: trdIkasle ; ... Ondorioz rdIkaslea eta rdIrakaslea bi aldagaiak datu-mota bera daukate oinarrian eta biak bat datoz goi-goian erakutsi den eskemarekin. Erregistro aldagai batean datuak gordetzeko, aldagaiaren identifikadorea eta eremuaren identifikadorea idatzi behar dira horien artean lokailu bat jarri beharra dago. Pascal lengoaiak identifikadore biren arteko elkarketa gauzatzeko puntu bat darabil, horrelaxe: writeln(rdIkaslea.sIzena) ; readln(rdIkaslea.rNota) ; Puntua ken daiteke WITH klausula erabiltzen bada, aurreko aginduak honelaxe idatziko lirateke: with rdIkaslea do begin        writeln(sIzena) ;        readln(rNota) ; end ;

ERAGIKETAK: IDATZI-IRAKURRI ETA ESLEIPENA Erregistro bat ezin daiteke ez irakurri ez idatzi, horregatik ondoko aginduak okerrak dira: writeln(rdIkaslea) ;     { HAU GAIZKI DAGO } readln(rdIrakaslea) ;    { HAU GAIZKI DAGO } Aurreko adibidearen erregistroaren eremuak idatz edo irakur daiteke, eta ondorioz agindu hauek zuzenak dira: writeln(rdIkaslea.sIzena) ; readln(rdIkaslea.rNota) ; Erregistro bati aplika dakioken eragiketa bakarra esleipena da, ondoko agindu hau zuzena da: rdIkaslea := rdIrakaslea ;

ERAGIKETAK: KONPARAKETAK Esan den bezala, erregistroek onartzen duten eragiketa bakarra asignazioa da. Hori dela eta, ezin daiteke erregistroen arteko konparaziorik egin. Labur azalduz: 6 konparatzaileetatik lau hauek ez dute zentzu handirik erregistroekin: <, >, <= eta >= 6 konparatzaileetatik beste biek (= eta <>) zentzua izan dezakete erregistroekin baina bi erregistroen arteko alderaketa ezin daiteke honela egin: if rdIkasle1 = rdIkasle2 then   { HAU GAIZKI DAGO } if rdIkasle1 <> rdIkasle2 then  { HAU GAIZKI DAGO } Horregatik erregistro bik informazio berdina gordetzen dutela frogatzeko eremuka lan egingo da. Konparaketa helburu horrekin, ErregistroBiBerdinakOteDiren izeneko adibidean, funtzio boolear bat garatu da.

ERREGISTROAK ETA ARRAYAK Sarritan erregistroak eta arrayak elkarrekin konbinatzen dira. Esate baterako, jarraian erregistroen array bat deklaratzen da:  ...         type trdIkasle = record sIzena: string[39] ; rNota: real ; end ; tardTalde = array[1..80] of trdIkasle ; var ardIkasgela: tardTalde ; iLuzera: integer ; Indize: integer ; ... Datuak sartu eta eskema bat eginez: Datuak sartu ondoren, ikusi nola eskuratuko genukeen irudiko P hori. Honelaxe zehaztuko genuke: ardIkasGela arraytik abiatuta Indize aldagaiak 2 balioa duelarik, arrayaren bigarren elementu hau ardIkasGela[2]erregistro bat da... eta sIzena eremua hartzean, hots, ardIkasGela[2].sIzena string bat da... eta string horren bere lehen karakterea eskuratzeko ardIkasGela[2].sIzena[1]erabiliko dugu

ARRAYAK ERREGISTROETAN Erregistro baten eremu bat array bat izan daiteke. Esate baterako, jarraian array bat daukan erregistro bat deklaratzen da: ...         type tasKateak = array [1..3] of string[39] ; trdIkasle = record asIzenDeiturak: tasKateak ; rNota: real ; end ; var rdIkaslea: trdIkasle ; ... Datuak sartu eta eskema bat eginez: Datuak sartu ondoren, ikusi nola eskuratuko genukeen irudiko M hori. Honelaxe zehaztuko genuke: rdIkaslea erregistrorik abiatuta rdIkaslea.asIzenDeiturak array bat da eta... bere hirugarren elementua rdIkaslea.asIzenDeiturak[3]izanik, badakigu string bat dela eta bere lehen karakterea eskuratzeko rdIkaslea.asIzenDeiturak[3][1]erabiliko dugu

ERREGISTROAK ERREGISTROETAN Erregistro baten eremu bat beste erregistro bat izan daiteke. Esate baterako, ikusi jarraian nola deklaratzen den DM_rdLangile erregistroa bere barnean DM_rdData erregistroa daukana: ...         type DM_rdData = record iUrtea: integer ; byHilea: byte ; byEguna: byte ; end ; DM_rdLangile = record sIzena : string[39] ; cKategoria : char ; rdJaioteguna : DM_rdData ; rdAintzinatasuna: DM_rdData ; end ; var rdMekanikoa: DM_rdLangile ; ... Datu-motaren eskema bat eginez: rdMekanikoa aldagaian datuak sartzeko bi bide ditugu. Puntu konektorea birritan erabili edo bestela WITH klausula erabili. Ondoko esleipenak zuzenak dira eta edozein modutan irudian erakusten den emaitza lortuko dugu: Puntu lokailua birritan erabiliz: ...         rdMekanikoa.sIzena := 'Alain' ; rdMekanikoa.cKategoria := 'B' ; rdMekanikoa.rdJaioteguna.iUrtea := 1975 ; rdMekanikoa.rdJaioteguna.byHilea := 11 ; rdMekanikoa.rdJaioteguna.byEguna := 27 ; rdMekanikoa.rdAintzinatasuna.iUrtea := 1997 ; rdMekanikoa.rdAintzinatasuna.byHilea := 10 ; rdMekanikoa.rdAintzinatasuna.byEguna := 30 ; ... WITH klausularen bitartez aurreneko rdMekanikoa. zatia ken daiteke: ...         with rdMekanikoa do begin sIzena := 'Alain' ; cKategoria := 'B' ; rdJaioteguna.iUrtea := 1975 ; rdJaioteguna.byHilea := 11 ; rdJaioteguna.byEguna := 27 ; rdAintzinatasuna.iUrtea := 1997 ; rdAintzinatasuna.byHilea := 10 ; rdAintzinatasuna.byEguna := 30 ; end ; ... WITH klausulak onartzen du bigarren puntua kentzea. Datu-motaren definizioaren arabera WITH klausula erabiltzean kontuz ibili behar da; esate baterako, aurreko adibidean ezinezkoa zaigu puntu konektorea kentzea rdAintzinatasuna identifikadorearekin lan egitean: ...         with rdMekanikoa, rdJaioteguna do begin sIzena := 'Alain' ; cKategoria := 'B' ; iUrtea := 1975 ; byHilea := 11 ; byEguna := 27 ; rdAintzinatasuna.iUrtea := 1997 ; rdAintzinatasuna.byHilea := 10 ; rdAintzinatasuna.byEguna := 30 ; end ; ... WITH klausulak ebaluatu behar dituen erregistroak aldatuz (rdMekanikoa eta rdAintzinatasuna idazten badira) puntuak horrela jarri beharko lirateke: ...         with rdMekanikoa, rdAintzinatasuna do begin sIzena := 'Alain' ; cKategoria := 'B' ; rdJaioteguna.iUrtea := 1975 ; rdJaioteguna.byHilea := 11 ; rdJaioteguna.byEguna := 27 ; iUrtea := 1997 ; byHilea := 10 ; byEguna := 30 ; end ; ... Erregistro batek beste erregistro bat duenaren adibibide hau aztertu: ErregistroakErregistroetan_WITH.pas

PARAMETRO IZATEAN JOKAMOLDEA Erregistro bat datu-mota egituratua delako, beti erreferentziaz pasatuko dugu azpiprogrametara. Horregatik, azpiprograma batean honela agertuko da jokamoldearen arabera: Irteerakoa denean parametro formalak VAR marka izango du aurrean Sarrerakoa denean parametro formalak CONST marka izango du aurrean Gogoratu arrayek modu beretsuan jokatzen zutela.

ERREGISTRO BAT ITZULTZEN DUEN AZPIPROGRAMA: FUNTZIOA EDO PROZEDURA Demagun erregistro baten eremuak azpiprograma baten barruan datuz betetzen direla eta azpiprogramak erregistroa programa nagusira itzuli egiten duela. Zer azpiprograma mota erabiliko dugu, funtzioa ala prozedura? Deiak hauek lirateke: ErregistroaBete(rdIkaslea) ;          { prozedura BAI } rdIkaslea := fnrdErregistoaBete ;     { funtzioa EZ } Prozesaketa batean erregistro bat aldatzeko, ez dugu funtziorik erabiliko. Erregistro bat azpiprograma baten bitartez prozesatzean aldatuko bada, beti prozedura erabiliko dugu. Gogoratu galdera bera arrayekin berdin erantzuten zela. Egoera biak hemen adierazten dira: Datu-mota eta azpiprogramak.

ADIBIDEAK Hona hemen erregistroen zenbait programa: Erregistroen array bat Erregistroen bektore bat lortu NxM taula erregistroekin Erregistroen bi bektore nahastu bektore bakar batean Bektore baten elementuak ezabatu Kaosa sortzen (array ordenatu bat desordenatzen)

INTEGER

REAL

BOOLEAN

CHAR

STRING

ARRAY

RECORD

FILE