Laborategiko gela batean, gehienez, 25 ikasle izango dira. Ikasleen datuak bektore batean biltzen dira. Bektorearen elementuak kateak izanik bertan izena eta zenbaki bat daude koma batez banaturik, honela adibidez:
Lehen zeregina erregistroen bektore baliokidea lortzea da, bektore hau hain zuzen ere:
Horretarako, ezinbestekoa da datu-motak era egokian definitzea. Ondoko irudian erakusten da programatzaile batek egindako datu-mota definizioa:
Ikasle baten bilaketa egin hasierako bektorean (karaktere kateak gordetzen dituen bektorean), eta ondoren ikasle baten bilaketa egin bukaerako bektorean (erregistroak gordetzen dituen bektorean). Ariketa honen enuntziatu inprimagarria hemendik hartu eta hauxe da programa ErregistroenBektoreBatLortu.PAS.
Programa hori abiapuntuz harturik funtzionalitate gehiago gehituko dizkiozu: bektore berria ordenatu noten arabera, bektore berria ordenatu izenen arabera, elementu bat kendu bektore berritik, elementu bat txertatu bektore berrian...
Erregistroen array bat daukagu. Erregistroak bi eremuz osaturik daude kate bat eta zenbaki bat. Erregistroen arrayaren datuak konstante diren bi arrayetatik hartzen dira. Erregistroen arrayaren datu-mota:
const
iZENBATIKASLE = 10;
type
tsKate49 = string[49];
trdIkasle = record
sNor: tsKate49;
rNota: real;
end;
tardIkasleak = array[1..iZENBATIKASLE] of trdIkasle;
asIZENAK array konstantea eta ordenatua da, arNOTAK array konstantea da. Bi array horietaz oinarriturik balioak hartuko ditu ardIkasleak arrayak zein alfabetikoki ordenaturik egongo den ere. ardIkasleak array ordenatuaren elementuak posizioz nahastuz lortuko da emaitza den ardKaotikoak arraya.
Nahasketa burutzen duen ZerrendaNahastu prozeduran 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: trdIkasle;
boGordeta: boolean;
end;
tardLaguntzaile = array[1..iZENBATIKASLE] of trdLaguntzaile;
var
ardLaguntzailea: tardLaguntzaile;
...
Array ordenatu bat desordenatzen duen programa hau izan daiteke:
program KaosaSortzenArrayBatean;
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;
{ ikasleen izenak eta notak array konstanteetan daude }
procedure DatuakBildu(var ardIkasleak: tardIkasleak; iLuzera: integer);
var
k: integer;
begin
for k:=1 to iLuzera do
begin
ardIkasleak[k].sNor := asIZENAK[k];
ardIkasleak[k].rNota := arNOTAK[k];
end;
end;
{ ikasleen izenak eta notak array konstanteetan daude }
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;
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
ardIkasleak: tardIkasleak;
iLuzera: integer;
ardKaotikoak: tardIkasleak;
begin
clrscr;
repeat
write('Zenbat ikasle dira? (1 eta ', iZENBATIKASLE, ' artean): ');
readln(iLuzera);
until (iLuzera >= 1) and (iLuzera <= iZENBATIKASLE);
DatuakBildu(ardIkasleak, iLuzera); { izenak eta notak ez dira parametro, konstante direlako }
writeln;
writeln('--Nahastu aurretik----------------------------------------------------------');
DatuakIkusi(ardIkasleak, iLuzera);
writeln;
ZerrendaNahastu(ardIkasleak, iLuzera, ardKaotikoak);
writeln('--Nahastu ondoren-----------------------------------------------------------');
DatuakIkusi(ardKaotikoak, iLuzera);
writeln;
repeat until keypressed;
end.
Galbahe (edo bahe) baten irudia. Galbaheri esker aleak sailka daitezkeen bezala, zenbaki zerrenda bati galbahe logikoren bat aplikatuz zenbakien segida desberdinak lor daitezke, adibidez: zenbaki lehenak identifikatzeko Eratostenes matematikari greziarrak asmatutakoa
11. astea | Eratostenes-en bahea (II) erregistroen dimentsio bakarreko array bat erabiliz
Eratostenes-en bahea zenbaki lehenak aurkitzeko algoritmo bat da, emandako n zenbaki arrunt bat baino txikiagoak direnen artean.
Lehendabizi, taula bat egiten da 2 eta n arteko zenbaki arruntekin, jarraian multiploak markatzen dira hurrengo ordena jarraituz:
2tik hasita, haren multiplo guztiak markatzen dira, ostean, hurrengo zenbakiarekin jarraituko da baina bi egoera daude:
Hurrengo zenbakia markaturik gabe dago, adibidez 3 zenbakia, eta lehen bezala bere multiplo guztiak markatzen dira
Hurrengo zenbakia markaturik dago, adibidez 4 zenbakia, kasu honetan ez da ezer markatzen eta bere hurrengo zenbakia hartzen da
5ekin markatu beharko litzateke (goiko lehen kasua), 6kin ez litzateke ezer markatuko (goiko bigarren kasua), 7ekin markatu beharko litzateke (goiko lehen kasua), 8, 9 eta 10ekin ez litzateke ezer markatuko (goiko bigarren kasuak), e.a.
Prozedura errepikatzen da hau betetzen den bitartean: (MarkatuGabekoZenbakia)2<n. Beste modu batez esanik, markatu gabeko zenbakiaren karratua n baino handiagoa denean eten prozesu errepikakorra
Eratostenes-en bahearen animazioa 120 baino gutxiagoko zenbaki lehenentzat:
(*
Muga den kopuru arrunta emanez, muga hori baino txikiagoak diren
"Zenbaki Lehenak" lortzeko metodo bat aurkitu zuen Eratostenesek.
Algoritmoa:
----------
2tik iMuga-rako zenbakiak zerrenda batean jartzen dira. Lehenengo, 2ren
multiplo guztiak markatzen dira, eta 2 zenbakia emaitza den lehenen
zerrendari gehituko zaio. Ondoren, 3ren multiplo guztiak markatuko dira,
eta 3 zenbakia gehituko zaio lehenen zerrendari. Gero, 4ari begiratzen
zaio, markatuta dagoela ikusten da, eta horrek esan nahi du 2rekin
zatigarria dela, eta, beraz, ez da lehena. Ondoren, 5era iristen da;
markatuta ez dagoenez, lehena da, bere multiplo guztiak markatzen dira
eta lehenen zerrendara gehituko da.
Prozesu errepikakorra bukatzeko baldintza: Une jakin batean aztertuko den
zenbakiaren karratua iMuga-tik beherakoa bada, jarraitu beharra dago.
Bestela, algoritmoa amaitu egiten da, eta markatu gabe geratu diren
guztiak zenbaki lehenak dira (emaitza-zerrendari gehitu beharrekoak).
Animazio hau ikusi:
https://upload.wikimedia.org/wikipedia/commons/b/b9/Sieve_of_Eratosthenes_animation.gif
Bi programa hauek aztertu:
* EratostenesenBahea_1 zenbaki osoen bi dimentsiotako array bat
* EratostenesenBahea_2 erregistroen dimentsio bakarreko array bat
*)
Program EratostenesenBahea_2;
const
MAX = 120;
type
trdDatua = record
iKopurua: integer;
boMarkatua: boolean;
end;
tardZenbakiak = array[2..MAX] of trdDatua;
taiLehenak = array[1..MAX-1] of integer;
procedure DatuakLortu(var ardDatuak: tardZenbakiak; var iLuzeraDatuak: integer);
var
k: integer;
begin
iLuzeraDatuak := MAX;
for k:=2 to iLuzeraDatuak do
begin
ardDatuak[k].iKopurua := k;
ardDatuak[k].boMarkatua := FALSE;
end;
end;
procedure ZenbakiakIkusi(const ardDatuak: tardZenbakiak; iLuzeraDatuak: integer);
var
k: integer;
iKont__TRUE: integer;
iKont_FALSE: integer;
begin
iKont__TRUE := 0;
iKont_FALSE := 1; // 1 zenbakia lehena da eta ez dugu begizta barruan prozesatuko
writeln('--------------------------------------------------------------------------------');
write(' 1-FALSE');
for k:=2 to iLuzeraDatuak do
begin
write(ardDatuak[k].iKopurua:4);
if ardDatuak[k].boMarkatua then
begin
write('--');
iKont__TRUE := iKont__TRUE +1;
end
else
begin
write('-');
iKont_FALSE := iKont_FALSE +1;
end;
write(ardDatuak[k].boMarkatua);
end;
writeln;
writeln('--------------------------------------------------------------------------------');
writeln(' Zenbakien kopurua = ', iLuzeraDatuak, ' Lehenen kopurua = ', iKont_FALSE, ' Zatigarrien kopurua = ', iKont__TRUE);
end;
procedure LehenakLortu(const ardDatuak: tardZenbakiak; iLuzeraDatuak: integer;
var aiLehenak: taiLehenak; var iLuzeraLehenak: integer);
var
k: integer;
begin
iLuzeraLehenak := 1;
aiLehenak[iLuzeraLehenak] := 1;
for k:=2 to iLuzeraDatuak do
begin
if not ardDatuak[k].boMarkatua then
begin
iLuzeraLehenak := iLuzeraLehenak +1;
aiLehenak[iLuzeraLehenak] := ardDatuak[k].iKopurua;
end;
end;
end;
procedure LehenakIkusi(const aiLehenak: taiLehenak; iLuzeraLehenak: integer);
var
k: integer;
begin
writeln('********************************************************************************');
for k:=1 to iLuzeraLehenak do
begin
write(aiLehenak[k]:3, ', ');
end;
writeln;
writeln('********************************************************************************');
writeln(' iLuzeraLehenak = ', iLuzeraLehenak);
end;
{-----------------------programa nagusia eta bere aldagaiak-----------------------}
var
ardDatuak: tardZenbakiak;
iLuzeraDatuak: integer;
aiLehenak: taiLehenak;
iLuzeraLehenak: integer;
iIterazioa: integer;
k: integer;
begin
DatuakLortu(ardDatuak, iLuzeraDatuak);
writeln;
writeln('Hasierako datuak:');
ZenbakiakIkusi(ardDatuak, iLuzeraDatuak);
writeln;
writeln;
writeln('1 zenbakia alde batera utzirik, prozesu errepikakorra 2 zenbakiarekin hasiko da');
writeln;
writeln;
iIterazioa := 2; // lehenengo iterazioan, 2ren multiploak markatzen dira
repeat
writeln('================================================================================');
if ardDatuak[iIterazioa].boMarkatua = FALSE then
begin
write(iIterazioa, ' zenbakia lehena da, ');
writeln(iIterazioa, ' zenbakiren multiploak markatzen...');
for k:=iIterazioa+1 to MAX do
begin
if ardDatuak[k].iKopurua mod iIterazioa = 0 then
begin
ardDatuak[k].boMarkatua := TRUE;
writeln(ardDatuak[k].iKopurua:4, ' zenbakia markaturik zatigarria delako');
end;
end;
end
else
writeln(iIterazioa, ' zenbakia zatigarria da');
writeln(iIterazioa, ' arteko datuak:');
ZenbakiakIkusi(ardDatuak, iLuzeraDatuak);
writeln('================================================================================');
iIterazioa := iIterazioa +1;
if iIterazioa*iIterazioa <= MAX then
writeln(' ', iIterazioa, 'x', iIterazioa, ' = ', iIterazioa*iIterazioa, ' <= ', MAX, ' prozesu errepikakorrarekin jarraitu')
else
writeln(' ', iIterazioa, 'x', iIterazioa, ' = ', iIterazioa*iIterazioa, ' > ', MAX, ' prozesu errepikakorra amaitu');
writeln;
writeln;
until iIterazioa*iIterazioa > MAX;
LehenakLortu(ardDatuak, iLuzeraDatuak, aiLehenak, iLuzeraLehenak);
writeln('Lehenen zerrenda:');
LehenakIkusi(aiLehenak, iLuzeraLehenak);
writeln;
writeln;
write('ENTER sakatu exekuzioa amaitzeko... ');
readln;
end.
Eratostenes (antzinako grezieraz: Ἐρατοσθένης; K.a. 276 inguru - K.a. 195 inguru) matematikari, geografo, kirolari, poeta eta astronomo greziarra izan zen. Alexandriako Liburutegia famatuaren zuzendari izendatu zuten eta aurkikuntza ugari egin zituen, hala nola, latitude eta longitude sistema. Eratostenes ezaguna da Lurraren zirkunferentzia kalkulatzen lehen greziarra izan zelako, baita Lurraren ardatzak duen makurdura. Bestalde, garaiko ezagutza geografikoaren araberako mundu mapa eratu zuen ere.
Arraya datuz betetzeko prozedura bat idatzi da (hainbat arrazoigatik ezin daiteke funtzio izan)
Arrayaren elementu baten datuak jasotzeko, hots, erregistro baten eremuak jasotzeko prozedura bat idatzi da (ezin daiteke funtzio izan parametroa erregistroa delako)
Arrayaren edukia erakusteko prozedura bat idatzi da (zentzurik ez daukalako, ezin daiteke funtzio izan ez baitu ezer itzultzen)
Arrayaren elementu baten datuak pantailaratzeko prozedura bat idatzi da (zentzurik ez daukalako, ezin daiteke funtzio izan ez baitu ezer itzultzen)
Aste honetako laborategian azalduko dugu proiektua garatzeko garaia heldu zaigula eta hirukoteak osatu behar dituzuela:
RECORD edo erregistro datu-mota, ataletan antolatzen den datu-mota egituratua da. Erregistro batek dituen elementuak eremuak deitzen dira eta eremuen datu-mota desberdinak izan daitezke elkarrekiko, erregistroaren elementu kopurua finitua da eta eremu bakoitzaren atzipena identifikadore baten bitartez gauzatzen da.
ESKEMA
DATU-MOTA SORTZEN
Erregistro datu-mota bat deklaratzean, eremuak izendatzeko identifikadorea erabaki behar da eta eremu bakoitza zein datu-motatakoa izango den.
Eskeman erakusten den rdIkaslea delako aldagaia lortzeko, aurretik deklarazio hau egin beharko da:
...
type
trdIkasle = record
sIzena: string[39] ;
rNota: real ;
sHelbidea: string[99] ;
byAdina: byte ;
end ;
var
rdIkaslea: trdIkasle ;
rdIrakaslea: trdIkasle ;
...
Ondorioz rdIkaslea eta rdIrakaslea bi aldagaiak datu-mota bera daukate oinarrian eta biak bat datoz goi-goian erakutsi den eskemarekin.
Erregistro aldagai batean datuak gordetzeko, aldagaiaren identifikadorea eta eremuaren identifikadorea idatzi behar dira horien artean lokailu bat jarri beharra dago. Pascal lengoaiak identifikadore biren arteko elkarketa gauzatzeko puntu bat darabil, horrelaxe:
writeln(rdIkaslea.sIzena) ;
readln(rdIkaslea.rNota) ;
Puntua ken daiteke WITH klausula erabiltzen bada, aurreko aginduak honelaxe idatziko lirateke:
with rdIkaslea do begin writeln(sIzena) ; readln(rNota) ; end ;
ERAGIKETAK: IDATZI-IRAKURRI ETA ESLEIPENA
Erregistro bat ezin daiteke ez irakurri ez idatzi, horregatik ondoko aginduak okerrak dira:
writeln(rdIkaslea) ; { HAU GAIZKI DAGO }
readln(rdIrakaslea) ; { HAU GAIZKI DAGO }
Aurreko adibidearen erregistroaren eremuak idatz edo irakur daiteke, eta ondorioz agindu hauek zuzenak dira:
writeln(rdIkaslea.sIzena) ;
readln(rdIkaslea.rNota) ;
Erregistro osoari aplika dakioken eragiketa bakarra esleipena da, ondoko agindu hau zuzena da:
rdIkaslea := rdIrakaslea ;
ERAGIKETAK: KONPARAKETAK
Esan den bezala, erregistroek onartzen duten eragiketa bakarra asignazioa da. Hori dela eta, ezin daiteke erregistroen arteko konparaziorik egin. Labur azalduz:
6 konparatzaileetatik lau hauek ez dute zentzu handirik erregistroekin: <, >, <= eta >=
6 konparatzaileetatik beste biek (= eta <>) zentzua izan dezakete erregistroekin baina bi erregistroen arteko alderaketa ezin daiteke honela egin:
if rdIkasle1=rdIkasle2 then { HAU GAIZKI DAGO }
if rdIkasle1<>rdIkasle2 then { HAU GAIZKI DAGO }
Horregatik erregistro bik informazio berdina gordetzen dutela frogatzeko eremuka lan egingo da. Konparaketa helburu horrekin, ErregistroBiBerdinakOteDiren izeneko adibidean, funtzio boolear bat garatu da.
ERREGISTROAK ETA ARRAYAK
Sarritan erregistroak eta arrayak elkarrekin konbinatzen dira. Esate baterako, jarraian erregistroen array bat deklaratzen da:
...
type
trdIkasle = record
sIzena: string[39] ;
rNota: real ;
end ;
tardTalde = array[1..80] of trdIkasle ;
var
ardIkasgela: tardTalde ;
iLuzera: integer ;
Indize: integer ;
...
Datuak sartu eta eskema bat eginez:
Datuak sartu ondoren, ikusi nola eskuratuko genukeen irudiko P hori. Honelaxe zehaztuko genuke:
ardIkasGela arraytik abiatuta
Indize aldagaiak 2 balioa duelarik, arrayaren bigarren elementu hau ardIkasGela[2]erregistro bat da...
eta sIzena eremua hartzean, hots, ardIkasGela[2].sIzena string bat da...
eta string horren bere lehen karakterea eskuratzeko ardIkasGela[2].sIzena[1]erabiliko dugu
ARRAYAK ERREGISTROETAN
Erregistro baten eremu bat array bat izan daiteke. Esate baterako, jarraian array bat daukan erregistro bat deklaratzen da:
...
type
tasKateak = array [1..3] of string[39] ;
trdIkasle = record
asIzenDeiturak: tasKateak ;
rNota: real ;
end ;
var
rdIkaslea: trdIkasle ;
...
Datuak sartu eta eskema bat eginez:
Datuak sartu ondoren, ikusi nola eskuratuko genukeen irudiko M hori. Honelaxe zehaztuko genuke:
rdIkaslea erregistrorik abiatuta
rdIkaslea.asIzenDeiturak array bat da eta...
bere hirugarren elementua rdIkaslea.asIzenDeiturak[3]izanik, badakigu string bat dela
eta bere lehen karakterea eskuratzeko rdIkaslea.asIzenDeiturak[3][1]erabiliko dugu
ERREGISTROAK ERREGISTROETAN
Erregistro baten eremu bat beste erregistro bat izan daiteke. Esate baterako, ikusi jarraian nola deklaratzen den DM_rdLangile erregistroa bere barnean DM_rdData erregistroa daukana:
...
type
DM_rdData = record
iUrtea: integer ;
byHilea: byte ;
byEguna: byte ;
end ;
DM_rdLangile = record
sIzena : string[39] ;
cKategoria : char ;
rdJaioteguna : DM_rdData ;
rdAintzinatasuna: DM_rdData ;
end ;
var
rdMekanikoa: DM_rdLangile ;
...
Datu-motaren eskema bat eginez:
rdMekanikoa aldagaian datuak sartzeko bi bide ditugu. Puntu konektorea birritan erabili edo bestela WITH klausula erabili. Ondoko esleipenak zuzenak dira eta edozein modutan irudian erakusten den emaitza lortuko dugu:
WITH klausularen bitartez aurrenekordMekanikoa. zatia ken daiteke:
...
with rdMekanikoa do
begin
sIzena := 'Alain' ;
cKategoria := 'B' ;
rdJaioteguna.iUrtea := 1975 ;
rdJaioteguna.byHilea := 11 ;
rdJaioteguna.byEguna := 27 ;
rdAintzinatasuna.iUrtea := 1997 ;
rdAintzinatasuna.byHilea := 10 ;
rdAintzinatasuna.byEguna := 30 ;
end ;
...
WITH klausulak onartzen du bigarren puntua kentzea. Datu-motaren definizioaren araberaWITH klausula erabiltzean kontuz ibili behar da; esate baterako, aurreko adibidean ezinezkoa zaigu puntu konektorea kentzea rdAintzinatasuna identifikadorearekin lan egitean:
Erregistro bat datu-mota egituratua delako, beti erreferentziaz pasatuko dugu azpiprogrametara. Horregatik, azpiprograma batean honela agertuko da jokamoldearen arabera:
Irteerakoa denean parametro formalak VAR marka izango du aurrean
Sarrerakoa denean parametro formalak CONST marka izango du aurrean
ERREGISTRO BAT ITZULTZEN DUEN AZPIPROGRAMA: FUNTZIOA EDO PROZEDURA
Demagun erregistro baten eremuak azpiprograma baten barruan datuz betetzen direla eta azpiprogramak erregistroa programa nagusira itzuli egiten duela. Zer azpiprograma mota erabiliko dugu, funtzioa ala prozedura? Deiak hauek lirateke:
Prozesaketa batean erregistro bat aldatzeko, ez dugu funtziorik erabiliko. Erregistro bat azpiprograma baten bitartez prozesatzean aldatuko bada, beti prozedura erabiliko dugu. Gogoratu galdera bera arrayekin berdin erantzuten zela. Egoera biak hemen adierazten dira: Datu-mota eta azpiprogramak.
Egutegia gogoratuz, ikastaroak aurrera darrai eta laster Udaberriko Oporraldia helduko da. Hona hemen hurrengo bi asteetan egiteko daukagunaren laburpena:
Astea
Gaia
Data
Zer
11.
RECORD datu-mota
2024/04/08
(T)
11.
(Azp3) bigarren kontrola
2024/04/08
(L)
11.
(Azp1) bigarren kontrola
2024/04/09
(L)
11.
(Azp2) bigarren kontrola
2024/04/10
(L)
11.
RECORD eta FILE datu-motak
2024/04/12
(T)
12.
FILE datu-mota
2024/04/15
(T)
12.
(Azp3) proiektua
2024/04/15
(L)
12.
(Azp1) proiektua
2024/04/16
(L)
12.
(Azp2) proiektua
2024/04/17
(L)
12.
FILE datu-mota
2024/04/19
(T)
(L) Laborategia (M) Mintegia (T) Teoria (t) Tutoretza
Eskola magistraletan hartutako sinaduren araberako grafikoa ikus dezakezu jarraian. Astelehenetako kopuruak gehi ostiraletako kopuruak zati 2 eginez, balio horiek ateratzen dira iazko 2022-23 ikasturterako eta urte honetako 2023-24 ikasturterako. Esan daiteke urte honetako datuak beste urte batzuetan eman direnak baino okerragoak direla:
