ariketa-emaitza etiketadun mezuak erakusten. Erakutsi mezu guztiak
ariketa-emaitza etiketadun mezuak erakusten. Erakutsi mezu guztiak

2024(e)ko apirilaren 20(a), larunbata

13. astea | fitxategi bat bitan banatu








Aurreko 13. astea | bi fitxategi nahastu ariketaren aurkakoa dela esan genezake!


Zenbakien fitxategi bateko datuak banatu

Demagun abiapuntuko fitxategiak zenbaki osoak dituela, eta datuak sailkatzeko baldintza zenbakia bakoitia/bikoitia izatea dela. Horren arabera progamak banaketa hau egingo du: zenbaki bakoitak fitxategi batera eta zenbaki bikoitiak beste fitxategi batera.

Abiapuntuko fitxategia ez da existitzen horregatik berria sortzen da

Abiapuntuko fitxategia existitzean datuak gehitzen dira

Hasierako fitxategiaren izena erabiltzaileak erabakiko du, goiko irudietan sartzen den izena Zenbakiak da eta programak C:\Datuak\Zenbakiak.DAT osatzen du. Ariketaren emaitza diren bi fitxategien izenak ez ditu erabiltzaileak hautatzen, emaitza diren fitxategiak hauek izango dira:
  • C:\Datuak\Bakoitiak.DAT
  • C:\Datuak\Bikoitiak.DAT   (0 zenbakia bikoititzak hartu)

Hona hemen, proposatutako ariketaren emaitza:
 

Fitxategi bat bitan banatzen duen programa hau izan daiteke:

program FitxategiBatBitanBanatzen;

uses
   sysutils;

type
   tfFitxategia = file of integer;
   tsKatea199 = string[199];


procedure FitxategiaIkusi(sFitxIzen: tsKatea199);
var
   f: tfFitxategia;
   iElementua: integer;
begin
   { uztartu }
   assign(f, sFitxIzen);
   reset(f);

   writeln(sFitxIzen, ' fitxategiak ', filesize(f), ' elementu ditu, bere edukia:');
   while not eof(f) do
   begin
      read(f, iElementua);
      write(iElementua:5);
   end;
   writeln;
   { itxi }
   close(f);
end;


procedure FitxategiaBete(sFitxIzen: tsKatea199);
var
   f: tfFitxategia;
   iElementua, k, iKopurua: integer;
begin
   { uztartu }
   assign(f, sFitxIzen);
   rewrite(f);

   write('Zenbat elementu nahi dituzu ', sFitxIzen, ' fitxategian? ');
   readln(iKopurua);

   randomize; { Random-aren hazia hasieratu }
   for k:=1 to iKopurua do
   begin
      iElementua:=random(10); { 0 eta 9 arteko zenbakia }
      write(f,iElementua);    { fitxategian idatzi eta hurrengo elementura pasa }
   end;
   { itxi }
   close(f);
end;


procedure FitxategiariElementuakGehitu(sFitxIzen: tsKatea199);
var
   f: tfFitxategia;
   iElementua: integer;
   cErantz: char;
begin
   {uztartu}
   assign(f, sFitxIzen);
   reset(f);
   seek(f, filesize(f));
   repeat
      write(sFitxIzen, ' fitxategian gordetzeko zenbaki bat eman: ');
      readln(iElementua);
      write(f, iElementua);
      write('Datu gehiagorik gorde nahi duzu?(B/E): ');
      readln(cErantz);
      cErantz := Upcase(cErantz);
   until cErantz <> 'B';
   { itxi }
   close(f);
end;


procedure FitxategiaBanatu(sFitxIzen, sFitxIzen1, sFitxIzen2: tsKatea199);
var
   f, f1, f2: tfFitxategia;
   iElementua: integer;
begin
   { uztartu }
   assign(f, sFitxIzen);
   reset(f);
   assign(f1, sFitxIzen1);
   rewrite(f1);
   assign(f2, sFitxIzen2);
   rewrite(f2);

   while not eof(f) do
   begin
      read(f, iElementua);
      if iElementua mod 2 <> 0 then
         write(f1, iElementua)
      else
         write(f2, iElementua);
   end;

   { itxi }
   close(f);
   close(f1);
   close(f2);
end;


{===================PROGRAMA NAGUSIA=====================}

var
   sIzena, sIzen1, sIzen2: tsKatea199;

