2024(e)ko martxoaren 23(a), larunbata

10. ASTEA | etxerako lana

10. astea (2024/03/26) etxean egitekoa

 
ordua: iruzkinik ez:
Etiketak:

10. ASTEA | laborategi/mintegian egin dena

10. astea (2024/03/26) laborategi/mintegian egindakoa

  • Zerrenda pasatu dugu. Deitutako 25en artean 6 ez dira etorri (zehaztapen gehiago eGela zerbitzuan)

Gaurko helburua bikoitza da:

  1. Arrayekin lan egitea 
  2. Unitateak zer diren azaltzea 

1. Arrayekin lanean, arrayaren elementuak datu-mota soilak (real, integer, string, char,...) 

2. Unitateak
 
ordua: iruzkinik ez:
Etiketak:

10. astea | izenen eta noten taula


asTaula hiru dimentsiotako taula bat da, kateak gorde ditzakeen asTaula arrayak 40 errenkada eta 3 zutabe ditu. Errenkada bakoitza ikasle bati dagokio: Errenkadaren lehen zutabean izena biltegitzen da, bigarrenean abizena eta hirugarren zutabean ikaslearen nota gordetzen da (hirurak string[19] datu-motakoak). Teoriako blogean gehiago...
 
ordua: iruzkinik ez:
Etiketak:

10. astea | elkar trukatu

Gehienez 25 elementu gordetzeko gai den array batekin lan egingo dugu. Arrayaren elementuak zenbaki errealak izango dira.


Datua den zenbaki erreal bat arrayean gorde aurretik, frogatu beharra dago errepikaturik ez dela egongo. Horretarako, teoriako blogearen 10. astea | bilaketa sekuentzialaren aplikazio bat programara jo eta bertako BilaketaLineala izeneko funtzioa erabili gure behar izanetara egokituz, hots, erabili beharko dituen moldapenak eginez.

 
?
Array bat elementu desberdinez bete ondoren,
maximoa eta minimoa posizioz elkar trukatu.
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
{ Zenbaki erreal desberdinez array bat elikatu ondoren, minimoaren eta }
{ maximoaren posizioak lortu bi haien arteko lekuak elkar trukatzeko.  }
program ElkarTrukatu;
uses
   crt;
 
const
   iBEHEMUGA = 1;
   iGOIMUGA = 20;
 
type
   tarZerrenda = array[iBEHEMUGA..iGOIMUGA] of real;
 
 
function fniBilatu(const arZerrenda: tarZerrenda;
                            iZenbat: integer;
                             rGakoa: real): integer;
var
   iKontagailu: integer;
   boAurkitua: boolean;
begin
   iKontagailu := iBEHEMUGA;
   boAurkitua := FALSE;
   while (iKontagailu <= iZenbat) and not boAurkitua do
   begin
      if arZerrenda[iKontagailu] = rGakoa then
      begin
         writeln(rGakoa:0:1, ' balioa ', iKontagailu:2, ' posizoan dago!');
         boAurkitua := TRUE;
      end
      else
      begin
         writeln(rGakoa:0:1, ' bilatzen, ', iKontagailu:2, '. elementuarekin ez du bat egiten, hurrengoa aztertu!');
         iKontagailu := iKontagailu + 1;
      end;
   end;
    
   if boAurkitua then
   begin
      fniBilatu := iKontagailu;
      writeln(rGakoa:0:1, ' balioa badago arrayan. Beste balio batekin saiatu!');
   end
   else
   begin
      fniBilatu := 0;
      writeln(rGakoa:0:1, ' balioa berria da eta ', iZenbat+1, '. posizioan kokatuko da');
   end;
   writeln;
end;
 
 
procedure ArrayaDatuDesberdinezBete(var arZerrenda: tarZerrenda;
                                       var iLuzera: integer);
var
   iKont: integer;
   rZbk: real;
begin
   randomize;
   iLuzera := random(iGOIMUGA) + 1;      { iBEHEMUGA eta iGOIMUGA arteko balioak }
   //writeln('iLuzera=', iLuzera);
    
   arZerrenda[iBEHEMUGA] := random(10) + 0.1*random(2);   { 0.0, 0.1, 1.0, 1.1, ... 8.0, 8.1, 9.0, 9.1 arteko balioak }
   writeln('1. datua = ', arZerrenda[iBEHEMUGA]:0:1);
   writeln;
   for iKont:=iBEHEMUGA+1 to iLuzera do
   begin    
      repeat
         rZbk := random(10) + 0.1*random(2);             { 0.0, 0.1, 1.0, 1.1, ... 8.0, 8.1, 9.0, 9.1 arteko balioak }
      until fniBilatu(arZerrenda, iKont-1, rZbk) = 0;
      arZerrenda[iKont] := rZbk;
   end;
end;
 
 
procedure ArrayarenEdukiaIkusi(const arZerrenda: tarZerrenda;
                                        iLuzera: integer);
var
   iKont: integer;
begin  
   for iKont:=iBEHEMUGA to iLuzera do
   begin    
      writeln(iKont:10, '. elementua = ', arZerrenda[iKont]:0:1);
   end;
   writeln;
end;
 
 
function fniArrayarenMaximoaNon(const arZerrenda: tarZerrenda;
                                         iLuzera: integer): integer;
var
   iKont, iMaxNon: integer;
   rMaximoa: real;
begin
   iMaxNon := iBEHEMUGA;
   rMaximoa := arZerrenda[iBEHEMUGA];
   for iKont:=iBEHEMUGA+1 to iLuzera do
   begin
      if arZerrenda[iKont] > rMaximoa then
      begin
         iMaxNon := iKont;
         rMaximoa := arZerrenda[iKont];
      end;
   end;
   fniArrayarenMaximoaNon := iMaxNon;
end;
 
 
function fniArrayarenMinimoaNon(const arZerrenda: tarZerrenda;
                                         iLuzera: integer): integer;
var
   iKont, iMinNon: integer;
   rMinimoa: real;
begin
   iMinNon := iBEHEMUGA;
   rMinimoa := arZerrenda[iBEHEMUGA];
       
   for iKont:=iBEHEMUGA+1 to iLuzera do
   begin
      if arZerrenda[iKont] < rMinimoa then
      begin
         iMinNon := iKont;
         rMinimoa := arZerrenda[iKont];
      end;
   end;
   fniArrayarenMinimoaNon := iMinNon;
end;
 
 
procedure ElementuakTrukatu(var arZerrenda: tarZerrenda;
                                   iPosMax: integer;
                                   iPosMin: integer);
var
   rLaguntzailea: real;
begin
   rLaguntzailea := arZerrenda[iPosMax];
   arZerrenda[iPosMax] := arZerrenda[iPosMin];
   arZerrenda[iPosMin] := rLaguntzailea;
end;
 
 
{ ------------------------- Programa Nagusia ------------------------- }
var
  arZerrenda: tarZerrenda;
  iLuzera, iPosMax, iPosMin: integer;
  cErantzuna: char;
begin
  repeat
    clrscr;
    writeln('----------------------------------------');
    ArrayaDatuDesberdinezBete(arZerrenda, iLuzera);
    writeln('Hasierako datuak:');
    ArrayarenEdukiaIkusi(arZerrenda, iLuzera);
 
    iPosMax := fniArrayarenMaximoaNon(arZerrenda, iLuzera);
    iPosMin := fniArrayarenMinimoaNon(arZerrenda, iLuzera);
     
    writeln('Maximoa ', iPosMax, ' posizioan');
    writeln('Minimoa ', iPosMin, ' posizioan');
    writeln('Elkar trukatu ondoren: ');
    writeln;
    ElementuakTrukatu(arZerrenda, iPosMax, iPosMin);
    writeln('Datuen trukaketa egin ondoren:');
    ArrayarenEdukiaIkusi(arZerrenda, iLuzera);
     
    writeln;
    repeat
       write('Amaitu nahi duzu? (b/e): ');
       cErantzuna := readkey;
       writeln(cErantzuna);
       cErantzuna := upcase(cErantzuna);
    until (cErantzuna = 'B') or (cErantzuna = 'E');
      
  until cErantzuna = 'B';
