24. Ariketa: erregistroak (III)

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:

Array datu-motako aldagai bateko elementuak erregistroak izanik, elementu guztiak desberdinak direla kontrolatu (18. Ariketa: zerrendak (I) gogoratu)
Array datu-motako aldagai bateko elementuak erregistroak izanik, beste array bat lortu eremu baten arabera sailkaturik
Array datu-motako aldagai bateko elementuak erregistroak izanik, beste array bat lortu bi eremuren arabera sailkaturik

Bestalde, arrayekin bezala, FUNCTION erako azpiprograma batek ez du Record datu-motako egitura bat itzuliko. Horregatik, erregistro bat emaitza izan behar bada beti PROCEDURE erako azpiprogramaz prozesatuko dugu.

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:

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

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

{ 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

Informatika ☆ 2023-24 | proiektua

Orriak

2024(e)ko apirilaren 8(a), astelehena

24. Ariketa: erregistroak (III)

iruzkinik ez:

Argitaratu iruzkina