2024(e)ko martxoaren 18(a), astelehena

21. Ariketa: zerrendak (IV)

ZER DAKIDAN:
Array bat erabiltzeko gai naiz.


ZER IKASIKO DUDAN:
FUNCTION erako azpiprograma batek ez du Array datu-motako zerrenda bat itzuliko. Horregatik, array bat emaitza izan behar bada beti PROCEDURE erako azpiprogramaz prozesatuko dugu.



ESKATZEN DEN PROGRAMA

Kateekin lan eginez 20. Ariketa: zerrendak (III) programatik abiatu eta ZZZZ-LLL itxurako matrikulak biltzen dituen hasierako zerrendatik beste zerrenda bat lortu LLLZZZZ itxurako datuekin. Suposatuko dugu programari emandako matrikulen datuak egokiak direla, baina programak datuen egokitasuna kontrolatu beharko balu gogoratu 19. Ariketa: karaktere-kateak (II) programan ikasitakoa.

Gure programaren zereginak:
  1. Datuak jaso eta ZZZZ-LLL itxurako matrikulen zerrenda lortu, hasierako zerrenda izango dena
  2. Hasierako zerrendaren elementu guztiak banan banan prozesatu eta LLLZZZZ itxurako zerrenda berria eskuratu
Hasierako zerrenda definitzeko asMatrikulak eta iLuzera aldagaiak behar dira; era beretsuan, bukaerako zerrenda definitzeko asKateak eta iLuzera aldagaiak behar dira (iLuzera berdina da kasu bietan). Helburuko asKateak zerrendari balioak emateko ondoko bi aukera hauek daude, baina horietarik bakarra ontzat emango dugu.

Prozedura bai, non bilatzen den zerrenda irteerako parametroa den:
?
1
2
3
procedure ZerrendaBerriaLortu(const asMatrikulak: tasHasierakoZerrenda;
                                    var asKateak: tasBukaerakoZerrenda;
                                         iLuzera: integer);
Funtzioa ez, array bat itzultzen duen funtziorik ez dugu onartuko:
?
1
2
function fnasZerrendaLortu(const asMatrikulak: tasHasierakoZerrenda;
                                      iLuzera: integer) : tasBukaerakoZerrenda ;

Hauxe da ariketaren programa:
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
{ 21. ariketa: hainbat matrikula zerrenda zerrenda batean jaso eta    }
{              zerrenda berri bat lortu.                              }
 
{ ZZZZ-LLL (non Z zifrak eta L letrak diren) formatuko matrikulak     }
{ gordetzen dituen arrayarekin lan egingo da. Zerrenda berria lortu   }
{ LLLZZZZ itxura datuekin.                                            }
  
program Ariketa_21 ;
 
const
   BEHEMUGA = 1 ;
   GOIMUGA = 10 ;
type
   tsKate8 = string[8] ;
   tasHasierakoZerrenda = array[BEHEMUGA..GOIMUGA] of tsKate8 ;
   tsKate7 = string[7] ;
   tasBukaerakoZerrenda = array[BEHEMUGA..GOIMUGA] of tsKate7 ;
 
 
procedure HasierakoZerrendaBete(var asMatrikulak: tasHasierakoZerrenda; var iLuzera: integer) ;
var
   k : integer ;
begin
   repeat
      write('   Zerrendak zenbat elementu izango ditu? ') ;
      readln(iLuzera) ;
   until (iLuzera >= BEHEMUGA) and (iLuzera <= GOIMUGA) ;
   writeln ;
    
   for k:=BEHEMUGA to iLuzera do
   begin
      write('   ''1234-XYZ'' itxurako ', k, '. matrikula eman: ') ;
      readln(asMatrikulak[k]) ;
   end ;
end ;
   
 
procedure HasierakoZerrendaIkusi(const asMatrikulak: tasHasierakoZerrenda; iLuzera: integer) ;
var
   iIndizea : integer ;
begin
   writeln('   Matrikulen zerrendaren edukia: ') ;
   for iIndizea:=BEHEMUGA to iLuzera do
   begin
      writeln(iIndizea:4, '. matrikula = ', asMatrikulak[iIndizea]) ;
   end ;
end ;
  
 
procedure BukaerakoZerrendaIkusi(const asKateak: tasBukaerakoZerrenda; iLuzera: integer) ;
var
   iIndizea : integer ;
begin
   writeln('   Emaitzen zerrendaren edukia: ') ;
   for iIndizea:=BEHEMUGA to iLuzera do
   begin
      writeln(iIndizea:4, '. katea = ', asKateak[iIndizea]) ;
   end ;
end ;
 
 
procedure ZerrendaBerriaLortu(const asMatrikulak: tasHasierakoZerrenda;
                                    var asKateak: tasBukaerakoZerrenda;
                                         iLuzera: integer) ;
