2024(e)ko abenduaren 18(a), asteazkena

Ariketa 25 | for habiaratuen hiru bertsio


ZER DAKIDAN:
Menpekoa den for agindu errepikakor bat beste for nagusi baten barnean nola erabili ikasi dut, hots, badakit for habiaratuak erabiltzen.



ZER IKASIKO DUDAN:
Menpekoa den for agindu errepikakor bat beste for nagusi baten barneko programaren bertsio hobetua programatuko dut (beharrezkoak ez diren iterazioak sahiestuz programa azkarrago ibiliko da).

Hurrengo lau ariketak berdintsuak dira:


Batugaien iZenbat kopurua zehaztuko duen balioa teklatuz irakurriz, kalkulatu ondoko batukaria eta emaitza liBatukaria aldagaian gorde. Ziurtatu iZenbat kopuru osoa, positiboa eta bikoitia dela.

Batukariaren batugaiak zenbait zenbakien faktorialak dira, hauek:

liBatukaria = 0! + 2! + 4! + 6! + ... + (iZenbat-2)! + iZenbat!

Batukaria lortzen duen programaren bi bertsio egingo ditugu.



1. BERTSIOA                 iZenbat=8                        
Kanpoko  i
hasieraketa
0!=1
1
2
3 4
5 6
7 8
Barruko  j
1
1..2
1..3
1..4
1..5
 1..6
1..7 1..8
liFaktoriala
1
2
6 24
120  720
5040 40320
liBatukaria
1
1
3
3 27
27 747
747 41067


  1. BERTSIOA 

 Kanpoko FOR
Kanpoko prozesu errepikakorra iZenbat aldiz errepikatuko da. Gogoratu prozesu errepikakorrera sartu aurretik beharrezkoak diren hasieraketak egin behar direla. Suposatuz prozesu errepikakorraren 0! lehen batugaia kanpoan egiten dela, lehen iterazioa i=1 hau izango litzateke:
           liBatukaria  =  liBatukaria + liFaktoriala ;
           liBatukaria   [hasieraketa] + [lehenengoa]
           liBatukaria      (0!=1)     +      1!         
           
           if (i % 2 != 0)   /* ez da betetzen */
             liBatukaria = liBatukaria + liFaktoriala ; 
    
Suposatuz prozesu errepikakorraren 0! kanpoan egiten dela, bigarren iterazioa i=2 hau izango litzateke:
           liBatukaria  =  liBatukaria + liFaktoriala ;
           liBatukaria     [metatua]   + [bigarrena]
           liBatukaria          1      +      2!            
           
           if (i % 2 != 0)   /* bai betetzen da */
             liBatukaria = liBatukaria + liFaktoriala ; 
                   3            1      +      2! 
    
Suposatuz prozesu errepikakorraren 0! kanpoan egiten dela, hirugarren iterazioa i=3 hau izango litzateke:
           liBatukaria  =  liBatukaria + liFaktoriala ;
           liBatukaria     [metatua]   + [hirugarrena]
           liBatukaria          3      +      3!            
           
           if (i % 2 != 0)   /* ez da betetzen */
             liBatukaria = liBatukaria + liFaktoriala ; 
    
Suposatuz prozesu errepikakorraren 0! kanpoan egiten dela, laugarren iterazioa i=4 hau izango litzateke:
           liBatukaria  =  liBatukaria + liFaktoriala ;
           liBatukaria     [metatua]   + [laugarrena]
           liBatukaria          3      +      4!            
           
           if (i % 2 != 0)   /* bai betetzen da */
              liBatukaria = liBatukaria + liFaktoriala ; 
                  27             3      +      4! 
     

 Barruko FOR
Barruko prozesu errepikakorrak faktoriala kalkulatuko du. Konkretuki, kanpoko i kontagailuaren faktoriala kalkulatuko du:
  liFaktoriala = 1 ;   /* i iterazioaren faktoriala kalkulatu */
  for (j=1; j<= i; j++)
  {
     liFaktoriala = liFaktoriala * j ;
     printf("i=%2d    j=%2d    liFaktoriala=%ld\n", i, j, liFaktoriala) ;
  }
    
/* Ariketa-25a_forHabiaratua-1: faktorialen batukari bat */

// iZenbat kopuru osoa, positiboa eta bikoitia teklatuaren bitartez irakurri
// eta batukari hau kalkulatu:
//      liBatukaria = 0! + 2! + 4! + ... + (iZenbat-2)! + iZenbat!

// 1. bertsioa: kanpoko begiztan iZenbat iterazio.

#include <stdio.h>

int main()
{
    int iZenbat, i, j;
    long liBatukaria, liFaktoriala;

    printf("\n\n");

    // erabiltzaileari datuak eskatu beharrezko baldintzak betetzen dituen bitartean
    do
    {
        printf("iZenbat zenbaki osoa, positiboa eta bikoitia eman: ");
        scanf("%d", &iZenbat);
        if (iZenbat < 0)
            printf("Kopuru positiboa behar da\n");
        if (iZenbat % 2 != 0)
            printf("Kopurua zenbaki bikoitia izan behar da\n");
    } while (iZenbat < 0 || iZenbat % 2 != 0);

    printf("\n");

    liBatukaria = 1; // 0! = 1, eta hasieran liBatukaria hori da

    printf("Hasieran, liBatukaria=%ld\n\n", liBatukaria);

    for (i = 1; i <= iZenbat; i++)
    {
        liFaktoriala = 1; // faktorialaren kalkulua hasieratu behar da i-rako
        for (j = 1; j <= i; j++)
        {
            liFaktoriala = liFaktoriala * j;
            printf("i=%2d    j=%2d    liFaktoriala=%ld\n", i, j, liFaktoriala);
        }

        if (i % 2 == 0)
            liBatukaria = liBatukaria + liFaktoriala;
        else
            printf("i=%2d bakoitia delako ez inkrementatu, ", i);

        printf("liBatukaria=%ld\n\n", liBatukaria);
    }

    printf("Batukaria = %ld\n", liBatukaria);

    printf("\n\n");
    printf("=======================\n");
    printf("RETURN sakatu amaitzeko\n");
    printf("=======================\n");
    getchar(); // Amaieran erabiltzailearen enter itxaron
    getchar();

    return 0;
}



      2. BERTSIOA                 iZenbat=8             
Kanpoko  i
hasieraketa
0!=1
1
2
3 4
Barruko  j
1..1x2
1..2x2
1..3x2
1..4x2
liFaktoriala
2
24
720 40320
liBatukaria
1
3
27
747 41067


  2. BERTSIOA 

 Kanpoko FOR
