Ariketa 39 | Triangeluaren Zirkunzentroa

ZER DAKIDAN: Ariketa bati dagokion kodifikazioa programa monolitiko batean idazteko gai naiz eta programa moduluetan zatitzeko gai naiz. ZER IKASIKO DUDAN: Programa bat zatitzen ikasiko dut moduluak sortuz, modulu horiek azpiprogramak deitzen dira eta bi motatakoak izan daitezke: funtzioak edo prozedurak. Ikas dezagun noiz erabili funtzioa eta noiz prozedura.

---

ESKATZEN DEN PROGRAMA

Zirkunzentro: Poligono batera zirkunskribatua dagoen zirkunferentziaren zentroa. Poligonoa triangelua bada, hiru erdibitzaileek elkar ebakitzen duten puntua da zirkunzentroa.

Triangeluaren zirkunzentroa eta zirkunferentzia zirkunskribatua

Triangeluaren zirkunzentroa non kokatzen den triangeluak dituen angeluen araberakoa da. Horrela, triangelu angeluzuzena bada zirkunzentroa triangeluaren hipotenusaren gainean kokatzen da, baina angelu kamutsa badu zirkunzentroa triangelutik kanpo geratzen da eta triangeluaren barruan angelu zorrotzak baditu.

Zirkunzentroaren kokapena triangeluarekiko

TRIANGELUAREN HIRU ERPINAK: A puntua eta B puntua segmentu horizontal batean daude     A puntua eta B puntua ez dira bat C puntua ez dago AB segmentu horizontalean (beraz, fCy koordenatua desberdin fAy koordenatua) C puntua A puntua eta B puntuaren artean dago (beraz, fCx koordenatuaren balioa fAx eta fBx artekoa da)

Goiko baldintzak betetzen dituzten triangeluaren hiru erpinen fAx, fAy, fBx, fBy, fCx eta fCy koordenatuak datutzat emanik, zirkunferentzia zirkunskribatuaren fR erradioa kalkulatu ondoko formula erabiliz:

fR = (fA*fB*fC) / (4*fS);

Non fA, fB eta fC triangeluaren aldeak diren eta fS azalera den

Horregatik, triangeluaren fA, fB eta fC aldeen luzerak eta fS azalera kalkulatu behar dira. Aldeak lortzeko Pitagorasen teorema aplikatuko dugu funtzio baten bitartez, eta fS azalera eskuratzeko ondoko formula barneratzen duen funtzioa idatziko dugu:

fS = 0.5*(fAx*fBy + fBx*fCy + fCx*fAy - fCx*fBy - fBx*fAy - fAx*fCy);

Triangelua eta zenbait aldagairen adierazpenak:
koordenatuak, distantziak, azalera, ...

Zirkunferentziaren erradioa zehaztu ondoren, zirkunferentziaren Z zentroa kalkulatuko dugu, hots, fZx eta fZy koordenatuak kalkulatuko ditugu. Horretarako, komenigarria izango da Ariketa 16 | Triangeluaren azalera ariketa birpasatzea, non zuzen bat adierazteko malda-desplazamendua bikotea erabiltzen den. Dagokigun ariketa honetan AC eta BC segmentuen maldak eta desplazamenduak eskuratzen dira, eta horiei esker AC eta BC segmentu biren ebakidura (fZx, fZy) puntuaren koordenatuak kalkulatzen dira.

Irudiko P puntua, ariketa honetan bilatzen den Z zentroa litzateke

Zirkunferentziaren erradioa eta zentroa ezagunak direla, frogatzerik dago zirkunferentzia horrek triangelua zirkunskribatzen duen, horretarako hiru erpinek zirkunferentziaren formula bete beharko dute. Hauxe da ariketaren programa nagusia eta azpiprogramen goiburuak:

/* Ariketa-39_TriangeluarenZirkunzentroa: sarrerako eta irteerako parametroak */

// A puntua eta B puntua segmentu horizontal batean daude
// A puntua eta B puntua ez dira bat
// C puntua ez dago AB segmentu horizontalean
// AC segmentua ez da bertikala
// BC segmentua ez da bertikala

// 39. ariketa: A, B eta C erpinez triangelua definitu (6 koordenatu). 

//     AB aldea horizontala izango da eta ABC triangeluari dagokion    
//     zirkunferentzia zirkunskribatuaren R erradioa kalkulatu.        
//     ABC triangeluari dagokion zirkunferentzia zirkunskribatuaren Z  
//     zentroaren bi koordenatuak Zx eta Zy kalkulatu.                 

//     Datuak hiru erpinen koordenatuak dira eta prozedura batean      
//     hartzen dira, adibidez: (0.0, 0.0), (4.0, 0.0) eta (2.0, 2.0)   


#include <stdio.h>
#include <math.h>

// ErpinakEskuratu: irteerako 6 parametro
void ErpinakEskuratu(float *fAx, float *fAy, float *fBx, float *fBy, float *fCx, float *fCy);
// AldeaLortu: sarrerako 4 parametro, emaitza float
float AldeaLortu(float f1x, float f1y, float f2x, float f2y);
// AzaleraLortu: sarrerako 6 parametro, emaitza float
float AzaleraLortu(float fAx, float fAy, float fBx, float fBy, float fCx, float fCy);
// ErrradioaLortu: sarrerako 4 parametro, emaitza float
float ErrradioaLortu(float fA, float fB, float fC, float fS);
// ZuzenarenMalda: sarrerako 4 parametro, emaitza float
float ZuzenarenMalda(float fPx, float fPy, float fQx, float fQy);
// SegmentuarenErdia: sarrerako 4 parametro, irteerako 2 parametro
void SegmentuarenErdia(float fPx, float fPy,
                       float fQx, float fQy,
                       float *fErdiaPQx, float *fErdiaPQy);
// ZentroaKalkulatu: sarrerako 4 parametro, irteerako 2 parametro
void ZentroaKalkulatu(float fM1, float fM2, float fD1, float fD2, float *fZx, float *fZy);
// ErpinaZirkunferentzianDago: sarrerako 5 parametro, emaitza int
int ErpinaZirkunferentzianDago(float fZx, float fZy, float fR, float fAx, float fAy);


int main()
{
    float fAx, fAy, fBx, fBy, fCx, fCy, fZx, fZy;       // koordenatuak
    float fErdiaACx, fErdiaACy, fErdiaBCx, fErdiaBCy;   // koordenatuak
    float fA, fB, fC, fR;                               // distantziak
    float fS;                                           // azalera
    float fMaldaAC, fPendikularraAC;                    // maldak
    float fMaldaBC, fPendikularraBC;                    // maldak
    float fDesplazamendu1, fDesplazamendu2;             // distantziak

    printf("\n\n\n");

    // triangeluaren hiru erpinak irakurri
    ErpinakEskuratu(&fAx, &fAy, &fBx, &fBy, &fCx, &fCy);

    printf("\n");

    // triangeluaren hiru aldeak lortu
    fA = AldeaLortu(fBx, fBy, fCx, fCy);    // BC segmentuaren luzera lortu
    fB = AldeaLortu(fAx, fAy, fCx, fCy);    // AC segmentuaren luzera lortu
    fC = AldeaLortu(fAx, fAy, fBx, fBy);    // AB segmentuaren luzera lortu

    printf("   fA aldea = %.2lf m\n", fA);  // BC segmentuaren luzera erakutsi
    printf("   fB aldea = %.2lf m\n", fB);  // AC segmentuaren luzera erakutsi
    printf("   fC aldea = %.2lf m\n", fC);  // AB segmentuaren luzera erakutsi

    // triangeluaren azalera kalkulatu erpinak ezagunak izatean
    fS = AzaleraLortu(fAx, fAy, fBx, fBy, fCx, fCy);

    printf("   fS azal. = %.3lf m^2\n\n", fS);

    // erradioa kalkulatzeko formula: (rA·rB·rC)/(4·rS)
    fR = ErrradioaLortu(fA, fB, fC, fS);

    printf("   fR erra. = %.3lf m\n\n", fR);

    // AC perpendikularraren malda
    fMaldaAC = ZuzenarenMalda(fAx, fAy, fCx, fCy);
    printf("   AC malda = %.2lf\n", fMaldaAC);
    fPendikularraAC = -(1 / fMaldaAC);
    printf("   AC perp. = %.2lf\n", fPendikularraAC);

    // AC perpendikularren zuzenak duen desplazamendua
    SegmentuarenErdia(fAx, fAy, fCx, fCy, &fErdiaACx, &fErdiaACy);
    printf("   AC erdia = (%.2lf, %.2lf)\n", fErdiaACx, fErdiaACy);
    fDesplazamendu1 = fErdiaACy + fErdiaACx / fMaldaAC;
    printf("   Desplaz1 = %.2lf m\n\n", fDesplazamendu1);

    // BC perpendikularraren malda
    fMaldaBC = ZuzenarenMalda(fBx, fBy, fCx, fCy);
    printf("   BC malda = %.2lf\n", fMaldaBC);
    fPendikularraBC = -(1 / fMaldaBC);
    printf("   BC perp. = %.2lf\n", fPendikularraBC);

    // BC perpendikularren zuzenak duen desplazamendua
    SegmentuarenErdia(fBx, fBy, fCx, fCy, &fErdiaBCx, &fErdiaBCy);
    printf("   BC erdia = (%.2lf, %.2lf)\n", fErdiaBCx, fErdiaBCy);
    fDesplazamendu2 = fErdiaBCy + fErdiaBCx / fMaldaBC;
    printf("   Desplaz2 = %.2lf m\n\n", fDesplazamendu2);

    // Zentroa bi zuzen perpendikularren arteko ebakidura izango da
    // Zuzen z1:   m1 = fPerpendikularraAC | d1 = fDesplazamendu1
    // Zuzen z2:   m2 = fPerpendikularraBC | d2 = fDesplazamendu2

    // Zuzen z1:   fZy = m1·fZx + d1
    // Zuzen z2:   fZy = m2·fZx + d2

    // m1·fZx + d1 = m2·fZx + d2  ==>  fZx = (d1 - d2) / (-m1 + m2)
    //         fZy = m1·fZx + d1  ==>  fZy = m1·(d1 - d2) / (-m1 + m2) + d1

    // fZx = (d1 - d2) / (-m1 + m2)
    // fZy = (m2·d1 - m1·d2) / (-m1 + m2)
    ZentroaKalkulatu(fPendikularraAC, fPendikularraBC, fDesplazamendu1, fDesplazamendu2, &fZx, &fZy);

    printf("   Z zentr. = (%.2lf, %.2lf)\n\n", fZx, fZy);
    printf("   (x - fZx)^2 + (y - fZy)^2 - fR^2  <  0.000001\n");

    if (ErpinaZirkunferentzianDago(fZx, fZy, fR, fAx, fAy))
        printf("   (%.2lf, %.2lf) erpina zirkunferentzian dago\n", fAx, fAy);
    else
        printf("   Errorea A erpinean\n");

    if (ErpinaZirkunferentzianDago(fZx, fZy, fR, fBx, fBy))
        printf("   (%.2lf, %.2lf) erpina zirkunferentzian dago\n", fBx, fBy);
    else
        printf("   Errorea B erpinean\n");

    if (ErpinaZirkunferentzianDago(fZx, fZy, fR, fCx, fCy))
        printf("   (%.2lf, %.2lf) erpina zirkunferentzian dago\n", fCx, fCy);
    else
        printf("   Errorea C erpinean\n");

    return 0;
} 