end. { programaren amaiera }
 
ordua: iruzkinik ez:
Etiketak:

10. astea | zenbakiak kendu

Gehienez 15 elementu gordetzeko gai diren arrayekin lan egingo dugu. Arrayen elementuak zenbaki osoak izango dira.


Programaren balizko exekuzio bat jarraian erakusten da:


 
?
Array laguntzaile baten bitartez hainbat elementu array batetik kendu.
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
{ Zenbaki osoak array batean gorde ondoren, bakoiti eta negatiboak  }
{ diren elementuak arraytik kendu (array laguntzaile bat erabiliz). }
program ZenbakiakKendu;
uses
   crt;
 
const
   iBEHEMUGA = 1;
   iGOIMUGA = 20;
 
type
   taiZerrenda = array[iBEHEMUGA..iGOIMUGA] of integer;
 
 
procedure ArrayaAleatoriokiDatuzBete(var aiZerrenda: taiZerrenda;
                                       var  iZenbat:integer);
var
  iKont: integer;
begin
   repeat
      write('Zenbat datu dira? (gehienez ', iGOIMUGA, '): ');
      readln(iZenbat);
   until  (iZenbat >= iBEHEMUGA) and (iZenbat <= iGOIMUGA);
 
   for iKont:=iBEHEMUGA to iGOIMUGA do
   begin
      aiZerrenda[iKont]:= random(40)-20;     { -20 eta 19 artek balioak }
   end;
end;
 
 
procedure ArrayarenEdukiaIkusi(const aiZerrenda: taiZerrenda;
                                        iLuzera: integer);
var
   iKont: integer;
begin  
   for iKont:=iBEHEMUGA to iLuzera do
   begin    
      writeln(iKont:10, '. elementua = ', aiZerrenda[iKont]:3);
   end;
   writeln;
end;
 
 
procedure BakoitiNegatiboakKendu(var aiZerrenda: taiZerrenda;
                                    var iLuzera: integer);
var
   iKont, iLuzeraBerria: integer;
   aiZerrendaBerria: taiZerrenda;
begin
   iLuzeraBerria := 0;
   for iKont:=iBEHEMUGA to iLuzera do
   begin    
      if (aiZerrenda[iKont] < 0) and (aiZerrenda[iKont] mod 2 <> 0) then
      begin
         writeln('Hau saihestu --->  aiZerrenda[', iKont:2,'] = ', aiZerrenda[iKont]:3);
      end   
      else  
      begin
         iLuzeraBerria := iLuzeraBerria + 1;
         aiZerrendaBerria[iLuzeraBerria] := aiZerrenda[iKont];
      end;  
   end;
    
   aiZerrenda := aiZerrendaBerria;
   iLuzera := iLuzeraBerria;
end;
 
 
{ ------------------------- Programa Nagusia ------------------------- }
var
   aiZerrenda: taiZerrenda;
   iLuzera: integer;
   cErantzuna: char;
begin
   repeat
      clrscr;
      writeln('--------------------------------------------');
      writeln('Datuak eskuratzen: ');
      ArrayaAleatoriokiDatuzBete(aiZerrenda, iLuzera);
       
      writeln('Hasierako datuak: ');
      ArrayarenEdukiaIkusi(aiZerrenda, iLuzera);
 
      BakoitiNegatiboakKendu(aiZerrenda, iLuzera);
       
      writeln;
      writeln('Bakoiti negatiboak kendu ondoren: ');
      ArrayarenEdukiaIkusi(aiZerrenda, iLuzera);
 
      repeat
         write('Amaitu nahi duzu? (b/e): ');
         cErantzuna := readkey;
         cErantzuna := upcase(cErantzuna);
         writeln(cErantzuna);
      until (cErantzuna = 'B') or (cErantzuna = 'E');
     
      writeln;
      writeln;
      writeln;
      writeln; 
   until cErantzuna = 'B';
end.    { programaren amaiera }
 
ordua: iruzkinik ez:
Etiketak:

10. astea | hiru array paralelo

Gehienez 20 elementu gordetzeko gai diren arrayekin lan egingo dugu. Arrayen elementuak zenbaki osoak izango dira.


 
?
Beterik dauden arrayekin lan eginez, kontaketak egin.
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
{ Luzera logikorik ez da erabiltzen hiru arrayak }
{ beti beterik daudela suposatzen delako.        }
program HiruArray;
uses
   crt;
 
const
   iBEHEMUGA = 1;
   iGOIMUGA = 20;
 
type
   taiZenbakiak = array[iBEHEMUGA..iGOIMUGA] of integer;
 
 
procedure ArrayakAleatoriokiBete(var aiZenbakiak1: taiZenbakiak;
                                 var aiZenbakiak2: taiZenbakiak);
var
   iKont: integer;
begin
   randomize;
   for iKont:=iBEHEMUGA to iGOIMUGA do
   begin
      aiZenbakiak1[iKont] := random(40) - 20;   { -20 eta 19 arteko balioak }
      aiZenbakiak2[iKont] := random(40) - 20;   { -20 eta 19 arteko balioak }
   end;
   writeln;
end;
 
 
procedure ArrayaBete(var aiZenbakiak: taiZenbakiak);
var
   iKont: Integer;
begin
   for iKont:=iBEHEMUGA to iGOIMUGA do
   begin
      write('Eman ', iKont:2, '. zenbakia: ');
      readln(aiZenbakiak[iKont]) ;
   end;
   writeln;
end;
 
 
procedure ArrayaIkusi(const aiZenbakiak: taiZenbakiak);
var
   iKont: integer;
begin
   for iKont:=iBEHEMUGA to iGOIMUGA do
   begin
      writeln(iKont:2, '. zenbakia = ', aiZenbakiak[iKont]);
   end;
   writeln;
end;
    
    
procedure ArrayaLortu(const aiX, aiY: taiZenbakiak;
                             var aiZ: taiZenbakiak);
var
   iKont: integer;
begin
   for iKont:=iBEHEMUGA to iGOIMUGA do
   begin
      if aiX[iKont] > aiY[iKont] then
         aiZ[iKont] := 1;
      if aiX[iKont] = aiY[iKont] then
         aiZ[iKont] := 0;
      if aiX[iKont] < aiY[iKont] then
         aiZ[iKont] := -1;     
   end;
end;
 
 
function fniKontatuZenbatPlus(const aiZ: taiZenbakiak): integer;
var
   iKont, iZenbat: integer;
begin
   iZenbat := 0;
   for iKont:=iBEHEMUGA to iGOIMUGA do
   begin
      if aiZ[iKont] = 1 then
         iZenbat := iZenbat + 1;
   end;
   fniKontatuZenbatPlus := iZenbat;
end;
 
 
function fniKontatuZenbatMinus(const aiZ: taiZenbakiak): integer;
var
   iKont, iZenbat: integer;
begin
   iZenbat := 0;
   for iKont:=iBEHEMUGA to iGOIMUGA do
   begin
      if aiZ[iKont] = -1 then
      begin
         iZenbat := iZenbat + 1;
      end;  
   end;
   fniKontatuZenbatMinus := iZenbat;
end;
 
 
function fniKontatuZenbatZero(const aiZ: taiZenbakiak): integer;
var
   iKont, iZenbat: integer;
begin
   iZenbat := 0;
   for iKont:=iBEHEMUGA to iGOIMUGA do
   begin
      if aiZ[iKont] = 0 then
      begin
         iZenbat := iZenbat + 1;
      end;  
   end;
   fniKontatuZenbatZero := iZenbat;
end;
 
 
procedure HiruKontaketakEgin(    const aiZeta: taiZenbakiak;
                              var iZenbatPlus: integer;
                             var iZenbatMinus: integer;
                              var iZenbatZero: integer);
var
   iKont: integer;