var
   iIndizea : integer ;
   sZenbakiak, s3Letrak : tsKate7 ;
begin
   for iIndizea:=BEHEMUGA to iLuzera do
   begin
      sZenbakiak := Copy(asMatrikulak[iIndizea], 1, 4) ;
      s3Letrak := Copy(asMatrikulak[iIndizea], 6, 3) ;
      asKateak[iIndizea] := s3Letrak + sZenbakiak ;
   end ;
end ;
 
 
{
function fnasZerrendaBerriaLortu(const asMatrikulak: tasHasierakoZerrenda;
                                            iLuzera: integer) : tasBukaerakoZerrenda ;
var
   asKateak : tasBukaerakoZerrenda ;
   iIndizea : integer ;
   sZenbakiak, s3Letrak : tsKate7 ;
begin
   for iIndizea:=BEHEMUGA to iLuzera do
   begin
      sZenbakiak := Copy(asMatrikulak[iIndizea], 1, 4) ;
      s3Letrak := Copy(asMatrikulak[iIndizea], 6, 3) ;
      asKateak[iIndizea] := s3Letrak + sZenbakiak ;
   end ;
   fnasZerrendaBerriaLortu := asKateak ;
end ;
}
 
(* ---------------------- PROGRAMA NAGUSIA ---------------------- *)
  
var
   asMatrikulak : tasHasierakoZerrenda ;
   asKateak : tasBukaerakoZerrenda ;
   iLuzera : integer ;
begin
   writeln ;
   writeln ;
   writeln ;
       
   HasierakoZerrendaBete(asMatrikulak, iLuzera) ;
   HasierakoZerrendaIkusi(asMatrikulak, iLuzera) ;
   writeln ;
    
   writeln('   Matrikulen zerrenda prozesatzen...') ;
   writeln ;
      
   ZerrendaBerriaLortu(asMatrikulak, asKateak, iLuzera) ;          { BAI }
   //asKateak := fnasZerrendaBerriaLortu(asMatrikulak, iLuzera) ;  { EZ }
    
   BukaerakoZerrendaIkusi(asKateak, iLuzera) ;
   writeln ;  
     
   readln ;
end.

Programaren balizko exekuzio bat hurrrengo irudian erakusten da:

Arraya itzultzen duen funtziorik ez dugu programatuko, gauza bera gertatzen da erregistroekin (22. Ariketa: erregistroak (I))

 
ordua: iruzkinik ez:
Etiketak:

20. Ariketa: zerrendak (III)

ZER DAKIDAN:
Zenbakiak, karaktereak eta kateak lantzeko gai naiz. Halaber, array bat erabiltzeko gai naiz.


ZER IKASIKO DUDAN:
Array datu-motako zerrenda batetik abiatuz beste zerrenda bi lortzen ikasiko dut.



ESKATZEN DEN PROGRAMA

Kateekin lan eginez, 1 eta 10 arteko kateen zerrenda bat lortu nahi da. Kateak autoen matrikulak direlako suposatuko dugu zerrendan kate errepikaturik ez dela egongo. Suposatzea aski ez bada eta gure programak egoera hori kontrolatu behar badu, gogoratu 18. Ariketa: zerrendak (I) programan ikasitakoa.

Programa honek lehenik zenbat matrikula gordeko dituen galdetuko du. Ondoren matrikulak banan banan teklatuz irakurriko ditu programak. Demagun matrikula guztien itxura ZZZZ-LLL dela, non Z zenbakizko zifra bat izango den eta L alfabeto larriaren letra bat. Suposatuko dugu programari emandako matrikulen datuak egokiak direla, baina programak datuen egokitasuna kontrolatu beharko balu, gogoratu 17. Ariketa: karaktere-kateak (II) programan ikasitakoa.

Gure programaren zereginak:
  1. Datuak jaso eta matrikulen zerrenda bat lortu, hasierako zerrenda izango dena
  2. Hasierako zerrendaren elementu guztiak banan banan prozesatu bi zerrenda berri eskuratzeko:
    • Matrikulen zifrak biltzen dituen zerrenda berria
    • Matrikulen letrak biltzen dituen zerrenda berria
  3. Zifrak biltzen dituen zerrenda berria prozesatu eragiketa aritmetikoak burutuz
  4. Letrak biltzen dituen zerrenda berria prozesatu maximoa eta minimoa zehaztuz

Hauxe da ariketaren programa:
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
{ 20. ariketa: hainbat matrikula zerrenda zerrenda batean jaso eta bi }
{              zerrenda berri lortu: zenbaki osoen zerrenda bat eta   }
{              kateen zerrenda bat.                                   }
 