Programaren balizko exekuzio bat hurrengo irudian erakusten da:

Eta hauxe kode osoa:

/* Ariketa-39_TriangeluarenZirkunzentroa: sarrerako eta irteerako parametroak */

// A puntua eta B puntua segmentu horizontal batean daude
// A puntua eta B puntua ez dira bat
// C puntua ez dago AB segmentu horizontalean
// AC segmentua ez da bertikala
// BC segmentua ez da bertikala

// 39. ariketa: A, B eta C erpinez triangelua definitu (6 koordenatu). 

//     AB aldea horizontala izango da eta ABC triangeluari dagokion    
//     zirkunferentzia zirkunskribatuaren R erradioa kalkulatu.        
//     ABC triangeluari dagokion zirkunferentzia zirkunskribatuaren Z  
//     zentroaren bi koordenatuak Zx eta Zy kalkulatu.                 

//     Datuak hiru erpinen koordenatuak dira eta prozedura batean      
//     hartzen dira, adibidez: (0.0, 0.0), (4.0, 0.0) eta (2.0, 2.0)   


#include <stdio.h>
#include <math.h>

// ErpinakEskuratu: irteerako 6 parametro
void ErpinakEskuratu(float *fAx, float *fAy, float *fBx, float *fBy, float *fCx, float *fCy);
// AldeaLortu: sarrerako 4 parametro, emaitza float
float AldeaLortu(float f1x, float f1y, float f2x, float f2y);
// AzaleraLortu: sarrerako 6 parametro, emaitza float
float AzaleraLortu(float fAx, float fAy, float fBx, float fBy, float fCx, float fCy);
// ErrradioaLortu: sarrerako 4 parametro, emaitza float
float ErrradioaLortu(float fA, float fB, float fC, float fS);
// ZuzenarenMalda: sarrerako 4 parametro, emaitza float
float ZuzenarenMalda(float fPx, float fPy, float fQx, float fQy);
// SegmentuarenErdia: sarrerako 4 parametro, irteerako 2 parametro
void SegmentuarenErdia(float fPx, float fPy,
                       float fQx, float fQy,
                       float *fErdiaPQx, float *fErdiaPQy);
// ZentroaKalkulatu: sarrerako 4 parametro, irteerako 2 parametro
void ZentroaKalkulatu(float fM1, float fM2, float fD1, float fD2, float *fZx, float *fZy);
// ErpinaZirkunferentzianDago: sarrerako 5 parametro, emaitza int
int ErpinaZirkunferentzianDago(float fZx, float fZy, float fR, float fAx, float fAy);


int main()
{
    float fAx, fAy, fBx, fBy, fCx, fCy, fZx, fZy;       // koordenatuak
    float fErdiaACx, fErdiaACy, fErdiaBCx, fErdiaBCy;   // koordenatuak
    float fA, fB, fC, fR, fS;                           // distantziak
    float fMaldaAC, fPendikularraAC;                    // maldak
    float fMaldaBC, fPendikularraBC;                    // maldak
    float fDesplazamendu1, fDesplazamendu2;             // distantziak

    printf("\n\n\n");

    // triangeluaren hiru erpinak irakurri
    ErpinakEskuratu(&fAx, &fAy, &fBx, &fBy, &fCx, &fCy);

    printf("\n");

    // triangeluaren hiru aldeak lortu
    fA = AldeaLortu(fBx, fBy, fCx, fCy);    // BC segmentuaren luzera lortu
    fB = AldeaLortu(fAx, fAy, fCx, fCy);    // AC segmentuaren luzera lortu
    fC = AldeaLortu(fAx, fAy, fBx, fBy);    // AB segmentuaren luzera lortu

    printf("   fA aldea = %.2lf m\n", fA);  // BC segmentuaren luzera erakutsi
    printf("   fB aldea = %.2lf m\n", fB);  // AC segmentuaren luzera erakutsi
    printf("   fC aldea = %.2lf m\n", fC);  // AB segmentuaren luzera erakutsi

    // triangeluaren azalera kalkulatu erpinak ezagunak izatean
    fS = AzaleraLortu(fAx, fAy, fBx, fBy, fCx, fCy);

    printf("   fS azal. = %.3lf m^2\n\n", fS);

    // erradioa kalkulatzeko formula: (fA·fB·fC)/(4·fS)
    fR = ErrradioaLortu(fA, fB, fC, fS);

    printf("   fR erra. = %.3lf m\n\n", fR);

    // AC perpendikularraren malda
    fMaldaAC = ZuzenarenMalda(fAx, fAy, fCx, fCy);
    printf("   AC malda = %.2lf\n", fMaldaAC);
    fPendikularraAC = -(1 / fMaldaAC);
    printf("   AC perp. = %.2lf\n", fPendikularraAC);

    // AC perpendikularren zuzenak duen desplazamendua
    SegmentuarenErdia(fAx, fAy, fCx, fCy, &fErdiaACx, &fErdiaACy);
    printf("   AC erdia = (%.2lf, %.2lf)\n", fErdiaACx, fErdiaACy);
    fDesplazamendu1 = fErdiaACy + fErdiaACx / fMaldaAC;
    printf("   Desplaz1 = %.2lf m\n\n", fDesplazamendu1);

    // BC perpendikularraren malda
    fMaldaBC = ZuzenarenMalda(fBx, fBy, fCx, fCy);
    printf("   BC malda = %.2lf\n", fMaldaBC);
    fPendikularraBC = -(1 / fMaldaBC);
    printf("   BC perp. = %.2lf\n", fPendikularraBC);

    // BC perpendikularren zuzenak duen desplazamendua
    SegmentuarenErdia(fBx, fBy, fCx, fCy, &fErdiaBCx, &fErdiaBCy);
    printf("   BC erdia = (%.2lf, %.2lf)\n", fErdiaBCx, fErdiaBCy);
    fDesplazamendu2 = fErdiaBCy + fErdiaBCx / fMaldaBC;
    printf("   Desplaz2 = %.2lf m\n\n", fDesplazamendu2);

    // Zentroa bi zuzen perpendikularren arteko ebakidura izango da
    // Zuzen z1:   m1 = fPerpendikularraAC | d1 = fDesplazamendu1
    // Zuzen z2:   m2 = fPerpendikularraBC | d2 = fDesplazamendu2

    // Zuzen z1:   fZy = m1·fZx + d1
    // Zuzen z2:   fZy = m2·fZx + d2

    // m1·fZx + d1 = m2·fZx + d2  ==>  fZx = (d1 - d2) / (-m1 + m2)
    //         fZy = m1·fZx + d1  ==>  fZy = m1·(d1 - d2) / (-m1 + m2) + d1

    // fZx = (d1 - d2) / (-m1 + m2)
    // fZy = (m2·d1 - m1·d2) / (-m1 + m2)
    ZentroaKalkulatu(fPendikularraAC, fPendikularraBC, fDesplazamendu1, fDesplazamendu2, &fZx, &fZy);

    printf("   Z zentr. = (%.2lf, %.2lf)\n\n", fZx, fZy);
    printf("   (x - fZx)^2 + (y - fZy)^2 - fR^2  <  0.000001\n");

    if (ErpinaZirkunferentzianDago(fZx, fZy, fR, fAx, fAy))
        printf("   (%.2lf, %.2lf) erpina zirkunferentzian dago\n", fAx, fAy);
    else
        printf("   Errorea A erpinean\n");

    if (ErpinaZirkunferentzianDago(fZx, fZy, fR, fBx, fBy))
        printf("   (%.2lf, %.2lf) erpina zirkunferentzian dago\n", fBx, fBy);
    else
        printf("   Errorea B erpinean\n");

    if (ErpinaZirkunferentzianDago(fZx, fZy, fR, fCx, fCy))
        printf("   (%.2lf, %.2lf) erpina zirkunferentzian dago\n", fCx, fCy);
    else
        printf("   Errorea C erpinean\n");

    return 0;
}