Kanpoko prozesu errepikakorra iZenbat/2 aldiz errepikatuko da. Gogoratu prozesu errepikakorrera sartu aurretik beharrezkoak diren hasieraketak egin behar direla. Suposatuz prozesu errepikakorraren 0! lehen batugaia kanpoan egiten dela, lehen iterazioa i=1 hau izango litzateke:
           liBatukaria  =  liBatukaria  + liFaktoriala ;
           liBatukaria    [hasieraketa] + [lehenengoa]
           liBatukaria       (0!=1)     +    (2*1)!
           
           liBatukaria  = liBatukaria + liFaktoriala ; 
                3              1      +      2!           
Suposatuz prozesu errepikakorraren 0! kanpoan egiten dela, bigarren iterazioa i=2 hau izango litzateke:
           liBatukaria  =  liBatukaria  + liFaktoriala ;
           liBatukaria     [metatua]    + [bigarrena]
           liBatukaria         3        +    (2*2)!            
           
           liBatukaria  = liBatukaria + liFaktoriala ; 
               27              3      +      4! 
    

 Barruko FOR
Barruko prozesu errepikakorrak faktoriala kalkulatuko du. Konkretuki, kanpoko i kontagailuaren dobleari dagokion faktoriala kalkulatuko du:
  liFaktoriala = 1 ;   /* i iterazioaren faktoriala kalkulatu */
  for (j=1; j<= i*2; j++)
  {
     liFaktoriala = liFaktoriala * j ;
     printf("i=%2d    j=%2d    liFaktoriala=%ld\n", i, j, liFaktoriala) ;
  }
    
/* Ariketa-25b_forHabiaratua-2: faktorialen batukari bat */

// iZenbat kopuru osoa, positiboa eta bikoitia teklatuaren bitartez irakurri
// eta batukari hau kalkulatu:
//      liBatukaria = 0! + 2! + 4! + ... + (iZenbat-2)! + iZenbat!

// 2. bertsioa: kanpoko begiztan iZenbat/2 iterazio.

#include <stdio.h>

int main()
{
    int iZenbat, i, j;
    long liBatukaria, liFaktoriala;

    printf("\n\n");

    // erabiltzaileari datuak eskatu beharrezko baldintzak betetzen dituen bitartean
    do
    {
        printf("iZenbat zenbaki osoa, positiboa eta bikoitia eman: ");
        scanf("%d", &iZenbat);
        if (iZenbat < 0)
            printf("Kopuru positiboa behar da\n");

        if (iZenbat % 2 != 0)
            printf("Kopurua zenbaki bikoitia izan behar da\n");
    } while (iZenbat < 0 || iZenbat % 2 != 0);

    printf("\n");

    liBatukaria = 1; // 0! = 1, eta hasieran liBatukaria hori da

    printf("Hasieran, liBatukaria=%ld\n\n", liBatukaria);

    for (i = 1; i <= iZenbat / 2; i++)
    {
        liFaktoriala = 1; // faktorialaren kalkulua hasieratu behar da i*2-rako
        for (j = 1; j <= i * 2; j++)
        {
            liFaktoriala = liFaktoriala * j;
            printf("i=%2d    j=%2d    liFaktoriala=%ld\n", i, j, liFaktoriala);
        }

        liBatukaria = liBatukaria + liFaktoriala;

        printf("liBatukaria=%ld\n\n", liBatukaria);
    }

    printf("Batukaria = %ld\n", liBatukaria);

    printf("\n\n");
    printf("=======================\n");
    printf("RETURN sakatu amaitzeko\n");
    printf("=======================\n");
    getchar(); // amaieran erabiltzailearen enter itxaron
    getchar();

    return 0;
}



      3. BERTSIOA                 iZenbat=8             
Kanpoko  i
hasieraketa
0!=1
2
4
6 8
Barruko  j
1..2
1..4
1..6
1..8
liFaktoriala
2
24
720 40320
liBatukaria
1
3
27
747 41067


  3. BERTSIOA 

 Kanpoko FOR
Kanpoko prozesu errepikakorra iZenbat aldiz errepikatuko da eta kanpoko aldagaiaren inkrementua i+2 izango da. Gogoratu prozesu errepikakorrera sartu aurretik beharrezkoak diren hasieraketak egin behar direla. Suposatuz prozesu errepikakorraren 0! lehen batugaia kanpoan egiten dela, lehen iterazioa i=2 hau izango litzateke:
           liBatukaria  =  liBatukaria  + liFaktoriala ;
           liBatukaria    [hasieraketa] + [lehenengoa]
           liBatukaria       (0!=1)     +    (2)!
           
           liBatukaria  = liBatukaria + liFaktoriala ; 
                3              1      +      2!           
Suposatuz prozesu errepikakorraren 0! kanpoan egiten dela, bigarren iterazioa i=4 hau izango litzateke:
           liBatukaria  =  liBatukaria  + liFaktoriala ;
           liBatukaria     [metatua]    + [bigarrena]
           liBatukaria         3        +    (4)!            
           
           liBatukaria  = liBatukaria + liFaktoriala ; 
               27              3      +      4! 
    

 Barruko FOR
Barruko prozesu errepikakorrak faktoriala kalkulatuko du. Konkretuki, kanpoko i kontagailuaren dagokion faktoriala kalkulatuko du:
  liFaktoriala = 1 ;   /* i iterazioaren faktoriala kalkulatu */
  for (j=1; j<=i; j++)
  {
     liFaktoriala = liFaktoriala * j ;
     printf("i=%2d    j=%2d    liFaktoriala=%ld\n", i, j, liFaktoriala) ;
  }
    
/* Ariketa-25c_forHabiaratua-3: faktorialen batukari bat */

// iZenbat kopuru osoa, positiboa eta bikoitia teklatuaren bitartez irakurri
// eta batukari hau kalkulatu:
//      liBatukaria = 0! + 2! + 4! + ... + (iZenbat-2)! + iZenbat!

// 3. bertsioa: kanpoko begiztan iZenbat iterazio eta kontrol-aldagaia i=i+2.

#include <stdio.h>

