2023(e)ko martxoaren 29(a), asteazkena

10. ASTEA | etxerako lana

 10. astea (2023/03/27) etxean egitekoa








    ARRAYEKIN LAN EGITEKO BALIABIDEAK:



 

10. ASTEA | laborategi/mintegian egin dena

 10. astea (2023/03/27) laborategi/mintegian egindakoa





Kontrolaren bidalketaren bitartez zerrenda pasatu dugu. Azterketarik bidali ez dutenak:

  1. Unai Aguinagalde del Barrio

  2. Ibon Carro Valladares

  3. Leire Garcia Baz

  4. Nagore Garcia Ibarra

  5. Garazi Iparragirre Martinez

  6. June Postigo Colas

  7. Uxue Rodriguez Calzada

  8. Maria Saenz de Buruaga Echevarria

  9. Haizea Seijo Gabicagogeascoa





 

Proiektua ebaluatzen

Ikasturtearen hasierako ebaluazioaren banaketa eta egin beharrekoak:










Proiektuaren kalifikazioa


Proiektuaren programa gehi proiektuari lotutako hirugarren kontrolak honako hau balio dute: 0,5 + 1,0 = 1,5 puntu.

















Hirugarren kontrola, ariketa handia (proiektua)


Iazko azterketa baten inguruan jardungo dugu kurtsoaren zehar.