void ErpinakEskuratu(float *fAx, float *fAy, float *fBx, float *fBy, float *fCx, float *fCy)
{
    printf("   A erpinaren koordenatuak eman,\n");
    printf("   Ax koordenatua: ");
    scanf("%f", fAx);
    printf("   Ay koordenatua: ");
    scanf("%f", fAy);
    printf("\n");

    printf("   B erpinaren koordenatuak eman,\n");
    do
    {
        printf("   Bx koordenatua: ");
        scanf("%f", fBx);
        if (*fBx == *fAx)
            printf("   Ax koordenatua eta Bx koordenatua desberdinak izan behar dira...\n\a");
    } while (*fBx == *fAx);
    *fBy = *fAy;  // AB segmentu horizontala
    printf("   By koordenatua: %.2lf\n", *fBy);
    printf("\n");

    printf("   C erpinaren koordenatuak eman,\n");
    if (*fAx < *fBx)
    {
        do
        {
            printf("   Cx koordenatua: ");
            scanf("%f", fCx);
            if (*fCx <= *fAx || *fCx >= *fBx)
                printf("   Ax < Cx < Bx bete behar da...\n\a");
        } while (*fCx <= *fAx || *fCx >= *fBx); //  fAx < fCx < fBx
    }
    else
    {
        do
        {
            printf("   Cx koordenatua: ");
            scanf("%f", fCx);
            if (*fCx <= *fBx || *fCx >= *fAx)
                printf("   Bx < Cx < Ax bete behar da...\n\a");
        } while (*fCx <= *fBx || *fCx >= *fAx); //  fBx < fCx < fAx
    }
    do
    {
        printf("   Cy koordenatua: ");
        scanf("%f", fCy);
        if (*fCy == *fAy)
            printf("   C ezin da egon AB segmentuan...\n\a");
    } while (*fCy == *fAy); // C ez da AB segmentuan
}

float AldeaLortu(float f1x, float f1y, float f2x, float f2y)
{
    return sqrt(pow(f2x - f1x, 2) + pow(f2y - f1y, 2));
}

float AzaleraLortu(float fAx, float fAy, float fBx, float fBy, float fCx, float fCy)
{
    return fabs(0.5 * (fAx * fBy + fBx * fCy + fCx * fAy - fCx * fBy - fBx * fAy - fAx * fCy));
}

float ErrradioaLortu(float fA, float fB, float fC, float fS)
{
    return (fA * fB * fC) / (4 * fS);
}

float ZuzenarenMalda(float fPx, float fPy, float fQx, float fQy)
{
    return (fQy - fPy) / (fQx - fPx);
}

void SegmentuarenErdia(float fPx, float fPy,
                       float fQx, float fQy,
                       float *fErdiaPQx, float *fErdiaPQy)
{
    if (fPx >= fQx)
        *fErdiaPQx = fQx + fabs(fPx - fQx) / 2;
    else
        *fErdiaPQx = fPx + fabs(fPx - fQx) / 2;

    if (fPy <= fQy)
        *fErdiaPQy = fPy + fabs(fPy - fQy) / 2;
    else
        *fErdiaPQy = fQy + fabs(fPy - fQy) / 2;
}

void ZentroaKalkulatu(float fM1, float fM2, float fD1, float fD2, float *fZx, float *fZy)
{
    *fZx = (fD1 - fD2) / (-fM1 + fM2);
    *fZy = (fM2 * fD1 - fM1 * fD2) / (-fM1 + fM2);
}

int ErpinaZirkunferentzianDago(float fZx, float fZy, float fR, float fAx, float fAy)
{
    return (pow(fAx - fZx, 2) + pow(fAy - fZy, 2) - pow(fR, 2) < 0.000001);
}

---

Ariketa-39_TriangeluarenZirkunzentroa.cbp | main.c

 

Ariketa 38 | Zenbaki Konbinatorioa (sarrera-irteerako parametroa)

ZER DAKIDAN: Badakit funtzio bati sarrerako parametroa balioz pasatzen zaiola eta funtzioak return bitartez itzul dezakeela emaitza. ZER IKASIKO DUDAN: Ireerako parametroak erabiltzen ikasiko dut, parametro horiek erreferentziaz pasarazi behar dizkiot funtzioari.

---

zenbaki konbinatorioa, kopuru osoa da eta hura lortzeko m eta n zenbaki osoak eta positiboak ezagutu behar dira. Jakinik ere, zenbaki negatiboen faktoriala definiturik ez dagoelako datuek baldintza hau betetzen dutela:   m >= n.

Ariketa 38 | Zenbaki Konbinatorioa (sarrerako parametroa) blog-artikuluan ikusi dugu liFaktoriala() izeneko funtzioak sarrerako parametro bat behar duela eta behar duen datua balioz pasatzen zaiola. Ikus dezagun orain funtzio bat zeinek bi irteera itzultzen dituen, bi parametroak, noski, erreferentziaz pasatzen dira.

Hau garrantzitsua da Parametroak erreferentziaz pasatzeak esan nahi du transferitutakoa ez direla balioak, baizik eta balio horiek dituzten aldagaien helbideak, eta, beraz, uneko parametroak alda daitezke. Parametroak erreferentziaz pasatzen dira irteerako parametroak direnean (zehatzago hitz eginez sarrera/irteerako parametroak direnean).

Hurrengo hiru programetan erreparatu DatuakHartu() izeneko funtzioan, EmaitzaEskuratu() izeneko funtzioan eta EmaitzaKalkulatu() izeneko funtzioan, horiek ulertzea baita blog-artikulu honen helburua.

Azpiprogramen deskribapen laburra eta bere parametroen jokamoldeak:

1. DatuakHartu()funtzioaren barruan bi scanf() egin ondoren irakurritako bi balioak main() funtzio nagusira bidaltzen dira.

• DatuakHartu() funtzioak void bat itzultzen du, hots, ez du ezer itzultzen. Parametroak:
• sarrerako parametroak: sarrerarik ez dago
• irteerako parametroak: bi irteera, biak int datu-motakoak

2. liFaktoriala()funtzioak zenbaki oso baten faktoriala kalkulatzen du.

• liFaktoriala() funtzioak long bat itzultzen du. Parametroak:
• Sarrerako parametroak: int bat
• Irteerako parametroak: irteerarik ez dago

Hau da Ariketa-38a_ZenbakiKonbinatorioa.cbp proiektuaren main.c fitxategiaren kodea:

/* Ariketa-38a_ZenbakiKonbinatorioa: parametroak balioz eta
                                     erreferentziaz igarotzen */

// Zenbaki osoekin lan eginez, DatuakHartu() funtzioan bi kopuru
// irakurri ondoren (m eta n), dagozkien zenbaki konbinatorioa
// kalkulatu. Faktorialak lortu fnlFaktoriala() funtzioa erabiliz.

#include <stdio.h>

void DatuakHartu(int *, int *);   // funtzioaren prototipoa
long liFaktoriala(int);           // funtzioaren prototipoa

int main()
{
    int iZbk_M, iZbk_N, iZbk_MkenN, iEmaitza;
    long liFakt_M, liFakt_N, liFakt_MkenN;

    printf("\n");

    printf("\n Zenbaki osoekin lan eginez...\n\n");

    DatuakHartu(&iZbk_M, &iZbk_N);     // uneko parametroak

    liFakt_M = liFaktoriala(iZbk_M);   // uneko parametroak
    printf("\n\t %d!=%ld", iZbk_M, liFakt_M);

    liFakt_N = liFaktoriala(iZbk_N);   // uneko parametroak
    printf("\n\t %d!=%ld", iZbk_N, liFakt_N);

    iZbk_MkenN = iZbk_M - iZbk_N;
    liFakt_MkenN = liFaktoriala(iZbk_MkenN);   // uneko parametroak
    printf("\n\t %d!=%ld", iZbk_MkenN, liFakt_MkenN);

    iEmaitza = liFakt_M / (liFakt_N * liFakt_MkenN);
    printf("\n\n Zenbaki konbinatorioa ZK=%d", iEmaitza);

    printf("\n\n");
    return 0;
}


// Irteerako parametroak
void DatuakHartu(int *iZbk_M, int *iZbk_N)   // parametro formalak
{
    do
    {
        printf(" 'm' zenbaki osoa eta positiboa eman: ");
        scanf("%d", iZbk_M);   //  iZbk_M helbidea da, zenbaki baten helbidea da
    } while (*iZbk_M < 0);     // *iZbk_M zenbakia da, iZbk_M helbideak seinalatutako zenbakia da

    do
    {
        printf(" 'n' zenbaki osoa eman (0 eta %d artekoa): ", *iZbk_M);
        scanf("%d", iZbk_N);       //  iZbk_N helbidea da, zenbaki baten helbidea da
    } while ((*iZbk_N < 0) ||      // *iZbk_N zenbakia da, iZbk_N helbideak seinalatutako zenbakia da
             (*iZbk_N > *iZbk_M));
}


// Sarrerako parametroa
long liFaktoriala(int iZenbakia)   // parametro formala
{
    int iKont;           // bertako aldagaia
    long liMetagailua;   // faktorialaren emaitza izango dena

    printf("\n\t %d! kalkulatzen...", iZenbakia);
    liMetagailua = 1;
    for (iKont = 1; iKont <= iZenbakia; iKont++)
    {
        liMetagailua = liMetagailua * iKont;
    }

    return(liMetagailua);
}

Azpiprogramen deskribapen laburra eta bere parametroen jokamoldeak:

1. DatuakHartu()funtzioaren barruan bi scanf() egin ondoren irakurritako bi balioak main() funtzio nagusira bidaltzen dira.

