2024(e)ko urtarrilaren 29(a), astelehena

2. astea | zenbaki errealetik kopuru osora


Zenbaki errealetan bi atal desberdintzen dira: alde osoa eta alde dezimala. Eta zenbaki erreal bati dagokion zenbaki osoa lor dezakegu, esate baterako:
        readln(rDatua);
        iOsoaTrunkatua := trunc(rDatua);
        iOsoaBiribildua := round(rDatua);
Zenbaki erreal bat teklatuaren bitartez irakurri eta bere dagozkion bi zenbaki oso erakutsi. Horretarako Trunc eta Round funtzio estandarrak aplikatuko dira, emaitzak zenbaki osoak izango dira. Sarrerako datua den zenbaki errealaren balioa moztuz ala biribilduz emaitza lortuko dugu:
{------------------------------------------------------------------------------
      Sarrera zenbaki erreala izanik irteera zenbaki osoa izango da
       
      round() funtzioa mugan, parametroa X.5 denean:
                 X bakoitia izatean    round(X.5)  --->  X+1
                 X bikoitia izatean    round(X.5)  --->  X
-------------------------------------------------------------------------------}
program TruncRound_funtzioak;
var
   rZbk1, rZbk2: real;
   iOsoaTrunkatua: integer;      { integer datu-mota derrigorrez }
   iOsoaBiribildua: integer;     { integer datu-mota derrigorrez }
begin
   writeln;
   writeln;
   write('Zenbaki erreala eta positiboa eman: ');
   readln(rZbk1);
   writeln;
 
   iOsoaTrunkatua := trunc(rZbk1);
   iOsoaBiribildua := round(rZbk1);
   
   writeln('Hona hemen emandako zenbakia: ', rZbk1:0:3);
   writeln('trunc(', rZbk1:0:3, ') = ', iOsoaTrunkatua);
   writeln('round(', rZbk1:0:3, ') = ', iOsoaBiribildua);
   writeln;
   
   iOsoaTrunkatua := trunc(-rZbk1);
   iOsoaBiribildua := round(-rZbk1);
   
   writeln('Hemen emandakoaren negatiboa: ', -rZbk1:0:3);
   writeln('trunc(', -rZbk1:0:3, ') = ', iOsoaTrunkatua);
   writeln('round(', -rZbk1:0:3, ') = ', iOsoaBiribildua);
   writeln;
   writeln;
 
   rZbk2 := rZbk1 + 0.4;
   iOsoaTrunkatua := trunc(rZbk2);
   iOsoaBiribildua := round(rZbk2);
   
   writeln('Aurreko sarrerari 0.4 gehitu: ', rZbk2:0:3);
   writeln('trunc(', rZbk2:0:3, ') = ', iOsoaTrunkatua);
   writeln('round(', rZbk2:0:3, ') = ', iOsoaBiribildua);
   writeln;
   
   iOsoaTrunkatua := trunc(-rZbk2);
   iOsoaBiribildua := round(-rZbk2);
   
   writeln('Hementxe berriaren negatiboa: ', -rZbk2:0:3);
   writeln('trunc(', -rZbk2:0:3, ') = ', iOsoaTrunkatua);
   writeln('round(', -rZbk2:0:3, ') = ', iOsoaBiribildua);
   writeln;
   writeln;
 
   writeln('=======================');
   writeln('RETURN sakatu amaitzeko');
   write  ('_______________________');
   readln;
end. { PROGRAMAREN BUKAERA }

Ikusi ere zenbaki erreal baten bi atalak nola eskuratzen diren (2. astea | zenbaki erreal baten atalak).

Round() funtzioaren muga X.5 kopurua da eta bere emaitza X araberakoa da, jakin dezagun Round() funtzioaren biribiltze emaitza zenbaki bikoitia dela ondoko irudian erakusten den bezala:


Noiz Trunc() funtzioa eta noiz Round() funtzioa? Adibide batekin erantzungo dugu, baina lehenik gogoratuz zenbaki erreal guztiak ezin direla errepresentatu memorian gordetzeko, ikusi izan dugu "zuloak" geratzen direla bi zenbaki erreal artean.

Noiz Trunc() funtzioa eta noiz Round() funtzioa? galderaren harira adibide hau azter ezazu:
2. astea | 3 zifra eta 2 dezimaleko zenbaki erreal bat atzekoz aurrera  (XYZ.AB → ZYX.BA   autoebaluazioa) .

