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

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

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

 
ordua: iruzkinik ez:
Etiketak:

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.
 
ordua: iruzkinik ez:
Etiketak:

8. astea | akronimoak


 

Programaren kodea:

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

uses
   crt;

type
   tKateLuze = string[99];

{ FUNTZIOA: fnboTestuaEgokiaDa, funtzioaren emaitza balio boolearra da
  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 hasiera eta bukaera ondo daude, baina esaldi hori');
         writeln('okerra da bi hitzen artean zuriune bakarra onartzen delako.');
      end;
   end;
end;


{ FUNTZIOA: fnsAkronimoakLortu, funtzioaren emaitza karaktere-katea da
  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.');
   
   { Prozesaketa errepikatzen da erabiltzailea kontrakoa erabaki arte }
   repeat
      repeat
         writeln;
         writeln('Sar ezazu sarrerako testua (hitzen artean zuriune bakarra):');
         readln(sKatea);
      until fnboTestuaEgokiaDa(sKatea);
      
      writeln;
      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 }
 
ordua: iruzkinik ez:
Etiketak:

2024(e)ko martxoaren 3(a), igandea

7. ASTEA | etxerako lana

 7. astea (2024/03/05) etxean egitekoa

Teoriako ikasgelan 6. astea | zenbaki bat asmatzen ariketa eta den 6. astea | letra bat asmatzen ariketaren azaldu genituen astelehenean:
Etxean birpasatu laborategian ikusi dugun 7. astea | Taylor azpiprogramaz (angelu txikiekin) ariketa. Horretarako, bi programa hauek argi eduki:

Taylor bitartez angelu txiki baten (1. koadrantekoa) kosinua kalkulatzen duen programa egina dagoenez, zuen lana litzateke 7. astea | Taylor azpiprogramaz (edozein angelurako) artikuluan eskatzen den ariketa programatzea.

Etxean birpasatu laborategian ikusi ditugun Azpiprogramak: Divide et Impera artikuluaren honako hauek:

  •   1. Uneko parametroak eta parametro formalak
  •   2. Sarrerako parametroak
  •   3. Uneko parametro eta parametro formalen arteko bateragarritasuna
  •   4. Irteerako parametroak
  •   5. Aldagai orokorrak
  •   6. Bertako aldagaiak
  •   7. Funtzioak
  •   8. Faktoriala kalkulatzen duen funtzio iteratiboa egin dugu (eta berredura kalkulatzen duena ere)
  •   9. Errekurtsibitatea (ez)
  • 10. Errekurtsibitateren adibidea (ezta ere)


Azpiprogramak erabat finkatzea da datorren asteko praktika saioaren helburua. Hori dela eta, hauxe da hurrengo autoebaluaziorako proposamenak:

7. asterako lan desberdinak agindu direnez, komeni da ezagutzea haien garrantzia edo premia zein den une honetan, eta, ondorioz, etxekolanen hurrenkera zein den:

  1. Birpasatu laborategian ikusi ditugun Azpiprogramak: Divide et Impera artikuluaren lehen zortzi atalak
  2. Programa nagusia emanda, Autoebaluazioa: triangelu baten zirkunzentroa ariketa bukatu eta eGela bitartez bidali
  3. fnliFaktorialaKalkulatu eta fnrBerreduraKalkulatu funtzioak programatzen dakigula, 7. astea | Taylor azpiprogramaz (angelu txikiekin) artikuluan deskribatzen den kosinua programatu
  4. Menua kudeatzen duen funtzioa erabiliz, Autoebaluazioa: menu bat azpiprogramaz ariketa kodetu eta eGela bitartez bidali

 
ordua: iruzkinik ez:
Etiketak:

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

7. ASTEA | laborategi/mintegian egin dena

 7. astea (2024/03/05) laborategi/mintegian egindakoa

  • Zerrenda pasatu dugu. Deitutako 25en artean 4 ez dira etorri (zehaztapen gehiago eGela zerbitzuan)
  • Praktika saio honek bi zati izan ditu. Lehen zatian, oso modu gidatuan, Azpiprogramak: Divide et Impera artikulua ikusi dugu, teoriako ikasgelan hasita daukagu gai hau eta laborategian, modu praktikoan, honako hau ikusi dugu:
    •   1. Uneko parametroak eta parametro formalak
    •   2. Sarrerako parametroak
    •   3. Uneko parametro eta parametro formalen arteko bateragarritasuna
    •   4. Irteerako parametroak
    •   5. Aldagai orokorrak
    •   6. Bertako aldagaiak
    •   7. Funtzioak
    •   8. Faktoriala kalkulatzen duen funtzio iteratiboa egin dugu
    •   9. Errekurtsibitatea (errekurtsibitatearen kontzeptua eman gabe geratu da)
    • 10. Errekurtsibitateren adibidea (adibide hau eman gabe geratu da ere)
ordua: iruzkinik ez:
Etiketak:

7. astea | Taylor (angelu txikiekin eta programa monolitikoan)

Angelu baten kosinua Taylor-ren arabera honela kalkula daiteke:
Non x radianetan emanikiko angelua den.

Programa bat idatzi kosinua kalkulatuko duena aurreko segidaren N batugai erabiliz. Batugaien N kopurua ez da ezaguna, batugaiak aintzat hartuko dira azken batugaiaren balio absolutua 0.00001 baino txikiagoa izan arte (doikuntza hori teklatuaren bitartez emango du programaren erabiltzaileak).

Algoritmoa:

  1. Erabiliko den rEpsilon prezisioa teklatuz irakurri
  2. Lehenego koadranteko rAng angelua graduetan, teklatuz irakurri
  3. Lehenego koadranteko rAng angelua radianetara igaro rX lortuz
  4. rX angeluari dagokion rKos kosinua lortu Taylor bitartez
  5. Taylor bitartez lortu den rKos emaitza eta cos(rX) balioa pantailan erakutsi eta bi balioak elkar alderatu

Ariketa hau egiteko, hasi hemendik (faktorialak) eta hemendik (berreturak). Hauxe izan daiteke programa horren irteera bat:



Kasu honetan, eta zero bertsioa delako, den-dena programa nagusian egingo duzue. Hurrengo bertsioetan azpiprogramak erabiliz programazioa hobetuko duzue.

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