• DatuakHartu() funtzioak void bat itzultzen du, hots, ez du ezer itzultzen. Parametroak:
• sarrerako parametroak: sarrerarik ez dago
• irteerako parametroak: bi irteera, biak int datu-motakoak

2. liFaktoriala()funtzioak zenbaki oso baten faktoriala kalkulatzen du.

• liFaktoriala() funtzioak long bat itzultzen du. Parametroak:
• Sarrerako parametroak: int bat
• Irteerako parametroak: irteerarik ez dago

3. EmaitzaEskuratu() funtzioak hiru faktorialak kalkulatu eta Zenbaki Konbinatorioa itzultzen du.

• EmaitzaEskuratu() funtzioak int bat itzultzen du. Parametroak:
• Sarrerako parametroak: bi sarrera, int datu-motako bi sarrera
• Irteerako parametroak: irteerako parametrorik ez dago.

Hau da Ariketa-38b_ZenbakiKonbinatorioa.cbp proiektuaren main.c fitxategiaren kodea:

/* Ariketa-38b_ZenbakiKonbinatorioa: parametroak balioz eta
                                     erreferentziaz igarotzen */

// Zenbaki osoekin lan eginez, DatuakHartu() funtzioan bi kopuru
// irakurri ondoren (m eta n), dagozkien zenbaki konbinatorioa
// lortu EmaitzaEskuratu() funtzioari esker. EmaitzaEskuratu()
// funtzioak fnlFaktoriala() funtzioari deiak egingo dizkio.

#include <stdio.h>

void DatuakHartu(int *, int *);   // funtzioaren prototipoa
long liFaktoriala(int);           // funtzioaren prototipoa
int EmaitzaEskuratu(int, int);    // funtzioaren prototipoa

int main()
{
    int iZbk_M, iZbk_N, iEmaitza;

    printf("\n");

    printf("\n Zenbaki osoekin lan eginez...\n\n");

    DatuakHartu(&iZbk_M, &iZbk_N);   // uneko parametroak

    iEmaitza = EmaitzaEskuratu(iZbk_M, iZbk_N);   // uneko parametroak

    printf("\n\n Zenbaki konbinatorioa ZK=%d", iEmaitza);

    printf("\n\n");
    return 0;
}


// Irteerako parametroak
void DatuakHartu(int *iZbk_M, int *iZbk_N)   // parametro formalak
{
    do
    {
        printf(" 'm' zenbaki osoa eta positiboa eman: ");
        scanf("%d", iZbk_M);   //  iZbk_M helbidea da, zenbaki baten helbidea da
    } while (*iZbk_M < 0);     // *iZbk_M zenbakia da, iZbk_M helbideak seinalatutako zenbakia da

    do
    {
        printf(" 'n' zenbaki osoa eman (0 eta %d artekoa): ", *iZbk_M);
        scanf("%d", iZbk_N);       //  iZbk_N helbidea da, zenbaki baten helbidea da
    } while ((*iZbk_N < 0) ||      // *iZbk_N zenbakia da, iZbk_N helbideak seinalatutako zenbakia da
             (*iZbk_N > *iZbk_M));
}


// Sarrerako parametroa
long liFaktoriala(int iZenbakia)   // parametro formala
{
    int iKont;          // bertako aldagaia
    long liMetagailua;   // faktorialaren emaitza izango dena

    printf("\n\t %d! kalkulatzen...", iZenbakia);
    liMetagailua = 1;
    for (iKont = 1; iKont <= iZenbakia; iKont++)
    {
        liMetagailua = liMetagailua * iKont;
    }

    return(liMetagailua);
}


// Sarrerako parametroak
int EmaitzaEskuratu(int iZbk_M, int iZbk_N)    // parametro formalak
{
    long liFakt_M, liFakt_N, liFakt_MkenN;     // bertako aldagaiak
    int iZbk_MkenN, iEmaitza;                  // bertako aldagaiak

    liFakt_M = liFaktoriala(iZbk_M);           // uneko parametroak
    printf("\n\t %d!=%ld", iZbk_M, liFakt_M);

    liFakt_N = liFaktoriala(iZbk_N);           // uneko parametroak
    printf("\n\t %d!=%ld", iZbk_N, liFakt_N);

    iZbk_MkenN = iZbk_M - iZbk_N;
    liFakt_MkenN = liFaktoriala(iZbk_MkenN);   // uneko parametroak
    printf("\n\t %d!=%ld", iZbk_MkenN, liFakt_MkenN);

    iEmaitza = liFakt_M / (liFakt_N * liFakt_MkenN);
    return(iEmaitza);
}

Azpiprogramen deskribapen laburra eta bere parametroen jokamoldeak:

1. DatuakHartu()funtzioaren barruan bi scanf() egin ondoren irakurritako bi balioak main() funtzio nagusira bidaltzen dira.

• DatuakHartu() funtzioak void bat itzultzen du, hots, ez du ezer itzultzen. Parametroak:
• sarrerako parametroak: sarrerarik ez dago
• irteerako parametroak: bi irteera, biak int datu-motakoak

2. liFaktoriala()funtzioak zenbaki oso baten faktoriala kalkulatzen du.

• liFaktoriala() funtzioak long bat itzultzen du. Parametroak:
• Sarrerako parametroak: int bat
• Irteerako parametroak: irteerarik ez dago

3. EmaitzaKalkulatu() funtzioak hiru faktorialak kalkulatu eta Zenbaki Konbinatorioa itzultzen du.

• EmaitzaKalkulatu() funtzioak void bat itzultzen du (ez du ezer itzultzen). Parametroak:
• Sarrerako parametroak: bi sarrera, int datu-motako bi sarrera
• Irteerako parametroak: irteera bakarra, int datu-motakoa

Hau da Ariketa-38c_ZenbakiKonbinatorioa.cbp proiektuaren main.c fitxategiaren kodea:

/* Ariketa-38c_ZenbakiKonbinatorioa: parametroak balioz eta
                                     erreferentziaz igarotzen */

// Zenbaki osoekin lan eginez, DatuakHartu() funtzioan bi kopuru
// irakurri ondoren (m eta n), dagozkien zenbaki konbinatorioa
// lortu EmaitzaKalkulatu() funtzioari esker. EmaitzaKalkulatu()
// funtzioak fnlFaktoriala() funtzioari deiak egingo dizkio.

#include <stdio.h>

void DatuakHartu(int *, int *);          // funtzioaren prototipoa
long liFaktoriala(int);                  // funtzioaren prototipoa
void EmaitzaKalkulatu(int, int, int *);  // funtzioaren prototipoa

int main()
{
    int iZbk_M, iZbk_N, iEmaitza;

    printf("\n");

    printf("\n Zenbaki osoekin lan eginez...\n\n");

    DatuakHartu(&iZbk_M, &iZbk_N);   // uneko parametroak

    EmaitzaKalkulatu(iZbk_M, iZbk_N, &iEmaitza);   // uneko parametroak

    printf("\n\n Zenbaki konbinatorioa ZK=%d", iEmaitza);

    printf("\n\n");
    return 0;
}


// Irteerako parametroak
void DatuakHartu(int *iZbk_M, int *iZbk_N)   // parametro formalak
{
    do
    {
        printf(" 'm' zenbaki osoa eta positiboa eman: ");
        scanf("%d", iZbk_M);   //  iZbk_M helbidea da, zenbaki baten helbidea da
    } while (*iZbk_M < 0);     // *iZbk_M zenbakia da, iZbk_M helbideak seinalatutako zenbakia da

    do
    {
        printf(" 'n' zenbaki osoa eman (0 eta %d artekoa): ", *iZbk_M);
        scanf("%d", iZbk_N);       //  iZbk_N helbidea da, zenbaki baten helbidea da
    } while ((*iZbk_N < 0) ||      // *iZbk_N zenbakia da, iZbk_N helbideak seinalatutako zenbakia da
             (*iZbk_N > *iZbk_M));
}


// Sarrerako parametroa
long liFaktoriala(int iZenbakia)   // parametro formala
{
    int iKont;          // bertako aldagaia
    long liMetagailua;   // faktorialaren emaitza izango dena

    printf("\n\t %d! kalkulatzen...", iZenbakia);
    liMetagailua = 1;
    for (iKont = 1; iKont <= iZenbakia; iKont++)
    {
        liMetagailua = liMetagailua * iKont;
    }

    return(liMetagailua);
}


// Sarrerako parametroak eta irteerako parametroa
void EmaitzaKalkulatu(int iZbk_M, int iZbk_N, int *iEmaitza)   // parametro formalak
{
    long liFakt_M, liFakt_N, liFakt_MkenN;     // bertako aldagaiak
    int iZbk_MkenN;                            // bertako aldagaia

    liFakt_M = liFaktoriala(iZbk_M);           // uneko parametroak
    printf("\n\t %d!=%ld", iZbk_M, liFakt_M);

    liFakt_N = liFaktoriala(iZbk_N);           // uneko parametroak
    printf("\n\t %d!=%ld", iZbk_N, liFakt_N);

    iZbk_MkenN = iZbk_M - iZbk_N;
    liFakt_MkenN = liFaktoriala(iZbk_MkenN);   // uneko parametroak
    printf("\n\t %d!=%ld", iZbk_MkenN, liFakt_MkenN);

    *iEmaitza = liFakt_M / (liFakt_N * liFakt_MkenN);
}

---

Ikusi parametroak sarrera/irteerakoak direnean adibide batzuk:

Ariketa-38a_ZenbakiKonbinatorioa.cbp | main.c Ariketa-38b_ZenbakiKonbinatorioa.cbp | main.c Ariketa-38c_ZenbakiKonbinatorioa.cbp | main.c

 