begin
   iZenbatPlus := 0;
   iZenbatMinus := 0;
   iZenbatZero := 0;
   for iKont:=iBEHEMUGA to iGOIMUGA do
   begin
      case aiZeta[iKont] of
         1: begin
               iZenbatPlus := iZenbatPlus + 1;
             end;  
        -1: begin
               iZenbatMinus := iZenbatMinus + 1;
             end; 
         0: iZenbatZero := iZenbatZero + 1;
      end;
   end;
end;
 
 
{ ------------------------- programa nagusia ------------------------- }
var
   aiX, aiY, aiZ: taiZenbakiak;
   iZenbatPlus, iZenbatMinus, iZenbatZero: integer;
begin
   clrscr;
   writeln('aiX eta aiY arrayen datuak aleatorioki hartuko dira');
   ArrayakAleatoriokiBete(aiX, aiY);
   writeln('aiX arrayaren edukia');
   ArrayaIkusi(aiX);
   writeln('aiY arrayaren edukia');
   ArrayaIkusi(aiY);
   writeln;
     
   ArrayaLortu(aiX, aiY, aiZ);
   writeln('aiZ arrayaren edukia');
   ArrayaIkusi(aiZ);
   writeln;
    
   iZenbatPlus := fniKontatuZenbatPlus(aiZ);
   iZenbatMinus := fniKontatuZenbatMinus(aiZ);
   iZenbatZero := fniKontatuZenbatZero(aiZ);
   writeln('Hiru funtzioz...');
   writeln('Xi elementuak Yi elementuak baino handiago: ', iZenbatPlus, ' aldiz' );
   writeln('Xi elementuak Yi elementuak baino txikiago: ', iZenbatMinus, ' aldiz' );
   writeln('Xi elementuak eta Yi elementuak berdinak:   ', iZenbatZero, ' aldiz' );
   writeln;
    
   HiruKontaketakEgin(aiZ, iZenbatPlus, iZenbatMinus, iZenbatZero);
   writeln('Prozedura bakarraz...');
   writeln('Xi elementuak Yi elementuak baino handiago: ', iZenbatPlus, ' aldiz' );
   writeln('Xi elementuak Yi elementuak baino txikiago: ', iZenbatMinus, ' aldiz' );
   writeln('Xi elementuak eta Yi elementuak berdinak:   ', iZenbatZero, ' aldiz' );
    
   repeat until keypressed;
end.    { programaren amaiera }
 
ordua: iruzkinik ez:
Etiketak:

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

Kontrola prestatzeko ariketa esanguratsuak

Bigarren kontrola prestatzeko ariketa esanguratsuak:

 
ordua: iruzkinik ez:
Etiketak:

9. ASTEA | etxerako lana

 9. astea (2024/03/19) etxean egitekoa

 
ordua: iruzkinik ez:
Etiketak:

9. ASTEA | laborategi/mintegian egin dena

 9. astea (2024/03/19) laborategi/mintegian egindakoa

  • Zerrenda pasatu dugu. Deitutako 25en artean 5 ez dira etorri (zehaztapen gehiago eGela zerbitzuan)
  • Saio honek bi zati izango ditu: kateak eta arrayak
 
ordua: iruzkinik ez:
Etiketak:

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

8. astea | zenbait noten batezbesteko aritmetikoa

Zenbait ikasleren noten batezbesteko aritmetikoa kalkulatu behar da. Ikasle bakoitzaren nota, bere izena eta bere deiturarekin batera dator.

Ikasleen kopurua programaren hasieran irakurriko da, eta kopuru hori teklatuz ematean karaktere-kate bat erabiliko da. Horrela, kopurua onargarria dela ziurtatu ahalko da eta ondorioz exekuzio-denborako errorerik ez da gertatuko.

Ikaslearen datua ere, karaktere-kate bat izango da. Ikasle jakin baten datua den karaktere-katearen ezaugarriak:

  • Datuaren luzera maximoa 30 karaktere
  • Datuan izena, deitura eta nota daude
  • Notak hainbat zifra ditu eta edozein tokitan izan daitezke:
    1. Gutxienez zifra bat dago
    2. Lehen zifra unitatea da eta gainerakoak hamartarrak
    3. Zifrak ez dira zertan jarraian egon behar
    4. Suposatu notarik txikiena 0 dela eta handiena 9.999 dela
  • Letrak direla eta, izena deitura baino lehenago dago
  • Izena letra larriz hasten da eta gainerakoak minuskulak dira
  • Deitura letra larriz hasten da eta gainerakoak minuskulak dira

Zenbat ikasle diren teklatuaren bitartez harturik, datuak eman, notak eskuratu eta nota guztien batezbestekoa kalkulatu. Adibidez:

Eleo72norIz1a ------> 7.21
Peru6Sala8zar ------> 6.8
AmagoiaLaka5rra ----> 5
4RuyRuiz91 ---------> 4.91

(+7.21 +6.8 +5 +4.91) / 4 = 5.98

?
ZenbaitNotenBatezbestekoAritmetikoa_HASIERA.pas
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
{
   Datuaren luzera maximoa 30 karaktere. Datuak banan banan aztertuz
   izena, deitura eta nota lortu. Nota guztien batezbestekoa kalkulatu.
    
   Programaren hasiera. Non ikasleen kopurua irakurtzen den eta for
   prozesu errepikakorrean DatuakBakandu() prozedurari deitzen zaion,
   azkenean noten batezbesteko aritmetikoa erakusten den.
}
 
program ZenbaitNotenBatezbestekoAritmetikoa_HASIERA;
type
   tsKate30 = string[30];
 
procedure DatuakBakandu(sIkaslea: tsKate30; var sIzena, sAbizena, sNota: tsKate30);
begin
 
end;
 
{-------------------------Programa Nagusia-------------------------}
var
   sZenbat, sIkaslea, sNota, sIzena, sAbizena: tsKate30;
   rNota, rBatukaria: real;
   iZenbatIkasle, iKont, iErroreaNon: integer;
begin
   writeln('//////////////////////////////////////');
   writeln;
   repeat
      write('Zenbat ikasle izango dira (adibidez 4): ');
      readln(sZenbat);
      val(sZenbat, iZenbatIkasle, iErroreaNon);
      if iErroreaNon <> 0 then
         writeln('Datu okerra ', iErroreaNon, '. posizioko karakterea onargarria ez delako.')
      else
        if iZenbatIkasle <= 0 then
           writeln('Ikasleen kopurua gutxienez 1 izan behar da.');
   until (iZenbatIkasle > 0) and (iErroreaNon = 0);
    
   rBatukaria := 0.0;
   for iKont:=1 to iZenbatIkasle do
   begin
    
      // DatuakBakandu(sIkaslea, sIzena, sAbizena, sNota);
    
   end;
 
   writeln; 
   writeln('Batezbestekoa = ', rBatukaria/iZenbatIkasle:0:3);
 
   writeln ;
   writeln('//////////////////////////////////////') ;
   readln ;
end.
Koloreen bitartez adierazten da pantailan idatzitakoa zein modulutik datorren
(handiago ikusteko irudiaren gainean klik egin)
?
ZenbaitNotenBatezbestekoAritmetikoa.pas
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
{
   Zenbait ikasleren noten batezbesteko aritmetikoa kalkulatu behar da.
   Ikasle bakoitzaren nota, bere izena eta deiturarekin batera dator.
    
   Ikasleen kopurua programaren hasieran irakurriko da, eta kopuru hori
   teklatuz ematean karaktere-kate bat erabiliko da. Horrela, kopurua
   onargarria dela ziurtatu ahalko da eta ondorioz exekuzio-denborako
   errorerik ez da gertatuko.
 
   Ikasle jakin baten datua den karaktere-katearen ezaugarriak:
 
     - Datuaren luzera maximoa 30 karaktere
     - Datuan izena, deitura eta nota daude
     - Notak hainbat zifra ditu eta edozein tokitan izan daitezke:
         * Gutxienez zifra bat dago
         * Lehen zifra unitatea da eta gainerakoak hamartarrak
         * Zifrak ez dira zertan jarraian egon behar
         * Suposatu notarik txikiena 0 dela eta handiena 9.999 dela
     - Letrak direla eta, izena deitura baino lehenago dago
     - Izena letra larriz hasten da eta gainerakoak minuskulak dira
     - Deitura letra larriz hasten da eta gainerakoak minuskulak dira
         
   Zenbat ikasle diren teklatuaren bitartez harturik, datuak eman, notak
   eskuratu eta nota guztien batezbestekoa kalkulatu. Adibidez:
    
        Eleo72norIz1a     ------> 7.21
        Peru6Sala8zarc
        AmagoiaLaka5rra   ------> 5
        4RuyRuiz91        ------> 4.91
     
        (+7.21 +6.8 +5 +4.91)/4 = 5.98
}
  
