| ZER DAKIDAN: Zenbakiak, karaktereak, kateak, zerrendak (arrayak) eta erregistroak lantzeko gai naiz. ZER IKASIKO DUDAN: Erregistroen array batean ondoko operazioak nola egiten diren ikasiko dut:
|
ESKATZEN DEN PROGRAMA
Erregistroekin lan eginez, 1 eta 30 arteko erregistroen sorta bat zerrenda batean gorde nahi da. Erregistro bakoitzak ibilgailu baten datuak bilduko ditu.
Gure programak lehenik zenbat erregistro gordeko dituen galdetuko du eta prozesu errepikakor batean sartuko da. Gero, prozesu errepikakor barruan, erregistro bakoitzaren eremuentzat balioak auzaz aukeratu (sMatrikula eremuetako balioak ez direla errepikatzen konprobatuko da) eta erregistroa bete ondoren zerrendan gordeko da.
Erregistroaren egitura honako hau da:
| 1. eremua | sMatrikula | 8 karaktereko kate bat, 'ZZZZ LLL' formatuko kate desberdinak izango dira zerrendaren elementu guztientzat |
| 2. eremua | cIbilgailuMota | karaktere bat |
| 3. eremua | rAldiunekoAbiadura | zenbaki erreal bat |
Hauxe da ariketaren programa:
{ 24. ariketa: auto bat radar atari azpitik igartzean ondoko datuak }
{ jaso eta gordetzen dira zerrenda batean: }
{ - Matrikula, karkatere-kate bat }
{ - Ibilgailu mota, karaktere bat }
{ - Aldi uneko abiadura, zenbaki erreal bat }
{ Datuak erdi automatikoki lortuko dira auzazko balioak sortuz. }
{ Matrikula bereko autoak ez direlako onartzen, matrikula jakin bat }
{ sortzean zerrendan berria izango dela frogatu beharra dago. }
{ ardZerrenda lehen zerrendatik abiatuta beste hiru zerrenda lortuko }
{ dira: }
{ - ardZerrenda_Mat matrikulen arabera sailkaturiko zerrenda }
{ - ardZerrenda_Abi abiaduren arabera sailkaturiko zerrenda }
{ - ardZerrenda_MotMat ibilgailu motaren arabera sailkaturiko }
{ zerrenda eta mota berekoen elementuak matrikulaz sailkaturik }
program Ariketa_24 ;
const
BEHEMUGA = 1 ;
GOIMUGA = 30 ;
type
tsKateMatrikula = string[8] ; { ZZZZ-LLL formatuko matrikula }
trdIbilgailua = record
sMatrikula : tsKateMatrikula ;
cIbilgailuMota : char ;
rAldiunekoAbiadura : real ;
end ;
tardZerrenda = array[BEHEMUGA..GOIMUGA] of trdIbilgailua ;
procedure IbilgailuarenDatuakJaso(var rdIbilgailua: trdIbilgailua) ;
var
iZenbat, iAusazkoa, iKont, k : integer ;
sMatrikula, sMatrikulaZifra : tsKateMatrikula ;
begin
iZenbat := 15 + random(16) ;
for iKont:=1 to iZenbat do
begin
sMatrikula := '' ;
for k:=1 to 4 do
begin
iAusazkoa := random(10) ;
Str(iAusazkoa, sMatrikulaZifra) ;
sMatrikula := sMatrikula + sMatrikulaZifra ;
end ;
iAusazkoa := random(5) ;
case iAusazkoa of
0: rdIbilgailua.sMatrikula := sMatrikula + ' KHS' ;
1: rdIbilgailua.sMatrikula := sMatrikula + ' BPK' ;
2: rdIbilgailua.sMatrikula := sMatrikula + ' KKK' ;
3: rdIbilgailua.sMatrikula := sMatrikula + ' XYZ' ;
4: rdIbilgailua.sMatrikula := sMatrikula + ' KGB' ;
end ;
iAusazkoa := random(4) ;
case iAusazkoa of
0: rdIbilgailua.cIbilgailuMota := 'A' ;
1: rdIbilgailua.cIbilgailuMota := 'B' ;
2: rdIbilgailua.cIbilgailuMota := 'C' ;
3: rdIbilgailua.cIbilgailuMota := 'D' ;
end ;
rdIbilgailua.rAldiunekoAbiadura := 50 + random(131) ; (* 50.0 eta 180.0 artean *)
end ;
end ;
{ Bilaketa gauzatzeko funtzioan while-DO egitura erabiltzen da }
function fniMatrikulaZerrendanBilatu(const ardZerrenda: tardZerrenda; iZenbat: integer; sMatrik: tsKateMatrikula): integer ;
var
iIndizea : integer ;
boAurkitua : boolean ;
begin
iIndizea := BEHEMUGA ;
boAurkitua := FALSE ;
while (iIndizea <= iZenbat) and not boAurkitua do
begin
if ardZerrenda[iIndizea].sMatrikula = sMatrik then
boAurkitua := TRUE
else
iIndizea := iIndizea + 1 ;
end ;
if boAurkitua = TRUE then
fniMatrikulaZerrendanBilatu := iIndizea
else
fniMatrikulaZerrendanBilatu := 0 ; { 0 gezurrezko posizioa litzateke }
end ;
procedure ZerrendaDatuDesberdinezBete(var ardZerrenda: tardZerrenda; iLuzera: integer) ;
var
iIndizea, iPosizioa : integer ;
rdIbilgailua : trdIbilgailua ;
begin
randomize ;
IbilgailuarenDatuakJaso(rdIbilgailua) ;
ardZerrenda[BEHEMUGA] := rdIbilgailua ; { Lehen matrikula beti izango da berria }
for iIndizea:=BEHEMUGA+1 to iLuzera do
begin
repeat
IbilgailuarenDatuakJaso(rdIbilgailua) ;
iPosizioa := fniMatrikulaZerrendanBilatu(ardZerrenda, iIndizea-1, rdIbilgailua.sMatrikula) ;
if iPosizioa <> 0 then
writeln(iIndizea:6, '. ibilgailurako: ''', rdIbilgailua.sMatrikula, ''' matrikula ', iPosizioa, '. posizioan dago!!!')
else
ardZerrenda[iIndizea] := rdIbilgailua ;
until iPosizioa = 0 ;
end ;
end ;
(* Parametro bat irteerakoa den bitartean bestea sarrerakoa *)
(* da. Horregatik arraya erreferentziaz pasatzen da baina *)
(* aldatzen ez den N iLuzera logikoari dagokion osoa balioz *)
procedure ZerrendaMatrikulazSailkatu(var ardZerrenda_Mat: tardZerrenda; N: integer) ;
var
Pos, j, k : integer ;
rdMinimoa : trdIbilgailua ;
begin
for k:=1 to N-1 do (* N-1 zergatia hau da: alde desordenatuan *)
begin (* elementu bakarra dagoenean bera da minimoa *)
rdMinimoa := ardZerrenda_Mat[k] ;
Pos := k ;
for j:=k+1 to N do (* ordenatu gabekoen artean *)
begin
if rdMinimoa.sMatrikula > ardZerrenda_Mat[j].sMatrikula then (* minimoa aurkitu *)
begin
rdMinimoa := ardZerrenda_Mat[j] ;
Pos := j ;
end ;
end ; (* k posizioan txikiena jarri *)
ardZerrenda_Mat[Pos] := ardZerrenda_Mat[k] ; (* txikiena rdMinimoa da eta Pos posizioan dago *)
ardZerrenda_Mat[k] := rdMinimoa ; (* k posiziokoa libratu ondoren bere edukia Pos *)
end; (* posizioan gordez k posizioan rdMinimoa jarri *)
end ;
(* Parametro bat irteerakoa den bitartean bestea sarrerakoa *)
(* da. Horregatik arraya erreferentziaz pasatzen da baina *)
(* aldatzen ez den N iLuzera logikoari dagokion osoa balioz *)
procedure ZerrendaAbiadurazSailkatu(var ardZerrenda_Abi: tardZerrenda; N: integer) ;
var
Pos, j, k : integer ;
rdMaximoa : trdIbilgailua ;
begin
for k:=1 to N-1 do (* N-1 zergatia hau da: alde desordenatuan *)
begin (* elementu bakarra dagoenean bera da minimoa *)
rdMaximoa := ardZerrenda_Abi[k] ;
Pos := k ;
for j:=k+1 to N do (* ordenatu gabekoen artean *)
begin
if rdMaximoa.rAldiunekoAbiadura < ardZerrenda_Abi[j].rAldiunekoAbiadura then (* maximoa aurkitu *)
begin
rdMaximoa := ardZerrenda_Abi[j] ;
Pos := j ;
end ;
end ; (* k posizioan handiena jarri *)
ardZerrenda_Abi[Pos] := ardZerrenda_Abi[k] ; (* handiena rdMaximoa da eta Pos posizioan dago *)
ardZerrenda_Abi[k] := rdMaximoa ; (* k posiziokoa libratu ondoren bere edukia Pos *)
end; (* posizioan gordez k posizioan rdMaximoa jarri *)
end ;
(* Parametro bat irteerakoa den bitartean bestea sarrerakoa *)
(* da. Horregatik arraya erreferentziaz pasatzen da baina *)
(* aldatzen ez den N iLuzera logikoari dagokion osoa balioz *)
procedure ZerrendaMotazMatrikulazSailkatu(var ardZerrenda_MotMat: tardZerrenda; N: integer) ;
var
Pos, j, k : integer ;
rdMinimoa : trdIbilgailua ;
begin
for k:=1 to N-1 do (* N-1 zergatia hau da: alde desordenatuan *)
begin (* elementu bakarra dagoenean bera da minimoa *)
rdMinimoa := ardZerrenda_MotMat[k] ;
Pos := k ;
for j:=k+1 to N do (* ordenatu gabekoen artean *)
begin
if (rdMinimoa.cIbilgailuMota > ardZerrenda_MotMat[j].cIbilgailuMota) or (* minimo nagusia aurkitu *)
((rdMinimoa.cIbilgailuMota = ardZerrenda_MotMat[j].cIbilgailuMota) and (* eta berdina denean beste *)
(rdMinimoa.sMatrikula > ardZerrenda_MotMat[j].sMatrikula)) then (* bigarren minimoa aurkitu *)
begin
rdMinimoa := ardZerrenda_MotMat[j] ;
Pos := j ;
end ;
end ; (* k posizioan txikiena jarri *)
ardZerrenda_MotMat[Pos] := ardZerrenda_MotMat[k] ; (* txikiena rdMinimoa da eta Pos posizioan dago *)
ardZerrenda_MotMat[k] := rdMinimoa ; (* k posiziokoa libratu ondoren bere edukia Pos *)
end; (* posizioan gordez k posizioan rdMinimoa jarri *)
end ;
procedure IbilgailuarenDatuakErakutsi(const rdIbilgailua: trdIbilgailua) ;
begin
write(rdIbilgailua.sMatrikula:15) ;
write(rdIbilgailua.cIbilgailuMota:9) ;
write(rdIbilgailua.rAldiunekoAbiadura:14:2) ;
writeln ;
end ;
procedure ZerrendaIkusi(const ardZerrenda: tardZerrenda; iLuzera: integer) ;
var
k : integer ;
rdIbilgailua : trdIbilgailua ;
begin
writeln('Matrikula Mota':28, 'Abiadura':14) ;
writeln('--------- ----':28, '--------':14) ;
for k:=BEHEMUGA to iLuzera do
begin
write(k:4) ;
rdIbilgailua := ardZerrenda[k] ;
IbilgailuarenDatuakErakutsi(rdIbilgailua) ;
end ;
end ;
(* ---------------------- PROGRAMA NAGUSIA ---------------------- *)
var
ardZerrenda, ardZerrenda_Mat, ardZerrenda_Abi, ardZerrenda_MotMat: tardZerrenda ;
iLuzera: integer ;
begin
writeln ;
writeln ;
writeln ;
repeat
write('Zenbat elementu izango dira (', BEHEMUGA, ' eta ', GOIMUGA, ' arteko balioa): ') ;
readln(iLuzera) ;
until (iLuzera >= BEHEMUGA) and (iLuzera <= GOIMUGA) ;
writeln ;
writeln('IBILGAILUEN DATUAK ESKURATZEN (ardZerrenda)') ;
ZerrendaDatuDesberdinezBete(ardZerrenda, iLuzera) ;
writeln ;
writeln('IBILGAILUEN DATUAK ERAKUSTEN (ardZerrenda)') ;
ZerrendaIkusi(ardZerrenda, iLuzera) ;
writeln ;
ardZerrenda_Mat := ardZerrenda ;
writeln('IBILGAILUEN DATUAK MATRIKULAZ SAILKATZEN...') ;
ZerrendaMatrikulazSailkatu(ardZerrenda_Mat, iLuzera) ;
writeln('IBILGAILUEN DATUAK ERAKUSTEN (ardZerrenda_Mat)') ;
ZerrendaIkusi(ardZerrenda_Mat, iLuzera) ;
writeln ;
ardZerrenda_Abi := ardZerrenda ;
writeln('IBILGAILUEN DATUAK ABIADURAZ SAILKATZEN...') ;
ZerrendaAbiadurazSailkatu(ardZerrenda_Abi, iLuzera) ;
writeln('IBILGAILUEN DATUAK ERAKUSTEN (ardZerrenda_Abi)') ;
ZerrendaIkusi(ardZerrenda_Abi, iLuzera) ;
writeln ;
ardZerrenda_MotMat := ardZerrenda ;
writeln('IBILGAILUEN DATUAK MOTAZ ETA MATRIKULAZ SAILKATZEN...') ;
ZerrendaMotazMatrikulazSailkatu(ardZerrenda_MotMat, iLuzera) ;
writeln('IBILGAILUEN DATUAK ERAKUSTEN (ardZerrenda_MotMat)') ;
ZerrendaIkusi(ardZerrenda_MotMat, iLuzera) ;
writeln ;
readln ;
end.
Programaren balizko exekuzio bat hurrrengo irudietan erakusten da:
 |
| ardZerrenda arrayaren 500 elementuak eskuratu dira eta horietarik lehen 20ak pantailaratu dira |
 |
| Matrikulen araberako sailkapena: ardZerrenda arrayatik abiatuta ardZerrenda_Mat array ordenatua lortu da |
 |
| Abiaduren araberako sailkapena: ardZerrenda arrayatik abiatuta ardZerrenda_Abi array ordenatua lortu da |
 |
| Sailkapenaren eremu nagusia cIbilgailuMota eta sMatrikula sailkapenaren bigarren mailako eremua: ardZerrenda arrayatik abiatuta ardZerrenda_MotMat array ordenatua lortu da |