Ariketa 38 | Zenbaki Konbinatorioa (sarrerako parametroa)

ZER DAKIDAN: Badakit funtzio estandarrak izan daitezkeela eta norberak programatutako funtzioak izan daitezkeela. Badakit ere funtzioa eta programa nagusia elkar komunikatzeko parametroak erabiltzen direla. ZER IKASIKO DUDAN: liFaktoriala() funtzioari esker Zenbaki Konbinatorioa kalkulatuz sarrerako parametroak erabiltzen ikasiko dut eta horrez gain, ikusiko dut ere funtzio batek balio bat itzuli behar duenean return bitartez egin dezakeela.

---

zenbaki konbinatorioa, kopuru osoa da eta hura lortzeko m eta n zenbaki osoak eta positiboak ezagutu behar dira. Jakinik ere, zenbaki negatiboen faktoriala definiturik ez dagoelako datuek baldintza hau betetzen dutela:   m >= n.

Hau garrantzitsua da Parametroak balioz pasatzeak esan nahi du uneko parametroak dagozkien parametro formaletan kopiatzen direla, ekintza hori automatikoki egiten da, eta, beraz, ez dira aldatzen uneko parametroak. Parametroak balioz pasatzen dira sarrerako parametroak direnean.

Ondoko programa honek, m eta n irakurri ondoren, hiru faktorialen ZK zenbaki konbinatorioa kalkulatzen du, baina faktorialaren kalkulua leku bakar batean egiten du liFaktoriala() izeneko funtzioan hain zuzen ere:

/* Ariketa-38_ZenbakiKonbinatorioa: parametroak balioz igarotzen */

// Zenbaki osoekin lan eginez, main() funtzio nagusian bi kopuru
// irakurri ondoren (m eta n), dagozkien zenbaki konbinatorioa
// kalkulatu. Faktorialak lortu fnlFaktoriala() funtzioa erabiliz.

#include <stdio.h>

long liFaktoriala(int);   // funtzioaren prototipoa

int main()
{
    int iZbk_M, iZbk_N, iZbk_MkenN, iEmaitza;
    long liFakt_M, liFakt_N, liFakt_MkenN;

    printf("\n");
    printf("\n Zenbaki osoekin lan eginez...\n\n");

    do
    {
        printf(" 'm' zenbaki osoa eta positiboa eman: ");
        scanf("%d", &iZbk_M);
    } while (iZbk_M < 0);

    do
    {
        printf(" 'n' zenbaki osoa eman (0 eta %d artekoa): ", iZbk_M);
        scanf("%d", &iZbk_N);
    } while ((iZbk_N < 0) || (iZbk_N > iZbk_M));

    liFakt_M = liFaktoriala(iZbk_M);   // uneko parametroak
    printf("\n\t %d!=%ld", iZbk_M, liFakt_M);

    liFakt_N = liFaktoriala(iZbk_N);   // uneko parametroak
    printf("\n\t %d!=%ld", iZbk_N, liFakt_N);

    iZbk_MkenN = iZbk_M - iZbk_N;
    liFakt_MkenN = liFaktoriala(iZbk_MkenN);   // uneko parametroak
    printf("\n\t %d!=%ld", iZbk_MkenN, liFakt_MkenN);

    iEmaitza = liFakt_M / (liFakt_N * liFakt_MkenN);
    printf("\n\n Zenbaki konbinatorioa ZK=%d", iEmaitza);

    printf("\n\n");
    return 0;
}


// Sarrerako parametroa
long liFaktoriala(int iZenbakia)   // parametro formala
{
    int iKont;
    long liMetagailua;   // faktorialaren emaitza izango dena

    printf("\n\t %d! kalkulatzen...", iZenbakia);
    liMetagailua = 1;
    for (iKont = 1; iKont <= iZenbakia; iKont++)
    {
        liMetagailua = liMetagailua * iKont;
    }

    return(liMetagailua);
}

Aurreko programan liFaktoriala() izeneko funtzioari deia egiten dio hiru aldiz, enuntziatuaren m!, n! eta (m-n)! kalkulatzeko hurrenez hurren. Funtzio horrek programa nagusiko datu bat jasotzen du eta dagokion faktoriala kalkulatu ondoren programa nagusiari itzultzen dio.

Funtzioa osatzean hiru elementu kontutan izan beharko dira:

1. Funtzioaren prototipoa programaren hasieran idatzi behar dela, horiek dira parametro formalak
2. Funtzioaren kodea programaren edozein tokitan jar daitekeela, ohitura da gorengoko posizioan main() funtzioa idaztea
3. Funtzioaren deiak egiterakoan uneko parametroak bat etorriko dira parametro formalekin

---

Ikusi parametroak sarrerakoak direnean adibide bat:

Ariketa-38_ZenbakiKonbinatorioa.cbp | main.c

 

Ariketa 37 | Funtzio baten parametroak

ZER DAKIDAN: Hainbat funtzio estandar ikasi dut eta badakit datu bat edo batzuk emanik emaitza itzultzen dutela. Esate baterako, fabs() funtzioak zenbakizko datu baten balio absolutua itzultzen du eta pow() funtzioak bi zenbaki behar ditu potentzia kalkulatu eta itzultzeko. ZER IKASIKO DUDAN: Funtzio estandarrak oso interesbarriak izanik, orain ikasiko dut nere funtzioak programatzen eta hartuko dudan lehen zeregina da parametroak zer diren ikastea.

---

Funtzioaren parametroak balioaren arabera edo erreferentziaren arabera igaro daitezke. Hau da, funtzio bati dei egiten zaionean, balioak edo erreferentziak izan daitezke uneko parametroak.

Hau garrantzitsua da Parametroak balioz pasatzeak esan nahi du uneko parametroak dagozkien parametro formaletan kopiatzen direla, ekintza hori automatikoki egiten da, eta, beraz, ez dira aldatzen uneko parametroak. Parametroak balioz pasatzen dira sarrerako parametroak direnean. Ikusi BatuketaEgin() izeneko funtzioa hurrengo Ariketa-37a programan.

Hau garrantzitsua da Parametroak erreferentziaz pasatzeak esan nahi du transferitutakoa ez direla balioak, baizik eta balio horiek dituzten aldagaien helbideak, eta, beraz, uneko parametroak alda daitezke. Parametroak erreferentziaz pasatzen dira irteerako parametroak direnean (zehatzago hitz eginez sarrera/irteerako parametroak direnean). Ikusi BaturaLortu() izeneko funtzioa Ariketa-37b delako programan.

Ondoko bi programa hauek ikusi eta aztertu BatuketaEgin() izeneko funtzioa eta BaturaLortu() funtzioa. Biek bi daturen batura kalkulatzen dute baina bakoitzak dituen parametroen jokamoldea desberdina da:

/* Ariketa-37a_FuntzioarenParametroak: balioz */

// Zenbaki osoekin lan eginez, main() funtzio nagusian bi kopuru
// irakurri ondoren funtzio honi deia egin:
//   - BatuketaEgin() funtzioaren bidez bi datuen batura lortu

#include <stdio.h>

int BatuketaEgin(int, int);  // funtzioaren prototipoa

int main()
{
    int iZbk1, iZbk2, iBatura;
    int *pErakuslea;  // oso bati seinalatzen dion erakuslea
                      // oso baten helbidea gordetzeko aldagaia
    printf("\n");
    printf("\n Zenbaki osoekin lan eginez...\n\n");

    printf(" Lehen batugaiaren balioa sartu: ");
    scanf("%d", &iZbk1);
    printf(" Bigarren batugaiarena eman ere: ");
    scanf("%d", &iZbk2);

    pErakuslea = &iZbk1;
    printf("\n===============================");
    printf("\n iZbk1=%d \t *pErakuslea=%d", iZbk1, *pErakuslea);
    printf("\n===============================\n");

    iBatura = BatuketaEgin(iZbk1, iZbk2);   // uneko parametroak
    printf("\n 'BatuketaEgin()' funtzioari deia egin ondoren:");
    printf("\n\t (%d) + (%d) = %d", iZbk1, iZbk2, iBatura);

    printf("\n\n");
    return 0;
}


// Bi parametroetatik biak sarrerakoak dira
int BatuketaEgin(int iZenbakia1, int iZenbakia2)   // parametro formalak
{
    return(iZenbakia1 + iZenbakia2);
}

Hona hemen Ariketa-37a_FuntzioarenParametroak.pas proiektuaren azalpenak:

• BatuketaEgin() izeneko funtzioaren bi sarrerak int datu-motakoak dira izanik, eta funtzioak beste int bat itzultzen du return aginduari esker
• pErakuslea aldagaia int bati seinalatzen dion erakuslea da, edo beste modu batez esanik int baten helbidea gordetzeko gaitasuna duen aldagaia da
• pErakuslea aldagaian iZbk1 aldagaiaren helbidea gordetzean, iZbk1 aldagaiaren edukia bi moduz eskura daiteke:
1. Aldagaiaren iZbk1 identifikadorearen bitartez
2. Aldagai-erakuslearen bitartez, erakuslearen *pErakuslea erakutsia idatziz

/* Ariketa-37b_FuntzioarenParametroak: erreferentziaz */

// Zenbaki osoekin lan eginez, main() funtzio nagusian bi kopuru
// irakurri ondoren funtzio honi deia egin:
//   - BaturaLortu() funtzioaren bidez bi datuen batura lortu

#include <stdio.h>

void BaturaLortu(int, int, int *);   // funtzioaren prototipoa

int main()
{
    int iZbk1, iZbk2, iBatura;
    int *pErakuslea;  // oso bati seinalatzen dion erakuslea
                      // oso baten helbidea gordetzeko aldagaia
    printf("\n");
    printf("\n Zenbaki osoekin lan eginez...\n\n");

    printf(" Lehen batugaiaren balioa sartu: ");
    scanf("%d", &iZbk1);
    printf(" Bigarren batugaiarena eman ere: ");
    scanf("%d", &iZbk2);

    pErakuslea = &iZbk2;
    printf("\n===============================");
    printf("\n iZbk2=%d \t *pErakuslea=%d", iZbk2, *pErakuslea);
    printf("\n===============================\n");

    BaturaLortu(iZbk1, iZbk2, &iBatura);   // uneko parametroak
    printf("\n 'BaturaLortu()' funtzioari deia egin ondoren:");
    printf("\n\t (%d) + (%d) = %d", iZbk1, iZbk2, iBatura);

    printf("\n\n");
    return 0;
}


// Hiru parametroetatik lehen biak sarrerakoak dira eta hirugarrena irteerakoa
void BaturaLortu(int iZenbakia1, int iZenbakia2, int *iKalkulua)   // parametro formalak
{
    *iKalkulua = iZenbakia1 + iZenbakia2;
}

Hona hemen Ariketa-37b_FuntzioarenParametroak.pas proiektuaren azalpenak:

• BaturaLortu() izeneko funtzioaren bi sarrerak int datu-motakoak dira izanik eta hirugarren parametroa int bati seinalatzen dion erakuslea denez irteerakoa izango da
• pErakuslea aldagaia int bati seinalatzen dion erakuslea da, edo beste modu batez esanik int baten helbidea gordetzeko gaitasuna duen aldagaia da
• pErakuslea aldagaian iZbk2 aldagaiaren helbidea gordetzean, iZbk2 aldagaiaren edukia bi moduz eskura daiteke:
1. Aldagaiaren iZbk2 identifikadorearen bitartez
2. Aldagai-erakuslearen bitartez, erakuslearen *pErakuslea erakutsia idatziz

Jakin badakigu aldagai bat memoriako zati bat dela eta identifikadore bati esker eskura dezakegula bai bere edukia eta bai aldagaiaren helbidea memorian. Hona hemen 37c_AldagaienHelbideak.cbp proiektua zeinek hainbat aldagaien edukiak eta helbideak erakusten dituen (programa hau konpilatzean ager daitezkeen abisuei jaramonik ez egin):

/* Ariketa-37c_AldagaienHelbideak: aldagaien helbideak pantailaratzen */

// Aldagaien helbideak erakusten dituen adibidea, 6 datu-mota:
// int, short, long, float, double eta char.

#include <stdio.h>

int main()
{
	int iZbk4 = 4;
	int iZbk3 = 3;
	int iZbk2 = 2;
	int iZbk1 = 1;

	printf("\n");
	printf("Int ---> %d byte\n", (int)sizeof(int));
	printf("\tiZbk1=%d    eta    &iZbk1=%d\n", iZbk1, (int)&iZbk1);
	printf("\tiZbk2=%d    eta    &iZbk2=%d\n", iZbk2, (int)&iZbk2);
	printf("\tiZbk3=%d    eta    &iZbk3=%d\n", iZbk3, (int)&iZbk3);
	printf("\tiZbk4=%d    eta    &iZbk4=%d\n", iZbk4, (int)&iZbk4);

	short shZbk1 = 1;
	short shZbk2 = 2;
	short shZbk3 = 3;
	short shZbk4 = 4;

	printf("\n");
	printf("Short ---> %d byte\n", (int)sizeof(short));
	printf("\tshZbk1=%d   eta    &shZbk1=%d\n", shZbk1, (int)&shZbk1);
	printf("\tshZbk2=%d   eta    &shZbk2=%d\n", shZbk2, (int)&shZbk2);
	printf("\tshZbk3=%d   eta    &shZbk3=%d\n", shZbk3, (int)&shZbk3);
	printf("\tshZbk4=%d   eta    &shZbk4=%d\n", shZbk4, (int)&shZbk4);

	long lZbk1 = 1;
	long lZbk2 = 2;
	long lZbk3 = 3;
	long lZbk4 = 4;

	printf("\n");
	printf("Long ---> %d byte\n", (int)sizeof(long));
	printf("\tlZbk1=%ld    eta    &lZbk1=%d\n", lZbk1, (int)&lZbk1);
	printf("\tlZbk2=%ld    eta    &lZbk2=%d\n", lZbk2, (int)&lZbk2);
	printf("\tlZbk3=%ld    eta    &lZbk3=%d\n", lZbk3, (int)&lZbk3);
	printf("\tlZbk4=%ld    eta    &lZbk4=%d\n", lZbk4, (int)&lZbk4);

	float fZbk1 = 1.1;
	float fZbk2 = 2.2;
	float fZbk3 = 3.3;
	float fZbk4 = 4.4;

	printf("\n");
	printf("Float ---> %d byte\n", (int)sizeof(float));
	printf("\tfZbk1=%.1f   eta   &fZbk1=%d\n", fZbk1, (int)&fZbk1);
	printf("\tfZbk2=%.1f   eta   &fZbk2=%d\n", fZbk2, (int)&fZbk2);
	printf("\tfZbk3=%.1f   eta   &fZbk3=%d\n", fZbk3, (int)&fZbk3);
	printf("\tfZbk4=%.1f   eta   &fZbk4=%d\n", fZbk4, (int)&fZbk4);

	double dZbk1 = 1.1;
	double dZbk2 = 2.2;
	double dZbk3 = 3.3;
	double dZbk4 = 4.4;

	printf("\n");
	printf("Double ---> %d byte\n", (int)sizeof(double));
	printf("\tdZbk1=%.1lf   eta   &dZbk1=%d\n", dZbk1, (int)&dZbk1);
	printf("\tdZbk2=%.1lf   eta   &dZbk2=%d\n", dZbk2, (int)&dZbk2);
	printf("\tdZbk3=%.1lf   eta   &dZbk3=%d\n", dZbk3, (int)&dZbk3);
	printf("\tdZbk4=%.1lf   eta   &dZbk4=%d\n", dZbk4, (int)&dZbk4);

	char cKar1 = 'A';
	char cKar2 = 'B';
	char cKar3 = 'C';
	char cKar4 = 'D';

	printf("\n");
	printf("Char ---> %d byte\n", (int)sizeof(char));
	printf("\tcKar1=%c    eta    &cKar1=%d\n", cKar1, (int)&cKar1);
	printf("\tcKar2=%c    eta    &cKar2=%d\n", cKar2, (int)&cKar2);
	printf("\tcKar3=%c    eta    &cKar3=%d\n", cKar3, (int)&cKar3);
	printf("\tcKar4=%c    eta    &cKar4=%d\n", cKar4, (int)&cKar4);
}

Programa honetan sizeof() funtzioari esker datu-mota batek zenbat byte hartzen dituen memorian erakusten
da lehenik, eta ondoren datu-mota horretako 4 aldagaien edukiak eta helbideak pantailaratzen dira.

---

Ikusi adibide honetan sarrerako parametroen eta irteerako parametroen arteko aldeak:

Ariketa-37a_FuntzioarenParametroak.cbp | main.c Ariketa-37b_FuntzioarenParametroak.cbp | main.c Ariketa-37c_AldagaienHelbideak.cbp | main.c

 

Ariketa 36 | Hainbat aukeren menu bat

ZER DAKIDAN: switch baldintzazko egitura ikasi nuen aukera anitzak antolatzeko. ZER IKASIKO DUDAN: Menu bat programa batean nola egiten den ikasiko dut, erabiltzaileak gogoko duen hautapena char datu-motako aldagai batean irakurriko dut. Bide batez system("cls") errutinaren funtzionamendua ikusiko dut ere. Eta, noski, menu bat prozesu errepikakor bat izan ohi da eta bertatik irteteko propio idaztiko dut aukera bat.

Ariketa 18 | Aukera anitzen arteko hautapena artikulua gogora ekarriz, programaren fluxua bideratzeko switch agindua erabilten da aukerak hiru edo gehiago direnean.

Jarraian erakusten den menua programa nagusian kokaturik dago, baina jakin ezazu hori horrela ez dela egingo behin azpiprogramen kontzeptua gureganatuko dugunetik aurrera.

Algoritmoa:

1. Programa osoa prozesu errepikakor bat da, eta errepikapenak mozteko menuaren aukera egokia hautatu behar da (lehen adibidean I, i edo 0 balioak, eta bigarren adibidean A edo a balioak)
   
2. Begiztaren iterazio bakoitzeko, pantaila garbitu system("cls") funtzioaren bitartez eta bost aukeren deskribapenak erakutsi
3. Begiztaren iterazio bakoitzeko, char datu-motako cAukera aldagaiari balioa teklatuz eman era kontrolatuan (teklatuaren karaktere bat irakurtzeko getche() funtzioa oso egokia da)
4. Irakurri den karaktere horren arabera switch egiturak kudeatuko du programaren fluxoa eta aukera horri dagozkion kalkuluak burutuko dira
   
5. Begiztaren iterazio bakoitzeko, programaren exekuzioa gelditu getch() funtzioaren bitartez tekla bat sakatu arte, horrela informazioa eta kalkuluen emaitzak ikusi ahal izango dira
   

Ondoko bi programak nahiko berdintsuak dira, batean konstanteak erakusten dira pantailan eta bestean kalkulu baten emaitza. Bi ariketetan garrantzitsuena da programa nola antolatu den.

Programa honek goiko algoritmoa aplikatzen du:

/* Ariketa-36a_MenuBat: hainbat aukeren menu bat, aukeratzailea char */