program ZenbaitNotenBatezbestekoAritmetikoa;
uses
   crt;
    
type
   tsKate30 = string[30];
 
procedure IzenAbizen_Nota(sIkaslea: tsKate30; var sIzenAbizen, sNota: tsKate30);
var
   iKont: integer;
begin
   writeln('IzenAbizen_Nota() prozeduran ------------------------------');
   sNota := '';
   sIzenAbizen := '';
   for iKont:=1 to length(sIkaslea) do
   begin
      if (sIkaslea[iKont] >= '0') and (sIkaslea[iKont] <= '9') then
         sNota := sNota + sIkaslea[iKont]
      else
         sIzenAbizen := sIzenAbizen + sIkaslea[iKont];
   end;
   writeln('      sNota (', length(sNota):2, ' karaktere)   |', sNota, '|');
   writeln('sIzenAbizen (', length(sIzenAbizen):2, ' karaktere)   |', sIzenAbizen, '|');
    
   writeln('IzenAbizen_Nota() prozeduraren amaiaera -------------------');
end;
    
    
procedure Izen_Abizen(sIzenAbizen: tsKate30; var sIzena, sAbizena: tsKate30);
var
   iKont, iHasieraNon: integer;
begin
   writeln('Izen_Abizen() prozeduran ----------------------------------');
    
   iHasieraNon := 2;
   iKont := 2;
   while sIzenAbizen[iKont] > 'Z' do
   begin
      writeln(iKont:2, '.  ---> ', sIzenAbizen[iKont]);
      iKont := iKont + 1;
   end;
   iHasieraNon := iKont;
    
   writeln('Deituraren hasierako posizioa ', iHasieraNon, ' da');  
     
   sIzena := copy(sIzenAbizen, 1, iHasieraNon-1);
   sAbizena := copy(sIzenAbizen, iHasieraNon, length(sIzenAbizen)-iHasieraNon+1);
    
   writeln('  sIzena (', length(sIzena):2, ' karaktere)   |', sIzena, '|');
   writeln('sAbizena (', length(sAbizena):2, ' karaktere)   |', sAbizena, '|');
    
   writeln('Izen_Abizen() prozeduraren amaiaera -----------------------');
end;
    
    
procedure DatuakBakandu(sIkaslea: tsKate30; var sIzena, sAbizena, sNota: tsKate30);
var
   iZenbatZifra: integer;
   sIzenAbizen: tsKate30;
begin
   textcolor(Cyan);
   writeln('DatuakBakandu() prozeduran --------------------------------');
    
   textcolor(Yellow);
   IzenAbizen_Nota(sIkaslea, sIzenAbizen, sNota);
    
   iZenbatZifra := length(sNota);
   if iZenbatZifra > 1 then
      insert('.', sNota, 2);
    
   textcolor(Magenta);
   Izen_Abizen(sIzenAbizen, sIzena, sAbizena);
    
   textcolor(Cyan);
   writeln('sIzena   (', length(sIzenA):2, ' karaktere)   |', sIzena, '|');
   writeln('sAbizena (', length(sAbizena):2, ' karaktere)   |', sAbizena, '|');
   writeln('sNota    (', length(sNota):2, ' karaktere)   |', sNota, '|');
    
   writeln('DatuakBakandu() prozeduraren amaiaera ---------------------');
   textcolor(LightGray);
end;
    
    
{-------------------------Programa Nagusia-------------------------}
var
   sZenbat, sIkaslea, sNota, sIzena, sAbizena: tsKate30;
   rNota, rBatukaria: real;
   iZenbatIkasle, iKont, iErroreaNon: integer;
begin
   writeln('//////////////////////////////////////');
   writeln;
   repeat
      write('Zenbat ikasle izango dira (adibidez 4): ');
      readln(sZenbat);
      val(sZenbat, iZenbatIkasle, iErroreaNon);
      if iErroreaNon <> 0 then
         writeln('Datu okerra ', iErroreaNon, '. posizioko karakterea onargarria ez delako.')
      else
        if iZenbatIkasle <= 0 then
           writeln('Ikasleen kopurua gutxienez 1 izan behar da.');
   until (iZenbatIkasle > 0) and (iErroreaNon = 0);
    
   rBatukaria := 0.0;
   for iKont:=1 to iZenbatIkasle do
   begin
      writeln;
      write(iKont, '. ikaslearen datuak (adibidez: Eleo72norIz1a): ');
      readln(sIkaslea);
    
      writeln;
      writeln('datua ==>', sIkaslea, '<==');
       
      DatuakBakandu(sIkaslea, sIzena, sAbizena, sNota);
       
      writeln(iKont:2, '. ikaslea (kateak)    >>>  |', sIzena,'|   |', sAbizena,'|   |', sNota,'|');
      val(sNota, rNota, iErroreaNon);
      writeln(iKont:2, '. ikaslea (zenbakiak) >>>  rNota = ', rNota:0:3, '   iErroreaNon = ', iErroreaNon);
       
      rBatukaria := rBatukaria + rNota;
   end;
      
   writeln; 
   writeln('Batezbestekoa = ', rBatukaria/iZenbatIkasle:0:3);
     
   writeln;
   writeln('//////////////////////////////////////');
   repeat until keypressed;
end.


Datuen eredua itxiagoa denean programa errazagoa izango da. Esate baterako, zifren kopurua ezaguna denean eta haien posizioak finkoak direnean, edo/eta izena eta abizena banatzeko karaktere jakin bat erabiltzen denean.

?
ZenbaitNotenBatezbestekoAritmetikoa.pas
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
{
   Zenbait ikasleren noten batezbesteko aritmetikoa kalkulatu behar da.
   Ikasle bakoitzaren nota, bere izena eta deiturarekin batera dator.
    
   Ikasleen kopurua programaren hasieran irakurriko da, eta kopuru hori
   teklatuz ematean karaktere-kate bat erabiliko da. Horrela, kopurua
   onargarria dela ziurtatu ahalko da eta ondorioz exekuzio-denborako
   errorerik ez da gertatuko.
 
   Ikasle jakin baten datua den karaktere-katearen ezaugarriak:
 
     - Datuaren luzera maximoa 30 karaktere
     - Datuan izena, deitura eta nota daude
     - Izena eta abizena '_' karakterez banaturik daude
     - Notak 3 zifra ditu:
         * Lehen posizioko karakterea zifra bat da eta unitatea adierazten du
         * Azkenaurreko karakterea zifra bat da eta hamarrekoa adierazten du
         * Azkeneko karakterea zifra bat da eta ehunekoa adierazten du
     - Izenak hainbat karaktere ditu:
         * Bigarren posizioko karakterea izenaren hasiera da
         * '_' karakterearen aurrekoa izenaren azken karakterea da
     - Abizenak hainbat karaktere ditu:
         * '_' karakterearen hurrengoa abizenaren hasiera da
         * Notaren hamarreko karakterearen aurrekoa abizenaren azkena da
         
   Zenbat ikasle diren teklatuaren bitartez harturik, datuak eman, notak
   eskuratu eta nota guztien batezbestekoa kalkulatu. Adibidez:
    
        7ana_iza21        ------> 7.21
        8Peru_SalaZar69   ------> 8.69
        3AMAIA_ORBE57     ------> 3.57
        4Ruy_Ruiz93       ------> 4.93
     
        (+7.21 +8.62 +3.57 +4.91)/4 = 6.10
}
  
