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 | 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 | 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 }