{ ZZZZ-LLL (non Z zifrak eta L letrak diren) formatuko matrikulak     }
{ gordetzen dituen arrayarekin lan egingo da. Zerrenda berriak lortu  }
{ ondoren, zifren zerrendarekin eragiketa aritmetikoak egingo dira    }
{ eta 3 karaktereko kateen zerrenda berriarekin minimoa eta maximoa   }
{ zehaztuko dira.                                                     }
   
  
{ Abiapuntuko zerrendaren datuak honelako kateak izan daitezke:       }
{                   '1234-XYZ'                                        }
{                   '8888-ABC'                                        }
{                   '4803-BPK'                                        }
{                   '6666-KHS'                                        }
  
program Ariketa_20 ;
 
const
   BEHEMUGA = 1 ;
   GOIMUGA = 10 ;
type
   tsKate8 = string[8] ;
   tasHasierakoZerrenda = array[BEHEMUGA..GOIMUGA] of tsKate8 ;
   tsKate3 = string[3] ;
   tasZerrendaBerria = array[BEHEMUGA..GOIMUGA] of tsKate3 ;
   taiZerrendaBerria = array[BEHEMUGA..GOIMUGA] of integer ;
 
 
(* Lehenengo parametroa array bat delako eta irteerakoa      *)
(* delako erreferentziaz pasatzen da. Gauza bera bigarren    *)
(* parametroarekin erreferentziaz ere bere balioa prozedura  *)
(* barruan hartu eta irteerakoa delako.                      *)
procedure HasierakoZerrendaBete(var asMatrikulak: tasHasierakoZerrenda; var iLuzera: integer) ;
var
   k : integer ;
begin
   repeat
      write('   Zerrendak zenbat elementu izango ditu? ') ;
      readln(iLuzera) ;
   until (iLuzera >= BEHEMUGA) and (iLuzera <= GOIMUGA) ;
   writeln ;
    
   for k:=BEHEMUGA to iLuzera do
   begin
      write('   ''1234-XYZ'' itxurako ', k, '. matrikula eman: ') ;
      readln(asMatrikulak[k]) ;
   end ;
end ;
   
  
(* Nahiz eta parametro biak sarrerakoak izan, lehenengoa     *)
(* array bat delako eta memorian kopia berriak ekiditeko     *)
(* erreferentziaz pasatzen da, const delako babesturik       *)
(* dago. Bigarren parametroa berriz balioz doa.              *)
procedure HasierakoZerrendaIkusi(const asMatrikulak: tasHasierakoZerrenda; iLuzera: integer) ;
var
   iIndizea : integer ;
begin
   writeln('   Matrikulen zerrendaren edukia: ') ;
   for iIndizea:=BEHEMUGA to iLuzera do
   begin
      writeln(iIndizea:4, '. matrikula = ', asMatrikulak[iIndizea]) ;
   end ;
end ;
  
 
procedure ZerrendaBanatu(const asMatrikulak: tasHasierakoZerrenda;
                           var ai4Zenbakiak: taiZerrendaBerria;
                           var asHiruLetrak: tasZerrendaBerria;
                                    iLuzera: integer) ;
var
   iIndizea, iGidoiaNon, iErrorea : integer ;
   s3Letrak : tsKate3 ;
   iZenbakiak : integer ;
   sZenbakiak : tsKate8 ;
begin
   for iIndizea:=BEHEMUGA to iLuzera do
   begin
      iGidoiaNon := Pos('-', asMatrikulak[iIndizea]) ;     
      if iGidoiaNon = 0 then writeln('   ERROREA: matrikulen datuak desegokiak dira')
      else
      begin
         sZenbakiak := Copy(asMatrikulak[iIndizea], 1, 4) ;
         s3Letrak := Copy(asMatrikulak[iIndizea], 6, 3) ;
         Val(sZenbakiak, iZenbakiak, iErrorea) ;
         if iErrorea <> 0 then
            writeln('   ERROREA: matrikulen datuak desegokiak dira') ;
         //writeln('iZenbakiak-->', iZenbakiak, '    s3Letrak-->', s3Letrak) ;
         ai4Zenbakiak[iIndizea] := iZenbakiak ;
         asHiruLetrak[iIndizea] := s3Letrak ;
      end ;
   end ;
end ;
 
 
procedure KateenZerrendaBerriaIkusi(const asHiruLetrak: tasZerrendaBerria; iLuzera: integer) ;
var
   iIndizea : integer ;
begin
   writeln('   Zerrenda berri baten edukia: ') ;
   for iIndizea:=BEHEMUGA to iLuzera do
   begin
      writeln(iIndizea:4, '. datua = ', asHiruLetrak[iIndizea]) ;
   end ;
end ;
 
 
procedure OsoenZerrendaBerriaIkusi(const ai4Zenbakiak: taiZerrendaBerria; iLuzera: integer) ;
var
   iIndizea : integer ;