program ZifraIzena_AbizenaZifrak;
uses
   crt;
    
type
   tsKate30 = string[30];
    
    
procedure DatuakBakandu(sIkaslea: tsKate30; var sIzena, sAbizena, sNota: tsKate30);
var
   iAzpimarraNon: integer;
begin
   writeln('DatuakBakandu() prozeduran ---------------------------------');
    
   sNota := sIkaslea[1] + '.' + sIkaslea[length(sIkaslea)-1] + sIkaslea[length(sIkaslea)];
    
   iAzpimarraNon := pos('_', sIkaslea);
   sIzena := copy(sIkaslea, 2, iAzpimarraNon-2);
   sAbizena := copy(sIkaslea, iAzpimarraNon+1, length(sIkaslea)-iAzpimarraNon-2);
    
   writeln('sIzena   (', length(sIzenA):2, ' karaktere)   |', sIzena, '|');
   writeln('sAbizena (', length(sAbizena):2, ' karaktere)   |', sAbizena, '|');
   writeln('sNota    (', length(sNota):2, ' karaktere)   |', sNota, '|');
    
   writeln('DatuakBakandu() prozeduraren amaiaera ----------------------');
end;
    
    
{-------------------------Programa Nagusia-------------------------}
var
   sZenbat, sIkaslea, sNota, sIzena, sAbizena: tsKate30;
   rNota, rBatukaria: real;
   iZenbatIkasle, iKont, iErroreaNon: integer;
begin
   writeln('//////////////////////////////////////');
   writeln;
   repeat
      write('Zenbat ikasle izango dira (adibidez 4): ');
      readln(sZenbat);
      val(sZenbat, iZenbatIkasle, iErroreaNon);
      if iErroreaNon <> 0 then
         writeln('Datu okerra ', iErroreaNon, '. posizioko karakterea onargarria ez delako.')
      else
        if iZenbatIkasle <= 0 then
           writeln('Ikasleen kopurua gutxienez 1 izan behar da.');
   until (iZenbatIkasle > 0) and (iErroreaNon = 0);
    
   rBatukaria := 0.0;
   for iKont:=1 to iZenbatIkasle do
   begin
      writeln;
      write(iKont, '. ikaslearen datuak (adibidez: 7ana_iza21): ');
      readln(sIkaslea);
    
      writeln;
      writeln('datua ==>', sIkaslea, '<==');
       
      DatuakBakandu(sIkaslea, sIzena, sAbizena, sNota);
       
      writeln(iKont:2, '. ikaslea (kateak)    >>>  |', sIzena,'|   |', sAbizena,'|   |', sNota,'|');
      val(sNota, rNota, iErroreaNon);
      writeln(iKont:2, '. ikaslea (zenbakiak) >>>  rNota = ', rNota:0:3, '   iErroreaNon = ', iErroreaNon);
       
      rBatukaria := rBatukaria + rNota;
   end;
      
   writeln; 
   writeln('Batezbestekoa = ', rBatukaria/iZenbatIkasle:0:3);
     
   writeln;
   writeln('//////////////////////////////////////');
   repeat until keypressed;
end.
 
ordua: iruzkinik ez:
Etiketak:

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

8. ASTEA | etxerako lana

 8. astea (2024/03/12) etxean egitekoa

Autoebaluazioa Azp-1: menu bat azpiprogramaz (kateak)

Aurreko astean eskatutako 7. astea | menu bat azpiprogramaz ariketa eredutzar harturik, antzekoa den beste hau egizu: Autoebaluazioa Azp-1: menu bat azpiprogramaz (kateak). Programa berria gidatzeko menu bat programatu beharra dago, aukerak hauek direla:

                                MENUA

        M  Maiuskulak eta minuskulak
        D   Katea pantailaratu diagonalki
        B   Bi noten batezbestekoa aritmetikoa
        H   Hainbat noten batezbestekoa aritmetikoa      

         I   Irten          

                           Zure aukera: __

Aukera guztiak azpiprograma banatan programatu, eta eskatzen diren aukera bakoitzaren kodea hemendik har daiteke 8. astea | kateen adibideak:
 
ordua: iruzkinik ez:
Etiketak:

8. ASTEA | laborategi/mintegian egin dena

 8. astea (2024/03/12) laborategi/mintegian egindakoa

  • Zerrenda pasatu dugu. Deitutako 25en artean 6 ez dira etorri (zehaztapen gehiago eGela zerbitzuan)
 
ordua: iruzkinik ez:
Etiketak:

8. astea | kateen adibideak

Katearen karaktereak banan-banan prozesatu.
?
MaiuskulakMinuskulak.pas
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
{
   Datuaren luzera maximoa 20 karaktere. Karaktereak banan banan
   aztertuz bokal guztiak maiuskuletan jarri eta gainerako
   karaktere guztiak minuskuletan jarri.
    
   Datua ------> KrokodiLO bErDe@ PoziK daGO
   Emaitza ----> krOkOdIlO bErdE@ pOz
}
 
program MaiuskulakMinuskulak ;
type
   tKate20 = string[20] ;
 
 
function fnboBokalaDa(cLetra: char): boolean ;
begin
   case cLetra of
      'a', 'e', 'i', 'o', 'u': fnboBokalaDa := TRUE ; 
      'A', 'E', 'I', 'O', 'U': fnboBokalaDa := TRUE
      else
         fnboBokalaDa := FALSE;
   end ;
end ;
 
 
{-------------------------Programa Nagusia-------------------------}
var
   sEsaldia: tKate20 ;
   k: integer ;
begin
   writeln('//////////////////////////////////////') ;
   writeln ;
   write('Esaldia eman: ') ;
   readln(sEsaldia) ;
 
   writeln('==>', sEsaldia, '<==') ;
    
   for k:=1 to length(sEsaldia) do
   begin
      if fnboBokalaDa(sEsaldia[k]) then
         sEsaldia[k] := upcase(sEsaldia[k])
      else
         sEsaldia[k] := lowercase(sEsaldia[k]) ;  
   end ;
 
   writeln('==>', sEsaldia, '<==') ;
 
   writeln ;
   writeln('//////////////////////////////////////') ;
   readln ;
end.

Bi kateren zatia eskuratu eta zenbaki bihurtu.
?
BiNotenBatezbestekoa.pas
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
{
    Datua den karaktere-katearen ezaugarriak:
       - Datuaren luzera maximoa 20 karaktere.
       - Datuaren hasieran izen bat dago, adibidez Eleonor izena.
       - Datuaren erdian banatzaile bat agertuko da, # karakterea.
       - Datuaren amaieran nota bat dago, adibidez 7.2 nota
         (beti zifra bat, puntua eta dezimal bakarra).
  
    Datu bi teklatuaren bitartez harturik, notak eskuratu eta
    nota biren batezbestekoa lortu.
    
    Eleonor#7.2
    Paul#6.8
    (7.2+6.8)/2 => 7.0
}
  
program BiNotenBatezbestekoa ;
type
   tKate20 = string[20] ;
  
  
procedure NotaBakandu(sIkaslea: tKate20; var sNota: tKate20) ;
var
   iBanatzaileaNon: integer ;
begin
   iBanatzaileaNon := pos('#', sIkaslea) ;
   writeln(sIkaslea, ' datuan # ', iBanatzaileaNon, '. posizioan') ;
     
   sNota := copy(sIkaslea, iBanatzaileaNon+1, 3) ;
end ;  
  
  
{-------------------------Programa Nagusia-------------------------}  
var
   sIkasle1, sIkasle2, sNota1, sNota2: tKate20 ;
   rNota1, rNota2: real ;
   iErroreaNon1, iErroreaNon2: integer ;