2. astea | zenbaki erreal baten atalak


Zenbaki errealetan bi atal desberdintzen dira: alde osoa eta alde dezimala.
        readln(rDatua);
        rAldeOsoa := int(rDatua);
        rAldeDezimala := frac(rDatua);
Zenbaki erreal bat teklatuaren bitartez irakurri eta bere atalak banatzeko funtzioak ikusten dira hemen. Sarrerako zenbaki errealaren atalak Int eta Frac funtzioek eskainiko dituzte eta zenbaki errealak izango dira ere, hots, bilatzen ditugun emaitzak zenbaki errealak izango dira:
{------------------------------------------------------------------------------
      Sarrera zenbaki erreala izanik irteera zenbaki erreala izango da
-------------------------------------------------------------------------------}
program IntFrac_funtzioak;
var
   rZbk1: real;
   rAldeOsoa: real;          { real datu-mota derrigorrez }
   rAldeDezimala: real;      { real datu-mota derrigorrez }
begin
   writeln;
   writeln;
   write('Zenbaki erreala eta positiboa eman: ');
   readln(rZbk1);
   writeln;

   rAldeOsoa := int(rZbk1);
   rAldeDezimala := frac(rZbk1);
   
   writeln('Hona hemen emandako zenbakia: ', rZbk1:0:3);
   writeln('  int(', rZbk1:0:3, ') = ', rAldeOsoa:0:3);
   writeln(' frac(', rZbk1:0:3, ') = ', rAldeDezimala:0:3);
   writeln;
   
   rAldeOsoa := int(-rZbk1);
   rAldeDezimala := frac(-rZbk1);
   
   writeln('Hemen emandakoaren negatiboa: ', -rZbk1:0:3);
   writeln('  int(', -rZbk1:0:3, ') = ', rAldeOsoa:0:3);
   writeln(' frac(', -rZbk1:0:3, ') = ', rAldeDezimala:0:3);
   writeln;
   writeln;

   writeln('=======================');
   writeln('RETURN sakatu amaitzeko');
   write  ('_______________________');
   readln;
end. { PROGRAMAREN BUKAERA }

Ikusi ere zenbaki erreal bat nola bihurtzen den zenbaki oso (2. astea | zenbaki errealetik kopuru osora).

2024(e)ko urtarrilaren 26(a), ostirala

2. ASTEA | ikasgelan egindakoa

 2. astea (2024/01/29 eta 2024/02/02) ikasgelan egin dena

  • Arbela erabiliz, INTEGER datu-mota artikulutik abiatuta ondoko kontzeptuak ikasi ditugu:
    •  ZENBAKIAREN KONTZEPTUA
      • Zenbatu
      • Neurtu
    • ZENBAKIEN OINARRIZKO TEOREMA
      • Zenbakien Sistema desberdinak
      • Bit-en taldekatzeak 
    • ZENBAKI OSOEN DATU-MOTAK 
      • Zenbaki osoen heinak (Integer datu-mota berezitxoa da) 
      • Zenbaki osoen eragile aritmetikoak
      • Zenbaki osoen erlaziozko eragileak 
    • ZENBAKI OSOEN IRTEERAKO FORMATUA
    • ZENBAKI OSOA TEKLATUAREN BITARTEZ IRAKURRI
    • PARAMETRO IZATEAN JOKAMOLDEA  (honek aurrerago garrantzia izango du) 
    • ADIBIDEAK  (aipatzea besterik ez dugu egin) 
  • INTEGER datu-mota artikulutik hartutako taula hau astiro azaldu dugu:
    Datu-motaFormatua Balio kopurua 2N  Balioen heina edo barrutia
    ShortInt
    8 bit (+ eta -)
    256
    -128..127
    Byte
    8 bit (+)
    256
    0..255
    SmallInt
    16 bit (+ eta -)
    65536
    -32768..32767
    Integer
    Integer
    16 bit (+ eta -)
     32 bit (+ eta -)
    65536
    4294967296
    -32768..32767
    -2147483648..2147483647
    Word
    16 bit (+)
    65536
    0..65535
    LongInt
    32 bit (+ eta -)
    4294967296
     -2147483648..2147483647 
  • Konturatu gaitezen Integer datu-mota hardwarearen araberakoa dela eta memorian 2 byte edo 4 byte har ditzakeela. Horren haritik bi programa erakutsi ditugu:
  • Arbela erabiliz eta REAL datu-mota artikulutik abiatuta ondoko atalak ikusi ditugu:
    • ZENBAKIAREN KONTZEPTUA  (errepikatu dugu) 
      • Zenbatu
      • Neurtu
      • Zenbaki osoen eta zenbaki ez-osoen haritik, gogoratu desberdiketa egin beharra daukagula zenbaki zenbakagarrien eta zenbaki zenbakaitzen artean
    • ZENBAKIEN OINARRIZKO TEOREMA  (errepikatu dugu) 
      • Koma Finkoko Adierazpidea
      • Koma Higikorreko Adierazpidea
    • ZENBAKI ERREALEN DATU-MOTAK
      • Zenbaki errealen heinak
      • Zenbaki errealen eragileak (aritmetikoak eta erlaziozkoak)
      • Eragile aritmetiko eta eragigaien arteko bateragarritasuna
    • ZENBAKI ERREALEN IRTEERAKO FORMATUA
      • WriteLn(rZenbakia)  ←  idazkera zientifikoa 23ko eremu batean
      • WriteLn(rZenbakia:n)  ←  idazkera zientifikoa nko eremu batean
      • WriteLn(rZenbakia:n:m)  ←  idazkera arrunta nko eremuan m dezimal
    • KOPURU OSOTIK ZENBAKI ERREALERA

    • PARAMETROA IZATEAN JOKAMOLDE  (honek aurrerago garrantzia izango du) 
  • Blogeko BOOLEAN datu-mota artikuluaren bitartez datu-mota boolearrari hasiera eman diogu
 