begin
   writeln('Zenbakiak gordeko dituen fitxategiaren izena ''Zenbakiak'' izan daiteke');
   write('Fitxategiaren izena: ');
   readln(sIzena);
   sIzena := 'C:\' + sIzena + '.DAT';

   if fileexists(sIzena) then
   begin
      FitxategiaIkusi(sIzena);
      FitxategiariElementuakGehitu(sIzena);
      FitxategiaIkusi(sIzena);
   end
   else
   begin
      FitxategiaBete(sIzena);
      FitxategiaIkusi(sIzena);
   end;

   sIzen1 := 'C:\' + 'Bakoitiak' + '.DAT';
   sIzen2 := 'C:\' + 'Bikoitiak' + '.DAT';
   writeln('Datuak banatzean ', sIzen1, ' eta ', sIzen2, ' fitxategietan gordeko dira');

   FitxategiaBanatu(sIzena, sIzen1, sIzen2);
   FitxategiaIkusi(sIzen1);
   FitxategiaIkusi(sIzen2);

   writeln;
   write('RETURN sakatu programa bukatzeko');
   readln;
end.
 

13. astea | bi fitxategi nahastu








Ezaguna den ariketa hau fitxategiak erabiliz egin!


Erregistroen bi bektore fitxategi nahastu


Laborategiko gelan, gehienez, 25 ikasle izango dira. Ikasleen datuak bi arrayetan biltzen dira, array bat lehen azterketari dagokio eta beste arraya bigarren azterketari dagokio.

Arrayaren elementuak kateak dira, eta bertan izena eta zenbaki bat / batez banaturik daude, zenbakien kopuru maximoa 9.9 izango eta minimoa 0.0 izango da.

Datuak teklatuaren bitartez ematen dira eta ikasleen posizioak arrayetan zaindu behar dira berdinak izan daitezan, hurrengo adibidean erakusten den bezala. asAzterketa1 eta asAzterketa2 abiapuntuko arrayak dira eta ardAzterketak arraya 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



Datu zerrenda bat array batean gorde daiteke, edo bestela fitxategi batean ere gorde daiteke. Ondoko ariketa egin dezagun: bi fitxategietatik abiatuta aurreko biak nahastuz fitxategi bakarra lortu.

Hona hemen, proposatutako ariketaren hasiera:

program ErregistroenBiFitxategiNahastenEMATEKOA;

type
   tsKate30 = string[30];
   tsKate250 = string[250];
   tfsAgendaZahar = file of tsKate30;

procedure DatuakSartu(sFitxIzen1, sFitxIzen2: tsKate250);
var
   f1, f2: tfsAgendaZahar;
   iZenbatElementu: integer;
   sDatua: tsKate30;
   sIzena: tsKate30;
   sZenbakiUnitate: tsKate30;
   sZenbakiHamarreko: tsKate30;
   iZenbakiUnitate: integer;
   iZenbakiHamarreko: integer;
   n: integer;
begin
   assign(f1, sFitxIzen1);
   rewrite(f1);
   assign(f2, sFitxIzen2);
   rewrite(f2);
   
   repeat
      write('Zenbat elementu gordeko dira bi fitxategietan? ');
      readln(iZenbatElementu);
   until iZenbatElementu > 0;
   
   for n:=1 to iZenbatElementu do
   begin
      write(n, '. lagunaren izena eman: ');
      readln(sIzena);
   
      iZenbakiUnitate := random(10);         (* 0 eta 9 artean *)
      Str(iZenbakiUnitate, sZenbakiUnitate);
      iZenbakiHamarreko := random(10);       (* 0 eta 9 artean *)
      Str(iZenbakiHamarreko, sZenbakiHamarreko);
      
      sDatua := sIzena + '/' + sZenbakiUnitate + '.' + sZenbakiHamarreko;
      write(f1, sDatua);     (* Fitxategi batean idatzi *)
   
      iZenbakiUnitate := random(10);         (* 0 eta 9 artean *)
      Str(iZenbakiUnitate, sZenbakiUnitate);
      iZenbakiHamarreko := random(10);       (* 0 eta 9 artean *)
      Str(iZenbakiHamarreko, sZenbakiHamarreko);
      
      sDatua := sIzena + '/' + sZenbakiUnitate + '.' + sZenbakiHamarreko;
      write(f2, sDatua);     (* Fitxategi batean idatzi *)   
   end;

   close(f1);    (* Fitxategiak itxi *)
   close(f2);
end;


procedure DatuakIkusi(sFitxIzen: tsKate250);
var
   f: tfsAgendaZahar;
   sDatua: tsKate30;
begin
   assign(f, sFitxIzen);
   reset(f);

   while not eof(f) do
   begin
      read(f, sDatua);
      writeln(FilePos(f)-1, '. posizioko datua: ', sDatua);
   end;

   close(f);    (* Fitxategia itxi *)
   writeln;
end;


{ ============================================================== }


var
   sAgendaIzen1, sAgendaIzen2: tsKate250;