begin
   writeln('//////////////////////////////////////') ;
   writeln ;
   write('Lehen ikaslearen datuak eman (adibidez: Eleonor#7.2): ') ;
   readln(sIkasle1) ;
   write('Bigarren ikaslearen datuak eman (adibidez: Paul#6.8): ') ;
   readln(sIkasle2) ;
  
   writeln('1==>', sIkasle1, '<==1') ;
   writeln('2==>', sIkasle2, '<==2') ;
   writeln ;
     
   NotaBakandu(sIkasle1, sNota1) ;
   writeln('1 sNota ==>', sNota1, '<==') ;
  
   NotaBakandu(sIkasle2, sNota2) ;
   writeln('2 sNota ==>', sNota2, '<==') ;
    
   writeln ;
     
   val(sNota1, rNota1, iErroreaNon1) ;
   writeln('1 rNota ==>', rNota1, '     iErroreaNon1=', iErroreaNon1) ;
   if iErroreaNon1 <> 0 then
      writeln('1==>', sIkasle1, '<==1 datua ez da egokia') ;
        
   val(sNota2, rNota2, iErroreaNon2) ;
   writeln('2 rNota ==>', rNota2, '     iErroreaNon2=', iErroreaNon2) ;
   if iErroreaNon2 <> 0 then
      writeln('2==>', sIkasle2, '<==2 datua ez da egokia') ;
  
   writeln ;     
   if (iErroreaNon1 = 0) and (iErroreaNon2 = 0) then
      writeln('Batezbestekoa = ', (rNota1+rNota2)/2:0:2)
   else
      writeln('Batezbestekoa ezin izan da kalkulatu') ;
     
   writeln ;
   writeln('//////////////////////////////////////') ;
   readln ;
end.

Bi kateren zatia eskuratu eta zenbaki bihurtu. Kontuz 0 posizioaren edukiarekin.
?
BiNotenBatezbestekoAritmetikoa.pas
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
{
    Datua den karaktere-katearen ezaugarriak:
       - Datuaren luzera maximoa 20 karaktere.
       - Datuaren hasieran izen bat dago, adibidez Eleonor izena.
       - Datuaren amaieran nota bat dago, adibidez 7.2 nota
         (beti zifra bat, puntua eta dezimal bakarra).
  
    Datu bi teklatuaren bitartez harturik, notak eskuratu eta
    nota biren batezbestekoa lortu.
    
    Liudmila7.2
    Kiril6.8
    (7.2+6.8)/2 => 7.0
}
  
program BiNotenBatezbestekoAritmetikoa;
type
   tKate20 = string[20];
  
  
function fnsNotaBakandu(sIkaslea: tKate20): tKate20;
var
   sNota: tKate20;
begin
   sNota := sIkaslea[length(sIkaslea)-2];
   sNota := sNota + sIkaslea[length(sIkaslea)-1]; 
   sNota := sNota + sIkaslea[length(sIkaslea)];
    
   fnsNotaBakandu := sNota;
end;  
  
  
{-------------------------Programa Nagusia-------------------------}  
var
   sIkasle1, sIkasle2, sNota1, sNota2: tKate20;
   rNota1, rNota2: real;
   iErroreaNon1, iErroreaNon2: integer;
begin
   writeln;
   writeln;
   writeln;
   writeln('//////////////////////////////////////');
   writeln;
   write('Lehen ikaslearen datuak eman (adibidez: Liudmila7.2): ');
   readln(sIkasle1);
   write('Bigarren ikaslearen datuak eman (adibidez: Kiril6.8): ');
   readln(sIkasle2);
  
   writeln('1==>', sIkasle1, '<==1');
   writeln('2--|', sIkasle2, '|--2');
   writeln;
     
   sNota1 := fnsNotaBakandu(sIkasle1);
   writeln('1 sNota ==>', sNota1, '<==');
  
   sNota2 := fnsNotaBakandu(sIkasle2);
   writeln('2 sNota --|', sNota2, '|--');
    
   writeln;
     
   Val(sNota1, rNota1, iErroreaNon1);
   writeln('1 rNota ==>', rNota1, '     iErroreaNon1=', iErroreaNon1);
   if iErroreaNon1 <> 0 then
      writeln('1==>', sIkasle1, '<==1 datua ez da egokia');
        
   Val(sNota2, rNota2, iErroreaNon2);
   writeln('2 rNota --|', rNota2, '     iErroreaNon2=', iErroreaNon2);
   if iErroreaNon2 <> 0 then
      writeln('2--|', sIkasle2, '|--2 datua ez da egokia');
  
   writeln;     
   if (iErroreaNon1 = 0) and (iErroreaNon2 = 0) then
      writeln('Batezbestekoa = ', (rNota1+rNota2)/2:0:2)
   else
      writeln('Batezbestekoa ezin izan da kalkulatu');
     
   writeln;
   writeln('//////////////////////////////////////');
   readln;
end.

Hainbat kateren zatia eskuratu eta zenbaki bihurtu.
?
HainbatNotenBatezbestekoAritmetikoa.pas
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
{
    Datua den karaktere-katearen ezaugarriak:
       - Datuaren luzera maximoa 30 karaktere.
       - Datuaren hasieran letrak daude, izen bati dagozkion letrak
       - Datuaren amaieran nota bat dago, adibidez 7.24 nota edo 6 nota
         edo 5.725 (lehen zifra, puntua eta dezimal batzuk; edo zifra
         bakar bat punturik gabe eta dezimalik gabe).
           
    Zenbat ikasle diren teklatuaren bitartez harturik, notak eskuratu eta
    nota guztien batezbestekoa lortu.
     
    Izaskun7.24
    Pili4.9
    Amagoia5
    Ruy6.3333
      
    (7.24 +4.9 +5 +6.3333) / 4 = 5.868325
}
   
program HainbatNotenBatezbestekoAritmetikoa;
type
   tKate30 = string[30];
   
   
procedure DatuakBakandu(sIkaslea: tKate30; var sIzena, sNota: tKate30);
var
   iLehenZifraNon: integer;
begin
   iLehenZifraNon:= 1;
   while (sIkaslea[iLehenZifraNon] < '0') or (sIkaslea[iLehenZifraNon] > '9') do
      iLehenZifraNon:= iLehenZifraNon +1 ; 
      
   sIzena:= copy(sIkaslea, 1, iLehenZifraNon-1);
   sNota:= copy(sIkaslea, iLehenZifraNon,  length(sIkaslea)-iLehenZifraNon+1);
     
   //writeln('sIzena   = ', sIzena);
   //writeln('sNota    = ', sNota);
end;  
   
   
{-------------------------Programa Nagusia-------------------------} 
var
   sIkaslea, sNota, sIzena: tKate30;
   rNota, rBatukaria: real;
   iZenbatIkasle, iKont: integer;
begin
   writeln;
   writeln;
   writeln;
   writeln('///////////////////////////////////////');
   writeln;
   repeat
      write('Zenbat ikasle izango dira (adibidez 4): ');
      readln(iZenbatIkasle);
   until iZenbatIkasle > 0;
   writeln;
     
   rBatukaria:= 0.0;
   for iKont:=1 to iZenbatIkasle do
   begin
      write(iKont, '. ikaslearen datuak (adibidez Eneko7.25 edo Ana3.6666): ');
      readln(sIkaslea);
     
      DatuakBakandu(sIkaslea, sIzena, sNota);
      writeln(iKont, '. ikaslea:  |', sIzena,'|  |', sNota,'|');
       
      val(sNota, rNota);
      writeln(iKont, '. ikaslearen nota = ', rNota:0:6);
      writeln;
        
      rBatukaria:= rBatukaria + rNota;
   end;
         
   writeln('Batezbestekoa = ', rBatukaria/iZenbatIkasle:0:6);
      
   writeln;
   writeln('///////////////////////////////////////');
   readln;
end.