REAL datu-mota


ZENBAKIAREN KONTZEPTUA

Zenbakia kontzeptua funtsezkoa da gizarteko komunikazio eta harremanetarako. Hizkera orokor arruntean, zenbakiek etengabeko presentzia dute, objektuak zenbatzeko eta neurtzeko ohitura baitugu, eta zenbatzean eta neurtzean zenbakiak erabili behar baititugu.

Zenbatu eta neurtu aditzak nahasirik erabil daitezke hizkera orokorrean, baina teknikan eta zientzian bereizi behar ditugu bakoitzak ekintza desberdina adierazten baitu. Nahiz eta ekintza bietan zenbakiak erabili gauza bat da zenbatu eta beste gauza bat da neurtu.

ADITZA ERAGIKETA EMAITZA OBJEKTUAK
Zenbatu
Zenbaketa
Kopurua
Zenbakagarriak (diskretuak)
Neurtu
Neurketa
Neurria
Zenbakaitzak (jarraituak)



Zenbatu

Zehatz hitz eginda, zenbatu aditzak mota bereko zenbat objektu dauden kontatzea adierazten du. Beraz, zenbatu aditzaren esanahia kontaketarekin loturik dago eta dagokion eragiketa zenbaketa deitzen da. Zenbaketa eragiketaren emaitza kopurua da, hots, zenbat objektu dauden esatea.

Zer esanik ez, zenbatu ahal izateko, objektuek edo magnitudeek diskretuak izan behar dute, zenbakagarriak alegia, eta zenbaketaren emaitza zenbaki osoa izango da.

Pascal programazio-lengoaian zenbaki osoak adierazteko ondoko datu-motak erabiliko ditugu:
  • LongInt
  • Integer
  • Byte


Neurtu

Bestalde, neurtu aditzak honako ekintza adierazten du: objektu edo magnitude fisiko neurrian unitatea zenbat aldiz sartzen den kalkulatzea. Beraz, neurtu aditzaren esanahia konparaketa batekin loturik dago eta dagokion eragiketa neurketa deitzen da. Neurketa eragiketaren emaitza neurria da, hots, magnitude fisikoa zein tamainatakoa den esatea.

Neurtu ahal izateko, magnitude fisikoek jarraituak izan behar dute, zenbakaitzak edo ez-zenbakagarriak alegia, eta neurketaren emaitza zenbaki ez-osoa izango da (edo bestela esanik zenbaki erreal).

Pascal programazio-lengoaian zenbaki ez-osoak adierazteko ondoko datu-mota erabiliko dugu:
  • Real

ZENBAKIEN OINARRIZKO TEOREMA

Zenbakien Oinarrizko Teorema gogoratuz, badakigu magnitude fisiko bat sistema bitarrean adieraz daitekeela. Zenbaki osoentzat Polinomioaren Adierazpidea erabiltzen bada, gauza bera egiten da ere zenbaki errealentzat.