begin
   write('1. agenda fitxategiaren izena eman: ');
   readln(sAgendaIzen1);
   
   write('2. agenda fitxategiaren izena eman: ');
   readln(sAgendaIzen2);
   
   DatuakSartu(sAgendaIzen1, sAgendaIzen2);
   writeln;
   
   writeln('1. agendaren datuak: ');
   DatuakIkusi(sAgendaIzen1);
   writeln;

   writeln('2. agendaren datuak: ');
   DatuakIkusi(sAgendaIzen2);
   writeln;

   { hemen idatzi ariketan eskatzen dena }

   writeln('Programa amaitzera doa');
   readln;
end.



Ariketen iturburu programak




Array datu-mota erabiliz
Fitxategien bitartez
 

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

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:
  1. ardAzterketak arrayarekin lan eginez, ikasgelako ikasle baten izena eman (Ane adibidez) eta kalifikazioa orokorra erakutsi (bere noten batezbesteko aritmetikoa)
  2. ardAzterketak arrayarekin lan eginez, lehen azterketako kalifikazioetatik lortzen den batezbesteko aritmetikoa kalkulatu
  3. ardAzterketak arrayarekin lan eginez, bigarren azterketako kalifikazioetatik lortzen den batezbesteko aritmetikoa kalkulatu
  4. ardAzterketak arrayarekin lan eginez, nork lortu du notarik onena eta zein azterketan gertatu da
  5. ardAzterketak arrayarekin lan eginez, ikasgelako ikasle baten izena eman (Ane adibidez) eta aurkitzen bada bere kalifikazioak aldatu
  6. ardAzterketak arrayarekin lan eginez, ikasgelako ikasle baten izena eman (Ane adibidez) eta aurkitzen bada arraytik ezabatu
  7. ardAzterketak arrayarekin lan eginez, ikasle aprobatuen zerrenda erakutsi pantailan (ikasle bat aprobatuko du bere nota biren batezbesteko artrmetikoa 5.0 edo handiagoa bada)
  8. ardAzterketak arrayarekin lan eginez, arraya ordenatu/sailkatu ikasleen izenen arabera
  9. 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:

{---------------------------------------------------------------------------}   
program ErregistroenBiArrayNahastuzDatuakBateratu ;
const
   BEHEMUGA = 1 ;
   GOIMUGA = 25 ;
type
   tKate39 = string[39] ;
   tasAzterketaBat = array[BEHEMUGA..GOIMUGA] of tKate39 ;

   trdIkaslea = record
                   sIzena: tKate39 ;
                    rNota: real ;
                end ;
   tardAzterketak = array[BEHEMUGA..2*GOIMUGA] of trdIkaslea ;

{--------------------------------------------------------------------}

procedure BiKontrolenDatuakJaso(var asAzterketa1: tasAzterketaBat;
                                var asAzterketa2: tasAzterketaBat;
                                     var iLuzera: integer) ;
var
   n: integer ;
   iUnitatea: integer ;
   iHamarrekoa: integer ;
   sUnitatea: tKate39 ;
   sHamarrekoa: tKate39 ;
   sIzena: tKate39 ;
   sNor: tKate39 ;
begin
   repeat
      write('Ikasleen kopurua eman: ':35) ;
      readln(iLuzera) ;
   until (iLuzera >= BEHEMUGA) and (iLuzera <= GOIMUGA) ;

   randomize ;
   for n:=BEHEMUGA to iLuzera do
   begin
      write(n:10, '. ikaslearen izena eman: ') ;
      readln(sIzena) ;

      iUnitatea := random(10) ;     (* 0 eta 9 arteko balioa *)
      iHamarrekoa := random(10) ;   (* 0 eta 9 arteko balioa *)

      str(iUnitatea, sUnitatea) ;
      str(iHamarrekoa, sHamarrekoa) ;

      sNor := sIzena + '/' + sUnitatea + '.' + sHamarrekoa ;
      asAzterketa1[n] := sNor ;

      iUnitatea := random(10) ;     (* 0 eta 9 arteko balioa *)
      iHamarrekoa := random(10) ;   (* 0 eta 9 arteko balioa *)

      str(iUnitatea, sUnitatea) ;
      str(iHamarrekoa, sHamarrekoa) ;

      sNor := sIzena + '/' + sUnitatea + '.' + sHamarrekoa ;
      asAzterketa2[n] := sNor ;
   end ;
end ;



procedure KontrolBatenDatuakIkusi(const asAzterketa: tasAzterketaBat;
                                            iLuzera: integer) ;
var
   n: integer ;
begin
   for n:=BEHEMUGA to iLuzera do
   begin
      writeln(n:18, '. ikaslea: ', asAzterketa[n]) ;
   end ;
end ;



procedure Nahastu(const asAzterketa1: tasAzterketaBat;
                  const asAzterketa2: tasAzterketaBat;
                             iLuzera: integer;
                   var ardAzterketak: tardAzterketak;
                         var iZenbat: integer) ;
