gogoratzeko etiketadun mezuak erakusten. Erakutsi mezu guztiak
gogoratzeko etiketadun mezuak erakusten. Erakutsi mezu guztiak

2024(e)ko apirilaren 21(a), igandea

Direktorioak: Non gaude?







Gure programetan sarritan egiten dugu hau, baina zer balio jarriko dugu sBIDEA kostantean:

   write(Fitxategiaren izena eman (LIBURUAK adibidez): ');
   readln(sFitxIzenLiburutegia);
   sFitxIzenLiburutegia := sBIDEA + sFitxIzenLiburutegia + '.DAT';

Beste modu batez galdeturik: datu-fitxategia non sortzen da?

  • HemenGaude direktorio bat sortu ordenadorearen edozein tokitan (mahaigainean adibidez), bere barnean HemenGorde direktorio bat sortu
  • HanGorde direktorio bat sortu C:\Dev-Pas direktorioan


Datu-fitxategia non sortzen da? galderari erantzuteko programa bat erakusten da beherago. Zenbakiak gordetzen dituen FitxategiakEtaDirektorioak programa deskriba dezagun urratsez urrats:

  • Hasieran uneko direktorioa erakusten da pantailan GetCurrentDirectory funtzioari esker
  • Ondoren, datu-fitxategiaren sIzena izena teklatuaren bitartez emango du erabiltzaileaak 
  • Datu-fitxaregiaren izen osoa eraikitzen da aurretik bidea jarriz eta ostean gehiagarri bat eta luzapena jarriz, bidearen aukerak hauek dira:
    1.   ''
    2.   'HemenGorde\'
    3.   GetCurrentDir + ''\''
    4.   'HanGorde\'
    5.   '\Dev-Pas\HanGorde\'
    6.   'C:\Dev-Pas\HanGorde\'
    7.   'E:\Dev-Pas\HanGorde\'
    8.   'E:\'
  • Datu-fitxategiaren izen osoa finkaturik bere existentzia aztertzen du programak, eta horren arabera bi bide irekitzen dira:
    • Datu-fitxategia ez bada existitzen sortu eta elementuak biltegitzen dira
    • Datu-fitxategia existitzen bada elementu berriak gehitzen dira bukaeran 

Iturburu-programa konpilatu ondoren FitxategiakEtaDirektorioak.exe programa exekutagarria lortuko dugu eta egikaratzeko bi modu daude: Dev-Pas programazio-ingurune barrutik eta Dev-Pas programazio-ingurunetik kanpo.




Dev-Pas programazio-ingurunetik kanpo

Iturburu-programa konpilatuz FitxategiakEtaDirektorioak.exe programa exekutagarria lortu ondoren, Dev-Pas ingurunetik irten HemenGaude direktoriora joateko eta FitxategiakEtaDirektorioak.exe gainean klik egiteko.


Uneko direktorioa HemenGaude delarik, datu-fitxategiarentzat bide desberdinak aukeratu eta emaitza hauek ikertu:


Bidea Datu-fitxategia non sortzen da
1 '' datu-fitxategia HemenGaude direktorioan
2 'HemenGorde\' datu-fitxategia HemenGorde direktorioan
3 GetCurrentDir + '\' datu-fitxategia HemenGaude direktorioan
4 'HanGorde\' exekuzio-denborako errorea
5 '\Dev-Pas\HanGorde\' datu-fitxategia HanGorde direktorioan
6 'C:\Dev-Pas\HanGorde\' datu-fitxategia HanGorde direktorioan
7 'E:\Dev-Pas\HanGorde\' errorea E: unitatean dauden direktorioen arabera
8 'E:\' E: unitatearen erroan (E: unitatean diskorik badago)




Dev-Pas programazio-ingurune barrutik

FitxategiakEtaDirektorioak.pas iturburu-programa konpilatu eta Dev-Pas programazio-ingurunearen menuko Run project aukera hautatu programa exekutatzeko.


Kasu honetan uneko direktorioa C:\Dev-Pas dela jakinik, datu-fitxategiarentzat bide desberdinak aukeratu eta emaitza hauek ikertu:


Bidea Datu-fitxategia non sortzen da
1 '' datu-fitxategia C:\Dev-Pas direktorioan
2 'HemenGorde\' exekuzio-denborako errorea
3 GetCurrentDir + '\' datu-fitxategia C:\Dev-Pas direktorioan
4 'HanGorde\' datu-fitxategia C:\Dev-Pas\HanGorde direktorioan
5 '\Dev-Pas\HanGorde\' datu-fitxategia C:\Dev-Pas\HanGorde direktorioan
6 'C:\Dev-Pas\HanGorde\' datu-fitxategia C:\Dev-Pas\HanGorde direktorioan
7 'E:\Dev-Pas\HanGorde\' errorea E: unitatean dauden direktorioen arabera
8 'E:\' E: unitatearen erroan (E: unitatean diskorik badago)



FitxategiakEtaDirektorioak.pas iturburu-programa:
program FitxategiakEtaDirektorioak;
 
uses
   sysutils;    (* GetCurrentDir eta FileExists funtzioek behar dutelako *)
 
type
   tfFitxategia = file of integer;
   tsKatea = string[199];
 
 
procedure FitxategiaIkusi(sFitxIzen: tsKatea);
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);
      writeln(iElementua:5);
   end;
   writeln('.....................................................................');
   writeln;
   { itxi }
   close(f);