Zenbaki errealen adierazpidea hasi aurretik, ikus dezagun eskematikoki nola igaro kopuru bat hamartarretik bitarrera. Zenbaki errealaren alde osoa eta alde frakzionatua desberdindu behar dira, bati zatiketa osoak aplikatuz eta bestetik hondarraren dobleak lortuz. Esate baterako, ikusi 42.375 zenbakia nola adierazten den kode bitarrean:

Zenbaki errealak errepresentatzeko bi idazkera edo adierazpide erabiltzen dira:
  1. Koma Finkoko Adierazpidea: dezimalen kopurua aldez aurretik finkaturik dago.
  2. Koma Higikorreko Adierazpidea: zati dezimalaren bit kopurua aldakorra da.
Aipaturiko bi adierazpide horiek estuki loturik daude. Izan ere, Koma Higikorreko Adierazpidea eraikitzean  Koma Finkoko Adierazpidea oinarritzat hartzen da.



Koma Finkoko Adierazpidea


Ikusten denez, kopuru hamartar guztiak ezin dira kode bitarrean errepresentatu. Goiko adibidean 0.16h kopuru hamartarra 0.0010b eta 0.0011b artekoa da, baina lau bitekin ezin da zehatz-mehatz adierazi. Goiko adibideko 0.16h kopuru hamartarrari gehien hurbiltzen zaien adierazpide bitarrak hauek dira:
  • 0.16h datuari hurbilketa bitar bat: 0.0010b ⇒ 0.125h
  • 0.16hri beste hurbilketa bitar bat: 0.0011b ⇒ 0.1875h


Koma Finkoa: Adibide bat


Arkitektura berezia eta mugatua duen ordenadore honek doitasun batekin lan egingo du, ondorioz irudi honetan erakusten diren zenbaki errealak errepresenta ditzake:

Esan bezala, makina digitalek ezin dituzte errepresentatu kopuru erreal guztiak. Hurrenez hurren dauden bi errepresentazio bitarren artean "zuloa" geratzen da, sistema informatikoak zenbat eta bit gehiago eduki zulo horiek txikiagoak izango dira. Edozein kasutan ere, makina digital batek doitasun jakin batekin jokatzen du. 


Koma Higikorreko Adierazpidea

Formatu exponentzial normalduan idazten dira zenbaki errealak. Zenbaki erreal bakoitzeko hiru kontzeptu gordetzen dira: zeinua, berretzailea eta mantisa.

ZENBAKI ERREALEN DATU-MOTAK

Aurredefiniturik dauden datu-mota errealak sei dira: Real, Single, Double, Extended, Comp eta Currency.


Zenbaki errealen heinak

Gorago aipatu den datu-mota bakoitzak, bit kopuru desberdinak hartzen dituzte memorian. Horren arabera, ondoko taulan datu-mota bakoitzearen behemuga eta goimuga erakusten dira:

Gure ariketa guztietan Real datu-mota erabiliko dugu, beste bostak ez ditugu beharko.



Zenbaki errealen eragileak (aritmetikoak eta erlaziozkoak)

Datu-mota errealek ezagutzen dituzten operazioak aritmetikoak eta erlaziozkoak dira. Lehenengoek, adierazpen aritmetikoak, formula matematikoak idazteko balio dute, eta erlaziozko eragileak berriz, adierazpen logikoak sortzeko erabiltzen dira. Ondoko tauletan biltzen dira operadore horiek:

Eragile horiek dituzten lehentasun arauak zenbaki osoek dituztenak berberak dira.


Eragile aritmetiko eta eragigaien arteko bateragarritasuna

Dagoenekoz zenbaki osoak eta zenbaki frakzionatuak adierazteko datu-motak ikasi ditugu, eta datu-motarekin batera memoriko biltegitze sistema bat eta onargarriak diren eragiketak definiturik daude. Orain arteko espresio aritmetikoetan zenbaki osoak eta zenbaki errealak erabili ditugu baina talde bakoitza bere aldetik eta nahastu gabe.