begin
   writeln('   Zerrenda berri baten edukia: ') ;
   for iIndizea:=BEHEMUGA to iLuzera do
   begin
      writeln(iIndizea:4, '. datua = ', ai4Zenbakiak[iIndizea]) ;
   end ;
end ;
 
  
(* Funtzio batean parametroak BETI sarrerakoak.              *)
function fnrBatezbestekoaKalkulatu(const ai4Zenbakiak: taiZerrendaBerria; iLuzera: integer) : real ;
var
   rMetagailu : real ;
   k : integer ;
begin
   rMetagailu := 0.0 ;
   for k:=BEHEMUGA to iLuzera do
   begin
      rMetagailu := rMetagailu + ai4Zenbakiak[k] ;
   end ;
  
   fnrBatezbestekoaKalkulatu := rMetagailu / iLuzera ;
end ;
  
 
function fnrMetatuaKalkulatu(const ai4Zenbakiak: taiZerrendaBerria; iLuzera: integer) : real ;
var
   rMetagailu : real ;
   k : integer ;
begin
   rMetagailu := 0.0 ;
   for k:=BEHEMUGA to iLuzera do
   begin
      rMetagailu := rMetagailu + ai4Zenbakiak[k] ;
   end ;
  
   fnrMetatuaKalkulatu := rMetagailu ;
end ;
 
 
function fniZehaztuMinimoaNon (const asHiruLetrak: tasZerrendaBerria; iLuzera : integer) : integer ;
var
   k, iMinimoaNon : integer ;
   sBalioMinimoa : tsKate3 ;
begin
   sBalioMinimoa := asHiruLetrak[BEHEMUGA] ;
   iMinimoaNon := BEHEMUGA ;
   for k:=BEHEMUGA to iLuzera do       (* edo ---> for k:=BEHEMUGA+1 to iLuzera do *)
   begin
      if asHiruLetrak[k] < sBalioMinimoa then
      begin
         sBalioMinimoa := asHiruLetrak[k] ;
         iMinimoaNon := k ;
      end ;
   end ;
 
   fniZehaztuMinimoaNon := iMinimoaNon ;
end ;
 
 
function fniZehaztuMaximoaNon (const asHiruLetrak: tasZerrendaBerria; iLuzera : integer) : integer ;
var
   k, iMaximoaNon : integer ;
   sBalioMaximoa : tsKate3 ;
begin
   sBalioMaximoa := asHiruLetrak[BEHEMUGA] ;
   iMaximoaNon := BEHEMUGA ;
   for k:=BEHEMUGA to iLuzera do       (* edo ---> for k:=BEHEMUGA+1 to iLuzera do *)
   begin
      if asHiruLetrak[k] > sBalioMaximoa then
      begin
         sBalioMaximoa := asHiruLetrak[k] ;
         iMaximoaNon := k ;
      end ;
   end ;
 
   fniZehaztuMaximoaNon := iMaximoaNon ;
end ;
 
(* ---------------------- PROGRAMA NAGUSIA ---------------------- *)
  
var
   asMatrikulak   : tasHasierakoZerrenda ;
   asHiruLetrak   : tasZerrendaBerria ;
   ai4Zenbakiak   : taiZerrendaBerria ;
   iLuzera        : integer ;
   rMetatua       : real ;
   rBatezbestekoa : real ;
   iMinimoaNon    : integer ;
   iMaximoaNon    : integer ;
begin
   writeln ;
   writeln ;
   writeln ;
       
   HasierakoZerrendaBete(asMatrikulak, iLuzera) ;
   HasierakoZerrendaIkusi(asMatrikulak, iLuzera) ;
   writeln ;
       
   ZerrendaBanatu(asMatrikulak, ai4Zenbakiak, asHiruLetrak, iLuzera) ;
    
   OsoenZerrendaBerriaIkusi(ai4Zenbakiak, iLuzera) ;
   KateenZerrendaBerriaIkusi(asHiruLetrak, iLuzera) ;
   writeln ;  
 
   rMetatua := fnrMetatuaKalkulatu(ai4Zenbakiak, iLuzera) ;
   writeln('   Zenbakien metatua = ', rMetatua:0:3) ;
   rBatezbestekoa := fnrBatezbestekoaKalkulatu(ai4Zenbakiak, iLuzera) ;
   writeln('   Batezbestekoa = ', rBatezbestekoa:0:3) ;
    
   iMinimoaNon := fniZehaztuMinimoaNon (asHiruLetrak, iLuzera) ;
   iMaximoaNon := fniZehaztuMaximoaNon (asHiruLetrak, iLuzera) ;
   writeln('   Kateen arteko txikiena = ', asHiruLetrak[iMinimoaNon]) ;
   writeln('   Kateen arteko handiena = ', asHiruLetrak[iMaximoaNon]) ;
     
   readln ;
end.

