8. jarduera (III) | Mediana eta batezbestekoa

ZER DAKIDAN: Bilaketa linealaren algoritmoari dagozkion programa, parametroak eta eskema ezagutzen ditut. ZER IKASIKO DUDAN: Bilaketa linealaren beste aplikazio bat ikusiko dut orain.

Gehienez 40 elementu gordetzeko gai den array batekin lan egingo dugu. Arrayaren elementuak zenbaki errealak izango dira.

Array zehatz honen datuek bi baldintza betetzen dituzte:

1. Arrayaren datu guztiak desberdinak dira. Arraya betetzean, datua den zenbaki erreala arrayean gorde aurretik, frogatu beharra dago errepikaturik ez dela egongo. Horretarako, teoriako blogearen 8. jarduera (II) | Bilaketa sekuentzialaren aplikazio bat programara jo eta bertako iZenbakiaBilatu izeneko funtzioa erabili gure behar izanetara egokituz, hots, beharko dituen moldapenak eginez
2. Arrayaren datu guztiak ordenaturik daude. Arraya betetzean, datu berria dela frogatu ondoren, zein tokitan txertatuko den zehaztu beharra dago eta non txertatu dakiguka tartekaketaren algoritmoa aplikatu (gogoratu 10. jarduera | Txertaketa array batean non elementu bat arrayaren posizio jakin batean tartekatzen den)

Zein da datuen fMed medianaren balioa? eta zein da datuen fBaBe batezbestekoaren balioa?

Mediana. Estatistikan, fMediana mediana hainbat datu txikienetik handienera ordenaturik daudela, erdian dagoen datua da. Datu-kopurua bakoitia bada, denak ordenaturik daudela, fMediana mediana erdiko datuak hartzen duen balioa da. Datu-kopurua bikoitia bada, datuak ordenaturik daudela, erdiko datu bi dagoenez, fMediana mediana erdiko bi datu horien batezbestekoa dela esan daiteke (fMediana aldagaiaren datu-mota float izango da).

Batezbestekoa. Batezbestekoaren balioa kalkulatzeko, fBatBesArit aldagaia erabiliko da (float datu-motakoa). Arrayak dituen balioen metekata egin ondoren, arrayaren elementu kopuruagatik zatiketa egingo da.

---

Arrayaren datu-mota eta arrayaren edukia

Arrayaren elementuak zenbaki errealak dira. Zehatzago hitz eginez, elementuen egitura hau da: 0 eta 9 arteko unitate bat, eta, 0 eta 9 arteko dezimal bat.

int main()
{
    float afZenbakiak[LUZERA]; // 40 zenbaki gordetzeko arraya, 0-tik 39-ra
    int iLuzera;
...   

Arrayaren elementu guztiak desberdinak dira elkarrekiko, eta sailkaturik daude txikitik handira. Adibidez, hau izan daiteke 10 elementu dituen array baten edukia:

     balioak ===>     0.3   1.6   2.1   2.2   3.9   5.6   7.4   8.8   8.9   9.5
    indizeak ===>      0     1     2     3     4     5     6     7     8     9

---

Programa nagusia

Programa nagusian array bat (eta bere luzera efektiboa) daukagu eta eskatzen diren mediana eta batezbesteko aritmetikoa kalulatzen dira.

// =============================programa nagusia============================ 
int main()
{
    float afZenbakiak[LUZERA]; // 40 zenbaki gordetzeko arraya, 0-tik 39-ra
    int iLuzera;
    float fMediana, fBatBesArit;

    srand(time(NULL));

    printf("\nArraya elementu desberdinez betetzen, ");
    ArrayaBete_DesberdinakEtaOrdenaturik(afZenbakiak, &iLuzera);
    printf("\nArrayaren edukia:\n");
    ArrayaIkusi(afZenbakiak, iLuzera);

    fMediana = fMedianaKalkulatu(afZenbakiak, iLuzera);
    printf("Mediana = %.2f\n\n", fMediana);

    fBatBesArit = fBatezbestekoaKalkulatu(afZenbakiak, iLuzera);
    printf("Batezbestekoa = %.2f\n", fBatBesArit);

    printf("\n");
    printf("====================================================\n");
    printf("           RETURN sakatu amaitzeko\n");
    printf("====================================================\n");
    getchar();

    return 0;
}

---

ArrayaBete_DesberdinakEtaOrdenaturik() funtzioa

Programaren eginkizun zailena ArrayaBete_DesberdinakEtaOrdenaturik() funtzio honetan burutzen da, bere lana bikoitza da: 1) elementu desberdinak eta 2) ordenaturik gorde.