end;
 
 
procedure FitxategiaSortuEtaBete(sFitxIzen: tsKatea);
var
   f: tfFitxategia;
   iElementua, i, kopurua: integer;
begin
   { uztartu }
   assign(f, sFitxIzen);
   rewrite(f);
 
   write('Zenbat elementu nahi dituzu "', sFitxIzen, '" fitxategian? ');
   readln(kopurua);
 
   randomize; { random-aren hazia hasieratu }
   for i:=1 to kopurua 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: tsKatea);
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;
 
 
{============================PROGRAMA NAGUSIA============================}
 
var
   sIzena: tsKatea;
   cAukera: char;
 
begin
   writeln;
   writeln;
   writeln('Uneko direktorioa: ', GetCurrentDir);
   writeln;
    
   writeln('Lanerako fitxategiaren izena eman ezazu (luzapenik gabe)...');
   write('Adibidez, "Datuak" izena: ');
   readln(sIzena);
 
   writeln;
 
   writeln;
   repeat
      writeln('     "', sIzena, '" fitxategiaren bidea aukeratu:');
      writeln('     1.  ""');;
      writeln('     2.  "HemenGorde\"');
      writeln('     3.  GetCurrentDir + "\"');
      writeln('     4.  "HanGorde\"');
      writeln('     5.  "\Dev-Pas\HanGorde\"');
      writeln('     6.  "C:\Dev-Pas\HanGorde\"');
      writeln('     7.  "E:\Dev-Pas\HanGorde\"');
      writeln('     8.  "E:\"');
      writeln;
      write('Exekuzio-denborako errorea gerta daitekeen arren, bide bat aukeratu: ');
      readln(cAukera);
   until (cAukera >= '1') and (cAukera <= '8');
    
   case cAukera of
      '1': sIzena := '' + sIzena + '_aukera-' + cAukera + '.DAT';
    //'1': sIzena :=      sIzena + '_aukera-' + cAukera + '.DAT';
      '2': sIzena := 'HemenGorde\' + sIzena + '_aukera-' + cAukera + '.DAT';
      '3': sIzena := GetCurrentDir + '\' + sIzena + '_aukera-' + cAukera + '.DAT';
      '4': sIzena := 'HanGorde\' + sIzena + '_aukera-' + cAukera + '.DAT';
      '5': sIzena := '\Dev-Pas\HanGorde\' + sIzena + '_aukera-' + cAukera + '.DAT';
      '6': sIzena := 'C:\Dev-Pas\HanGorde\' + sIzena + '_aukera-' + cAukera + '.DAT';
      '7': sIzena := 'E:\Dev-Pas\HanGorde\' + sIzena + '_aukera-' + cAukera + '.DAT';
      '8': sIzena := 'E:\' + sIzena + '_aukera-' + cAukera + '.DAT';
   end;
 
   writeln;
 
   if fileexists(sIzena) then
   begin
      writeln('"', sIzena, '" fitxategia existitzen da, lan egin dezagun.');
      writeln;
      FitxategiaIkusi(sIzena);
      FitxategiariElementuakGehitu(sIzena);
      FitxategiaIkusi(sIzena);
   end
   else
   begin
      writeln('"', sIzena, '" fitxategia ez da existitzen, sortuko dugu.');
      writeln;
      FitxategiaSortuEtaBete(sIzena);
      FitxategiaIkusi(sIzena);
   end;
 
   writeln;
   write('RETURN sakatu programa bukatzeko');
   readln;