Programaren balizko exekuzio bat hurrrengo irudian erakusten da:


 
ordua: iruzkinik ez:
Etiketak:

19. Ariketa: zerrendak (II)

ZER DAKIDAN:
Zenbakiak, karaktereak eta kateak lantzeko gai naiz. Halaber, array bat erabiltzeko gai naiz.


ZER IKASIKO DUDAN:
Array datu-motako zerrenda batean ondoko bi algoritmoak ikasiko ditut:
  • Elementu berri bat zerrendaren erdian txertatzen ikasiko dut
  • Zerrendaren erdiko elementu bat ezabatzen ikasiko dut



ESKATZEN DEN PROGRAMA (I) 

Abiadurak adierazten dituzten zenbaki errealekin lan eginez, 1 eta 10 arteko errealen zerrenda bat lortu nahi da. Zerrendaren elementuak abiadurak dira eta balio errepikatuak onartzen dira.

Programa honek lehenik zenbat abiadura gordeko dituen erabakitzen du, eta gero abiaduren zerrenda osatzen du. Bildutako abiaduren balioak pantailaratu ondoren, rAbiaduraBerria elementu berri bat eta iNon posizio bat eskatuko ditu programak, bi datu horiekin burutzen da elementu berriaren tartekaketa zerrendan (aurreko guztia baldin eta lekurik badago zerrendan). Bukatzean, zerrenda berria pantailaratuko du progranak.

Hauxe da ariketaren programa:
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
{ 19. ariketa: hainbat abiaduren zerrenda osatu ondoko baldintzekin:  }
{     - Abiaduren kopurua zerrendan 1 eta 10 artekoa izango da        }
{     - Abiaduren balioak 30.0 Km eta 179.9 Km artekoak izango dira   }
 
{ Abiaduren zerrenda lortu eta elementu berri bat txertatu zerrendan. }
 
program Ariketa_19_I ;
 
const
  BEHEMUGA = 1 ;
  GOIMUGA = 10 ;
   
type
  tarAbiadurenSorta = array[BEHEMUGA..GOIMUGA] of real ;
 
    
procedure AbiadurenarrayaBete(var arAbiadurak: tarAbiadurenSorta;
                                  var iLuzera: integer) ;
var
   iIndizea: integer ;
begin
   Randomize ;
   iLuzera := Random(GOIMUGA) + 1 ;
 
   writeln('    Abiaduren zerrendan ', iLuzera, ' datu gordetzen...') ;
   writeln('    Aurrera egiteko RETURN sakatu!') ;
   readln ;
             
   for iIndizea:=BEHEMUGA to iLuzera do
   begin
      arAbiadurak[iIndizea] := 30 + 150*Random ;      { 30.0 eta 179.9 arteko balioak }
   end ;
end ;
 
 
procedure AbiadurenarrayaIkusi(const arAbiadurak: tarAbiadurenSorta;
                                         iLuzera: integer) ;
var
   iIndizea: integer ;
begin
   writeln ;
   writeln('    Abiaduren zerrendaren edukia: ') ;
   for iIndizea:=BEHEMUGA to iLuzera do
   begin
      writeln(iIndizea:22, '. abiadura = ', arAbiadurak[iIndizea]:0:3) ;
   end ;
   writeln ;
end ;
 
  
procedure Tartekaketa(var arAbiadurak: tarAbiadurenSorta;
                          var iLuzera: integer;
                           rElementua: real;
                                 iNon: integer) ;
var
   iIndizea: integer ;
begin
   for iIndizea:=iLuzera doWNto iNon do
   begin
      arAbiadurak[iIndizea+1] := arAbiadurak[iIndizea] ;
   end ;
   arAbiadurak[iNon] := rElementua ;
   iLuzera := iLuzera + 1 ;
end ;
 
{ ---------------------- PROGRAMA NAGUSIA ---------------------- }
 
var
   arAbiadurak: tarAbiadurenSorta ;
   iLuzera, iNon: integer ;
   rAbiaduraBerria: real ;
begin
   writeln ;
   writeln ;
   writeln ;
    
   AbiadurenarrayaBete(arAbiadurak, iLuzera) ;
   AbiadurenarrayaIkusi(arAbiadurak, iLuzera) ;
 
   if iLuzera < GOIMUGA then
   begin
      write('    Eman abiadura berriaren balioa (30.0 eta 179.9 artekoa) ') ;
      readln(rAbiaduraBerria) ;
      repeat
         write('    Eman abiadura berriaren posizioa zerrendan: ') ;
         readln(iNon) ;
      until (iNon >= BEHEMUGA) and (iNon <= iLuzera) ;
 
      Tartekaketa(arAbiadurak, iLuzera, rAbiaduraBerria, iNon) ;
      AbiadurenarrayaIkusi(arAbiadurak, iLuzera) ;
   end
   else
      writeln('    Zerrenda beterik dago, ezin da elementu berria txertatu.') ;
       
   readln ;