Adierazpen aritmetiko batek, ikusi dugunez, balio bakar batera ebaluatzen da. Adierazpen aritmetikoaren eragigaietan datu-mota ezberdinak agertzen direnean, espresioak hartzen duen balio bakar hori adierazpen aritmetikoaren emaitza izango da, eta honen datu-mota ere bakarra izango da. Baina, zein emaitzaren datu-mota eragigaiak datu-mota desberdinekoak badira? Adibidez, iEgunak zenbaki osoa izanik, eta rAbiadura zenbaki erreala izanik, zer datu-motakoa izango da haien arteko biderkadura?
      Emaitza := iEgunak * rAbiadura ;   { Emaitza REAL ala INTEGER? }
? 21 1.5
? 20 1.5

Argi dago Emaitza aldagaiak 31.5 balioa jaso behar duela kasu batean, eta 30.0 balioa bestean. Horregatik Emaitza aldagaia Real datu-motakoa izan beharko da derrigorrez.

Eragigaien konpatibilitatea edo bateragarritasuna lege batez gidatzen da: bi eragigai arteko operazio batean, eragigai bat datu-mota batekoa izanik eta beste eragigaia beste datu-mota batekoa izanik, emaitzari dagokion datu-mota eragigaien bi datu-motetatik garaiena izango da. Esate baterako, Real datu-mota Integer datu-mota baino "handiagoa" da.

Lege horren ondorio bezala, ondokoa baiezta daiteke: bi eragigai arteko operazio bat egitean, eragigai biak datu-mota berekoak direnean, emaitzaren datu-mota eragigaiena izango da; baldin eta operazioak berak kontrakorik behartzen ez badu. Esate baterako, eragigai biak osoak izan arren / zatiketaren emaitzari dagokion datu-mota beti erreala izango da.

Eragile aritmetikoak eta euren eragigaien arteko konpatibilitatea taula honetan laburbiltzen dira:
ZENBAKI ERREALEN IRTEERAKO FORMATUA

Datu-mota errealeko aldagai baten edukia pantailan idatzi nahi denean Write eta WriteLn prozedura estandarrak erabiliko dira. Zenbaki erreala pantailaratzekoan ez bada kontrakorik agintzen zenbaki idazkera zientifikoan agertuko da, horretarako 23 karaktereko eremu bat erabiltzen da honela banaturik:
  •   3 posizio (zeinua, unitatea eta puntua)
  • 15 posizio (hamabost zifra)
  •   5 posizio (E, zeinua, hiru zifra)
Zenbaki errealen idazkera zientifikoa mantenduz, dezimal gutxiago erakutsi nahi baditugu, formatua zehaztu beharko da, horretarako :n gehitu beharko dugu (non, n kopuru osoa den). Zenbaki errealak idazkera zientifikoan erakustea ekidin nahi badugu, formatua zehaztu beharko da, horretarako :n:m gehitu beharko dugu (non, n eta m kopuru osoak diren).

Esate baterako, demagun rZbk aldagaian 123.456789 gorde dela eta bi instrukzio hauek idatzi direla:
  WriteLn('rZbk|', rZbk) ;    { positibo baten idazkera zientifikoa }
WriteLn('rZbk|', -rZbk) ; { negatibo baten idazkera zientifikoa }
Bi pantailaraketak honako hauek izango dira, hurrenez hurren:
                11111111112222
12345678901234567890123
rZbk| 1.234567890000000E+002
rZbk|-1.234567890000000E+002
12312345678901234512345

Aurreko rZbk aldagaiaren edukia mantenduz, demagun instrukzioak hauek direla non :n formatua erabili den:
  WriteLn('rZbk|', rZbk:15) ;  { 15eko eremu batean idazkera zientifikoa }
  WriteLn('rZbk|', rZbk:10) ;  { 10eko eremu batean idazkera zientifikoa }
  WriteLn('rZbk|', rZbk:5) ;   {  5eko eremu batean idazkera zientifikoa }
WriteLn('rZbk|', rZbk:1) ; { 1eko eremu batean idazkera zientifikoa }
  WriteLn('rZbk|', rZbk:30) ;  { 30eko eremu batean idazkera zientifikoa } 
Bigarren adibiderako pantailaraketak honako hauek izango dira, hurrenez hurren:
                111111
123456789012345
123123456712345
rZbk| 1.2345679E+002 [15eko eremuan]
 123123456712345
 rZbk| 1.23E+002 [10eko eremuan]
rZbk| 1.2E+002 [ 5eko eremuan]
rZbk| 1.2E+002 [ 1eko eremuan]
rZbk| 1.234567890000000E+002 [30eko eremuan]
123456712312345678901234512345
123456789012345678901234567890
111111111122222222223

