10. astea | izenen eta noten taula

asTaula hiru dimentsiotako taula bat da, kateak gorde ditzakeen asTaula arrayak 40 errenkada eta 3 zutabe ditu. Errenkada bakoitza ikasle bati dagokio: Errenkadaren lehen zutabean izena biltegitzen da, bigarrenean abizena eta hirugarren zutabean ikaslearen nota gordetzen da (hirurak string[19] datu-motakoak). Teoriako blogean gehiago...

 

10. astea | elkar trukatu

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

Datua den zenbaki erreal bat 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, erabili beharko dituen moldapenak eginez.

 

{ Zenbaki erreal desberdinez array bat elikatu ondoren, minimoaren eta }
{ maximoaren posizioak lortu bi haien arteko lekuak elkar trukatzeko.  }
program ElkarTrukatu;
uses
   crt;

const
   iBEHEMUGA = 1;
   iGOIMUGA = 20;

type
   tarZerrenda = array[iBEHEMUGA..iGOIMUGA] of real;


function fniBilatu(const arZerrenda: tarZerrenda;
                            iZenbat: integer;
                             rGakoa: real): integer;
var
   iKontagailu: integer;
   boAurkitua: boolean;
begin
   iKontagailu := iBEHEMUGA;
   boAurkitua := FALSE;
   while (iKontagailu <= iZenbat) and not boAurkitua do
   begin
      if arZerrenda[iKontagailu] = rGakoa then
      begin
         writeln(rGakoa:0:1, ' balioa ', iKontagailu:2, ' posizoan dago!');
         boAurkitua := TRUE;
      end
      else
      begin 
         writeln(rGakoa:0:1, ' bilatzen, ', iKontagailu:2, '. elementuarekin ez du bat egiten, hurrengoa aztertu!');
         iKontagailu := iKontagailu + 1;
      end;
   end;
   
   if boAurkitua then
   begin
      fniBilatu := iKontagailu;
      writeln(rGakoa:0:1, ' balioa badago arrayan. Beste balio batekin saiatu!'); 
   end
   else
   begin
      fniBilatu := 0;
      writeln(rGakoa:0:1, ' balioa berria da eta ', iZenbat+1, '. posizioan kokatuko da');
   end;
   writeln;
end;


procedure ArrayaDatuDesberdinezBete(var arZerrenda: tarZerrenda;
                                       var iLuzera: integer);
var
   iKont: integer;
   rZbk: real;
begin
   randomize;
   iLuzera := random(iGOIMUGA) + 1;      { iBEHEMUGA eta iGOIMUGA arteko balioak }
   //writeln('iLuzera=', iLuzera);
   
   arZerrenda[iBEHEMUGA] := random(10) + 0.1*random(2);   { 0.0, 0.1, 1.0, 1.1, ... 8.0, 8.1, 9.0, 9.1 arteko balioak }
   writeln('1. datua = ', arZerrenda[iBEHEMUGA]:0:1);
   writeln;
   for iKont:=iBEHEMUGA+1 to iLuzera do
   begin     
      repeat 
         rZbk := random(10) + 0.1*random(2);             { 0.0, 0.1, 1.0, 1.1, ... 8.0, 8.1, 9.0, 9.1 arteko balioak }
      until fniBilatu(arZerrenda, iKont-1, rZbk) = 0;
      arZerrenda[iKont] := rZbk;
   end;
end;


procedure ArrayarenEdukiaIkusi(const arZerrenda: tarZerrenda;
                                        iLuzera: integer);
var
   iKont: integer;
begin   
   for iKont:=iBEHEMUGA to iLuzera do
   begin     
      writeln(iKont:10, '. elementua = ', arZerrenda[iKont]:0:1);
   end;
   writeln;
end;


function fniArrayarenMaximoaNon(const arZerrenda: tarZerrenda;
                                         iLuzera: integer): integer;
var
   iKont, iMaxNon: integer;
   rMaximoa: real;
begin 
   iMaxNon := iBEHEMUGA;
   rMaximoa := arZerrenda[iBEHEMUGA];
   for iKont:=iBEHEMUGA+1 to iLuzera do
   begin
      if arZerrenda[iKont] > rMaximoa then
      begin
         iMaxNon := iKont;
         rMaximoa := arZerrenda[iKont];
      end;
   end;
   fniArrayarenMaximoaNon := iMaxNon;