end.

Programaren balizko exekuzio bat hurrrengo irudian erakusten da:




ESKATZEN DEN PROGRAMA (II) 

Abiadurak adierazten dituzten zenbaki errealekin lan eginez, 1 eta 10 arteko errealen zerrenda bat lortu nahi da. Zerrendaren elementuak abiadurak dira eta balio errepikatuak onartzen dira.

Programa honek (aurrekoak bezala) lehenik zenbat abiadura gordeko dituen erabakitzen du, eta gero abiaduren zerrenda osatzen du. Bildutako abiaduren balioak pantailaratu ondoren, zerrendatik kenduko den elementuaren iNon posizioa eskatuko du programak, datu horrekin burutzen da elementuaren ezabaketa zerrendatik. Bukatzean, zerrenda berria pantailaratuko du progranak eta ezabatutako abiadura erakutsiko du ere.

Hauxe da ariketaren programa:
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
{ 19. ariketa: hainbat abiaduren zerrenda osatu ondoko baldintzekin:  }
{     - Abiaduren kopurua zerrendan 1 eta 10 artekoa izango da        }
{     - Abiaduren balioak 30.0 Km eta 179.9 Km artekoak izango dira   }
 
{ Abiaduren zerrenda lortu eta elementu jakin bat zerrendatik kendu.  }
 
program Ariketa_19_II ;
 
const
  BEHEMUGA = 1 ;
  GOIMUGA = 10 ;
   
type
  tarAbiadurenSorta = array[BEHEMUGA..GOIMUGA] of real ;
 
 
procedure AbiadurenarrayaBete(var arAbiadurak: tarAbiadurenSorta;
                                  var iLuzera: integer) ;
var
   iIndizea: integer ;
begin
   Randomize ;
   iLuzera := Random(GOIMUGA) + 1 ;
 
   writeln('    Abiaduren zerrendan ', iLuzera, ' datu gordetzen...') ;
   writeln('    Aurrera egiteko RETURN sakatu!') ;
   readln ;
             
   for iIndizea:=BEHEMUGA to iLuzera do
   begin
      arAbiadurak[iIndizea] := 30 + 1530*Random ;      { 30.0 eta 179.9 arteko balioak }
   end ;
end ;
 
 
procedure AbiadurenarrayaIkusi(const arAbiadurak: tarAbiadurenSorta;
                                         iLuzera: integer) ;
var
   iIndizea: integer ;
begin
   writeln ;
   writeln('    Abiaduren zerrendaren edukia: ') ;
   for iIndizea:=BEHEMUGA to iLuzera do
   begin
      writeln(iIndizea:22, '. abiadura = ', arAbiadurak[iIndizea]:0:3) ;
   end ;
   writeln ;
end ;
 
 
procedure Ezabaketa(var arAbiadurak: tarAbiadurenSorta;
                        var iLuzera: integer;
                               iNon: integer) ;
var
   iIndizea: integer ;
begin
   for iIndizea:=iNon to iLuzera-1 do
   begin
      arAbiadurak[iIndizea] := arAbiadurak[iIndizea+1] ;
   end ;
   iLuzera := iLuzera - 1 ;
end ;
 
{ ---------------------- PROGRAMA NAGUSIA ---------------------- }
 
var
  arAbiadurak: tarAbiadurenSorta ;
  iLuzera, iNon: integer ;
  rElemKopia: real ;
begin
   writeln ;
   writeln ;
   writeln ;
    
   AbiadurenarrayaBete(arAbiadurak, iLuzera) ;
   AbiadurenarrayaIkusi(arAbiadurak, iLuzera) ;
 
   repeat
      write('    Ezabatuko den abiaduraren posizioa zerrendan: ') ;
      readln(iNon) ;
   until (iNon >= BEHEMUGA) and (iNon <= iLuzera) ;
 
   rElemKopia := arAbiadurak[iNon] ;        { aterako den datuaren kopia egin }
 
   Ezabaketa(arAbiadurak, iLuzera, iNon) ;
 
   AbiadurenarrayaIkusi(arAbiadurak, iLuzera) ;
   writeln('    Hona hemen zerrendatik ezabatu den abiadura: ', rElemKopia:0:3) ;
    
   readln ;
end.

Programaren balizko exekuzio bat hurrrengo irudian erakusten da:


 
ordua: iruzkinik ez:
Etiketak:

18. Ariketa: zerrendak (I)

ZER DAKIDAN:
Zenbakiak, karaktereak eta kateak lantzeko gai naiz.