...
void ArrayaBete_DesberdinakEtaOrdenaturik(float afZenbakiak[], int *iLuzera)
{
    *iLuzera = rand() % LUZERA +1 ;  // gutxienez elementu 1

    printf("guztira %d elementu:\n", *iLuzera);

    for (int iKont = BEHEMUGA; iKont < *iLuzera; iKont++)
    {
        int iNonDago, iNonTxertatu;
        float fZbk;
        do
        {
            int iUnitatea = rand() % 10;
            int iDezimala = rand() % 10;
            fZbk = iUnitatea * 1.0 + iDezimala * 0.1;

            iNonDago = iZenbakiaBilatu(afZenbakiak, *iLuzera, fZbk);
            if (iNonDago != -1)
            {
                printf("iKont=%d-rako proposamena: %.1f  |  afZenbakiak[%d]=%.1f errepikatuta %d. posizioan\n", iKont, fZbk, iNonDago, fZbk, iNonDago);
                ArrayaIkusi(afZenbakiak, iKont);
            }
        } while (iNonDago != -1);

        iNonTxertatu = iBerePosizioaAurkitu(afZenbakiak, iKont, fZbk);
        ZbkTartekatu(afZenbakiak, iKont, fZbk, iNonTxertatu);
    }
}
...

iBerePosizioaAurkitu funtzioak bilaketa sekuentzialaren algoritmoa barneratzen du. Eta, ZbkTartekatu prozedurak elementu baten 10. jarduera | Txertaketa array batean barneratzen du.

Hona hemen 8c-Jarduera_Mediana.cbp programaren kodea eta bi exekuzioen balizko pantailaraketak:

Datu-kopurua bakoitia izatean

Datu-kopurua bikoitia izatean

/* 8c-Jarduera_Mediana: Zenbaki errealean array bat bete ondoren
                        datuen sortaren mediana kalkulatu. */

/*
{-------------------------------------------------------------------------------------}
{ Zenbaki errealen array bat datuz bete: bere elementu guztiak desberdinak izango     }
{ dira, eta horrez gain datuak ordenaturik kokatuko dira array barruan.               }
{                                                                                     }
{ Elementu jakin bat berria dela frogatu ondoren, berari dagokion posizioa arrayean   }
{ zehaztu eta bertan txertatu tartekaketa bat burutuz.                                }
{-------------------------------------------------------------------------------------}

{-------------------------------------------------------------------------------------}
{ Zein da fMediana medianaren balioa? eta fBatBesArit batezbestekoaren balioa?        }
{                                                                                     }
{ Estatistikan, fMediana mediana hainbat datu txikienetik handienera ordenaturik      }
{ daudela, erdian dagoen datua da. Datu-kopurua bakoitia bada, denak ordenaturik      }
{ daudela, fMediana mediana erdiko datuak hartzen duen balioa da. Baina, datu-kopurua }
{ bikoitia bada, datuak ordenaturik daudela, erdiko datuak bi direz, fMediana mediana }
{ erdiko bi datu horien batezbestekoa izango da.                                      }
{                                                                                     }
{ Programa bukatzeko, batezbestekoaren balioa kalkulatzen da eta float datu-motako    }
{ fBatBesArit aldagaia erabiliko da.                                                  }
{-------------------------------------------------------------------------------------}
*/

#include <stdio.h>
#include <stdlib.h>    // rand() eta srand() funtzioetarako
#include <time.h>      // time() funtzioarako
#include <stdbool.h>   // bool datu-motarako

#define BEHEMUGA 0
#define GOIMUGA 39
#define LUZERA  40

void ZbkTartekatu(float afZenbakiak[], int iKont, float fZbk, int iNonTxertatu);
int iBerePosizioaAurkitu(const float afZenbakiak[], int iKont, float fZbk);
int iZenbakiaBilatu(const float afZenbakiak[], int iLuzera, float fZbk);
void ArrayaBete_DesberdinakEtaOrdenaturik(float afZenbakiak[], int *iLuzera);
void ArrayaIkusi(const float afZenbakiak[], int iLuzera);
float fMedianaKalkulatu(const float afZenbakiak[], int iLuzera);
float fBatezbestekoaKalkulatu(const float afZenbakiak[], int iLuzera);