end;


function fniArrayarenMinimoaNon(const arZerrenda: tarZerrenda;
                                         iLuzera: integer): integer;
var
   iKont, iMinNon: integer;
   rMinimoa: real;
begin 
   iMinNon := iBEHEMUGA;
   rMinimoa := arZerrenda[iBEHEMUGA];
      
   for iKont:=iBEHEMUGA+1 to iLuzera do
   begin
      if arZerrenda[iKont] < rMinimoa then
      begin
         iMinNon := iKont;
         rMinimoa := arZerrenda[iKont];
      end;
   end;
   fniArrayarenMinimoaNon := iMinNon;
end;


procedure ElementuakTrukatu(var arZerrenda: tarZerrenda;
                                   iPosMax: integer;
                                   iPosMin: integer);
var
   rLaguntzailea: real;
begin
   rLaguntzailea := arZerrenda[iPosMax];
   arZerrenda[iPosMax] := arZerrenda[iPosMin];
   arZerrenda[iPosMin] := rLaguntzailea;
end;


{ ------------------------- Programa Nagusia ------------------------- }
var
  arZerrenda: tarZerrenda;
  iLuzera, iPosMax, iPosMin: integer;
  cErantzuna: char;
begin
  repeat 
    clrscr;
    writeln('----------------------------------------');
    ArrayaDatuDesberdinezBete(arZerrenda, iLuzera);
    writeln('Hasierako datuak:');
    ArrayarenEdukiaIkusi(arZerrenda, iLuzera);

    iPosMax := fniArrayarenMaximoaNon(arZerrenda, iLuzera);
    iPosMin := fniArrayarenMinimoaNon(arZerrenda, iLuzera);
    
    writeln('Maximoa ', iPosMax, ' posizioan');
    writeln('Minimoa ', iPosMin, ' posizioan');
    writeln('Elkar trukatu ondoren: ');
    writeln;
    ElementuakTrukatu(arZerrenda, iPosMax, iPosMin);
    writeln('Datuen trukaketa egin ondoren:');
    ArrayarenEdukiaIkusi(arZerrenda, iLuzera);
    
    writeln;
    repeat
       write('Amaitu nahi duzu? (b/e): ');
       cErantzuna := readkey;
       writeln(cErantzuna);
       cErantzuna := upcase(cErantzuna);
    until (cErantzuna = 'B') or (cErantzuna = 'E');
     
  until cErantzuna = 'B';
end. { programaren amaiera }

 

10. astea | zenbakiak kendu

Gehienez 15 elementu gordetzeko gai diren arrayekin lan egingo dugu. Arrayen elementuak zenbaki osoak izango dira.

Programaren balizko exekuzio bat jarraian erakusten da:

 

{ Zenbaki osoak array batean gorde ondoren, bakoiti eta negatiboak  }
{ diren elementuak arraytik kendu (array laguntzaile bat erabiliz). }
program ZenbakiakKendu;
uses
   crt;

const
   iBEHEMUGA = 1;
   iGOIMUGA = 20;

type
   taiZerrenda = array[iBEHEMUGA..iGOIMUGA] of integer;


procedure ArrayaAleatoriokiDatuzBete(var aiZerrenda: taiZerrenda;
                                       var  iZenbat:integer);
var
  iKont: integer;
begin
   repeat
      write('Zenbat datu dira? (gehienez ', iGOIMUGA, '): ');
      readln(iZenbat);
   until  (iZenbat >= iBEHEMUGA) and (iZenbat <= iGOIMUGA);

   for iKont:=iBEHEMUGA to iGOIMUGA do
   begin
      aiZerrenda[iKont]:= random(40)-20;     { -20 eta 19 artek balioak }
   end;
end;


procedure ArrayarenEdukiaIkusi(const aiZerrenda: taiZerrenda;
                                        iLuzera: integer);
var
   iKont: integer;
begin   
   for iKont:=iBEHEMUGA to iLuzera do
   begin     
      writeln(iKont:10, '. elementua = ', aiZerrenda[iKont]:3);
   end;
   writeln;