end.
 

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

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.
 

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
 

13. astea | fitxategi beraren edukia modu desberdinez pantailaratzen








Demagun erregistroen fitxategi bat sortu dugula. Fitxategiaren elementu bakoitza erregistro bat da, eta erregistroak bi eremu ditu: lehena Integer datu-motakoa eta bigarrena Real datu-motakoa.
     trdIntReal = RECORD
                     Lehena   : integer ;
                     Bigarrena: real ;
                  END ;
Demagun sortutako fitxategiaren izena Zenbakiak.dat dela eta bere edukia datu-mota desberdineko fitxategien bitartez pantailaratzea nahi dugula. Eduki bera pantailaratzeko lau fitxategiren datu-motak erabiliko dira.

1


Zenbakiak.dat fitxategiaren edukia pantailaratzeko erabiliko dugun datu-mota DM_rdIntReal da, hots, sorrerako datu-mota berbera. Ondorioz, pantailaratuko den informazioa "jatorrizkoa" izango da. Adibidean:
1. eremuan 163 balioa eta 2. eremuan 1.1295338E+001 balioa.

2


Zenbakiak.dat fitxategiaren edukia pantailaratzeko erabiliko dugun datu-mota DM_rdRealInt da, jatorrizkoaren antzekoa baina eremuen datu-motak elkar trukaturik (lehena Real datu-motakoa eta bigarrena Integer datu-motakoa):
     trdRealInt = RECORD
                     Lehena   : real ;
                     Bigarrena: integer ;
                  END ;
Ondorioz, nahiz eta Zenbakiak.dat fitxategiaren edukia ez den aldatu, pantailaratuko den informazioa bestelakoa izango da. Adibidean:
1. eremuan 9.7150463E+302 balioa eta 2. eremuan 1076270902 balioa.

3


Zenbakiak.dat fitxategiaren edukia pantailaratzeko erabiliko dugun FILE datu-mota DM_fbyBytak da, hots, fitxategian BYTE datu-motako informazioa dagoela interpretatzen duen fitxategia. Horregatik, Zenbakiak.dat fitxategiaren edukia hainbat byten sorta delakoan, byte guztiak banan-banan pantailaratuko dira.


4


Zenbakiak.dat fitxategiaren edukia pantailaratzeko erabiliko dugun FILE datu-mota DM_fcKaraktereak da, hots, fitxategian CHAR datu-motako informazioa dagoela interpretatzen duen fitxategia. Horregatik, Zenbakiak.dat fitxategiaren edukia hainbat karakteren sorta delakoan, karaktere guztiak banan-banan pantailaratuko dira; bide batez, karaktere bakoitzaren ordinala ere erakusten da (3 urratseko informazio bera da).



Hona hemen, fitxategi beraren edukia modu desberdinez pantailaratzen duen programa:

{----------------------------------------------------------------
  Erregistroak gordetzen dituen "Zenbakiak.dat" fitxategia sortu 
  eta datu-mota desberdineko fitxategien bitartez atzitu.
 ----------------------------------------------------------------}

program Fitxategi_integerrealbytechar;

type
   tsKate99 = string[99];

   trdIntReal = record
                   Lehena   : integer;
                   Bigarrena: real;
                end;
 
   tfrdIntReal = file of trdIntReal;

   trdRealInt = record
                   Lehena   : real;
                   Bigarrena: integer;
                end;

   tfrdRealInt = file of trdRealInt;

   tfbyBytak = file of byte;

   tfcKaraktereak = file of char;