Aurreko rZbk aldagaiaren edukia mantenduz, demagun instrukzioak hauek direla non :n:m formatua erabili den:
  WriteLn('rZbk|', rZbk:17:4) ;  { 17ko eremu batean 4 dezimalekin idatzi }
WriteLn('rZbk|', rZbk:11:4) ; { 11ko eremu batean 4 dezimalekin idatzi }
WriteLn('rZbk|', rZbk:0:4) ; { 0ko eremu batean 4 dezimalekin idatzi }
Hirugarren adibiderako pantailaraketak honako hauek izango dira, hurrenez hurren:
  rZbk|         123.4568   [17ko eremuan 4 dezimal]
rZbk| 123.4568 [11ko eremuan 4 dezimal]
rZbk|123.4568 [ 0ko eremuan 4 dezimal]
12345678901234567
11111111

KOPURU OSOTIK ZENBAKI ERREALERA

Datu-mota osoa den aldagai baten edukia zenbaki erreala bihurtzeko ez da aparteko ezer egin behar. Adibidez, demagun iKopura aldagaiak 73 balioa gordetzen duela, balio hori zuzen-zuzean esleitu ahal diogu rEmaitza aldagai erreal bati:
  Write('iKopurua aldagaian kopuru osoa gorde: ') ;
ReadLn(iKopurua) ; { adibidez, 73 balio osoa teklatuaz irakurri }
rEmaitza := iKopurua ; { 73.0 balioa gordetzen da rEmaitza aldagaian }
Erreala den aldagaiari esleipena egitean, 73 kopuru osoaren 73.0 bihurketa automatikoki egiten da.
ZENBAKI ERREAL BATEN ATALAK ETA ZENBAKI ERREALETIK KOPURU OSORA

Zenbaki erreal batek bi atal izango ditu: alde osoa eta alde dezimala. Zenbaki erreal baten atal biak eskuratzeko Int eta Frac funtzio estandarrak aplikatuko dira (bi funtzio horien emaitza zenbaki erreala izango da). Int eta Frac funtzioen azalpena 2. astea | zenbaki erreal baten atalak artikuluan ikus daiteke.

Zenbaki erreal baten baliotik kopuru oso bat lor dezakegu, baina bihurketa egiterakoan erabaki behar da zenbaki errealaren alde dezimala moztuko dugun, ala emaitza osoa lortzeko zenbaki erreala biribilduz egingo den. Zenbaki errealetik kopuru osora igarotzeko Trunc eta Round funtzio estandarrak aplikatuko dira (bi funtzio horien emaitza zenbaki osoa izango da). Trunc eta Round funtzioen azalpena 2. astea | zenbaki errealetik kopuru osora artikuluan ikus daiteke.
PARAMETRO IZATEAN JOKAMOLDEA

Datu-mota erreala sinplea izanik, azpiprograma batean honela agertuko da jokamoldearen arabera:
  • Irteerakoa denean VAR marka izango du aurrean
  • Sarrerakoa denean ez du inolako markarik izango
ADIBIDEAK

Hona hemen zenbaki errealen zenbait programa:
INTEGER REAL BOOLEAN CHAR STRING ARRAY RECORD FILE

 

1. astea | segundoen kopuruak

Datu-motaFormatua Balio kopurua 2N  Balioen heina edo barrutia
ShortInt
8 bit (+ eta -)
256
-128..127
Byte
8 bit (+)
256
0..255
SmallInt
16 bit (+ eta -)
65536
-32768..32767
Integer
Integer
16 bit (+ eta -)
 32 bit (+ eta -)
65536
4294967296
-32768..32767
-2147483648..2147483647
Word
16 bit (+)
65536
0..65535
LongInt
32 bit (+ eta -)
4294967296
 -2147483648..2147483647 

Goiko taula aintzakotzat harturik ondoko bi ariketak egin:


Ariketa_1:

INTEGER datu-motak 2 byte har ditzan, zure programan {$MODE TP} konpilazio-direktiba idatzi eta ondoko hau egin:
iSegundo kopuru handi bat teklatuz irakurri, non iSegundo aldagaia INTEGER datu-motakoa den. Irakurritako denbora pantailaratu orduak-minutuak-segundoak bezala (hiru balioetatik bat edo beste zero balitz, ez da pantailaratu beharko).
{-----------------------------------------------------------------
      Behartu INTEGER datu-motak 2 byte hartzera.
 ------------------------------------------------------------------}