end;


procedure BakoitiNegatiboakKendu(var aiZerrenda: taiZerrenda;
                                    var iLuzera: integer);
var
   iKont, iLuzeraBerria: integer;
   aiZerrendaBerria: taiZerrenda; 
begin
   iLuzeraBerria := 0;
   for iKont:=iBEHEMUGA to iLuzera do
   begin     
      if (aiZerrenda[iKont] < 0) and (aiZerrenda[iKont] mod 2 <> 0) then
      begin
         writeln('Hau saihestu --->  aiZerrenda[', iKont:2,'] = ', aiZerrenda[iKont]:3);
      end    
      else   
      begin
         iLuzeraBerria := iLuzeraBerria + 1;
         aiZerrendaBerria[iLuzeraBerria] := aiZerrenda[iKont];
      end;   
   end;
   
   aiZerrenda := aiZerrendaBerria;
   iLuzera := iLuzeraBerria;
end;


{ ------------------------- Programa Nagusia ------------------------- }
var
   aiZerrenda: taiZerrenda;
   iLuzera: integer;
   cErantzuna: char;
begin
   repeat 
      clrscr;
      writeln('--------------------------------------------');
      writeln('Datuak eskuratzen: '); 
      ArrayaAleatoriokiDatuzBete(aiZerrenda, iLuzera);
      
      writeln('Hasierako datuak: ');
      ArrayarenEdukiaIkusi(aiZerrenda, iLuzera);

      BakoitiNegatiboakKendu(aiZerrenda, iLuzera);
      
      writeln;
      writeln('Bakoiti negatiboak kendu ondoren: ');
      ArrayarenEdukiaIkusi(aiZerrenda, iLuzera);

      repeat
         write('Amaitu nahi duzu? (b/e): ');
         cErantzuna := readkey;
         cErantzuna := upcase(cErantzuna);
         writeln(cErantzuna);
      until (cErantzuna = 'B') or (cErantzuna = 'E');
    
      writeln;
      writeln;
      writeln;
      writeln;  
   until cErantzuna = 'B';
end.    { programaren amaiera }

 

10. astea | hiru array paralelo

Gehienez 20 elementu gordetzeko gai diren arrayekin lan egingo dugu. Arrayen elementuak zenbaki osoak izango dira.

 

{ Luzera logikorik ez da erabiltzen hiru arrayak }
{ beti beterik daudela suposatzen delako.        }
program HiruArray;
uses
   crt;

const
   iBEHEMUGA = 1;
   iGOIMUGA = 20;

type
   taiZenbakiak = array[iBEHEMUGA..iGOIMUGA] of integer;


procedure ArrayakAleatoriokiBete(var aiZenbakiak1: taiZenbakiak;
                                 var aiZenbakiak2: taiZenbakiak);
var
   iKont: integer;
begin
   randomize;
   for iKont:=iBEHEMUGA to iGOIMUGA do
   begin
      aiZenbakiak1[iKont] := random(40) - 20;   { -20 eta 19 arteko balioak }
      aiZenbakiak2[iKont] := random(40) - 20;   { -20 eta 19 arteko balioak }
   end;
   writeln;
end;


procedure ArrayaBete(var aiZenbakiak: taiZenbakiak);
var
   iKont: Integer;
begin
   for iKont:=iBEHEMUGA to iGOIMUGA do
   begin
      write('Eman ', iKont:2, '. zenbakia: ');
      readln(aiZenbakiak[iKont]) ;
   end;
   writeln;
end;


procedure ArrayaIkusi(const aiZenbakiak: taiZenbakiak);
var
   iKont: integer;
begin
   for iKont:=iBEHEMUGA to iGOIMUGA do
   begin
      writeln(iKont:2, '. zenbakia = ', aiZenbakiak[iKont]);
   end;
   writeln;
end;
   
   
procedure ArrayaLortu(const aiX, aiY: taiZenbakiak; 
                             var aiZ: taiZenbakiak);
var
   iKont: integer;