ZER IKASIKO DUDAN:
Oinarrizko datu-mota bateko balioak zerrendetan antolatzen eta gordetzen ikasiko dut. Horretarako Array datu-mota funtsezkoa da. Array datu-motako aldagai batek bere elementuak elkar ondoan kokatzen ditu memorian eta elementu bakoitzari erreferentzia egiteko indize bat erabiltzen da.



ESKATZEN DEN PROGRAMA (I) 

Karaktereekin lan eginez, 1 eta 10 arteko karaktereen zerrenda bat lortu nahi da. Baina, zerrendan ez da onartuko karaktere errepikaturik.

Gure programak lehenik zenbat karaktere gordeko dituen galdetuko du. Ondoren karaktereak banan banan teklatuz irakurriko ditu programak. Karaktere bat irakurtzean zerrendan gorde aurretik, konprobatu beharko da lehendik ez dagoela.

Hauxe da ariketaren programa:
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
{ 18. ariketa: hainbat karakteren zerrenda osatu ondoko baldintzekin: }
{     - Karakteren kopurua 1 eta 10 artekoa izango da                 }
{     - Karakatereak ez dira errepikatuko zerrendan                   }
 
program Ariketa_18_I ;
 
const
   BEHEMUGA = 1 ;
   GOIMUGA = 10 ;
type
   tacZerrenda = array[BEHEMUGA..GOIMUGA] of char ;
 
 
{ Bilaketa gauzatzeko funtzioan while-DO egitura erabiltzen da }
function fniDatuaZerrendanBilatu(const acLetrak: tacZerrenda; iZenbat: integer; cKarak: char): integer ;
var
   iIndizea : integer ;
   boAurkitua : boolean ;
begin
   iIndizea := BEHEMUGA ;
   boAurkitua := FALSE ;
   while (iIndizea <= iZenbat) and not boAurkitua do
   begin
      if acLetrak[iIndizea] = cKarak then
         boAurkitua := TRUE
      else
         iIndizea := iIndizea + 1 ;
   end ;
 
   if boAurkitua = TRUE then
     fniDatuaZerrendanBilatu := iIndizea
   else
     fniDatuaZerrendanBilatu := 0 ;          { 0 gezurrezko posizioa litzateke }
end ;
 
 
procedure ZerrendaDatuDesberdinekinBete(var acLetrak: tacZerrenda; iLuzera: integer) ;
var
   iIndizea, iPosizioa: integer ;
   cKarak: char ;
begin
   write('   Eman zerrendaren ', BEHEMUGA, '. datua: ') ;
   readln(acLetrak[BEHEMUGA]) ;           (* Lehen datua beti izango da berria *)
   for iIndizea:=BEHEMUGA+1 to iLuzera do
   begin
      repeat
         write('   Eman zerrendaren ', iIndizea, '. datua: ') ;
         readln(cKarak) ;
         cKarak := upcase(cKarak) ;
 
         iPosizioa := fniDatuaZerrendanBilatu(acLetrak, iIndizea-1, cKarak) ;
 
         if iPosizioa <> 0 then
            writeln(cKarak:9, ' balioa ', iPosizioa, '. posizioan dago, beste balio bat aukeratu.')
         else
            acLetrak[iIndizea] := cKarak ;
      until iPosizioa = 0 ;
   end ;
end ;
 
 
procedure ZerrendarenEdukiaIkusi(const acLetrak: tacZerrenda; iLuzera: integer) ;
var
   iIndizea: integer ;
begin
   writeln('   Zerrendaren edukia: ') ;
   for iIndizea:=BEHEMUGA to iLuzera do
   begin
      writeln(iIndizea:4, '. karakterea = ', acLetrak[iIndizea]) ;
   end ;
   writeln ;
end ;
 
{ ---------------------- PROGRAMA NAGUSIA ---------------------- }
 
var
   acLetrak: tacZerrenda ;
   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 ;
   ZerrendaDatuDesberdinekinBete(acLetrak, iLuzera) ;
    
   writeln ;
   ZerrendarenEdukiaIkusi(acLetrak, iLuzera) ;
 
   readln ;
end.

Programaren balizko exekuzio bat hurrrengo irudian erakusten da:




ESKATZEN DEN PROGRAMA (II) 

Aurreko programaren aldaera bat: Karaktereekin lan egin ordez kateekin lan egin daiteke, hots, autoen matrikulak jaso daitezke zerrenda batean matrikula errepikatuak onartu gabe.

Gure programak lehenik zenbat matrikula gordeko dituen galdetuko du. Ondoren matrikulak banan banan teklatuz irakurriko ditu programak. Matrikula bat irakurtzean zerrendan gorde aurretik, konprobatu beharko da lehendik ez dagoela.

Hauxe da programaren aldaerak zerrendarako definituko duen datu-mota:
?
1
2
3
4
5
6
7
8
9
10
11
12
13
{ 18. ariketa: hainbat matrikulen zerrenda osatu ondoko baldintzekin: }
{     - Matrikulen kopurua 1 eta 10 artekoa izango da                 }
{     - Matrikulak ez dira errepikatuko zerrendan                     }
 