// Programa hau 'Ariketa-18_MenuBat' programaren jarraipena da,
// harekiko dituen hobekuntzak:
//    1. Aldagai aukeratzailea char datu-motakoa da
//    2. Aldagai aukeratzailea irakurtzean egokitasuna kontrolatzen da
//    3. Iterazio bakoitzean pantaila garbitzen da
//    4. Menuak irteteko aukera du

#include <stdio.h>
#include <stdlib.h>   // system() funtziorako
#include <conio.h>    // getche() eta getch() funtzioetarako

#define LAT_A -34.927499   // Adelaide
#define LON_A 138.600000
#define LAT_B -15.793889   // Brasilia
#define LON_B -47.882778
#define LAT_C 51.047500    // Calgary
#define LON_C -114.062500
#define LAT_D 48.008889    // Donetsk
#define LON_D 37.804167

int main()
{
   char cAukera;

   do
   {
       system("cls");
       printf("\n");
       printf("\n ======Hiri baten datuak======");
       printf("\n     A. Adelaide");
       printf("\n     B. Brasilia");
       printf("\n     C. Calgary");
       printf("\n     D. Donetsk");
       printf("\n\n     I. Programatik irten");
       printf("\n =============================");

       do
       {
           printf("\n Zure aukera: ");
           cAukera = getche();
           fflush(stdin);
       } while ((cAukera != 'A') && (cAukera != 'a') &&
                (cAukera != 'B') && (cAukera != 'b') &&
                (cAukera != 'C') && (cAukera != 'c') &&
                (cAukera != 'D') && (cAukera != 'd') &&
                (cAukera != 'I') && (cAukera != 'i'));

       printf("\n");

       switch(cAukera)
       {
           case 'A':
           case 'a':
               printf("\n Adelaide");
               printf("\n Koordenatuak: (%.6f, %.6f)", LAT_A, LON_A);
               printf("\n Hego hemisferioko ekialdea");
               break;
           case 'B':
           case 'b':
               printf("\n Brasilia");
               printf("\n Koordenatuak: (%.6f, %.6f)", LAT_B, LON_B);
               printf("\n Hego hemisferioko mendebaldea");
               break;
           case 'C':
           case 'c':
               printf("\n Calgary");
               printf("\n Koordenatuak: (%.6f, %.6f)", LAT_C, LON_C);
               printf("\n Ipar hemisferioko mendebaldea");
               break;
           case 'D':
           case 'd':
               printf("\n Donetsk");
               printf("\n Koordenatuak: (%.6f, %.6f)", LAT_D, LON_D);
               printf("\n Ipar hemisferioko ekialdea");
               break;
           default:
               printf("\n Irtetera goaz.");
       }  // switch

       if ((cAukera != 'I') && (cAukera != 'i'))
       {
           printf("\n\n Edozein tekla sakatu aurrera egiteko...");
           getch();   // pantailaratutako informazioa ikusi ahal izateko
       }
   } while ((cAukera != 'I') && (cAukera != 'i'));

   printf("\n\n");
   return 0;
}

Programa honek ere goiko algoritmoa aplikatzen du:

/* Ariketa-36a2_MenuBat: hainbat aukeren menu bat, aukeratzailea int */

// Programa hau 'Ariketa-18_MenuBat' programaren jarraipena da,
// harekiko dituen hobekuntzak:
//    1. Aldagai aukeratzailea char datu-motakoa da
//    2. Aldagai aukeratzailea irakurtzean egokitasuna kontrolatzen da
//    3. Iterazio bakoitzean pantaila garbitzen da
//    4. Menuak irteteko aukera du

#include <stdio.h>
#include <stdlib.h>   // system() funtziorako
#include <conio.h>    // getche() eta getch() funtzioetarako

#define LAT_A -34.927499   // Adelaide
#define LON_A 138.600000
#define LAT_B -15.793889   // Brasilia
#define LON_B -47.882778
#define LAT_C 51.047500    // Calgary
#define LON_C -114.062500
#define LAT_D 48.008889    // Donetsk
#define LON_D 37.804167

int main()
{
   int iAukera;

   do
   {
       system("cls");
       printf("\n");
       printf("\n ======Hiri baten datuak======");
       printf("\n     1. Adelaide");
       printf("\n     2. Brasilia");
       printf("\n     3. Calgary");
       printf("\n     4. Donetsk");
       printf("\n\n     0. Programatik irten");
       printf("\n =============================\n");

       do
       {
           printf(" Zure aukera: ");
           scanf("%d", &iAukera);
       } while ((iAukera < 0) || (iAukera > 4));

       printf("\n");

       switch(iAukera)
       {
           case 1:
               printf("\n Adelaide");
               printf("\n Koordenatuak: (%.6f, %.6f)", LAT_A, LON_A);
               printf("\n Hego hemisferioko ekialdea");
               break;
           case 2:
               printf("\n Brasilia");
               printf("\n Koordenatuak: (%.6f, %.6f)", LAT_B, LON_B);
               printf("\n Hego hemisferioko mendebaldea");
               break;
           case 3:
               printf("\n Calgary");
               printf("\n Koordenatuak: (%.6f, %.6f)", LAT_C, LON_C);
               printf("\n Ipar hemisferioko mendebaldea");
               break;
           case 4:
               printf("\n Donetsk");
               printf("\n Koordenatuak: (%.6f, %.6f)", LAT_D, LON_D);
               printf("\n Ipar hemisferioko ekialdea");
               break;
           default:
               printf("\n Irtetera goaz.");
       }  // switch

       if (iAukera != 0)
       {
           printf("\n\n Edozein tekla sakatu aurrera egiteko...");
           getch();   // pantailaratutako informazioa ikusi ahal izateko
       }
   } while (iAukera != 0);

   printf("\n\n");
   return 0;
}

Programa honek ere goiko algoritmoa aplikatzen du:

/* Ariketa-36b_MenuBat: hainbat aukeren menu bat */

// Programa hau 'Ariketa-18_MenuBat' programaren antzekoa da,
// harekiko dituen hobekuntzak:
//    1. Aldagai aukeratzailea char datu-motakoa da
//    2. Aldagai aukeratzailea irakurtzean egokitasuna kontrolatzen da
//    3. Iterazio bakoitzean pantaila garbitzen da
//    4. Menuak irteteko aukera du

#include <stdio.h>
#include <stdlib.h>   // system() funtziorako
#include <conio.h>    // getche() eta getch() funtzioetarako

int main()
{
   char cAukera;
   float fEragigai1, fEragigai2;

   do
   {
       system("cls");
       printf("\n");
       printf("\n ============Menua============");
       printf("\n   +   Batura lortzeko");
       printf("\n   -   Kendura lortzeko");
       printf("\n   *   Biderkadura lortzeko");
       printf("\n   /   Zatiketa burutzeko");
       printf("\n\n   A   Amaitu programa");
       printf("\n =============================");

       do
       {
           printf("\n Zure aukera: ");
           cAukera = getche() ;
           fflush(stdin) ;
       } while ((cAukera != '+') &&
                (cAukera != '-') &&
                (cAukera != '*') &&
                (cAukera != 'x') &&
                (cAukera != 'X') &&
                (cAukera != '/') &&
                (cAukera != 'A') && (cAukera != 'a'));

       printf("\n\n");

       switch(cAukera)
       {
           case '+':
               printf(" Zenbaki errealekin lan eginez, lehenengo batugaiaren balioa eman: ");
               scanf("%f", &fEragigai1);
               printf(" Zenbaki errealekin lan eginez, bigarren batugaiaren balioa eman:  ");
               scanf("%f", &fEragigai2);
               printf(" %.2f + %.2f = %.2f", fEragigai1, fEragigai2, fEragigai1+fEragigai2);
               break;
           case '-':
               printf(" Zenbaki errealekin lan eginez, kenkizunaaren balioa eman: ");
               scanf("%f", &fEragigai1);
               printf(" Zenbaki errealekin lan eginez, kentzailearen balioa eman: ");
               scanf("%f", &fEragigai2);
               printf(" %.2f - %.2f = %.2f", fEragigai1, fEragigai2, fEragigai1-fEragigai2);
               break;
           case '*':
           case 'x':
           case 'X':
               printf(" Zenbaki errealekin lan eginez, lehenengo biderkagaiaren balioa eman: ");
               scanf("%f", &fEragigai1);
               printf(" Zenbaki errealekin lan eginez, bigarren biderkagaiaren balioa eman:  ");
               scanf("%f", &fEragigai2);
               printf(" %.2f * %.2f = %.2f", fEragigai1, fEragigai2, fEragigai1*fEragigai2);
               break;
           case '/':
               printf(" Zenbaki errealekin lan eginez, zatikizunaren balioa eman:  ");
               scanf("%f", &fEragigai1);
               do
               {
                   printf(" Zenbaki errealekin lan eginez, zatitzailearen balioa eman: ");
                   scanf("%f", &fEragigai2);
               } while (fEragigai2 == 0.0);
               printf(" %.2f / %.2f = %.2f", fEragigai1, fEragigai2, fEragigai1/fEragigai2);
               break;
           default:
               printf("\n Amaitzera goaz.");
       }  // switch

       if ((cAukera != 'A') && (cAukera != 'a'))
       {
           printf("\n\n Edozein tekla sakatu aurrera egiteko...");
           getch();   // kalkuluaren emaitza ikusi ahal izateko
       }
   } while ((cAukera != 'A') && (cAukera != 'a'));

   printf("\n\n");
   return 0;
} 

---

Ariketa-36a1_MenuBat.cbp | main.c       [aukeratzailea char] Ariketa-36a2_MenuBat.cbp | main.c       [aukeratzailea int] Ariketa-36b_MenuBat.cbp | main.c         [aukeratzailea char]

 

Ariketa 35 | Bi letren arteko distantzia