program SegundoenKopurua_INTEGER;
{$MODE TP}

var
   iSegundo: integer;


Ariketa_2:

liSegundo kopuru erraldoi bat teklatuz irakurri, non liSegundo aldagaia LONGINT datu-motakoa den. Irakurritako denbora pantailaratu egunak-orduak-minutuak-segundoak bezala (hiru balioetatik bat edo beste zero balitz, ez da pantailaratu beharko).
{-----------------------------------------------------------------
      INTEGER datu-motak 2 byte edo 4 byte hartuko ditu.
      LONGINT datu-motak beti 4 byte hartuko ditu memorian.
 ------------------------------------------------------------------}
program SegundoenKopurua_LONGINT;

var
   liSegundo: longint;

1. astea | hiru zifrako zenbaki oso bat atzekoz aurrera

Osoa den hiru zifrako zenbakia atzekoz aurrera jarri

Idatz ezazu zera burutzen duen programa Pascal lengoaia erabiliz. Programak teklatutik hiru digituko zenbaki bakarra irakurri eta emandako hiru digituak alderantzizko ordenan idatzi egiten duena. Honez gain, alderantzizko ordenak osatzen duen zenbakia ere pantailaratuko du programak.

Adibidez:
Sartu hiru digituko zenbakia, 100 eta 999 artekoa: 123
Emandako zenbakiaren digituak atzekoz aurrera: 3, 2, 1

Sartutako zenbakia: 123
Atzekoz aurrerakoa: 321
Oharra: Erabiltzaileak sartutako zenbakia (123) lodian dago eta ReadLn bakar baten bitartez irakurri da programan. Ariketaren programa bat hau izan daiteke:

LASTER   IKUSGAI


Hemen daukazu programa hori exekutatzean lortzen den emaitzaren irudi bat:


Aurreko programa hau aintzat harturik, oso antzekoa den  1. astea | billeteak eta txanponak ariketari ekin.

 

1. astea | billeteak eta txanponak

ADI!
1. astea | billeteak eta txanponak ariketa hau eta aurrerago ikusiko den 2. astea | radianak bihurtu gradu-minutu-segundo ariketa desberdinak dira. Izan ere, kalkuluak era desberdinean burutzen dira ariketa batean abiapuntuko datua Integer datu-motakoa delako eta beste ariketan sarrerako datua Real datu-motakoa delako.




iEuroak euro kopurua emanik, kalkulatu zenbat 500, 200, 100, 50, 20, 10, eta 5 euroko billete, eta  euro bateko eta 2 euroko txanponak behar diren emandako kopurua osatzeko. Banaketa egitean billete eta txanpon kopurua ahalik eta txikien izan beharko dira.

Eskatzen den BilleteakTxanponak.pas programa hau 1. astea | hiru zifrako zenbaki oso bat atzekoz aurrera ariketa bezalakoa da. Eskatzen den BilleteakTxanponak.pas programa exekutatzean lor daitekeen balizko irteera bat hau izan daiteke:


Eskatzen den BilleteakTxanponak.pas iturburu-programari dagokion BilleteakTxanponak.exe programa exekutagarria hemendik jaso dezakezu: BilleteakTxanponak.exe.

1. astea | hamartarretik bitarrera


Zenbaki osoen datu-mota batzuk hurrengo taulan biltzen dira tamainaren arabera, gogoratu Integer datu-motak 2 edo 4 byte har ditzakeela hardwarearen arabera:





Jarraian garatzen diren lehen hiru azpiataletan kopuru hamartar bat kode bitarrera bihurtzen da IntToBin funtzioari esker. Laugarren azpiatalekoa ezin da egin.




1 byte

ShortInt eta Byte datu-motek byte bakarra hartzen dute memorian eta ondorioz 28=256 aukera daude kopuruak adierazteko.

Hementxe ematen den IntToBin_BYTE_adibidea izeneko programan IntToBin funtzioa erabiltzen da, funtzio horrek kopuru oso bat hartzen du eta testu bat sortzen du. IntToBin funtzioa ez da ikasi behar baina programa exekutatu eta bere irteera aztertu eta ulertu behar da:
program IntToBin_byte_adibidea ;

uses
   strutils ;
 
const
   iDIGITUAK = 8 ;
   iZURIUNEAK = 4 ;   
var
   byZenbakiarenBalioa: byte ;
   sEmaitza: string ;
   