program Ariketa_18_II ;
 
const
   BEHEMUGA = 1 ;
   GOIMUGA = 10 ;
type
   tsMatrikula = string[8] ;
   tasZerrenda = array[BEHEMUGA..GOIMUGA] of tsMatrikula ;
...  






 
ordua: iruzkinik ez:
Etiketak:

2024(e)ko martxoaren 8(a), ostirala

17. Ariketa: karaktere-kateak (II)

ZER DAKIDAN:
Zenbakiak eta karaktereak lantzeko gai naiz.


ZER IKASIKO DUDAN:
Esaldiak prozesatzen, karaktere-kateak prozesatzen, ikasiko dut. Horretarako string datu-mota funtsezkoa da. Karaktere-kate baten edukia lantzen ikasiko dut.



ESKATZEN DEN PROGRAMA

Demagun gure sistema informatikoan gordeko ditugun ibilgailuen matrikulak, 1234-XYZ itxurako kateak direla. Non, lehen 4 karaktereak digituak diren, ondoren - sinboloa datorren, eta, bukatzeko, alfabetoko 3 letra dauden (A-tik Z bitarteko letra larriak).

Gure programan karaktere-kate bat teklatuz irakurriko dugu eta emandako datua matrikula bat ez bada, programak adieraziko digu akatsa non gertatu den zehaztuz. Hauxe da programaren balizko irteera bat:


Ikusten den bezala, aurreko adibidean matrikula teklatuaren bitartez irakurtzean A bokala sartu da, gogoratu zenbait estatutan ez dela bokalik onartzen ibilgailuen matrikuletan.






 
ordua: iruzkinik ez:
Etiketak:

16. Ariketa: karaktere-kateak (I)

ZER DAKIDAN:
Zenbakiak eta karaktereak lantzeko gai naiz.


ZER IKASIKO DUDAN:
Esaldiak prozesatzen (karaktere-kateak prozesatzen) ikasiko dut. Horretarako string datu-mota funtsezkoa da. Karaktere-kateak elkar konparatzen ikasiko dut.



SARRERA

Ibilgailu baten matrikulak formatu asko jarrai ditzake. Esate baterako, hauek dira Europako matrikulen formatuak 2021. urtean:


Ariketa larregi ez konplikatzearren, ibilgailu guztien matrikulak 8 karaktereko kateak izango direla suposatuko dugu. Ondorioz, matrikula bat gordetzen duen karaktere-katearen barne antolaketa honako hau izango dela onartuko dugu:

ZifraZifraZifraZifra
Marratxoa
LetraLetraLetra (*)
1234
-
KZW
(*) letretan bokalik ez da onartzen



ESKATZEN DEN PROGRAMA

Ibilgailu baten matrikula 8 karaktereko kate batean jasotzen da. Bi ibilgailuen matrikulak teklatuz irakurri ondoren, pantailan adierazi zein kate den bestea baino handiagoa. Hauxe da programa:
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
{     Matrikula bat teklatuz irakurri, beste matrikula bat irakurri   }
{     eta matrikulak elkarrekiko alderatu ondoren informazioa eman.   }
 
program Ariketa_16 ;
  
const
   iMAX = 8 ;
type
   tsKatea = string[iMAX] ;
 
var
   sMatrikula1, sMatrikula2 : tsKatea ;
begin
   writeln ;
   writeln ;
   writeln ;
   writeln ;
    
   writeln('   Bi matrikula artean, zein da handiena?') ;
   writeln ;
      
   write('      Lehen matrikula idatzi: ') ;
   readln(sMatrikula1) ;
      
   write('   Bigarren matrikula idatzi: ') ;
   readln(sMatrikula2) ;
   writeln ;
      
   if sMatrikula1 < sMatrikula2 then
      writeln('   ''', sMatrikula1, ''' txikiagoa da ', '''', sMatrikula2, ''' baino') ;
 
   if sMatrikula1 > sMatrikula2 then
      writeln('   ''', sMatrikula1, ''' handiagoa da ', '''', sMatrikula2, ''' baino') ;
 
   if sMatrikula1 = sMatrikula2 then
      writeln('   ''', sMatrikula1, ''' eta ', '''', sMatrikula2, ''' berdinak dira') ;
 
  writeln ;
  readln ;
end.

Eta hauek dira programaren balizko bost irteera:






Aurreko adibideetan ikusten da matrikulak teklatuaren bitartez irakurtzean bokalak sartu direla, zenbait estatutan ez da bokalik onartzen ibilgailuen matrikuletan.






 
ordua: iruzkinik ez:
Etiketak:
Harpidetu honetara: Mezuak (Atom)