var
   n: integer ;
   sNorZer: tKate39 ;
   iBanatzaileaNon: integer ;
   sIzena: tKate39 ;
   sNota: tKate39 ;
   rNota: real ;
begin
   iZenbat := 0 ;
   for n:=BEHEMUGA to iLuzera do
   begin
      sNorZer := asAzterketa1[n] ;
      iBanatzaileaNon := pos('/', sNorZer) ;

      sIzena := copy(sNorZer, 1, iBanatzaileaNon-1) ;
      sNota := copy(sNorZer, iBanatzaileaNon+1, 3) ;
      val(sNota, rNota) ;

      iZenbat := iZenbat + 1 ;
      ardAzterketak[iZenbat].sIzena := sIzena ;
      ardAzterketak[iZenbat].rNota := rNota ;

      sNorZer := asAzterketa2[n] ;
      sNota := copy(sNorZer, iBanatzaileaNon+1, 3) ;
      val(sNota, rNota) ;

      iZenbat := iZenbat + 1 ;
      ardAzterketak[iZenbat].sIzena := sIzena ;
      ardAzterketak[iZenbat].rNota := rNota ;
   end ;
end ;



procedure IkasleBatErakutsi(const rdIkasleBat: trdIkaslea) ;
begin
   writeln(rdIkasleBat.sIzena:15, rdIkasleBat.rNota:5:1) ;
end ;



procedure KontrolBirenDatuakIkusi(const ardAzterketak: tardAzterketak;
                                              iZenbat: integer) ;
var
   n: integer ;
begin
   for n:=BEHEMUGA to iZenbat do
   begin
      write(n:18, '. ikaslea:') ;
      IkasleBatErakutsi(ardAzterketak[n]) ;
   end ;
end ;

{--------------------------------------------------------------------}

var
   asAzterketa1: tasAzterketaBat ;
   asAzterketa2: tasAzterketaBat ;
   iLuzera: integer ;
   ardAzterketak: tardAzterketak ;
   iZenbat: integer ;
begin
   writeln ;
   writeln ;
   BiKontrolenDatuakJaso(asAzterketa1, asAzterketa2, iLuzera) ;
   
   writeln ;
   writeln('---1. kontolaren informazioa------------------------------') ;
   KontrolBatenDatuakIkusi(asAzterketa1, iLuzera) ;
   
   writeln ;
   writeln('---2. kontolaren informazioa------------------------------') ;
   KontrolBatenDatuakIkusi(asAzterketa2, iLuzera) ;

   Nahastu(asAzterketa1, asAzterketa2, iLuzera, ardAzterketak, iZenbat) ;

   writeln ;
   writeln('---Bi kontrolen informazioa-------------------------------') ;
   KontrolBirenDatuakIkusi(ardAzterketak, iZenbat) ;

   writeln ;
   writeln('=====================================================') ;
   writeln('               RETURN sakatu amaitzeko               ') ;
   writeln('=====================================================') ;
   readln ;
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:

  1. Ikasle baten izenaren hasiera A bada, ikasle hori zerrendatik kenduko da (ez da array laguntzailerik erabiltzen)
  2. 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 (desberdinduz benetako txertaketa den ala gehiketa den).


Ariketaren balizko kodea ikusi:

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 BektoreaDatuDesberdinezBete(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('Lehen ikaslearen izena berria delako ez dago errepikaturik...');
   writeln;
     
   write('Eman ', BEHEMUGA, '. ikaslearen izena: ');
   readln(ardIkasgela[BEHEMUGA].sIzena);
   write('Eman ', BEHEMUGA, '. ikaslearen adina: ');
   readln(ardIkasgela[BEHEMUGA].iAdina);
   
   writeln;
   writeln('Gainerako ikaslen izenak ez dira errepikatzen...');
   writeln;
   for k:=BEHEMUGA+1 to iLuzera do
   begin
      repeat
         write('Eman ', k, '. ikaslearen izena: ');
         readln(sNor);
         iPosizioa := fniIkasleaBilatu(ardIkasgela, k-1, 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);
      writeln;
   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;
   BektoreaDatuDesberdinezBete(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+1, ') artekoa: ');
         readln(iNon);
      until (iNon >= BEHEMUGA) and (iNon <= iLuzera+1);
      
      IkasleBatenDatuakJaso(rdIkasleBerria);
      if iNon = iLuzera+1 then    { txertaketa baino gehiago gehiketa da }
      begin
         ardIkasgela[iNon] := rdIkasleBerria;
         iLuzera := iLuzera+1;
      end
      else                        { elementu berri baten txertaketa }
      begin
         IkasleBatTxertatu(ardIkasgela, iLuzera, rdIkasleBerria, iNon);
      end;
      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 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.