{--------------bakarra den fitxategia sortu--------------}
procedure INTEGER_REAL_FitxategiaSortu(sFitxIzen: tsKate99);
var
   f: tfrdIntReal;
   rdZenbakiak: trdIntReal;
   k, iZenbat: integer; 
begin
   assign(f, sFitxIzen);
   rewrite(f);
   
   write('Zenbat elementu nahi dituzu (2 elementu adibidez): ');
   readln(iZenbat);
   
   randomize;
   for k:=1 to iZenbat do
   begin 
      rdZenbakiak.Lehena := random(256);      (* byte baten balioak    *)
      rdZenbakiak.Bigarrena := random*100;    (* 0.0 eta 99.99 artekoa *)
      write(f, rdZenbakiak);
   end;
   
   close(f);
end;

{-----bakarra den fitxategia INTEGER_REAL bezala ikusi-----}
procedure INTEGER_REAL_FitxategiaIkusi(sFitxIzen: tsKate99);
var
   f: tfrdIntReal;
   rdZenbakiak: trdIntReal;
begin
   assign(f, sFitxIzen);
   reset(f);
   
   while not eof(f) do
   begin
      read(f, rdZenbakiak);
      writeln(filepos(f)-1, ' posizioan    1. eremua = ', rdZenbakiak.Lehena:3, '2. eremua = ':25, rdZenbakiak.Bigarrena:0:2);
   end;
   
   close(f);
end;

{-----bakarra den fitxategia REAL_INTEGER bezala ikusi-----}
procedure REAL_INTEGER_FitxategiaIkusi(sFitxIzen: tsKate99);
var
   f: tfrdRealInt;
   rdZenbakiak: trdRealInt;
begin
   assign(f, sFitxIzen);
   reset(f);
   
   while not eof(f) do
   begin
      read(f, rdZenbakiak);
      writeln(filepos(f)-1, ' POSIZIOAN    1. EREMUA =', rdZenbakiak.Lehena:12, '2. EREMUA = ':16, rdZenbakiak.Bigarrena:2);
   end;
   
   close(f);
end;

{-----bakarra den fitxategia CHAR bezala ikusi-----}
procedure CHAR_FitxategiaIkusi(sFitxIzen: tsKate99);
var
   f: tfcKaraktereak;
   cKarakterea: char;
   k: integer;
begin
   assign(f, sFitxIzen);
   reset(f);
   
   k:= 0;
   while not eof(f) do
   begin
      read(f, cKarakterea);
      k := k + 1;
      writeln(k:3, '. elementua = |', cKarakterea, '|    ', Ord(cKarakterea):3);
   end;
   
   close(f);
end;

{-----bakarra den fitxategia BYTE bezala ikusi-----}
procedure BYTE_FitxategiaIkusi(sFitxIzen: tsKate99);
var
   f: tfbyBytak;
   byByte: byte;
   k: integer;
begin
   assign(f, sFitxIzen);
   reset(f);
   
   k:= 0;
   while not eof(f) do
   begin
      read(f, byByte);
      k := k + 1;
      writeln(k:3, '. elementua = ', byByte:3);
   end;
   
   close(f);
end;

var {---------------------- Programa Nagusiko aldagaiak ---------------}
   sFitxIzen: tsKate99;