int main()
{
    float afZenbakiak[LUZERA]; // 40 zenbaki gordetzeko arraya, 0-tik 39-ra
    int iLuzera;
    float fMediana, fBatBesArit;

    srand(time(NULL));

    printf("\nArraya elementu desberdinez betetzen, ");
    ArrayaBete_DesberdinakEtaOrdenaturik(afZenbakiak, &iLuzera);
    printf("\nArrayaren edukia:\n");
    ArrayaIkusi(afZenbakiak, iLuzera);

    fMediana = fMedianaKalkulatu(afZenbakiak, iLuzera);
    printf("Mediana = %.2f\n\n", fMediana);

    fBatBesArit = fBatezbestekoaKalkulatu(afZenbakiak, iLuzera);
    printf("Batezbestekoa = %.2f\n", fBatBesArit);

    printf("\n");
    printf("====================================================\n");
    printf("           RETURN sakatu amaitzeko\n");
    printf("====================================================\n");
    getchar();

    return 0;
}


// ZbkTartekatu funtzioa
void ZbkTartekatu(float afZenbakiak[], int iKont, float fZbk, int iNonTxertatu)
{
    for (int k = iKont; k >= iNonTxertatu; k--)
    {
        afZenbakiak[k + 1] = afZenbakiak[k];
    }
    afZenbakiak[iNonTxertatu] = fZbk;
}


// iBerePosizioaAurkitu funtzioa
int iBerePosizioaAurkitu(const float afZenbakiak[], int iKont, float fZbk)
{
    int iBerePosizioa = BEHEMUGA;
    while (iBerePosizioa < iKont && afZenbakiak[iBerePosizioa] < fZbk)
    {
        iBerePosizioa++;
    }
    return iBerePosizioa;
}


// iZenbakiaBilatu funtzioa
int iZenbakiaBilatu(const float afZenbakiak[], int iLuzera, float fZbk)
{
    int iKont = BEHEMUGA;
    bool boAurkitua = false;
    while ((iKont < iLuzera) && !boAurkitua)
    {
        if (afZenbakiak[iKont] == fZbk)
            boAurkitua = true;
        else
            iKont++;
    }
    return boAurkitua ? iKont : -1;
}


// ArrayaBete_DesberdinakEtaOrdenaturik funtzioa
void ArrayaBete_DesberdinakEtaOrdenaturik(float afZenbakiak[], int *iLuzera)
{
    *iLuzera = rand() % LUZERA +1 ;  // gutxienez elementu 1

    printf("guztira %d elementu:\n", *iLuzera);

    for (int iKont = BEHEMUGA; iKont < *iLuzera; iKont++)
    {
        int iNonDago, iNonTxertatu;
        float fZbk;
        do
        {
            int iUnitatea = rand() % 10;
            int iDezimala = rand() % 10;
            fZbk = iUnitatea * 1.0 + iDezimala * 0.1;

            iNonDago = iZenbakiaBilatu(afZenbakiak, *iLuzera, fZbk);
            if (iNonDago != -1)
            {
                printf("iKont=%d-rako proposamena: %.1f  |  afZenbakiak[%d]=%.1f errepikatuta %d. posizioan\n", iKont, fZbk, iNonDago, fZbk, iNonDago);
                ArrayaIkusi(afZenbakiak, iKont);
            }
        } while (iNonDago != -1);

        iNonTxertatu = iBerePosizioaAurkitu(afZenbakiak, iKont, fZbk);
        ZbkTartekatu(afZenbakiak, iKont, fZbk, iNonTxertatu);
    }
}


// ArrayaIkusi funtzioa
void ArrayaIkusi(const float afZenbakiak[], int iLuzera)
{
    for (int iKont = BEHEMUGA; iKont < iLuzera; iKont++)
    {
        printf("%10d. elementua = %.1f\n", iKont, afZenbakiak[iKont]);
    }
}


// fMedianaKalkulatu funtzioa
float fMedianaKalkulatu(const float afZenbakiak[], int iLuzera)
{
    int iErdia;
    if ((iLuzera+1) % 2 != 0)
    {
        iErdia = iLuzera / 2;
        printf("iErdia = %d    -->    ", iErdia);
        return afZenbakiak[iErdia];
    }
    else
    {
        iErdia = iLuzera / 2;
        printf("iErdia = %d     iErdia+1 = %d    ==>    ", iErdia, iErdia + 1);
        return (afZenbakiak[iErdia] + afZenbakiak[iErdia + 1]) / 2;
    }
}


// fBatezbestekoaKalkulatu funtzioa
float fBatezbestekoaKalkulatu(const float afZenbakiak[], int iLuzera)
{
    float fMetatua = 0.0;
    for (int iKont = BEHEMUGA; iKont < iLuzera; iKont++)
    {
        fMetatua += afZenbakiak[iKont];
    }
    return fMetatua / iLuzera;
}

---

8c-Jarduera_Mediana.cbp | main.c