begin
   writeln ;
   writeln ;
   writeln('====BYTE datu-motarekin lan eginez=========================') ;
   writeln ; 
   
   writeln('              byte = ', sizeof(byte), ' byte = ', 8*sizeof(byte), ' bit') ;
   writeln('               2^8 = 256 aukera') ;
   writeln ;
   writeln('      Txikiena (0) = ', 0) ;
   writeln('Handiena (2^8 - 1) = ', 255) ;
   writeln ;
     
   write('Zenbaki osoaren balio hamartarra eman: ') ;
   readln(byZenbakiarenBalioa) ;
   
   sEmaitza := IntToBin(byZenbakiarenBalioa, iDIGITUAK, iZURIUNEAK) ;   
   
   writeln ; 
   writeln('Hamartarra = ', byZenbakiarenBalioa) ;
   writeln('   Bitarra = ', sEmaitza, '   [', byZenbakiarenBalioa, ']') ;
   writeln ;
   writeln('  Txikiena = ', IntToBin(0, iDIGITUAK, iZURIUNEAK), '   [0]') ;
   writeln('        +1 = ', IntToBin(1, iDIGITUAK, iZURIUNEAK), '   [1]') ;
   writeln('        +2 = ', IntToBin(2, iDIGITUAK, iZURIUNEAK), '   [2]') ;
   writeln('        +3 = ', IntToBin(3, iDIGITUAK, iZURIUNEAK), '   [3]') ;
   writeln('        +4 = ', IntToBin(4, iDIGITUAK, iZURIUNEAK), '   [4]') ;
   writeln('       ...      ...      ...') ;
   writeln('  Aurrekoa = ', IntToBin(254, iDIGITUAK, iZURIUNEAK), '   [254]') ;
   writeln('  Handiena = ', IntToBin(255, iDIGITUAK, iZURIUNEAK), '   [255]') ;
   
   writeln ;
   writeln('===========================================================') ;
   
   writeln ;
   writeln ;
   writeln('ENTER sakatu exekuzioa amaitzeko...') ;
   readln ;
end.

Goiko IntToBin_BYTE_adibidea programaren antzekoa IntToBin_SHORTINT_adibidea programa litzateke. Hau eskatzen da: ShortInt datu-motako aldagaia erabiliz, hurrengo irudiaren araberako programa idatzi:
program IntToBin_SHORTINT_adibidea ;

uses
   strutils ;
 
const
   iDIGITUAK = 8 ;
   iZURIUNEAK = 4 ;   
var
   shZenbakiarenBalioa: shortint ;
   sEmaitza: string ;
   
begin
   ...



2 byte

SmallInt eta Word datu-motek bi byte hartzen ditzute memorian eta ondorioz 216=65536 aukera daude kopuruak adierazteko. 

Aukera horietatik erdiak kopuru negatiboentzat erabiltzen ditu SmallInt datu motak eta beste erdiak zeroa eta kopuru positiboentzat. Ondorioz, SmallInt datu motaren mugak -32768 eta 32767 dira. Word datu-motaren kasuan, zeinurik ez delako adierazi behar kopuruen mugak 0 eta 65535 dira.

SmallInt eta Word datu-motetako aldagaiak erabili bi programa hauek idatzi dira:
Bi programa horiek exekutatu eta ulertu.



4 byte

LongInt eta LongWord datu-motek lau byte hartzen ditzute memorian eta ondorioz 232=4294967296 aukera daude kopuruak adierazteko. 

Aukera horietatik erdiak kopuru negatiboentzat erabiltzen ditu LongInt datu motak eta beste erdiak zeroa eta kopuru positiboentzat. Ondorioz, LongInt datu motaren mugak -2147483648 eta 2147483647 dira. LongWord datu-motaren kasuan, zeinurik ez delako adierazi behar kopuruen mugak 0 eta 4294967295 dira.

SmallInt eta Word datu-motetako aldagaiak erabili bi programa hauek idatzi dira:
Bi programa horiek exekutatu eta ulertu.



8 byte

Int64 eta QWord datu-motek zortzi byte hartzen ditzute memorian eta ondorioz 264=1.8446744e+19 aukera daude kopuruak adierazteko, eta konstante horretatik abiatuta Int64 eta QWord datu-moten mugak kalkula daitezke. Baina datu-mota zabal hauei IntToBin funtzioa ezin zaie aplikatu.