begin {--------------------------- Programa Nagusia -------------------}
   
   { sFitxIzen := 'C:\Datuak\Zenbakiak.dat';
     writeln('Fitxategi bitarraren izena: ', sFitxIzen); }
   
   sFitxIzen := 'Zenbakiak.dat'; 
   writeln('Fitxategi bitarraren izena: ', sFitxIzen);
   
   writeln;
   writeln('sizeof(tsKate99)   = ', sizeof(tsKate99):3, ' byte');
   writeln('sizeof(integer)    = ', sizeof(integer):3, ' byte');
   writeln('sizeof(real)       = ', sizeof(real):3, ' byte');
   writeln('sizeof(byte)       = ', sizeof(byte):3, ' byte');
   writeln('sizeof(char)       = ', sizeof(char):3, ' byte');
   writeln('sizeof(trdIntReal) = ', sizeof(trdIntReal):3, ' byte');
   writeln('sizeof(trdRealInt) = ', sizeof(trdRealInt):3, ' byte');
   writeln;
   writeln('RETURN sakatu aurrera egiteko!');
   readln;
   
   INTEGER_REAL_FitxategiaSortu(sFitxIzen);  { Lehen eremua integer }
   writeln;                                  { Bigarren eremua real }
   
   writeln('Zenbakiak.dat fitxategiaren edukia integer-real bezala azterturik:');
   writeln('------------------------------------------------------------');
   INTEGER_REAL_FitxategiaIkusi(sFitxIzen);
   writeln('------------------------------------------------------------');
   writeln;
   
   writeln('Zenbakiak.dat fitxategi bera real-integer bezala azterturik:');
   writeln('------------------------------------------------------------');
   REAL_INTEGER_FitxategiaIkusi(sFitxIzen);
   writeln('------------------------------------------------------------');
   writeln;
   
   writeln('Zenbakiak.dat fitxategi bera BYTE bezala azterturik:');
   writeln('------------------------------------------------------------');
   BYTE_FitxategiaIkusi(sFitxIzen);
   writeln('------------------------------------------------------------');
   writeln;
   
   writeln('Zenbakiak.dat fitxategi bera CHAR bezala azterturik:');
   writeln('------------------------------------------------------------');
   CHAR_FitxategiaIkusi(sFitxIzen);
   writeln('------------------------------------------------------------');
   writeln;
   
   writeln;
   writeln ('Programa amaitzeko RETURN tekla sakatu');
   readln;
   
end.   { PROGRAMAREN BUKAERA }
 

2024(e)ko apirilaren 12(a), ostirala

(III) Ikusitako funtzio eta prozedura estandarrak








Hona hemen, orain arte, ezagutu behar dituzun funtzio eta prozedura estandarrak:

Zenbakiak
Azpiprograma Deskribapen laburra Adibidea
abs Zenbaki baten balio absolutua lortzeko gogoratu
int, frac Zenbaki erreal baten atalak, emaitza erreala gogoratu
gogoratu
trunc, round Zenbaki erreal bat zenbaki oso bihurtzeko
sqr, sqrt Zenbaki baten karratua eta erro koadroa gogoratu
cos, sin Funtzio trigonometrikoak, angelua radianetan gogoratu
gogoratu
gogoratu
gogoratu
arcsin, arccos Funtzio trigonometrikoak, angelua radianetan
arctan Funtzio trigonometrikoa, angelua radianetan
ln, exp Logaritmo nepertarraren funtzioa eta bere berreketaren funtzioa (edozein oinarriko logaritmoa eta berreketa) gogoratu
gogoratu
random Zenbaki sasi-aleatorio bat lortzeko funtzioa gogoratu
gogoratu
randomize Zenbaki aleatorioen hasiera finkatzeko prozedura

Karaktereak eta kateak
Azpiprograma Deskribapen laburra Adibidea
ord, chr Karaktere eta zenbakien arteko lotura gogoratu
gogoratu
pred, succ Karaktere baten aurrekoa eta ondokoa
upcase, lowercase Karaktere baten edo karatere-kate baten bihurketa gogoratu
clrscr Pantaila garbitzen duen prozedura gogoratu
readkey Karaktere bat teklatuz irakurtzeko
keypressed Tekla bat sakatzean TRUE itzultzen duen funtzioa
length Karaktere-katearen 0 posizioari dagokion ordinala gogoratu
pos Azpikateari dagokion lehen agerpenaren posizioa katean gogoratu
copy Karaktere-kate baten hainbat karakterez osaturiko azpikatea gogoratu
delete Karaktere-kate bati hainbat karaktere kentzeko gogoratu
insert Karaktere-kate bati hainbat karaktere txertatzeko gogoratu
str Zenbaki batetik abiatuta dagokion katea lortzeko gogoratu
val Karaktere-kate batetik abiatuta dagokion zenbakia lortzeko gogoratu