begin
   for iKont:=iBEHEMUGA to iGOIMUGA do
   begin
      if aiX[iKont] > aiY[iKont] then
         aiZ[iKont] := 1;
      if aiX[iKont] = aiY[iKont] then
         aiZ[iKont] := 0;
      if aiX[iKont] < aiY[iKont] then
         aiZ[iKont] := -1;      
   end;
end;


function fniKontatuZenbatPlus(const aiZ: taiZenbakiak): integer;
var
   iKont, iZenbat: integer;
begin
   iZenbat := 0;
   for iKont:=iBEHEMUGA to iGOIMUGA do
   begin
      if aiZ[iKont] = 1 then
         iZenbat := iZenbat + 1;
   end;
   fniKontatuZenbatPlus := iZenbat;
end;


function fniKontatuZenbatMinus(const aiZ: taiZenbakiak): integer;
var
   iKont, iZenbat: integer;
begin
   iZenbat := 0;
   for iKont:=iBEHEMUGA to iGOIMUGA do
   begin
      if aiZ[iKont] = -1 then
      begin
         iZenbat := iZenbat + 1;
      end;   
   end;
   fniKontatuZenbatMinus := iZenbat;
end;


function fniKontatuZenbatZero(const aiZ: taiZenbakiak): integer;
var
   iKont, iZenbat: integer;
begin
   iZenbat := 0;
   for iKont:=iBEHEMUGA to iGOIMUGA do
   begin
      if aiZ[iKont] = 0 then
      begin
         iZenbat := iZenbat + 1;
      end;   
   end;
   fniKontatuZenbatZero := iZenbat;
end;


procedure HiruKontaketakEgin(    const aiZeta: taiZenbakiak;
                              var iZenbatPlus: integer;
                             var iZenbatMinus: integer;
                              var iZenbatZero: integer);
var
   iKont: integer;
begin
   iZenbatPlus := 0;
   iZenbatMinus := 0;
   iZenbatZero := 0;
   for iKont:=iBEHEMUGA to iGOIMUGA do
   begin
      case aiZeta[iKont] of
         1: begin
               iZenbatPlus := iZenbatPlus + 1;
             end;   
        -1: begin
               iZenbatMinus := iZenbatMinus + 1;
             end;  
         0: iZenbatZero := iZenbatZero + 1;
      end;
   end;
end;


{ ------------------------- programa nagusia ------------------------- }
var
   aiX, aiY, aiZ: taiZenbakiak;
   iZenbatPlus, iZenbatMinus, iZenbatZero: integer;
begin
   clrscr;
   writeln('aiX eta aiY arrayen datuak aleatorioki hartuko dira');
   ArrayakAleatoriokiBete(aiX, aiY);
   writeln('aiX arrayaren edukia');
   ArrayaIkusi(aiX);
   writeln('aiY arrayaren edukia');
   ArrayaIkusi(aiY);
   writeln;
   	
   ArrayaLortu(aiX, aiY, aiZ);
   writeln('aiZ arrayaren edukia');
   ArrayaIkusi(aiZ);
   writeln;
   
   iZenbatPlus := fniKontatuZenbatPlus(aiZ);
   iZenbatMinus := fniKontatuZenbatMinus(aiZ);
   iZenbatZero := fniKontatuZenbatZero(aiZ);
   writeln('Hiru funtzioz...');
   writeln('Xi elementuak Yi elementuak baino handiago: ', iZenbatPlus, ' aldiz' );
   writeln('Xi elementuak Yi elementuak baino txikiago: ', iZenbatMinus, ' aldiz' );
   writeln('Xi elementuak eta Yi elementuak berdinak:   ', iZenbatZero, ' aldiz' );
   writeln;
   
   HiruKontaketakEgin(aiZ, iZenbatPlus, iZenbatMinus, iZenbatZero);
   writeln('Prozedura bakarraz...');
   writeln('Xi elementuak Yi elementuak baino handiago: ', iZenbatPlus, ' aldiz' );
   writeln('Xi elementuak Yi elementuak baino txikiago: ', iZenbatMinus, ' aldiz' );
   writeln('Xi elementuak eta Yi elementuak berdinak:   ', iZenbatZero, ' aldiz' );
   
   repeat until keypressed;
end.    { programaren amaiera }