Hainbat kateren zatia eskuratu eta zenbaki bihurtu.
?
HainbatNotenBatezbestekoa.pas
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
{
    Datua den karaktere-katearen ezaugarriak:
       - Datuaren luzera maximoa 30 karaktere.
       - Datuaren hasieran izen bat dago, adibidez Eleonor izena.
       - Datuaren erdian nota bat dago, adibidez +7.2 nota edo -6.8 nota
         (zeinua, lehen zifra, puntua eta dezimal bakarra).
       - Datuaren amaieran abizena dago, adibidez Iza abizena.
          
    Zenbat ikasle diren teklatuaren bitartez harturik, notak eskuratu eta
    nota guztien batezbestekoa lortu.
    
    Eleonor+7.2Iza
    Paul-6.8Salazar
    Amagoia+5.5Lakarra
    Ruy-4.9Ruiz
     
    (7.2 -6.8 +5.5 -4.9) / 4 = 0.25
}
  
program HainbatNotenBatezbestekoa ;
type
   tKate30 = string[30] ;
  
  
procedure NotaBakandu(sIkaslea: tKate30; var sIzena, sAbizena, sNota: tKate30) ;
var
   iBanatzaileaNon: integer ;
begin
   iBanatzaileaNon := pos('+', sIkaslea) ;
   if iBanatzaileaNon = 0 then
      iBanatzaileaNon := pos('-', sIkaslea) ;
       
   writeln('Banatzailearen posizioa ', iBanatzaileaNon, ' da') ;  
     
   sIzena := copy(sIkaslea, 1, iBanatzaileaNon-1) ;
   sNota := copy(sIkaslea, iBanatzaileaNon, 4) ;
   sAbizena := copy(sIkaslea, iBanatzaileaNon+4, length(sIkaslea)-iBanatzaileaNon+4) ;
    
   writeln('sIzena   = ', sIzena) ;
   writeln('sNota    = ', sNota) ;
   writeln('sAbizena = ', sAbizena) ;
end ;  
  
  
{-------------------------Programa Nagusia-------------------------}  
var
   sIkaslea, sNota, sIzena, sAbizena: tKate30 ;
   rNota, rBatukaria: real ;
   iZenbatIkasle, k, iErroreaNon: integer ;
begin
   writeln('//////////////////////////////////////') ;
   writeln ;
   repeat
      write('Zenbat ikasle izango dira (adibidez 4): ') ;
      readln(iZenbatIkasle) ;
   until iZenbatIkasle > 0 ;
    
   rBatukaria := 0.0 ;
   for k:=1 to iZenbatIkasle do
   begin
      write(k, '. ikaslearen datuak (adibidez: Ruy+7.2Ruiz): ') ;
      readln(sIkaslea) ;
    
      writeln ;
      writeln('datua ==>', sIkaslea, '<==') ;
    
      NotaBakandu(sIkaslea, sIzena, sAbizena, sNota) ;
      writeln(k, '. ikaslea:  |', sIzena,'|  |', sAbizena,'|  |', sNota,'|') ;
      
      writeln ;
      val(sNota, rNota, iErroreaNon) ;
      //writeln(k, '. ikaslea:   rNota = ', rNota:0:1, '   iErroreaNon = ', iErroreaNon) ;
       
      rBatukaria := rBatukaria + rNota ;
   end ;
      
   writeln ; 
   writeln('Batezbestekoa = ', rBatukaria/iZenbatIkasle:0:3) ;
     
   writeln ;
   writeln('//////////////////////////////////////') ;
   readln ;
end.

Datuen egokitasuna zainduz, hainbat kateren zatia eskuratu eta zenbaki bihurtu.
?
HainbatNotenBatezbestekoa_DatuakKontrolatuz.pas
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
{
    Datua den karaktere-katearen ezaugarriak:
       - Datuaren luzera maximoa 30 karaktere.
       - Datuaren hasieran izen bat dago, adibidez Eleonor izena.
       - Datuaren erdian nota bat dago, adibidez +7.2 nota edo -6.8 nota
         (zeinua, lehen zifra, puntua eta dezimal bakarra).
       - Datuaren amaieran abizena dago, adibidez Iza abizena.      
  
    Zenbat ikasle diren teklatuaren bitartez harturik, ikaslearen datuak hartu eta
    egokitasuna frogatu ondoren nota eskuratu, nota guztien batezbestekoa lortzeko.
    
    Eleonor+7.2Iza
    Paul-6.8Salazar
    Amagoia+5.5Lakarra
    Ruy-4.9Ruiz
     
    (7.2 -6.8 +5.5 -4.9) / 4 = 0.25
}
  
program KatearenEgokitasunaKontrolatu ;
type
   tKate30 = string[30] ;
  
  
function fnboDatuaEgokiaDa(sIkaslea: tkate30): boolean ;
var
   iZeinuaNon, iErroreaNon: integer ;
   sNota: tkate30 ;
   rNota: real ;
begin
   fnboDatuaEgokiaDa := TRUE ;
    
   if (pos('+', sIkaslea) = 0) and (pos('-', sIkaslea) = 0) then
   begin
      writeln('Zeinua falta da!!!') ;
      fnboDatuaEgokiaDa := FALSE ;
   end ;
    
   if (pos('+', sIkaslea) <> 0) or (pos('-', sIkaslea) <> 0) then
   begin
      if pos('+', sIkaslea) = 0 then
         iZeinuaNon := pos('-', sIkaslea)
      else 
         iZeinuaNon := pos('+', sIkaslea) ;
      
      sNota := copy(sIkaslea, iZeinuaNon, 4) ;
      writeln('sNota = |', sNota,'|') ;
      val(sNota, rNota, iErroreaNon) ;
      if iErroreaNon <> 0 then
      begin
         writeln('Zifrak edo puntua oker, notaren ', iErroreaNon, '. posizioan errorea dago!!!') ;
         fnboDatuaEgokiaDa := FALSE ;
      end
      else  (* zeinua eta nota ondo daudenean *)
      begin
         if iZeinuaNon = 1 then
         begin
            writeln('Izena falta da!!!') ;
            fnboDatuaEgokiaDa := FALSE ;
         end ;
         if iZeinuaNon+3 = length(sIkaslea) then
         begin
            writeln('Abizena falta da!!!') ;
            fnboDatuaEgokiaDa := FALSE ;
         end ;
      end ;
   end ; 
end ;
 
  
procedure DatuakBakandu(sIkaslea: tKate30; var sIzena, sAbizena, sNota: tKate30) ;
var
   iBanatzaileaNon: integer ;
begin
   iBanatzaileaNon := pos('+', sIkaslea) ;
   if iBanatzaileaNon = 0 then
      iBanatzaileaNon := pos('-', sIkaslea) ;
       
   writeln('Zeinuaren posizioa ', iBanatzaileaNon, ' da') ;  
     
   sIzena := copy(sIkaslea, 1, iBanatzaileaNon-1) ;
   sNota := copy(sIkaslea, iBanatzaileaNon, 4) ;
   sAbizena := copy(sIkaslea, iBanatzaileaNon+4, length(sIkaslea)-iBanatzaileaNon+4) ;
    
   writeln('sIzena   = ', sIzena) ;
   writeln('sNota    = ', sNota) ;
   writeln('sAbizena = ', sAbizena) ;
end ;  
  
   
{-------------------------Programa Nagusia-------------------------}  
var
   sIkaslea, sNota, sIzena, sAbizena: tKate30 ;
   rNota, rBatukaria: real ;
   iZenbatIkasle, k: integer ;
   boDatuaEgokiaDa: boolean ;
begin
   writeln('//////////////////////////////////////') ;
   writeln ;
   repeat
      write('Zenbat ikasle izango dira (adibidez 4): ') ;
      readln(iZenbatIkasle) ;
   until iZenbatIkasle > 0 ;
   writeln ;
    
   rBatukaria := 0.0 ;
   for k:=1 to iZenbatIkasle do
   begin
      repeat
         write(k, '. ikaslearen datuak (adibidez: Ruy+7.2Ruiz): ') ;
         readln(sIkaslea) ;
         boDatuaEgokiaDa := fnboDatuaEgokiaDa(sIkaslea) ;
         if not boDatuaEgokiaDa then
         begin
            writeln('Datua berriro errepikatu!!!') ;
            writeln ;
         end ;  
      until boDatuaEgokiaDa ;
    
      writeln ;
      writeln('datua ==>', sIkaslea, '<==') ;
    
      DatuakBakandu(sIkaslea, sIzena, sAbizena, sNota) ;
      writeln(k, '. ikaslea:  |', sIzena,'|  |', sAbizena,'|  |', sNota,'|') ;
      
      writeln ;
      val(sNota, rNota) ;
       
      rBatukaria := rBatukaria + rNota ;
   end ;
      
   writeln ; 
   writeln('Batezbestekoa = ', rBatukaria/iZenbatIkasle:0:3) ;
     
   writeln ;
   writeln('//////////////////////////////////////') ;
   readln ;