int main()
{
    int iZenbat, i, j;
    long liBatukaria, liFaktoriala;

    printf("\n\n");

    // erabiltzaileari datuak eskatu beharrezko baldintzak betetzen dituen bitartean
    do
    {
        printf("iZenbat zenbaki osoa, positiboa eta bikoitia eman: ");
        scanf("%d", &iZenbat);
        if (iZenbat < 0)
            printf("Kopuru positiboa behar da\n");

        if (iZenbat % 2 != 0)
            printf("Kopurua zenbaki bikoitia izan behar da\n");
    } while (iZenbat < 0 || iZenbat % 2 != 0);

    printf("\n");

    liBatukaria = 1; // 0! = 1, eta hasieran liBatukaria hori da

    printf("Hasieran, liBatukaria=%ld\n\n", liBatukaria);

    for (i = 2; i <= iZenbat; i = i + 2)
    {
        liFaktoriala = 1; // faktorialaren kalkulua hasieratu behar da i-rako
        for (j = 1; j <= i; j++)
        {
            liFaktoriala = liFaktoriala * j;
            printf("i=%2d    j=%2d    liFaktoriala=%ld\n", i, j, liFaktoriala);
        }

        liBatukaria = liBatukaria + liFaktoriala;

        printf("liBatukaria=%ld\n\n", liBatukaria);
    }

    printf("Batukaria = %ld\n", liBatukaria);

    printf("\n\n");
    printf("=======================\n");
    printf("RETURN sakatu amaitzeko\n");
    printf("=======================\n");
    getchar(); // amaieran erabiltzailearen enter itxaron
    getchar();

    return 0;
}







  • Ariketa-25a_forHabiaratuak.cbp | main.c  
  • Ariketa-25b_forHabiaratuak.cbp | main.c  
  • Ariketa-25c_forHabiaratuak.cbp | main.c  


 

Ariketa 24 | for: Potentzien batukariak

ZER DAKIDAN:
Agindu errepikakorretan do-while eta for ezagutzen ditut.



ZER IKASIKO DUDAN:
Menpekoa den for agindu errepikakor bat beste for nagusi baten barnean nola erabili ikasiko dut, hots, for habiaratuekin jarraituko dugu.

Hurrengo lau ariketak berdintsuak dira:


Oinarria eta berretzailea kopuru osoak eta positiboak teklatuaren bitartez jaso ondoren, berretura edo potentzia kalkulatzen duen programa hau Ariketa 20 | for agindua: faktoriala eta potentzia kalkulatzen berraztertu.

Aurreko programa aintzat harturik eta FOR-DO agindu errepikakorra ezagutzen duzula hurrengo bi ariketak egin:


Batugaien iZenbat kopurua zehazten duen balioa teklatuz irakurriz eta iOina oinarria teklatuz irakurriz, kalkulatu ondoko batukaria eta emaitza liBatukaria aldagaian gorde. Ziurtatu iZenbat kopuru osoa, positiboa eta bikoitia dela. Ziurtatu ere iOina kopuru osoa eta positiboa dela.

Batukariaren batugaiak zenbait zenbakien potentziak dira, hauek:

          liBatukaria = iOina0 + iOina2 + iOina4 + ... + iOinaiZenbat

Programaren exekuzioko irteera hau aztertu:



Batugaien iZenbat kopurua zehaztuko duen balioa teklatuz irakurriz eta iOina oinarria teklatuz irakurriz, kalkulatu ondoko batukaria eta emaitza liBatukaria aldagaian gorde. Ziurtatu iZenbat kopuru osoa, positiboa eta bikoitia dela. Ziurtatu ere iOina kopuru osoa eta positiboa dela.

Batukariaren batugaiak zenbait zenbakien faktorialak dira, hauek:

          liBatukaria = iOina0 - iOina2 + iOina4 - ... (+/-) iOinaiZenbat

Programaren exekuzioko irteera hau aztertu:



2025 urtea duela gutxi hasi dela, zenbaki honi buruzko jakingarri batzuk ikus ditzagun. Hasteko, "karratu perfektu" esaten esaten zaiola hau betetzen delako: 2025=452. Beste karratu perfektu batzuk hauek dira: 1, 4, 9, 16, 25, 36, 49, 64, 81, ...

Baina 2025 zenbakiak beste bi ekuazio hauek betetzen ditu ere:

  2025 = (0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9)²   sistema hamartarraren digitu
                                                    guztien batura lortu ondoren
                                                    emaitza 45 da, bere karratua
                                                    2025 da

  2025 = 0³ + 1³ + 2³ + 3³ + 4³ + 5³ + 6³ + 7³ + 8³ + 9³  sistema hamartarraren
                                                          digitu guztien kuboen
                                                          batura 2025 da 

Bi ekuazio horien zuzentasuna frogatzen duen programa jarraian erakusten da:

/* Ariketa-24c_FaktorialenBatukariak: 2025 karratu prefektua. */

// --------------------------------------------------------------
//     2025 = (0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9)²
//
//     2025 = 0³ + 1³ + 2³ + 3³ + 4³ + 5³ + 6³ + 7³ + 8³ + 9³
// --------------------------------------------------------------

#include <stdio.h>  // printf() funtzioarako
#include <math.h>   // pow() funtzioarako

#define BEHEMUGA 1
#define GOIMUGA 9