Fitxategiak
Azpiprograma Deskribapen laburra Adibidea
assign Fitxategi fisikoa eta logikoa elkar uztartzeko gogoratu
close Fitxategi fisikoaren eta logikoaren arteko elkarketa mozteko gogoratu
reset Lehendik dagoen fitxategia ireki (bere edukia mantentzen da)
gogoratu
rewrite Fitxategi berri bat sortu (lehendik bada edukia galtzen da)
gogoratu
read Fitxategitik elementu bat irakurtzeko gogoratu
gogoratu
write Fitxategian elementu bat idazteko
filepos Fitxategiaren erakusleari dagokion posizioa ezagutzeko gogoratu
gogoratu
filesize Fitxategiaren elementu kopurua ezagutzeko 
seek Fitxategiaren posizio jakin batean erakuslea kokatzeko
eof Fitxategiaren erakuslea fitxategiaren bukaeran dagoen jakiteko gogoratu
fileexists Fitxategia existitzen ote den jakiteko gogoratu
truncateFitxategia mozteko gogoratu
erase Fitxategia ezabatzeko gogoratu
rename Fitxategiari izena aldatzeko gogoratu
 

Fitxategiak: non gaude?








Fitxategi batekin lanean gaudela, hurrengo idazketa/irakurketa zein posiziotan gertatuko da? Beste era batera galdeturik, nola mugitu ahal dugu fitxategiak duen uneko posizioren erakuslea?

Demagun 4 elementuko fitxategi bat daukagula, adibidez hurrengo irudian ematen den zenbaki errealen fitxategia. Fitxategiaren posizioa zein den, eta posizio horri dagokion fitxategiaren elementua zenbatgarrena den kontzeptu desberdinak dira, nahiz eta biak elkar erlazionaturik dauden kontzeptu desberdinak dira. Adibidearen 4 elementuko fitxategiak dituen posizio posibleak 5 dira: 0, 1, 2, 3 eta 4. Eta 5 posizio horietatik, une jakin batean bakarra izango da jasango duen hurrengo idazketa/irakurketa operazioa.

Hurrengo idazketa/irakurketa operazioa fitxategiaren zein posiziotan gertatuko den guk geuk kontrolatu nahi badugu seek prozedura aplikatu beharko dugu. Gogora dakargun seek prozedura estandarra, zeinek bi parametro behar dituen:

  • fitxategia adierazten duen file datu-motako aldagaia
  • helburuko posizioa adierazten duen zenbaki osoa

Jarraian erakusten diren datu-mota eta aldagai hauek ditugula, horiei loturiko seek prozedura estandarraren dei desberdiak azalduko dira:

type
   tfrFitxategia = file of real ;
   tsKatea = string[199] ;

var
   f: tfiFitxategia ;        (* kopuru errealak biltzen dituen fitxategia *)
   rZbk_R: real ;            (* fitxategitik elementu bat irakurtzeko     *)
   rZbk_D: real ;            (* fitxategian elementu bat idazteko         *)
   liPosizioa: longint ;     (* fitxategiaren helburuko posizioa          *)
...

Seek prozeduraren bigarren parametroak har ditzaken balioak 0 eta filesize(f) artekoak izan daitezke (adibidean 0 eta 4 artekoak). Funtsean bi kasu daude:

  1. fitxategiaren filesize(f) bukaeran kokatzea, ala,
  2. fitxategiaren bukaeran ez den beste posizio batean kokatzea. Esate baterako, fitxategiaren lehen elementuaren gainean kokatzea edo fitxategiaren azken-aurreko posizioan kokatzea (fitxategiaren azken elementuaren gainean).


seek(f, filesize(f)) fitxategiaren bukaera

Fitxategiaren azken posizioan elementurik ez dago fitxategiaren bukaera delako. Fitxategiaren bukaeran kokaturik gaudela, ezin daiteke bertatik elementurik irakurri baina bai bertan elementu berri bat idatzi. Elementu berri bat idaztean fitxategiaren tamaina handituko da. Hurrengo adibide-programan ikusi I-A eta I-B kasuak.




seek(f, filesize(f)-1) fitxategiaren azken-aurreko posizioa