15. astean, azken praktika egunean, proiektuari buruzko bakarkako froga:
  • azp1, 2023-05-9an
  • azp2, 2023-05-10ean
  • azp3, 2023-05-8an



     
     
    %66a










    1,0 puntu






    Proiektuaren emaitza (proiektuaren programa).

    Lantaldeko partaideek kalifikazio berdina.


      %33a


      0,5 puntu


      Irakasgaiaren ebaluazioa artikulutik hartutako taula


       

      Proiektua: jorratu beharreko ibilbidea



      Baliabideak


      Proiektuarekin lotutako hasierako informazioa hau da:









      Bidea


      Udaberriko oporraldira joan aurretik, apirilaren 10eko laborategi egunean, irakasleak proiektuaren enuntziatua azaldu zuen eta erabiliko diren unitateei dagozkien interfazeen deskribapenak egin zituen (baliabideak lau direnez datu_mota, biblioteka, erabiltzaile eta top10 unitateak azaldu ziren).



      Ondoren, bide hau ireki zen:






      Bideak hiru munarri ditu:



      1. Proiektuaren baliabideak unitate batean garaturik daude, apirilaren 10ean unitatearen funtzionamendua laborategian ikusi da. Zuen lana: etxeko ordenadorean unitate baten funtzionamendua frogatzea, bi adibide: itsas-bataila (i) eta itsas-bataila (ii)

      2. Proiektuari gehituko dizkiozuen hobekuntzen aitorpena, gehien jota apirilaren 22rako (astearterako) bete behar duzue Proiektua: hobekuntzak aitortu (2023) izeneko zereginari erantzunez

      3. Proiektua garatu, gehien jota maiatzaren 1erako (astelehenerako) bukatu beharko duzue eta bere entrega Proiektua amaiturik (2023) izeneko zereginaren bitartez egingo duzue



      Goiko irudia begiratu, ikusten duzue bidea bukatzen den tontorraren ostean beste tontor bat agertzen dela? Ba bai, halaxe da, oraindik zerbait gehiago falta da, hau:


      Hirugarren munarrian entregatu duzuen lanaren gaineko azterketa bat pasatu beharko duzue 15. asteko praktika egunean (maiatzaren 8an). Lantaldearen kide bakoitzak froga bera egin beharko du bakarka, ordenagailuaren aurrean garatutako proiektuaren gaineko ariketa bat izango da.






      Entregak


      Goiko irudian proiektuaren urratsak erakusten badira, hurrengo irudi honetan urrats bakoitzean zer entregatuko duzuen erakusten da:



      1. Proiektuari laguntzen dion unitate sorta: zuen etxeko ordenagailuan frogatu. Entregarik ez dago, baina arazorik baduzue tutoretza bat eska ezazue

      2. Proiektuari gehitu dizkiozuen hobekuntzen aitorpena: txosten bat idatzi bat

      3. Proiektua garatu: txosten bat idatzi bat eta programa bat (programa iruzkindu)

      4. Proiektuaren gaineko bakarkako froga: programa bat











      Kalifikazioa


      Guzti honetatik 1,0 + 0,5 = 1,5 puntu ateratzen dira:

















      Hirugarren kontrola, ariketa handia (proiektua)


      Iazko azterketa baten inguruan jardungo dugu kurtsoaren zehar.

      15. astean, azken praktika egunean, proiektuari buruzko bakarkako froga:
      • azp1, 2023-05-9an
      • azp2, 2023-05-10ean
      • azp3, 2023-05-8an



         
         
        %66a










        1,0 puntu






        Proiektuaren emaitza (proiektuaren programa).

        Lantaldeko partaideek kalifikazio berdina.


          %33a


          0,5 puntu


          Irakasgaiaren ebaluazioa artikulutik hartutako taula


           

          Proiektuaren taldekideak

          Esan bezala, proiektuak taldeka burutuko dira eta taldeen antolaketa ikasleen esku geratuko da. Taldeak hirukoteka osatuko dira beheko taulan ikasle bakoitzaren izena idatziz:






          Taularen ikuspegi osoa nahiago baduzu esteka honen gainean klikatuz taulara joan zaitezke




          Zure izena taulan idazteko urratsak:


          1. AZP3 taulara joan

          2. Zure gmail kontua erabiliz identifikatu

          3. Taula ireki (hurrengo irudia ikusi)

          4. Taula editatu zure izena idatziz






          Hau egiteko egun tartea: martxoaren 31tik apirilaren 5era.


           

          Proiektua zergatik eta zertarako

          Ikasketa prozesuan ikasleak ariketa laburrak egin beharko ditu kontzeptu zehatz bat edo beste ikaste aldera. Baina, azken azterketa, bilduma bat delako, ariketa handia izango da. Horregatik, komenigarria da azken azterketaren neurriko proiektu bat urratsez urrats ikasturtearen zehar garatzea.



          Proiektua mintegiko (12+24 orduak) eskolekin lotuta dago, batez ere gelaz kanpoko 24 orduekin lotuta dago.

          Proiektua bideratzeko Informatika ☆ 2022-23  |  proiektua izeneko bloga erabiliko dugu, non 2021-22 ikasturteko azterketa baten gaineko ariketak erakusten diren. Liburutegi kasu bat aitzakiz hartuz, datuen multzoak prozesatzea izango da proiektuaren helburua.






          Proiektuaren garapenaren urrats bakoitzean, ikasleak argi beharko du izan zer da dagoeneko dakiena eta zer ikasiko duen urrats horretan. Urrats bakoitzaren hasieran, adibidez, honelako informazioa jasoko du ikasleak:






          ZER DAKIDAN:

          Badakit testuak eta konstanteen balioak pantailan idazten.








          ZER IKASIKO DUDAN:

          ReadLn prozedurari esker, teklatuaren bitartez, balio bat aldagai batean gordetzen ikasiko dut. Esleipena operazioaren bitartez aldagai batean balio jakin bat  gordetzen ikasiko dut.




          Azkeneko laborategi egunean, maiatzaren 8an, proiektua gaitzat harturik ikasleak azterketa bat pasatu beharko du.



           


          2023(e)ko martxoaren 14(a), asteartea

          9. ASTEA | etxerako lana

           9. astea (2023/03/20) etxean egitekoa






          Kontrola prestatzeko ariketa esanguratsuak:





           

          9. ASTEA | laborategi/mintegian egin dena

           9. astea (2023/03/20) laborategi/mintegian egindakoa






          • Zerrenda pasatzeko, eGela zerbitzuko 9. saioan egindako programak bidalketaren bitartez. Lanik bidali ez dutenak:


            1. Jon Arana San Anton

            2. Unai Aguinagalde del Barrio

            3. Beñat Alegre Bezares    asteartean etorriko da 

            4. Ibon Carro Valladares

            5. Leire Garcia Baz

            6. Nagore Garcia Ibarra

            7. June Postigo Colas

            8. Uxue Rodriguez Calzada

            9. Maria Saenz de Buruaga Echevarria

            10. Haizea Seijo Gabicagogeascoa

            11. Naia Talles Nanclares





          • Aurreko astean amaitu gabe geratu zen 8. astea | palindromoak ariketa programatu dugu ñ eta Ñ karaktereak aintzat hartu gabe







           

          2023(e)ko martxoaren 8(a), asteazkena

          8. astea | kateen adibideak





          Katearen karaktereak banan-banan prozesatu.


          {
          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.


          {
          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.


          {
          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.


          {
          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.


          {
          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.


          {
          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.


           

          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:



            (* katearen k-garren karakterea ñ da? *) { HAU EZ }
            if sEsaldi[k] = 'ñ' then


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



            (* 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:



            (* 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:



            (* k-garren posizioan 165 ordinalari dagokion Ñ karakterea gorde *)
            sEsaldi[k] := chr(165); (* k-garren posizioan Ñ gorde *) { HAU BAI }









          Programa osatuaren kodea:






          {---------------------------------------------------------
          Palindromoak.pas
          Deskribapena: Esaldia palindromoa den aztertu
          ---------------------------------------------------------}
          program Palindromoak;
          uses crt;

          const
          MAX = 100;

          type
          tKateBat = string[MAX];


          { FUNTZIOA: fnsKontsonanteBerezia
          SARRERA PARAMETROAK: string bat
          IRTEERA PARAMETROAK: string bat
          ATAZA: Emandako testuan ñ minuskula badago upcase funtzioak ez du Ñ larri bihurtuko,
          guk geuk egin beharko dugu. Baina, tamalez, konparaketa hau ez dabil:
          if sEsaldi[k] = 'ñ' then
          eta ñ minuskularen 164 ordinala erabili beharko dugu, horrela:
          if ord(sEsaldi[k]) = 164 then
          Gero, Ñ larria esleitzeko ezin daiteke egin naturala litzetekeen hau:
          sEsaldi[k] := 'Ñ';
          eta berriro ere ordinala erabili beharko da, Ñ larriaren 165 zenbakia:
          sEsaldi[k] := chr(ord(165)); }
          function fnsKontsonanteBerezia(sEsaldi: tKateBat): tKateBat;
          var
          k: integer;
          begin
          { Esaldiko karaktereak banan-banan aztertu eta ñ bada bere ordez Ñ jarri }
          for k:=1 to length(sEsaldi) do
          begin
          //writeln(sEsaldi[k],' ord(sEsaldi[k]) = ', ord(sEsaldi[k]));

          //if sEsaldi[k] = 'ñ' then (* konparaketa modu arruntan eginik, baina ez dabil *)
          if ord(sEsaldi[k]) = 164 then
          begin
          //writeln(sEsaldi[k],' aldatu baino lehen: ORD(sESALDI[k]) = ', ord(sEsaldi[k]));

          //sEsaldi[k] := 'Ñ'; (* esleipena modu arruntan eginik, baina ez dabil *)
          sEsaldi[k] := chr(165);
          //writeln(sEsaldi[k],' aldatu ondoren: ORD(sESALDI[k]) = ', ord(sEsaldi[k]));
          end;
          end;
          fnsKontsonanteBerezia := sEsaldi;
          end;


          { FUNTZIOA: fnsEzabatu
          SARRERA PARAMETROAK: string bat
          IRTEERA PARAMETROAK: string bat
          ATAZA: Emandako testuan Ñ edo A..Z artekoa ez dena ezabatzen da }
          function fnsEzabatu(sEsaldi: tKateBat): tKateBat;
          var
          sK: tKateBat;
          k: integer;
          begin
          sK := ''; { sK aldagai lokala hasieratu }
          { Esaldiko karaktereak banan-banan aztertu eta Ñ edo A..Z artekoa ote den }
          for k:=1 to length(sEsaldi) do
          begin
          if (sEsaldi[k] >= 'A') and (sEsaldi[k] <= 'Z') or (ord(sEsaldi[k]) = 165) then
          sK := sK + sEsaldi[k]; { sEsaldi[k] = 'Ñ' }
          end; { konparaketa arrunta ez dabil }
          fnsEzabatu := sK;
          end;


          { FUNTZIOA: fnsSimetrikoalortu
          SARRERA PARAMETROAK: string bat
          IRTEERA PARAMETROAK: string bat
          ATAZA: Sartutako string hori atzekoz aurrera jarri }
          function fnsSimetrikoalortu(sEsaldi: tKateBat): tKateBat;
          var
          sSimetriko: tKateBat; { sEsaldi katearen simetrikoa }
          k: integer;
          begin
          sSimetriko := ''; { kate simetrikoa hasieratu }
          for k:=length(sEsaldi) downto 1 do
          begin
          sSimetriko := sSimetriko + sEsaldi[k]; { kate simetrikoa osatu }
          end;
          fnsSimetrikoalortu := sSimetriko;
          end;


          {--------------------------PROGRAMA NAGUSIA--------------------------}
          var
          sHasierakoKatea, sSarreraMoldatua, sSimetrikoa: tKateBat;
          cAukera: char;
          begin
          writeln('--------------------------------':50);
          writeln('Palindromoak aztertzeko programa':50);
          writeln('--------------------------------':50);
          writeln;

          { Azterketa errepikatzen da erabiltzaileak kontrakoa erabaki arte }
          repeat
          writeln('Sar ezazu aztertu behar den testua:');
          write(' ');
          readln(sHasierakoKatea);
          writeln('Irakurritakoa: sHasierakoKatea >>>>>', sHasierakoKatea, '<<<<<');

          { Letra larriz idatzi }
          sSarreraMoldatua := upcase(sHasierakoKatea);
          writeln('Letra larriz: sSarreraMoldatua >>>>>', sSarreraMoldatua, '<<<<<');

          { ñ minuskula bada Ñ larria jarri }
          sSarreraMoldatua := fnsKontsonanteberezia(sSarreraMoldatua);
          writeln(chr(164), ' badago ', chr(165), ' jarri: sSarreraMoldatua >>>>>', sSarreraMoldatua, '<<<<<');

          { Letra ez dena ezabatu }
          sSarreraMoldatua := fnsEzabatu(sSarreraMoldatua);

          { Sarreraren simetrikoa lortu }
          sSimetrikoa := fnsSimetrikoalortu(sSarreraMoldatua);

          writeln;
          writeln('Sarrera moldatua---|', sSarreraMoldatua, '|---Simetrikoa---|', sSimetrikoa);
          writeln;

          { Emaitza pantailaratu, adierazi testua palindromoa den ala ez den }
          if sSarreraMoldatua = sSimetrikoa then
          writeln('"', sHasierakoKatea, '" datua palindromo da')
          else
          writeln('"', sHasierakoKatea, '" datua ez da palindromo');

          { Hurrengo iterazioa prestatu }
          writeln;
          write('Beste testu bat aztertu nahi duzu: (B ala E): ');
          readln(cAukera);
          cAukera := upcase(cAukera);
          until cAukera = 'E'; { Ez, testu gehiagorik ez }

          repeat until keypressed;
          end.


           


          8. astea | akronimoak




           



          Programaren kodea:




           



          { -----------------------------------------------------------------
          Akronimoak1.pas:
          Gaia: Karaktere-kateak
          Deskribapena: Esaldiaren akronimoak lortu
          ------------------------------------------------------------------ }
          program Akronimoak_hitzak_bakandu_gabe;

          uses
          crt;

          type
          tKateLuze = string[99];

          { FUNTZIOA: fnboTestuaEgokiaDa
          SARRERA PARAMETROAK: kate bat
          IRTEERA PARAMETROAK:
          ATAZA: sartutako kate horrek gehiegizko zuriunerik ez daukala aztertu }
          function fnboTestuaEgokiaDa(sKatea: tKateLuze): boolean ;
          begin
          fnboTestuaEgokiaDa := TRUE;
          if sKatea[1]=' ' then
          begin
          fnboTestuaEgokiaDa := FALSE;
          writeln('Testuaren lehen karakterea ezin daiteke izan zuriunea');
          end;
          if sKatea[length(sKatea)]=' ' then
          begin
          fnboTestuaEgokiaDa := FALSE;
          writeln('Testuaren azken karakterea ezin daiteke izan zuriunea');
          end;
          if (sKatea[1]<>' ') and (sKatea[length(sKatea)]<>' ') then
          begin
          if pos(' ', sKatea) <> 0 then
          begin
          fnboTestuaEgokiaDa := FALSE;
          writeln('Testuaren bi hitzen artean zuriune bakarra onartzen da');
          end;
          end;
          end;


          { FUNTZIOA: fnsAkronimoakLortu
          SARRERA PARAMETROAK: kate bat
          IRTEERA PARAMETROAK:
          ATAZA: Sartutako kate hori mozten joan eta iterazio bakoitzeko lehen letra hartu }
          function fnsAkronimoakLortu(sEsaldia: tKateLuze): tKateLuze;
          var
          sEmaitza: tKateLuze;
          iZuriuneaNon: integer;
          begin
          { sarrera letra larritan jarriko dugu }
          sEsaldia := upcase(sEsaldia);

          { emaitza izango den katea hasieratu, datuaren lehen karakterea eta puntua }
          sEmaitza := sEsaldia[1] + '.';
          writeln('sEmaitza dagoeneko >>>', sEmaitza, '<<<');
          writeln;
          repeat
          iZuriuneaNon := pos(' ', sEsaldia);
          writeln('iZuriuneaNon = ', iZuriuneaNon);
          { katea moztu hurrengo hitzaren hasiera lortzeko }
          delete(sEsaldia, 1, iZuriuneaNon) ;
          writeln('sEsaldia moztu ondoren >>>', sEsaldia, '<<<');

          {emaitza izango den kateari akronimo berria eta puntua gehitu}
          sEmaitza := sEmaitza + sEsaldia[1] + '.';
          writeln('sEmaitza dagoeneko >>>', sEmaitza, '<<<');
          writeln;
          until iZuriuneaNon = 0 ;

          { repeat-until baldintza dela eta, azkeneko akronimoa bikoiztuta
          geratzen delako azkeneko bi karakterak ezabatu beharko ditugu,
          hau da, azken akronimoa eta bere puntua kendu beharko ditugu. }
          writeln('Azken bi karaktereak soberan daude eta kenduko ditugu!');
          delete(sEmaitza, length(sEmaitza)-2, 2);
          writeln;

          fnsAkronimoakLortu := sEmaitza;
          end;


          { --------------------------PROGRAMA NAGUSIA----------------------------------- }
          var
          sKatea, sEmaitza: tKateLuze;
          cAukera: char;
          begin
          writeln('Esaldi baten akronimoak lortzeko programa, esaldi horren hasieran eta bukaeran');
          writeln('zuriunerik ez dago, esaldiaren hitzen arteko banatzailea zuriune bakarra da.');
          writeln;

          { Prozesaketa errepikatzen da erabiltzailea kontrakoa erabaki arte }
          repeat
          repeat
          writeln('Sar ezazu sarrerako testua (hitzen artean zuriune bakarra):');
          readln(sKatea);
          until fnboTestuaEgokiaDa(sKatea);

          sEmaitza := fnsAkronimoakLortu(sKatea);

          writeln(sKatea, '===>', sEmaitza);
          writeln;

          { Hurrengo exekuzioa prestatzen dugu eta erantzuna E izanez gero amaitu egiten da }
          write('Beste testu bat aztertu nahi duzu: (B ala E): ');
          { Erantzuna B ala E dela ziurtatzen dugu }
          repeat
          cAukera := upcase(readkey);
          until (cAukera = 'B') or (cAukera = 'E');
          clrscr;
          until cAukera = 'E';
          end. { PROGRAMAren amaiera }



           

          8. astea | esaldiaren hitzak




           



          Programaren kodea:




           



          {--------------------------------------------------------------
          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.



           


          8. ASTEA | etxerako lana

           8. astea (2023/03/13) etxean egitekoa


          Aurreko astean eskatutako 7. astea | menu bat azpiprogramaz ariketa eredutzar harturik, antzekoa den beste hau egizu: Autoebaluazioa Azp-3: 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:


           



          8. ASTEA | laborategi/mintegian egin dena

           8. astea (2023/03/13) laborategi/mintegian egindakoa






          • Zerrenda pasatzeko, eGela zerbitzuko 8. saioan egindako programak bidalketaren bitartez. Lanik bidali ez dutenak:


            1. Aritz Gonzalez de Audikana Garai

            2. Unai Aguinagalde del Barrio

            3. Jon Arana San Anton

            4. Leire Garcia Baz

            5. Maria Saenz de Buruaga Echevarria

            6. Haizea Seijo Gabicagogeascoa

            7. Naia Talles Nanclares

            8. Unai Uriondo Zabala

            9. Xabier Zubeldia Poza








           

          15. ASTEA | laborategi/mintegian egin dena

           15. astea (2023/05/08) laborategi/mintegian egindakoa 24 ikasleetatik 11 ikasleek kontrol-ariketaren bidalketa egin dute Hirugarren kont...