end.
 
ordua: iruzkinik ez:
Etiketak:

8. astea | palindromoak

Teklatuaren bidez sartutako esaldia palindromoa den aztertu behar du programak. Horretarako, honako azpiprograma haek derrigorrez erabili behar dira:

  • Esaldiaren karaktere alfabetikoak letra larriz idazten dituen funtzioa
  • Alfabetikoak ez diren esaldiko karaktereak kentzen dituen funtzioa
  • Aurreko azpiprogramak aplikatu ondoren, esaldia palindromoa den aztertzen duen funtzio boolearra

Palindromoa: Definizioz, aurretik atzera eta atzetik aurrera irakurketa berdina duen esaldia.

Adibidez:

  • Zein?, Ni ez                                                    [ZEINNIEZ]
  • Atara zarata!!!                                              [ATARAZARATA]
  • Iker! Ireki                                                      [IKERIREKI]
  • Ama zen ene zama                                           [AMAZENENEZAMA]
  • Nik enara neraman amaren aranekin      [NIKENARANERAMANAMARENARANEKIN]
  • Ze nekeza inori atea irekitzea eztikeria eta ironia zekenez                                                                              [ZENEKEZAINORIATEAIREKITZEAEZTIKERIAETAIRONIAZEKENEZ]

Ñ eta ñ kontsonante berezien prozesaketa da egin gabe geratu da laborategian. Hona hemen azalpena.

  • Hasteko, froga ezazu upcase funtzio estandarrak ñ kontsonantea hartzen badu ez duela bihurtzen Ñ karakterea, beraz eskuz egin beharko dugu. 

  • Horrez gain, ñ karakterea katean identifikatzeko ezin daiteke egin normala den konparaketa hau:

    ?
    0 | HAU TXARTO DAGO
    1
    2
    (* katearen k-garren karakterea ñ da? *) { HAU EZ }
    if sEsaldi[k] = 'ñ' then

    Derrigorrez, ASCII taularen araberako ñ karaktereari dagokion ordinala erabili beharko dugu, 164 zenbakia. Horrela:

    ?
    0 | HAU ONDO DAGO
    1
    2
    (* katearen k-garren karakterearen ordinala 164 da? *) { HAU BAI }
    if ord(sEsaldi[k]) = 164 then

  • Bukatzeko, ñ karakterea identifikaturik daukagunean ezin dugu bere ordez Ñ jarri esleipen arruntaren bitartez:

    ?
    0 | HAU TXARTO DAGO
    1
    2
    (* katearen k-garren karakterea orain Ñ gorde *) {HAU EZ}
    sEsaldi[k] := 'Ñ';

    Derrigorrez, berriro ere, ASCII taularen araberako Ñ karaktereari dagokion ordinala erabili beharko dugu, 165 zenbakia. Horrela:

    ?
    0 | HAU ONDO DAGO
    1
    2
    (* k-garren posizioan 165 ordinalari dagokion Ñ karakterea gorde *)
    sEsaldi[k] := chr(165); (* k-garren posizioan Ñ gorde *) { HAU BAI }

Programa osatuaren kodea:

 
ordua: iruzkinik ez:
Etiketak:

8. astea | esaldiaren hitzak


 

Programaren kodea:

?
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
{--------------------------------------------------------------
  Esaldi bat hartu eta bere hitzak banatu egiten duen programa
 --------------------------------------------------------------}
 
program EsaldiBatetikBereHitzakLortu;
uses
   crt;
type
   tKateLuze = string[100];
 
 
function fnsAurrekoakKendu(sEsaldia: tKateLuze): tKateLuze;
//var
//   k: integer;
begin
   writeln('/////fnsAurrekoakKendu funtzio barruan/////');
 
   //k := 1;
   while sEsaldia[1] = ' ' do
   begin
      delete(sEsaldia, 1, 1);
      writeln('posizioa ', 1, ' denean/////', sEsaldia,'/////');
   end;
 
   fnsAurrekoakKendu := sEsaldia;
end;
 
 
function fnsAtzekoakKendu(sEsaldia: tKateLuze): tKateLuze;
var
   iAzkenposizioa: integer;
begin
   writeln('\\\\\fnsAtzekoakKendu funtzio barruan\\\\\');
 
   iAzkenposizioa := length(sEsaldia);
   while sEsaldia[iAzkenposizioa] = ' ' do
   begin
      delete(sEsaldia, iAzkenposizioa, 1);
      writeln('posizioa ', iAzkenposizioa, ' denean\\\\\', sEsaldia,'\\\\\');
      iAzkenposizioa := length(sEsaldia);
   end;
 
   fnsAtzekoakKendu := sEsaldia;
end;
 
 
function fnsErdikoakKendu(sEsaldia: tKateLuze): tKateLuze;
var
   iNon: integer;
begin
   writeln('|||||fnsErdikoakKendu funtzio barruan|||||');
 
   repeat
      iNon := pos('  ', sEsaldia);   (* zuriune bikotea bilatu *)
      write('iNon: ', iNon, ', ');
 
      delete(sEsaldia, iNon, 1);     (* bikotetik zuriune bat kendu *)
      writeln('delete ondoren|||||', sEsaldia,'|||||');
   until iNon = 0;                   (* azken bikotearen bigarren zuriunea geratzen da *)
 
   fnsErdikoakKendu := sEsaldia;
end;
 
 
procedure HitzakErakutsi(sEsaldia: tKateLuze);
var
   sHitza: tKateLuze ;
   k, iNon: integer;
begin
   writeln('#####HitzakErakutsi prozedura barruan#####');
 
   sEsaldia := sEsaldia + ' ';
   k := 1 ;
   iNon := pos(' ', sEsaldia);
   while iNon <> 0 do
   begin
      sHitza := copy(sEsaldia, 1, iNon-1);
 
      delete(sEsaldia, 1, iNon);
     // writeln(k, ' itzulian, delete ondoren#####', sEsaldia,'#####');
 
     writeln(k, '. hitza#####', sHitza,'#####');
     k := k + 1;
     iNon := pos(' ', sEsaldia);
   end;
end;
 
 
{---------------------Programa nagusia---------------------}
var
   sEsaldia, sEsaldiBerri1, sEsaldiBerri2, sEsaldiBerri3: tKateLuze;
begin
   clrscr;
    
   write('Sarrerako esaldia eman: ');
   readln(sEsaldia);
   writeln('===>', sEsaldia, '<===');
 
   writeln;
   sEsaldiBerri1 := fnsAurrekoakKendu(sEsaldia);
   writeln('===>', sEsaldiBerri1, '<===');
 
   writeln;
   sEsaldiBerri2 := fnsAtzekoakKendu (sEsaldiBerri1);
   writeln('===>', sEsaldiBerri2, '<===');
 
   writeln;
   sEsaldiBerri3 := fnsErdikoakKendu (sEsaldiBerri2);
   writeln('===>', sEsaldiBerri3, '<===');
 
   (* esaldi barruan hitzak zuriune bakarrez banaturik daude *)
   (* hitzak esalditik banatu, horretarako zuriuneak bilatu  *)
   writeln;
   HitzakErakutsi(sEsaldiBerri3);
 
   writeln;
   writeln('=======================');
   writeln('RETURN sakatu amaitzeko');
   writeln('=======================');
   readln;
end.
 
ordua: iruzkinik ez:
Etiketak:
Harpidetu honetara: Mezuak (Atom)