ZER DAKIDAN: Orain arte garatu ditugun programetan ikusi dut programa batek algoritmo bat jarraitzen duela. ZER IKASIKO DUDAN: char datu-mota erabiliz, karaktere sorta baten minimoa nola zehazten den ikasiko dut. Algoritmo bera aplikatu beharko nuke zenbakiekin lan eginez gero.

A eta Z arteko letra maiuskula bat gure erreferentzia da. Prozesu errepikakor bat hasi eta teklatuaren bitartez letra bat irakurri, ereferentziaren eta irakurriko letraren arteko distantzia (zenbaki bat) kalkulatu balio minimoa gordez. Prozesu errepikakorretik irteteko erreferentzia den letra teklatuz irakurri. Programa amaitu aurretik pantailaratu letrarik hurbilena eta bere distantzia erreferentziarekiko.

Algoritmoa:

1. Erreferentzia teklatutik irakurri, cErreferentzia aldagaiari balioa eman (jakinik letra maiuskula bat izan beharko dela)
2. Hasieraketak. Bi izan daitezke, alde batetik distantzia minimoa gordeko duen iMinimoa zenbaki osoa (minimoa bilatzen ari garelako hasieran kopurua handi bat jarri beharko da); bigarren hasieraketa letrarik hurbilena gordetzeko cHurbilena aldagaia izango da, baina aurreko aldagaiarekin lotuta dagoenez bere hasieraketa ez da derrigorrezkoa
3. Begiztaren iterazio bakoitzeko: cLetra aldagaiari balioa teklatuz eman, eta erreferentziarekiko iDistantzia aldagaiari distantzia kalkulatu ord funtzio estandarra aplikatuz, iDistantzia aldagaiaren balioa eta iMinimoa aldagaiaren balioa alderatu erabakiak hartzeko (emaitzak zehazteko, hots, minimoak zehazteko)
4. Prozesu errepikakorretik irten cErreferentzia aldagaiaren balioa eta cLetra aldagaiaren balioa bat bera denean, baina kontuz, irtetean haien arteko diztantzia 0 izango da eta horrek minimoaren kalkuluarengan eragina du
5. cLetra aldagaiaren balioa eta iMinimoa aldagaiaren balioa pantailaratu

Programa honek goiko algoritmoa aplikatzen du:

/* Ariketa-35_BiLetrenArtekoDistantzia: minimoaren algoritmoa */

// Programa honetan minimoaren algoritmoa garatzen da.
// Berezitasun bezala, ikus daiteke bi karakteren arteko kenketa
// egin daitekeela: iDistantzia = fabs(cErreferentzia - cLetra);

#include <stdio.h>
#include <conio.h>    // getche() funtziorako
#include <math.h>     // fabs() funtziorako

int main()
{
    char cErreferentzia, cLetra, cHurbilena;
    int iDistantzia, iMinimoa;

    printf("\n");

    do
    {
        printf("\n Erreferentzia izango den A..Z alfabetoko letra eman: ");
        cErreferentzia = getche();
        if ((cErreferentzia < 'A') || (cErreferentzia > 'Z'))
            printf("\n Datua larrien alfabetoko letra bat izan dadila! ");
    } while ((cErreferentzia < 'A') || (cErreferentzia > 'Z'));

    printf("\n\n Orain prozesu errepikakor batean sartuko gara, begizta edo itzuli bakoitzean");
    printf("\n letra majuskula bat sartuz eta erreferentziarekiko distantzia kalkulatuz.\n");

    iMinimoa = (int)('Z') - (int)('A') + 1 ;   // alfabetoaren maximoa baino 1 gehiago
    cHurbilena = cErreferentzia ;              // hasieraketa hau ez da derrigorrezkoa
    do
    {
        do
        {
            printf("\n A..Z alfabetoko letra eman (bukatzeko %c eman): ", cErreferentzia);
            cLetra = getche();
        } while ((cLetra < 'A') || (cLetra > 'Z'));
        if (cLetra != cErreferentzia)
        {
            iDistantzia = fabs((int)cErreferentzia - (int)cLetra);
            printf("\n '%c' eta '%c' arteko aldea %d da", cLetra, cErreferentzia, iDistantzia);
            if (iDistantzia < iMinimoa)
            {
                cHurbilena = cLetra;
                iMinimoa = iDistantzia;
            }
        }
    } while (cLetra != cErreferentzia);

    printf("\n Letrarik hurbilena: %c", cHurbilena);
    printf("\n '%c' eta '%c' arteko aldea %d da", cHurbilena, cErreferentzia, iMinimoa);

    printf("\n\n");
    return 0;
}

---

Ariketa-35_BiLetrenArtekoDistantzia.cbp | main.c

 

Ariketa 34 | Zesar zifratze-sistema

ZER DAKIDAN: Karaktereen char datu-mota ezagutzen dut eta karaktereak ASCII taularen arabera sailkatzen direla dakit. ZER IKASIKO DUDAN: char datu-motako aldagai bat teklatuz irakurri ondoren, Zesar zifratze-metodoa erabiliz karaktere zifratua nola lor daitekeen ikasiko dut.

Kriptografian, Zesarren zifratze-sistema (edo Zesar zifratzea) mezuak enkriptatzeko teknikarik zaharrenetarikoa da, baita erabilienetako bat ere. Metodo honek Julio Zesar ospetsuaren ohorean dauka izena, zeinek bere jeneralekin komunikatzeko erabiltzen zuen. Ordezkatze-metodo bat da, non hasierako mezuaren letra bakoitza beste letra batengatik ordezkatzen den: Alfabetoan 3 posizio aurrerago dagoen letrarengatik. Horrela, A letra D letra bihurtuko litzateke, B-a E etab.

Programa honek Zesar zifratzea delako enkriptazio teknika erakusten du, alfabeto larrien letra bat eman eta programak bere karaktere zifratua erakutsiko du (ASCII taulako 3 posizio aurrerago dagoena). Adibidez, A sartzean emaitza D izango da, B sartzean emaitza E izango da, X sartzean emaitza A izango da, Y sartzean emaitza B izango da eta Z sartzean emaitza C izango da:

Zesar zifratzea programaren lehen bertsioan switch agindu bat erabiltzen da datua den alfabeto larrien letra zifratzeko:

/* Ariketa-34a_ZesarZifratzeSistema: Zesarren zifratze-sistema */

// Zesar zifratze-teknikan letra bakoitzaren desplazamendua 3 da. Karaktere bat
// sartu eta switch agindu bati esker bere karaktere desplazatua lortuko da.

#include <stdio.h>
#define iDESPLAZAMENDUA 3

int main()
{
    char cDatua;
    char cEmaitza;

    printf("\n");
    do
    {
        printf("Zifratu nahi den karakterea sartu (A eta Z artekoa): ");
        scanf("%c", &cDatua);
        fflush(stdin);
    } while (cDatua < 'A' || cDatua > 'Z');

    switch(cDatua)
    {
     case 'Z': cEmaitza = 'C';
               break;
     case 'Y': cEmaitza = 'B';
               break;
     case 'X': cEmaitza = 'A';
               break;
     default:  // sartzen da cDatua ez denean: X, Y edo Z
               cEmaitza = cDatua + iDESPLAZAMENDUA;
    }
    printf("\t%c >>> %c\n", cDatua, cEmaitza);

    return 0;
}

Alfabeto larrien letra bat zifratzeko datuari +3 egingo zaio. Alfabetoaren zerrenda zirkular bat osatuko da, zerrendaren oinarria A karakterea da eta alfabetoak 26 letra dituenez zatiketa osoaren hondarraz lortzen dira karaktereen emaitza zifratuak.

Zesar zifratzea programaren bigarren bertsioan A-Z alfabetoaren zerrenda zirkular bat osatuko da:

/* Ariketa-34b_ZesarZifratzeSistema: Zesarren zifratze-sistema */

// Zesar zifratze-teknikan letra bakoitzaren desplazamendua 3 da. Baina
// programa honek desplazamenduaren neurria hautatzeko aukera ematen du.
// Alfabetoaren zerrenda zirkular bat osatuz, desplazamendua finkatu eta
// datua den letra bati dagokion karaktere desplazatua lortuko da.

#include <stdio.h>

int main()
{
    char cDatua;
    char cEmaitza;
    int iDesplazamendua;

    printf("\n");
    printf("         1         2     2\n");
    printf("12345678901234567890123456\n");
    printf("ABCDEFGHIJKLMNOPQRSTUVWXYZ    26 karaktere\n\n");

    do
    {
        printf("Zifratu nahi den karakterea sartu (A eta Z artekoa): ");
        scanf("%c", &cDatua);
        fflush(stdin);
    } while (cDatua < 'A' || cDatua > 'Z');

    printf("Enkriptatze-gakoa sartu (kopuru oso bat): ");
    scanf("%d", &iDesplazamendua);
    if (iDesplazamendua < 0)  // gako negatiboa bada positibo jarri
        iDesplazamendua = iDesplazamendua * (-1);

    cEmaitza = (cDatua - 'A' + iDesplazamendua) % 26 + 'A';
    printf("\t%c >>> %c\n", cDatua, cEmaitza);

    return 0;
}

Argi dago azken programa hau aurrekoa baino ahaltsuagoa dela. Izan ere, desplazamendua beti 3 izan beharrean teklatuz irakurtzen den balio bat baita. Aurrerago erakutsiko den Ariketa 49 | Zesar zifratze-sistema artikuluan mezu osoak enkriptatzen eta desenkriptatzen ikasiko dugu.

---

Ariketa-34a_ZesarZifratzeSistema.cbp | main.c   Ariketa-34b_ZesarZifratzeSistema.cbp | main.c