Fitxategiaren azken-aurreko posizioa fitxategiaren azken elementuarena da. Fitxategiaren azken-aurreko posizioan  kokaturik gaudela, bertako elementua irakur daiteke eta azken-aurreko posizio horretan idatz daiteke (noski, idazketa burutuko balitz elementu berriak aurrekoa ordezkatuko luke). Hurrengo adibide-programan ikusi II kasua.




seek(f, 0) fitxategiaren lehen posizioa

Fitxategiaren 0 posizioa fitxategiaren lehen elementuarena da. Fitxategiaren 0 posizioan  kokaturik gaudela, bertako elementua irakur daiteke eta 0 posizio horretan idatz daiteke ere (noski, idazketa burutuko balitz elementu berriak aurrekoa ordezkatuko luke). Hurrengo adibide-programan ikusi III kasua.




seek(f, filepos(f)-1) fitxategiaren uneko posizioaren aurrekoa

Fitxategiaren uneko posizioa filepos(f) funtzioaren bitartez ezagut daiteke. Fitxategiaren uneko posiziotik bat atzera egiteko seek(f, filepos(f)-1) agindua idatzi beharko da, jakinik exekuzio-denborako errorea gertatuko litzatekeela fitxategiaren uneko posizioa 0 bada (izan ere, fitxategiaren lehen elementuko aurrekorik ez dago). Hurrengo adibide-programan ikusi IV kasua.


Adibide-programa:

program SeekProzedura ;

uses
   sysutils ;    (* FileExists funtzioak behar duelako *)

const
   sBIDEA = 'C:\Datuak\' ;

type
   tfiFitxategia = file of real ;
   tsKatea = string[199] ;

procedure FitxategiaIkusi(sFitxIzen: tsKatea) ;
var
   f: tfiFitxategia ;
   rElementua: real ;
begin
   { uztartu }
   assign(f, sFitxIzen) ;
   reset(f) ;

   writeln('"', sFitxIzen, '" fitxategiak ', filesize(f), ' elementu ditu, bere edukia:') ;
   while not eof(f) do
   begin
      read(f, rElementua) ;
      writeln(rElementua:10:2) ;
   end ;
   writeln('.....................................................................') ;
   writeln ;
   { itxi }
   close(f) ;
end ;


procedure FitxategiaSortuEtaBete(sFitxIzen: tsKatea) ;
var
   f: tfiFitxategia ;
   rElementua: real ;
   i, kopurua: integer ;
begin
   { uztartu }
   assign(f, sFitxIzen) ;
   rewrite(f) ;

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

   randomize; { random-aren hazia hasieratu }
   for i:=1 to kopurua do
   begin
      rElementua:=random*10 ;   { 0.0 eta 9.9 arteko zenbakia }
      write(f, rElementua) ;    { fitxategian idatzi eta hurrengo elementura pasa }
   end ;
   { itxi }
   close(f) ;
end ;


procedure FitxategiarenElementuBatProzesatu(sFitxIzen: tsKatea) ;
var
   f: tfiFitxategia ;        (* kopuru errealak biltzen dituen fitxategia *)
   rZbk_R: real ;            (* fitxategitik elementu bat irakurtzeko     *)
   rZbk_D: real ;            (* fitxategian elementu bat idazteko         *)
   liPosizioa: longint ;     (* fitxategiaren helburuko posizioa          *)
   cEragiketa: char ;        (* fitxategitik irakurri, fitxategian idatzi *)
   cBaiEz: char ;            (* fitxategiaren azken elementua aldatzeko   *)