int main()
{
    int iKont, iBatura;

    printf("\n");
    printf("\n ================================================");
    printf("\n 2025 = (0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9)^2");
    printf("\n ================================================\n");

    printf(" 2025 = (0 + ");
    iBatura = 0;
    for (iKont = BEHEMUGA; iKont < GOIMUGA; iKont++)
    {
        printf("%d + ", iKont);
        iBatura = iBatura + iKont;
    }
    iBatura = iBatura + iKont;
    printf("9)^2 = %d", iBatura*iBatura);

    printf("\n\n");

    printf("\n ================================================================");
    printf("\n 2025 = 0^3 + 1^3 + 2^3 + 3^3 + 4^3 + 5^3 + 6^3 + 7^3 + 8^3 + 9^3");
    printf("\n ================================================================\n");

    printf(" 2025 = 0^3 + ");
    iBatura = 1; // kanpoko 0^3 = 1
    for (iKont = BEHEMUGA; iKont < GOIMUGA; iKont++)
    {
        printf("%d^3 + ", iKont);
        iBatura = iBatura + pow(iKont, 3);
    }
    iBatura = iBatura + pow(iKont, 3);
    printf("9^3 = %d", iBatura);

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






  • Ariketa-24a_PotentzienBatukariak.cbp | main.c  
  • Ariketa-24b_PotentzienBatukariak.cbp | main.c  
  • Ariketa-24c_PotentzienBatukariak.cbp | main.c  


 

Ariketa 23 | for: Faktorialen batukariak

ZER DAKIDAN:
Agindu errepikakorretan do-while eta for ezagutzen ditut.



ZER IKASIKO DUDAN:
Menpekoa den for agindu errepikakor bat beste for nagusi baten barnean nola erabili ikasiko dut; hau da, for habiaratuekin jarraituko dugu.

Hurrengo lau ariketak berdintsuak dira:


iZbk zenbaki osoko eta positiboa teklatuaren bitartez jaso ondoren, iZbk zenbakiaren faktoriala kalkulatzen duen programa hau Ariketa 20 | for agindua: faktoriala eta potentzia kalkulatzen berraztertu.

Aurreko programa aintzat harturik eta for agindu errepikakorra ezagutzen duzula hurrengo bi ariketak egin:


Batugaien iZenbat kopurua zehaztuko duen balioa teklatuz irakurriz, kalkulatu ondoko batukaria eta emaitza lBatukaria aldagaian gorde. Ziurtatu iZenbat kopuru osoa, positiboa eta bikoitia dela.

Batukariaren batugaiak hainbat zenbakien faktorialak dira, hauek:

          lBatukaria = 0! + 2! + 4! + ... + (iZenbat-2)! + iZenbat!

Programaren exekuzioko irteera hau aztertu:



Batugaien iZenbat kopurua zehaztuko duen balioa teklatuz irakurriz, kalkulatu ondoko batukaria eta emaitza lBatukaria aldagaian gorde. Ziurtatu iZenbat kopuru osoa, positiboa eta bikoitia dela.

Batukariaren batugaiak hainbat zenbakien faktorialak dira, hauek:

          lBatukaria = 0! - 2! + 4! - ... - (iZenbat-2)! + iZenbat!
edo
          lBatukaria = 0! - 2! + 4! - ... + (iZenbat-2)! - iZenbat! 

Programaren exekuzioko irteera hau aztertu:







  • Ariketa-23a_FaktorialenBatukariak.cbp | main.c  
  • Ariketa-23b_FaktorialenBatukariak.cbp | main.c  


 

Ariketa 22 | for adibideak (2)

ZER DAKIDAN:
Agindu errepikakorretan do-while eta for ezagutzen ditut.



ZER IKASIKO DUDAN:
Menpekoa den for agindu errepikakor bat beste for nagusi baten barnean nola erabili ikasiko dut (beheko irudiak adierazten duen bezala for habiaratuak kasuaz ariko gara).

Hurrengo lau ariketak berdintsuak dira:


Kanpoko begiztak 5 iterazio ematen ditu eta barruko begiztak 10

Arestian ikusitako Ariketa 21 | for adibideak (1) artikulua gogora ekarriz, hurrengo adibideetan for egitura errepikakorrarekin jarraituko dugu lanean. Baina adibideen bigarren sorta honetan for aginduaren barruan beste for agindu bat aurkituko dugu, goiko irudiak erakusten duen antzera.

Bi prozesu errepikakor koordinatuak, bata nagusia eta bestea bere menpekoa. Hurrengo hiru ariketetan for bat beste for baten barnean aurkituko ditugu:

/* Ariketa-22a_forAdibideak-2: bi lauki marrazten. */

// {--------------------------------------------------------------
//      Zenbaki osoa eta positiboekin lan eginez, sarrerako
//      kopuruarean araberako lauki parea pantailaratuko da.
//  --------------------------------------------------------------}

#include <stdio.h>   // printf() funtzioarako

#define BEHEMUGA 1
#define GOIMUGA 9

int main()
{
    int iKanpokoKont, iBarrukoKont, iZenbakia;

    printf("\n\n");
    do
    {
        printf(" %d eta %d artekoa den zenbaki osoa eman (5 adibidez): ", BEHEMUGA, GOIMUGA);
        scanf("%d", &iZenbakia);
    } while ((iZenbakia < BEHEMUGA) || (iZenbakia > GOIMUGA));

    printf("\n %dx%d laukia: ", iZenbakia, iZenbakia);
    printf("\n ----------\n");

    for (iKanpokoKont=1; iKanpokoKont<=iZenbakia; iKanpokoKont++)
    {
        for (iBarrukoKont=1; iBarrukoKont<=iZenbakia; iBarrukoKont++)
        {
            printf("%2d", iZenbakia);
        }
        printf("\n");
    }

    printf("\n %dx%d laukia: ", iZenbakia, 2*iZenbakia);
    printf("\n -----------\n");

    for (iKanpokoKont=1; iKanpokoKont<=iZenbakia; iKanpokoKont++)
    {
        for (iBarrukoKont=1; iBarrukoKont<=2*iZenbakia; iBarrukoKont++)
        {
            printf("%2d", iZenbakia);
        }
        printf("\n");
    }

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


/* Ariketa-22b_forAdibideak-2: triangelu bat marrazten. */

// {-----------------------------------------------------------------
//   Zenbaki osoa eta positiboekin lan eginez, sarrerako kopuruarean
//   araberako triangelu laukizuzen bat pantailaratuko da.
//  -----------------------------------------------------------------}

#include <stdio.h>   // printf() funtzioarako

#define BEHEMUGA 1
#define GOIMUGA 9

int main()
{
    int iKanpokoKont, iBarrukoKont, iZenbakia;

    printf("\n\n");
    do
    {
        printf(" %d eta %d artekoa den zenbaki osoa eman (5 adibidez): ", BEHEMUGA, GOIMUGA);
        scanf("%d", &iZenbakia);
    } while ((iZenbakia < BEHEMUGA) || (iZenbakia > GOIMUGA));

    printf("\n %dx%d hirukia: ", iZenbakia, iZenbakia);
    printf("\n -----------\n");

    for (iKanpokoKont=1; iKanpokoKont<=iZenbakia; iKanpokoKont++)
    {
        for (iBarrukoKont=1; iBarrukoKont<=iKanpokoKont; iBarrukoKont++)
        {
            printf("%2d", iZenbakia);
        }
        printf("\n");
    }

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


/* Ariketa-22c_forAdibideak-2: potentziak batzen. */

// {--------------------------------------------------------------------
//   iMuga emanda >>> liBatukaria = 1^1 + 2^2 + 3^3 + ... + iMuga^iMuga
//   KONTUZ!!! long datu-motarekin iMuga=10 denean gainezkatzea dago.
//  --------------------------------------------------------------------}

#include <stdio.h>   // printf() funtzioarako
#include <limits.h>  // LONG_MAX erabiltzeko

#define BEHEMUGA 0
#define GOIMUGA 10

int main()
{
    int iMuga, iKontKanpo, iKontBarru;
    long lBatugaia, lBatukaria;

    printf("\n\n");
    printf("\n ---------------------------------------------------------");
    printf("\n  liBatukaria = 1^1 + 2^2 + 3^3 + 4^4 + ... + iMuga^iMuga");
    printf("\n ---------------------------------------------------------\n\n");

    do
    {
        printf(" Muga adierazten duen zenbaki osoa eta positiboa eman (5 adibidez): ");
        scanf("%d", &iMuga);
        if (iMuga < BEHEMUGA)
            printf("\n Muga kopuru positiboa izan behar da\n");
        if (iMuga >= GOIMUGA)
        {
            printf("\n\t Mugaren kopuru maximoa 9 da. Muga 10 bada");
            printf("\n\t long datu-motako batukariaren emaitzak");
            printf("\n\t LONG_MAX=%ld balioa gainditzen du.\n", LONG_MAX);
        }
    } while ((iMuga < BEHEMUGA) || (iMuga >= GOIMUGA));

    lBatukaria = 0;

    for (iKontKanpo=1; iKontKanpo<=iMuga; iKontKanpo++)
    {
        lBatugaia = 1;
        for (iKontBarru=1; iKontBarru<=iKontKanpo; iKontBarru++)
        {
            lBatugaia = lBatugaia*iKontKanpo;
            printf("\n\t iKontKanpo=%d \t\t iKontBarru=%d \t\t lBatugaia=%ld", iKontKanpo, iKontBarru, lBatugaia);
        }
        lBatukaria = lBatukaria + lBatugaia;
        printf("\n\t\t lBatugaia=%ld \t\t lBatukaria=%ld", lBatugaia, lBatukaria);
        printf("\n");
    }

    printf("\n\t\t Azken batukaria = %ld", lBatukaria);
    printf("\n\n");
    return 0;
}







  • Ariketa-22a_forAdibideak-2.cbp | main.c  
  • Ariketa-22b_forAdibideak-2.cbp | main.c  
  • Ariketa-22c_forAdibideak-2.cbp | main.c  
 

Ariketa 21 | for adibideak (1)


ZER DAKIDAN:
Sekuentzialki multzokatzen diren aginduak ezagutzen ditut, bide desberdinak erabakitzeko baldintzazko aginduak (if eta switch) ezagutzen ditut. Datuak teklatuz modu kontrolatuan jasotzeko do-while agindu errepikakorra ere erabili izan dut.



ZER IKASIKO DUDAN:
Agindu errepikakorrekin jarraituz for ikasiko dut (for soil-soilak kasu hauetan).

Batugaien kopurua ezaguturik batukariak kalkula ditzagun

Hurrengo adibideetan for egitura errepikakorra landuko dugu. Adibide guztiak oinarrizkoak direnez for aginduaren barruan ez da izango beste agindu errepikakorrik, horregatik for artikulu honek jarraipena izango du beste artikulu batean —Ariketa 22 | for adibideak (2)— non for agindu habiaratuak landuko ditugun.

Gogoratu for agindu erabili ahal izateko iterazioen kopurua ezaguna izango dela. Iruzkinak:

  1. Iterazioen kopurua kontrolatzeko Kontagailua izeneko aldagaia diskretua izango da (int datu-mota familiakoa edo char datu-motakoa)
  2. Kontagailua izeneko aldagaiaren hasieraketa for aginduan bertan egiten da
  3. Prozesu errepikakorra eteteko Kontagailua aldagaiaren balioa aztertzen da adierazpen logiko batean (egia ala gezurra ebaluatzen den adierzpena), eta baldintzaren emaitza egia den bitartean prozesu errepikakorrak jarraituko du
  4. Kontagailua aldagaiaren balioa aldatuz doa iterazio batetik bestera



Batukariak eta biderkariak kalkulatzen for aginduarekin trebatzeko:

/* Ariketa-21a_forAdibideak-1: batukari baten kalkulua. */

// {------------------------------------------------------------------------------
//      iMuga emanda lortu iBatukaria = 1 + 2 + 3 + ... + (iMuga-1) +  iMuga
//  ------------------------------------------------------------------------------}

#include <stdio.h>   // printf() funtzioarako

int main()
{
    int iKont, iMuga, iBatukaria;

    printf("\n\n");
    do
    {
        printf(" 'iMuga' zenbaki osoa eta positiboa eman (5 adibidez): ");
        scanf("%d", &iMuga);
    } while (iMuga < 0);

    iBatukaria = 0;
    printf("\n Hasieran iBatukaria=%d", iBatukaria);

    printf("\n ---------------------------------------------");
    for (iKont=1; iKont<=iMuga; iKont++)
    {
        iBatukaria = iBatukaria + iKont;
        printf("\n \t %2d iterazioan iBatukaria=%d", iKont, iBatukaria);
    }
    printf("\n ---------------------------------------------");

    printf("\n Irten ondoren:    iKont=%d", iKont);
    printf("\n Azkenean:    iBatukaria=%d", iBatukaria);

    printf("\n\n");
    return 0;
}
iBatukaria = 1 + 2 + 3 + ... + (iMuga-1) + iMuga


/* Ariketa-21b_forAdibideak-1: biderkari baten kalkulua (faktorialaren kalkulua). */

// {------------------------------------------------------------------------------
//     iMuga emanda lortu liBiderkaria = 1 * 2 * 3 * ... * (iMuga-1) * iMuga
//  ------------------------------------------------------------------------------}

#include <stdio.h>   // printf() funtzioarako

int main()
{
    int iKont, iMuga;
    long lBiderkaria;

    printf("\n\n");
    do
    {
        printf(" 'iMuga' zenbaki osoa eta positiboa eman (5 adibidez): ");
        scanf("%d", &iMuga);
    } while (iMuga < 0);

    lBiderkaria = 1;
    printf("\n Hasieran lBiderkaria=%ld", lBiderkaria);

    printf("\n ---------------------------------------------------");
    for (iKont=1; iKont<=iMuga; iKont++)
    {
        lBiderkaria = lBiderkaria*iKont;
        printf("\n \t %2d iterazioan lBiderkaria=%ld", iKont, lBiderkaria);
    }
    printf("\n ---------------------------------------------------");

    printf("\n Irten ondoren:       iKont=%d", iKont);
    printf("\n Azkenean:      lBiderkaria=%ld", lBiderkaria);

    printf("\n\n");
    return 0;
}
lBiderkaria = 1 * 2 * 3 * ... * (iMuga-1) * (iMuga)


/* Ariketa-21c_forAdibideak-1: batukari baten kalkulua. */

// {-----------------------------------------------------------------------------
//      iMuga emanda lortu iBatukaria = iMuga + (iMuga-1) + ... + 3 + 2 + 1
//  -----------------------------------------------------------------------------}

#include <stdio.h>   // printf() funtzioarako

int main()
{
    int iIterazio, iKont, iMuga, iBatukaria;

    printf("\n\n");
    do
    {
        printf(" 'iMuga' zenbaki osoa eta positiboa eman (5 adibidez): ");
        scanf("%d", &iMuga);
    } while (iMuga < 0);

    iBatukaria = 0;
    printf("\n Hasieran iBatukaria=%d", iBatukaria);
    iIterazio = 0;

    printf("\n -------------------------------------------------------");
    for (iKont=iMuga; iKont>=1; iKont--)
    {
        iIterazio++;
        iBatukaria = iBatukaria + iKont;
        printf("\n \t %2d. iterazioan:  iKont=%d iBatukaria=%d", iIterazio, iKont, iBatukaria);
    }
    printf("\n -------------------------------------------------------");

    printf("\n Irten ondoren:    iKont=%d", iKont);
    printf("\n               iIterazio=%d", iIterazio);
    printf("\n Azkenean:    iBatukaria=%d", iBatukaria);

    printf("\n\n");
    return 0;
}
iBatukaria = iMuga + (iMuga-1) + ... + 3 + 2 + 1


/* Ariketa-21d_forAdibideak-1: batukari baten kalkulua. */

// {-----------------------------------------------------------------------------
//     Negatiboa den iMuga emanda lortu iBatukaria = -1 -2 -3 -4 - ... -iMuga
//  -----------------------------------------------------------------------------}

#include <stdio.h>   // printf() funtzioarako

int main()
{
    int iIterazio, iKont, iMuga, iBatukaria;

    printf("\n\n");
    do
    {
        printf(" 'iMuga' zenbaki osoa eta negatiboa eman (-5 adibidez): ");
        scanf("%d", &iMuga);
    } while (iMuga > 0);

    iBatukaria = 0;
    printf("\n Hasieran iBatukaria=%d", iBatukaria);
    iIterazio = 0;

    printf("\n -------------------------------------------------------");
    for (iKont=-1; iKont>=iMuga; iKont--)
    {
        iIterazio++;
        iBatukaria = iBatukaria + iKont;
        printf("\n \t %2d. iterazioan:  iKont=%d iBatukaria=%d", iIterazio, iKont, iBatukaria);
    }
    printf("\n -------------------------------------------------------");

    printf("\n Irten ondoren:    iKont=%d", iKont);
    printf("\n               iIterazio=%d", iIterazio);
    printf("\n Azkenean:    iBatukaria=%d", iBatukaria);

    printf("\n\n");
    return 0;
}
iBatukaria = -1 -2 -3 -4 - ... -iMuga


/* Ariketa-21e_forAdibideak-1: batukari baten kalkulua. */

// {------------------------------------------------------------------------------
//    Mugak emanda lortu iBatukaria = iBeheMuga + (iBeheMuga+1) + ... + iGoiMuga
//  ------------------------------------------------------------------------------}

#include <stdio.h>   // printf() funtzioarako

int main()
{
    int iIterazio, iKont, iBeheMuga, iGoiMuga, iBatukaria;

    printf("\n\n");
    do
    {
        printf(" 'iBeheMuga' zenbaki osoa eta positiboa eman (5 adibidez): ");
        scanf("%d", &iBeheMuga);
    } while (iBeheMuga < 0);

    do
    {
        printf(" %d baino handiagoa den 'iGoiMuga' zenbakia eman (8 adibidez): ", iBeheMuga);
        scanf("%d", &iGoiMuga);
    } while (iGoiMuga <= iBeheMuga);

    iBatukaria = 0;
    printf("\n Hasieran iBatukaria=%d", iBatukaria);
    iIterazio = 0;

    printf("\n -------------------------------------------------------");
    for (iKont=iBeheMuga; iKont<=iGoiMuga; iKont++)
    {
        iIterazio++;
        iBatukaria = iBatukaria + iKont;
        printf("\n \t %2d. iterazioan:  iKont=%d iBatukaria=%d", iIterazio, iKont, iBatukaria);
    }
    printf("\n -------------------------------------------------------");

    printf("\n Irten ondoren:    iKont=%d", iKont);
    printf("\n               iIterazio=%d", iIterazio);
    printf("\n Azkenean:    iBatukaria=%d", iBatukaria);

    printf("\n\n");
    return 0;
}
iBatukaria = iBeheMuga + (iBeheMuga+1) + ... + iGoiMuga


/* Ariketa-21f-a_forAdibideak-1: batukari baten kalkulua. */

// {------------------------------------------------------------------------------
//      iMuga emanda lortu iBatukaria = 1 + 3 + 5 + ... + (iMuga-2) + iMuga
//  ------------------------------------------------------------------------------}

#include <stdio.h>   // printf() funtzioarako

int main()
{
    int iKont, iMuga, iBatukaria;

    printf("\n\n");
    do
    {
        printf(" 'iMuga' zenbaki osoa eta positiboa eman (15 adibidez): ");
        scanf("%d", &iMuga);
    } while (iMuga < 0);

    iBatukaria = 0;
    printf("\n Hasieran iBatukaria=%d", iBatukaria);

    printf("\n ------------------------------------------------------------------------");
    for (iKont=1; iKont<=iMuga; iKont++)
    {
        if (iKont %2 == 1)
        {
            iBatukaria = iBatukaria + iKont;
            printf("\n \t %2d iterazioan iBatukaria=%2d   <=== %d gehitu bakoitietan", iKont, iBatukaria, iKont);
        }
        else
            printf("\n \t %2d iterazioan iBatukaria=%2d   <--- bikoitietan ez gehitu", iKont, iBatukaria);
    }
    printf("\n ------------------------------------------------------------------------");

    printf("\n Irten ondoren:        iKont=%d", iKont);
    printf("\n Azkenean:        iBatukaria=%d", iBatukaria);

    printf("\n\n");
    return 0;
}  
iBatukaria = 1 + 3 + 5 + ... + (iMuga-2) + iMuga


/* Ariketa-21f-b_forAdibideak-1: batukari baten kalkulua. */

// {------------------------------------------------------------------------------
//      iMuga emanda lortu iBatukaria = 1 + 3 + 5 + ... + (iMuga-2) + iMuga
//  ------------------------------------------------------------------------------}

#include <stdio.h>   // printf() funtzioarako

int main()
{
    int iKont, iMuga, iBatukaria;

    printf("\n\n");
    do
    {
        printf(" 'iMuga' zenbaki osoa eta positiboa eman (15 adibidez): ");
        scanf("%d", &iMuga);
    } while (iMuga < 0);

    iBatukaria = 0;
    printf("\n Hasieran iBatukaria=%d", iBatukaria);

    printf("\n ------------------------------------------------------------------------");
    for (iKont=1; iKont<=iMuga; iKont=iKont+2)
    {
        iBatukaria = iBatukaria + iKont;
        printf("\n \t %2d iterazioan iBatukaria=%2d   <=== %d gehitu", iKont, iBatukaria, iKont);
    }
    printf("\n ------------------------------------------------------------------------");

    printf("\n Irten ondoren:        iKont=%d", iKont);
    printf("\n Azkenean:        iBatukaria=%d", iBatukaria);

    printf("\n\n");
    return 0;
}  
iBatukaria = 1 + 3 + 5 + ... + (iMuga-2) + iMuga


/* Ariketa-21g_forAdibideak-1: karratuen batukari baten kalkulua. */

// {------------------------------------------------------------------------------
//      iMuga emanda (1 eta 9 artekoa) batukari hau kalkulatu:
//          iBatukaria = +1^2 -2^2 +3^2 -4^2 +5^2 -6^2 + ... -+iMuga^2
//  ------------------------------------------------------------------------------}

#include <stdio.h>   // printf() funtzioarako

#define BEHEMUGA 1
#define GOIMUGA 9

int main()
{
    int iKont, iMuga, iBatugaia, iBatukaria;

    printf("\n\n");
    do
    {
        printf(" %d eta %d artekoa den 'iMuga' zenbaki osoa eman (7 adibidez): ", BEHEMUGA, GOIMUGA);
        scanf("%d", &iMuga);
    } while ((iMuga < BEHEMUGA) || (iMuga > GOIMUGA));

    iBatukaria = 0;
    printf("\n Hasieran iBatukaria=%d", iBatukaria);

    printf("\n --------------------------------------------------------------------------");
    for (iKont=1; iKont<=iMuga; iKont++)
    {
        if (iKont %2 == 1)
        {
            iBatugaia = iKont*iKont;
            iBatukaria = iBatukaria + iBatugaia;
            printf("\n \t %2d iterazioan iBatukaria=%3d   <=== bakoitietan %3d gehitu", iKont, iBatukaria, iKont*iKont);
        }
        else
        {
            iBatugaia = (-1)*iKont*iKont;
            iBatukaria = iBatukaria + iBatugaia;
            printf("\n \t %2d iterazioan iBatukaria=%3d   <=== bikoitietan %3d gehitu", iKont, iBatukaria, -iKont*iKont);
        }
    }
    printf("\n --------------------------------------------------------------------------");

    printf("\n Irten ondoren:        iKont=%d", iKont);
    printf("\n Azkenean:        iBatukaria=%d", iBatukaria);

    printf("\n\n");
    return 0;
}
iBatukaria = +12 -22 +32 -42 +52 -62 + ... ±iMuga2






  • Ariketa-21a_forAdibideak-1.cbp | main.c  
  • Ariketa-21b_forAdibideak-1.cbp | main.c  
  • Ariketa-21c_forAdibideak-1.cbp | main.c  
  • Ariketa-21d_forAdibideak-1.cbp | main.c  
  • Ariketa-21e_forAdibideak-1.cbp | main.c  
  • Ariketa-21f-a_forAdibideak-1.cbp | main.c  
  • Ariketa-21f-b_forAdibideak-1.cbp | main.c  
  • Ariketa-21g_forAdibideak-1.cbp | main.c  

 

Ariketa 20 | for agindua: faktoriala eta potentzia kalkulatzen


ZER DAKIDAN:
Sekuentzialki multzokatzen diren aginduak ezagutzen ditut, bide desberdinak erabakitzeko baldintzazko aginduak (if eta switch) ezagutzen ditut. Datuak teklatuz modu kontrolatuan jasotzeko do-while agindu errepikakorra ere erabili izan dut.



ZER IKASIKO DUDAN:
Agindu errepikakorrekin jarraituz for ikasiko dut.

C programazioan, begizta bat erabiltzen da kode bloke bat hainbat aldiz errepikatzeko. Begizta bat osatzeko for agindua da modurik trinkoena da.


    Hona hemen 1 eta 5 zenbakiak inprimatzen dituen adibide sinple bat:
for (int iKont=1; iKont<=5; iKont++)
{
    printf("%d\n", iKont);
}
    Nola funtzionatzen duen. Begiztak hiru zati ditu:
  1. Hasieraketa: Begizta kontrolatzen duen iKont aldagaiari hasierako balioa ematen zaio.
  2. Baldintza: Begiztak jarraitzen du baldintza betetzen den bitartean.
  3. Iterazioa: Begiztaren iterazo bakoitzaren printf() funtzioa exekutatzen da eta iKont inkrementatzen da.

    Baldintzak adierazten duen egoera faltsua denean (iKont-ek 6 balioko duenean),
    amaitzen da begizta.



Ondoko adibidea aztertu non do-while aginduari esker ziurtatzen da iZbk datu positiboa den, eta, for aginduari esker lFakt faktoriala kalkulatzen den.

Hona hemen Ariketa-20a_FaktorialaKalkulatzen.cbp proiektuaren main() funtzioa gordetzen duen main.c fitxategiaren edukia:

/* Ariketa-20a_FaktorialaKalkulatzen: for aginduaren adibidea. */

// Zenbaki osoekin lan egingo dugu, iZbk teklatuaren bitartez
// irakurri eta lFakt=iZbk! faktoriala kalkulatu for bitartez.

#include <stdio.h>   // printf() funtzioarako

int main()
{
    int iZbk, iKont;
    long lFakt;

    printf("\n");
    printf("\n Kopuru osoko eta positiboekin lan egingo da");
    printf("\n -------------------------------------------\n");

    printf("\n Zenbaki osoa eta positiboa eman eta dagokion");
    printf("\n faktoriala kalkulatu eta pantailaratuko da.\n\n");
    do
    {
        printf(" Zenbaki osoa eta positiboa eman (5 adibidez): ");
        scanf("%d", &iZbk);
    } while (iZbk < 0);

    lFakt = 1;

    for (iKont=1; iKont<=iZbk; iKont++)
    {
        lFakt = lFakt*iKont;
        printf("\n \t %d iterazioan lFakt= %ld", iKont, lFakt);
    }

    printf("\n\n \t \t %d! = %ld", iZbk, lFakt);

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


Ondoko adibidea aztertu non do-while aginduari esker ziurtatzen da iBerretzailea datu positiboa den, eta, for aginduari esker 2 konstantearen lBerredura potentzia kalkulatzen den. Lortutako emaitzaren zuzentasuna konprobatuko dugu pow(2, iBerretzailea) funtzioa aplikatuz.

Hauxe da potenzia edo berredura kalkulatzen duen Ariketa-20b_PotentziaKalkulatzen.cbp proiektuaren main.c fitxategiaren edukia:

/* Ariketa-20b_PotentziaKalkulatzen: for aginduaren adibidea. */

// Zenbaki osoekin lan eginez, iBerretzailea teklatuz irakurri
// eta 2^iBerretzailea potentzia kalkulatu for bitartez, emaitza
// konprobatuko dugu pow(2, iBerretzailea) funtzioa aplikatuz.
// ADI: Emaitza long bada 31 datuarekin gainezkatzea gertatzen da.

#include <stdio.h>   // printf() funtzioarako
#include <math.h>    // pow() funtzioarako
#define OINARRIA 2
#define MUGA 30

int main()
{
    int iBerretzailea, iKont;
    long lBerredura;

    printf("\n");
    printf("\n Kopuru osoko eta positiboekin lan egingo da");
    printf("\n -------------------------------------------\n");

    printf("\n iBerretzailea zenbaki osoa eta positiboa eman eta dagokion");
    printf("\n 2^iBerretzailea potentzia (edo berredura) kalkulatuko da.\n\n");
    do
    {
        printf(" Berretzailea adierazten duen zenbaki osoa eta positiboa eman (5 adibidez): ");
        scanf("%d", &iBerretzailea);
        if ((iBerretzailea < 0) || (iBerretzailea > MUGA))
            printf(" Datua 0 eta %d artekoa (biak barne) \n", MUGA);
    } while ((iBerretzailea < 0) || (iBerretzailea > MUGA));

    lBerredura = 1;

    for (iKont = 1; iKont <= iBerretzailea; iKont++)
    {
        lBerredura = lBerredura*OINARRIA;
        printf("\n \t %2d iterazioan lBerredura= %ld", iKont, lBerredura);
    }

    printf("\n\n \t \t 2^%d = %ld", iBerretzailea, lBerredura);
    printf("\n \t   pow(2, %d) = %.0f", iBerretzailea, pow(2, iBerretzailea));

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






  • Ariketa-20a_FaktorialaKalkulatzen.cbp | main.c  
  • Ariketa-20b_PotentziaKalkulatzen.cbp | main.c  

 

Sekuentziak, baldintzak eta errepikapenak (eskemak)

Orain arte aginduen sekuentziak ikusi ditugu eta erabakiak hartzeko baldintzako if eta switch aginduak. Hemendiak aurrera agindu errepikakorrekin (do-while, while eta for) ere lan egingo dugu, hauei esker iterazioak burutu daitezke.

Hona hemen aginduak antolatzeko hiru moduen eskemak:  

Sekuentziazko aginduen, baldintzazko aginduen eta agindu errepikakorren eskemak

Aginduen sekuentzietan programaren fluxuak beti aurrera egiten du eta agindu guztiak betetze dira bide bakar bat dagoelako. Baldintzako aginduetan ere programaren fluxuak beti aurrera egiten du, baina bide desberdinak daudelako, agindu batzuk beteko dira ala ez. Agindu errepikakorretan programaren fluxuak atzera egiten du agindu batzuk berriro betetzeko, horri iterazio esaten zaio:  



Baldintzazko aginduetan fluxuak aurrera egiten du



Agindu errepikakorretan fluxuak atzera egiten du

do-while eta while agindu errepikakorren arteko aldea kontzeptu bakarrean ematen da: Prozesu errepikakorra eteteko baldintza non kokatzen den, iterazioa baino lehen ala iterazioaren ostean. Bietan, bai do-while aginduan zein while aginduan prozesu errepikakorra eteteko baldintzaren logika berdina da: galderaren erantzuna ezezkoa bada eteteko da prozesu errepikakorra. Eskematikoki:  

while: iterazioa baino lehen ebaluatzen da galdera
do-while: iterazioa bukatzean ebaluatzen da galdera

Hirugarren agindu errepikakorra for da, agindu oso trinkoa delako bere erabilpena erraza da baina bere eskema marraztea ez da horren erraza. Noiz erabili for, do-while edo while agindu errepikakorrak? Araua argia da: prozesu errepikakorraren iterazio kopurua ezaguna denean for agindua erabiliko dugu, eta prozesu errepikakorraren iterazio kopurua ez dugunean ezagutzen do-while agindua edo while agindua erabili beharko dugu ezin bestean.

 

Datu-moten bihurketa automatikoa

C lengoaiak adierazpen berean datu-mota ezberdineko gaiak agertzea ahalbidetzen du, konpiladorea arduratzen da eragiketak behar bezala egiteaz. Adierazpen berean bi datu-mota edo gehiago agertzen direnean, eragigai guztien datu-motak bihurtzen ditu C lengoaiaren konpiladoreak eragigaietan dagoen datu-motarik handienera, honako bi arau hauen arabera:

  1. char eta short int guztiak int bihurtzen dira, float guztiak double bihurtzen dira
  2. Eragigai pare guztietarako, honako hau sekuentzian gertatzen da:
    • Eragigaietako bat long double bada, bestea long double bihurtzen da
    • Eragigaietako bat double bada, bestea double bihurtzen da
    • Eragigaietako bat long bada, bestea long bihurtzen da
    • Eragigaietako bat unsigned bada, bestea unsigned bihurtzen da.

Konpiladoreak bihurketa-arau horiek aplikatu ondoren, eragigaiak datu-mota berekoak izango dira, eta emaitza eragigaien datu-motako horretakoa izango da. Adibide bat ikus dezagun:

    char cKarak;
    int iKop;
    float fZbk;
    double dZbk;

    ( cKarak  /  iKop )  -  ( fZbk  +  iKop )  +  ( fZbk  *  dZbk ) ;
       char      int          float    int          float   double

Adierazpen aritmetikoan datu-mota desberdinak daudelako, lehenengo araua aplikatuko da. Lehenengo arauaren arabera, char datu-motako cKarak aldagaiaren balioa int bihurtzen da, eta, era berean, float datu-motako fZbk aldagaiaren balioa double bihurtzen da. Egoera berria hau delarik:

    ( cKarak  /  iKop )  -  ( fZbk  +  iKop )  +  ( fZbk  *  dZbk ) ;
       int       int         double    int         double   double

Hiru blokeak ikus ditzagun banan-banan. Lehen blokeko bi eragigaiak mota berekoak direnez, lehenengo eragiketa egingo dugu (cKarak/iKop), eta emaitza int datu-motakoa izango da. Era berean, hirugarren blokeko eragiketan bi biderkagaiak datu-mota berekoak direnez fZbk*dZbk eragiketa burutuko da emaitza double datu-motakoa delarik. Baina, bigarren blokeko batugaiak datu-mota desberdinekoak dira, horregatik, bigarren araua aplikatuz int datu-motakoa double datu-motara bihurtzen da eta fZbk+iKop emaitza double izango da.

    ( cKarak  /  iKop )  -  ( fZbk  +  iKop )  +  ( fZbk  *  dZbk ) ;
       int       int         double    int         double   double
       -------------         -------------         ---------------
            int                  double               double        

Hiru blokeak ebaluatu ondoren, haien integrazioa egin beharko da. Lehen blokea int datu-motakoa izango denez, eta bigarren blokea double datu-motakoa denez, lehen blokeari bihurketa bat egiten zaio double izan dadin eta bi bloken arteko kendura double datu-motakoa izango da. Amaitzeko hirugarren blokea gehituko zaio aurreko emaitzari eta biak double datu-motakoak direnez azken emaitza ere double izango da.

    ( cKarak  /  iKop )  -  ( fZbk  +  iKop )  +  ( fZbk  *  dZbk ) ;
       int       int         double    int         double   double
       -------------         -------------         ---------------
            int                  double                 double
            ---------------------------
                     double                             double
                     -----------------------------------------
                                        double