begin
   assign(f, sFitxIzen) ;
   reset(f) ;

   repeat
      write('Helburuko posizioa eman (0 eta ', filesize(f), ' ) artekoa: ') ;
      readln(liPosizioa) ;
      if liPosizioa < 0 then
         writeln('Posiziorik txikiena 0 da') ;
      if liPosizioa > filesize(f) then
         writeln('Fitxategiaren bukaera ', filesize(f), ' da') ;
   until (liPosizioa >= 0) and (liPosizioa <= filesize(f)) ;

   repeat
      writeln('Fitxategiaren ', liPosizioa, ' posizioan dagoen elementuarekin zer nahi duzu egin?') ;
      write('Irakurri (R) edo idatzi (D)? ') ;
      readln(cEragiketa) ;
      cEragiketa := upcase(cEragiketa) ;
   until (cEragiketa = 'R') or (cEragiketa = 'D') ;

   writeln ;

   if cEragiketa = 'R' then   (* irakurketa fitxategitik *)
      if liPosizioa = filesize(f) then                             (* I-A kasua *)
         writeln(liPosizioa, ' posiziotik (fitxategiaren bukaeratik) ezin daiteke irakurri')
   else
   begin
      seek(f, liPosizioa) ;
      read(f, rZbk_R) ;
      writeln(rZbk_R:0:2, ' kopurua fitxategiaren ', liPosizioa , ' posizioan') ;
   end ;

   if cEragiketa = 'D' then   (* idazketa fitxategian *)
   begin
      write('Fitxategian idatziko den kopurua eman: ') ;
      readln(rZbk_D) ;

      if liPosizioa = filesize(f) then
      begin
         writeln(liPosizioa, ' posizioan (fitxategiaren bukaeran) idaztean elementu berri bat gehituko zaio fitxategiari') ;
         seek(f, liPosizioa) ;
         write(f, rZbk_D) ;                                        (* I-B kasua *)
      end
      else
      begin
         seek(f, liPosizioa) ;
         read(f, rZbk_R) ;
         writeln('Fitxategiaren ', liPosizioa , ' posizioan dagoen ', rZbk_R:0:2, ' kopurua galduko da') ;
         seek(f, filepos(f)-1) ;                                   (* IV kasua *)
         write(f, rZbk_D) ;
      end ;
   end ;

   seek(f, 0) ;                                                    (* III kasua *)
   writeln('"', sFitxIzen, '" fitxategiaren eduki berria:') ;
   while not eof(f) do
   begin
      read(f, rZbk_R) ;
      writeln(rZbk_R:10:2) ;
   end ;

   repeat
      write(filesize(f)-1, ' posizioko fitxategiaren azken elementua inkrementatu nahi (B/E)? ') ;
      readln(cBaiEz) ;
      cBaiEz := upcase(cBaiEz) ;
   until (cBaiEz = 'B') or (cBaiez = 'E') ;

   writeln ;

   if cBaiEz = 'B' then   (* irakurketa eta idazketa fitxategian *)
   begin
      seek(f, filesize(f)-1) ;                                     (* II kasua *)
      read(f, rZbk_R) ;
      rZbk_D := rZbk_R + 1 ;
      seek(f, filepos(f)-1) ;                                      (* IV kasua *)
      write(f, rZbk_D) ;

      seek(f, 0) ;                                                 (* III kasua *)
      writeln('"', sFitxIzen, '" fitxategiaren eduki berria:') ;
      while not eof(f) do
      begin
         read(f, rZbk_R) ;
         writeln(rZbk_R:10:2) ;
      end ;
   end ;

   close(f) ;
end ;


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

var
   sIzena: tsKatea ;
begin
   writeln ;
   writeln ;
   writeln('"C:\Datuak" direktorioan lan eginez,') ;
   writeln('fitxategiaren izena eman ezazu (luzapenik gabe)...') ;
   write('Adibidez, "Kopuruak" izena: ') ;
   readln(sIzena) ;
   sIzena := sBIDEA + sIzena + '.dat' ;
   writeln ;

   if fileexists(sIzena) then
   begin
      writeln('"', sIzena, '" fitxategia existitzen da, lan egin dezagun.') ;
      writeln ;
      FitxategiaIkusi(sIzena) ;
      FitxategiarenElementuBatProzesatu(sIzena) ;
   end
   else
   begin
      writeln('"', sIzena, '" fitxategia ez da existitzen, sortuko dugu.') ;
      writeln ;
      FitxategiaSortuEtaBete(sIzena) ;
      FitxategiaIkusi(sIzena) ;
   end ;

   writeln ;
   writeln ('ENTER sakatu programaren exekuzioa amaitzeko...') ;
   readln ;
end.