Ariketa 66 | Koloreak

ZER DAKIDAN: Informazioa pantailan idazteko printf() funtzioa ezagutzen dut. ZER IKASIKO DUDAN: Informazioa koloretan pantailaratzen ikasiko dut.

Kontsolan testu bat idazten denean, bere kolorea eta atributuak aukera daitezke. Artikulo honen beheko aldean dauden tauletan biltzen diren ANSI ihes-sekuentziak kontsolan idazten diren testuen koloreak eta atributuak kontrolatzeko balio dute.

ANSI ihes-sekuentziei esker, kontrol-informazioa bidal daiteke kontsolara, irudikatutako testuaren atributuak aldatzeko. Modu horretan, honako hauek hauta daitezke:

• Testuaren estiloa:
  • normala 0
  • argia/lauso 1
  • indartua/lodia 2
  • azpimarratua 4
  • klikalaria/keinukaria 5
  • alderantzizkoa 7
  • ezkutukoa 8
• Hondoaren kolorea
• Testuaren kolorea

Funtzionamendua erraza da. Kontsolara irteeran bidaltzen den informazioaren artean, testua irudikatzeko jarraibideak ematen dituzten ihes-sekuentziak daude.

Adibidez, printf() funtzioari "%sTestua pantailan%s" parametroa hau ematen bazaio, non lehen %s bitartez testuaren itxura zehazten den eta bigarren %s bitartez testua ohiko itxurar itzultzen duen.

Sintaxia hau izango litzateke:       "\033 [x; xxx; xxxm"

Non x bakoitzak digitu bat irudikatzen duen. Lehen digituak estiloa zehazten du, bigarren digituak hondoren kolorea zehazten du eta hirugarren digituak testuaren kolorea zehazten du.

Esate baterako, hemen kode batzuk eta haien esanahiak:

• "\033[0;43;36m"       normala, hondoa marroia, testua zyana
• "\033[4;102;34m"     azpimarratua, hondoa berde distiratsua, testua urdina
• "\033[5;47;101m"     kliskalaria, hondoa zuria, testua gorri distiratsua
• "\033[0m"                   ohiko itxurara itzuli

Kode horiek programa batean erabil ditzagun.

/* Ariketa-66_Koloreak: testuen koloreak */

#include <stdio.h>

// ANSI kolore kodeak

// ohikoa berreskuratu
#define RESET   "\033[0m"

// testuaren kolore arruntak
#define BELTZA  "\033[0,30m"
#define GORRIA  "\033[0,31m"
#define BERDEA  "\033[0,32m"
#define MARROIA "\033[0,33m"
#define URDINA  "\033[0,34m"
#define MAGENTA "\033[0,35m"
#define ZYANA   "\033[0,36m"
#define ZURIA   "\033[0,37m"

// testuaren kolore distiratsuak
#define BELTZ_DISTIRATSUA   "\033[90m"
#define GORRI_DISTIRATSUA   "\033[91m"
#define BERDE_DISTIRATSUA   "\033[92m"
#define MARROI_DISTIRATSUA  "\033[93m"
#define URDIN_DISTIRATSUA   "\033[94m"
#define MAGENTA_DISTIRATSUA "\033[95m"
#define ZYAN_DISTIRATSUA    "\033[96m"
#define ZURI_DISTIRATSUA    "\033[97m"

// hondoaren kolore arruntak
#define BELTZ_HONDOA   "\033[0;40m"
#define GORRI_HONDOA   "\033[0;41m"
#define BERDE_HONDOA   "\033[0;42m"
#define MARROI_HONDOA  "\033[0;43m"
#define URDIN_HONDOA   "\033[0;44m"
#define MAGENTA_HONDOA "\033[0;45m"
#define ZYAN_HONDOA    "\033[0;46m"
#define ZURI_HONDOA    "\033[0;47m"

// hondoaren kolore distiratsuak
#define BELTZ_DISTIRATSUA_HONDOA   "\033[0;100m"
#define GORRI_DISTIRATSUA_HONDOA   "\033[0;101m"
#define BERDE_DISTIRATSUA_HONDOA   "\033[0;102m"
#define MARROI_DISTIRATSUA_HONDOA  "\033[0;103m"
#define URDIN_DISTIRATSUA_HONDOA   "\033[0;104m"
#define MAGENTA_DISTIRATSUA_HONDOA "\033[0;105m"
#define ZYAN_DISTIRATSUA_HONDOA    "\033[0;106m"
#define ZURI_DISTIRATSUA_HONDOA    "\033[0;107m"

// konbinazio bat (hiru gai: itxura, hondoa eta testua)
#define Norma__H_BERDEA__T_URDINA "\033[0;44;32m"
#define Lauso__H_BERDEA__T_URDINA "\033[1;44;32m"
#define Betea__H_BERDEA__T_URDINA "\033[2;44;32m"
#define Azpim__H_BERDEA__T_URDINA "\033[4;44;32m"
#define Klisk__H_BERDEA__T_URDINA "\033[5;44;32m"
#define Alder__H_BERDEA__T_URDINA "\033[7;44;32m"

// konbinazio bat (hiru gai: itxura, hondoa eta testua)
#define Norma__H_ZYAN__T_MARROIDISTIRA "\033[0;46;93m"
#define Lauso__H_ZYAN__T_MARROIDISTIRA "\033[1;46;93m"
#define Betea__H_ZYAN__T_MARROIDISTIRA "\033[2;46;93m"
#define Azpim__H_ZYAN__T_MARROIDISTIRA "\033[4;46;93m"
#define Klisk__H_ZYAN__T_MARROIDISTIRA "\033[5;46;93m"
#define Alder__H_ZYAN__T_MARROIDISTIRA "\033[7;46;93m"

// konbinazio bat (hiru gai: itxura, hondoa eta testua)
#define Norma__H_BELTZDISTIRA__T_GORRI "\033[0;100;31m"
#define Lauso__H_BELTZDISTIRA__T_GORRI "\033[1;100;31m"
#define Betea__H_BELTZDISTIRA__T_GORRI "\033[2;100;31m"
#define Azpim__H_BELTZDISTIRA__T_GORRI "\033[4;100;31m"
#define Klisk__H_BELTZDISTIRA__T_GORRI "\033[5;100;31m"
#define Alder__H_BELTZDISTIRA__T_GORRI "\033[7;100;31m"

// konbinazio bat (hiru gai: itxura, hondoa eta testua)
#define Norma__H_MAGENTADISTIRA__T_ZYANA "\033[0;105;36m"
#define Lauso__H_MAGENTADISTIRA__T_ZYANA "\033[1;105;36m"
#define Betea__H_MAGENTADISTIRA__T_ZYANA "\033[2;105;36m"
#define Azpim__H_MAGENTADISTIRA__T_ZYANA "\033[4;105;36m"
#define Klisk__H_MAGENTADISTIRA__T_ZYANA "\033[5;105;36m"
#define Alder__H_MAGENTADISTIRA__T_ZYANA "\033[7;105;36m"

// konbinazio bat (hiru gai: itxura, hondoa eta testua)
#define Norma__H_ZURIDISTIRA__T_URDINA "\033[0;107;34m"
#define Lauso__H_ZURIDISTIRA__T_URDINA "\033[1;107;34m"
#define Betea__H_ZURIDISTIRA__T_URDINA "\033[2;107;34m"
#define Azpim__H_ZURIDISTIRA__T_URDINA "\033[4;107;34m"
#define Klisk__H_ZURIDISTIRA__T_URDINA "\033[5;107;34m"
#define Alder__H_ZURIDISTIRA__T_URDINA "\033[7;107;34m"

// konbinazio bat (hiru gai: itxura, hondoa eta testua)
#define Norma__H_ZURIA__T_GORRIDISTIRA "\033[0;47;91m"
#define Lauso__H_ZURIA__T_GORRIDISTIRA "\033[1;47;91m"
#define Betea__H_ZURIA__T_GORRIDISTIRA "\033[2;47;91m"
#define Azpim__H_ZURIA__T_GORRIDISTIRA "\033[4;47;91m"
#define Klisk__H_ZURIA__T_GORRIDISTIRA "\033[5;47;91m"
#define Alder__H_ZURIA__T_GORRIDISTIRA "\033[7;47;91m"


void Koloreak()
{
    printf("Hondoa BERDE eta testua URDIN:\n");
    printf("\t%sNormala     %s\n", Norma__H_BERDEA__T_URDINA, RESET);
    printf("\t%sLausoa      %s\n", Lauso__H_BERDEA__T_URDINA, RESET);
    printf("\t%sBetea       %s\n", Betea__H_BERDEA__T_URDINA, RESET);
    printf("\t%sAzpimarratua%s\n", Azpim__H_BERDEA__T_URDINA, RESET);
    printf("\t%sKliskagarri %s\n", Klisk__H_BERDEA__T_URDINA, RESET);
    printf("\t%sAlderantziz %s\n", Alder__H_BERDEA__T_URDINA, RESET);
    printf("\n");
    printf("Hondoa ZYAN eta testua MARROI DISTIRATSU:\n");
    printf("\t%sNormala     %s\n", Norma__H_ZYAN__T_MARROIDISTIRA, RESET);
    printf("\t%sLausoa      %s\n", Lauso__H_ZYAN__T_MARROIDISTIRA, RESET);
    printf("\t%sBetea       %s\n", Betea__H_ZYAN__T_MARROIDISTIRA, RESET);
    printf("\t%sAzpimarratua%s\n", Azpim__H_ZYAN__T_MARROIDISTIRA, RESET);
    printf("\t%sKliskagarri %s\n", Klisk__H_ZYAN__T_MARROIDISTIRA, RESET);
    printf("\t%sAlderantziz %s\n", Alder__H_ZYAN__T_MARROIDISTIRA, RESET);
    printf("\n");
    printf("Hondoa BELTZ DISTIRATSUA eta testua GORRI:\n");
    printf("\t%sNormala     %s\n", Norma__H_BELTZDISTIRA__T_GORRI, RESET);
    printf("\t%sLausoa      %s\n", Lauso__H_BELTZDISTIRA__T_GORRI, RESET);
    printf("\t%sBetea       %s\n", Betea__H_BELTZDISTIRA__T_GORRI, RESET);
    printf("\t%sAzpimarratua%s\n", Azpim__H_BELTZDISTIRA__T_GORRI, RESET);
    printf("\t%sKliskagarri %s\n", Klisk__H_BELTZDISTIRA__T_GORRI, RESET);
    printf("\t%sAlderantziz %s\n", Alder__H_BELTZDISTIRA__T_GORRI, RESET);
    printf("\n");
    printf("Hondoa MAGENTA DISTIRATSUA eta testua ZYAN:\n");
    printf("\t%sNormala     %s\n", Norma__H_MAGENTADISTIRA__T_ZYANA, RESET);
    printf("\t%sLausoa      %s\n", Lauso__H_MAGENTADISTIRA__T_ZYANA, RESET);
    printf("\t%sBetea       %s\n", Betea__H_MAGENTADISTIRA__T_ZYANA, RESET);
    printf("\t%sAzpimarratua%s\n", Azpim__H_MAGENTADISTIRA__T_ZYANA, RESET);
    printf("\t%sKliskagarri %s\n", Klisk__H_MAGENTADISTIRA__T_ZYANA, RESET);
    printf("\t%sAlderantziz %s\n", Alder__H_MAGENTADISTIRA__T_ZYANA, RESET);
    printf("\n");
    printf("Hondoa ZURI DISTIRATSUA eta testua URDIN:\n");
    printf("\t%sNormala     %s\n", Norma__H_ZURIDISTIRA__T_URDINA, RESET);
    printf("\t%sLausoa      %s\n", Lauso__H_ZURIDISTIRA__T_URDINA, RESET);
    printf("\t%sBetea       %s\n", Betea__H_ZURIDISTIRA__T_URDINA, RESET);
    printf("\t%sAzpimarratua%s\n", Azpim__H_ZURIDISTIRA__T_URDINA, RESET);
    printf("\t%sKliskagarri %s\n", Klisk__H_ZURIDISTIRA__T_URDINA, RESET);
    printf("\t%sAlderantziz %s\n", Alder__H_ZURIDISTIRA__T_URDINA, RESET);
    printf("\n");
    printf("Hondoa ZURI eta testua GORRI DISTIRATSU:\n");
    printf("\t%sNormala     %s\n", Norma__H_ZURIA__T_GORRIDISTIRA, RESET);
    printf("\t%sLausoa      %s\n", Lauso__H_ZURIA__T_GORRIDISTIRA, RESET);
    printf("\t%sBetea       %s\n", Betea__H_ZURIA__T_GORRIDISTIRA, RESET);
    printf("\t%sAzpimarratua%s\n", Azpim__H_ZURIA__T_GORRIDISTIRA, RESET);
    printf("\t%sKliskagarri %s\n", Klisk__H_ZURIA__T_GORRIDISTIRA, RESET);
    printf("\t%sAlderantziz %s\n", Alder__H_ZURIA__T_GORRIDISTIRA, RESET);
}


int main()
{
    Koloreak();

    printf("\n\n");
    printf("Programa amaitzera doa");
    printf("\n\n");

    return 0;
}

ANSI ihes-sekuentziak: koloreak eta atributuak kontsolan

Kolore arruntak Kolorea   Kodea Beltza "\033[0,30m" Gorria "\033[0,31m" Berdea "\033[0,32m" Marroia "\033[0,33m" Urdina "\033[0,34m" Magenta "\033[0,35m" Zyana "\033[0,36m" Zuria "\033[0,37m"	Lausoak Kolorea   Kodea Beltza "\033[1,30m" Gorria "\033[1,31m" Berdea "\033[1,32m" Marroia "\033[1,33m" Urdina "\033[1,34m" Magenta "\033[1,35m" Zyana "\033[1,36m" Zuria "\033[1,37m"	Bold edo lodiak Kolorea   Kodea Beltza "\033[2,30m" Gorria "\033[2,31m" Berdea "\033[2,32m" Marroia "\033[2,33m" Urdina "\033[2,34m" Magenta "\033[2,35m" Zyana "\033[2,36m" Zuria "\033[2,37m"
Azpimarratuak Kolorea   Kodea Beltza "\033[4,30m" Gorria "\033[4,31m" Berdea "\033[4,32m" Marroia "\033[4,33m" Urdina "\033[4,34m" Magenta "\033[4,35m" Zyana "\033[4,36m" Zuria "\033[4,37m"	Kliskalariak Kolorea   Kodea Beltza "\033[5,30m" Gorria "\033[5,31m" Berdea "\033[5,32m" Marroia "\033[5,33m" Urdina "\033[5,34m" Magenta "\033[5,35m" Zyana "\033[5,36m" Zuria "\033[5,37m"	Alderantzizkoak Kolorea   Kodea Beltza "\033[7,30m" Gorria "\033[7,31m" Berdea "\033[7,32m" Marroia "\033[7,33m" Urdina "\033[7,34m" Magenta "\033[7,35m" Zyana "\033[7,36m" Zuria "\033[2,37m"
Kolore distiratsuak Kolorea   Kodea Beltza "\033[0,90m" Gorria "\033[0,91m" Berdea "\033[0,92m" Marroia "\033[0,93m" Urdina "\033[0,94m" Magenta "\033[0,95m" Zyana "\033[0,96m" Zuria "\033[0,97m"	Hondoak Kolorea   Kodea Beltza "\033[0,40m" Gorria "\033[0,41m" Berdea "\033[0,42m" Marroia "\033[0,43m" Urdina "\033[0,44m" Magenta "\033[0,45m" Zyana "\033[0,46m" Zuria "\033[0,47m"	Hondo distiratsuak Kolorea   Kodea Beltza "\033[0,100m" Gorria "\033[0,101m" Berdea "\033[0,102m" Marroia "\033[0,103m" Urdina "\033[0,104m" Magenta "\033[0,105m" Zyana "\033[0,106m" Zuria "\033[0,107m"
Ohikoa berreskuratzeko Kolorea   Kodea Reset "\033[0m"

---

Ariketa-66_Koloreak.cbp | main.c

 

Ariketa 65 | Kateen taula

ZER DAKIDAN: Arrayak ezagutzen ditut. ZER IKASIKO DUDAN: Bi dimentsiotako kateen array baten ariketa bat programatuko dut. Ariketa hau hobeto programatzen da laster ikusiko den erregistroen (edo struct datu-mota) array bat erabiliz.

asTaula hiru dimentsiotako taula bat da, kateak gorde ditzakeen asTaula arrayak 40 errenkada eta 3 zutabe ditu. Errenkada bakoitza ikasle bati dagokio: Errenkadaren lehen zutabean izena biltegitzen da, bigarrenean abizena eta hirugarren zutabean ikaslearen nota gordetzen da (hirurak string[19] datu-motakoak).

Taula baten dimentsioak zehazteko, bi indize behar dira: Indize bat lerro baliodunak zehazteko eta beste indize bat baliozko zutabeak adierazteko. Baina, asTaula arraya taula bat izan arren, array horren dimentsio efektiboa zenbaki oso batek adierazten du (hiru zutabeak beti beterik daudelako). Jarraian ematen den irudian, luzera efektiboaren lana errenkadak mugatzea dela ikusten da:

      iLuzeraTaula=5

asTaula
	0	1	2
0	'Laura'	'Urioste'	'4.8'
1	'Joseba'	'Salazar'	'6.333'
2	'Irina'	'Belasko'	'5.666'
3	'Patxi'	'Larrabe'	'9.1'
4	'Jordi'	'Coll'	'4.25'
5
6
...
39

Eskatzen da:

• Nota guztien arteko batezbesteko aritmetikoa lortu: 
  
  
• Noten batezbestekoarekin, desbideratze estandarra kalkulatu: 
  
  
• Notarik txikiena eskuratu duen ikaslea nor da? 
• Notarik handiena eskuratu duen ikaslea nor da? 
• Aprobatuen array dimentsiobakar hau lortu: 

                iLuzeraAprob=3

	asAprobatuak
0	'Salazar, Joseba'
1	'Belasko, Irina'
2	'Larrabe, Patxi'
3
4
...
40

 

/* Ariketa-65_KateenTaula: kateak gordetzen dituen bi dimentsiotako array sortuko da.
                           Errenkadak 40 izango dira (0tik 39ra) eta zutabeak 3 izango
                           dira (0tik 2ra). Errenkada bakoitzeko, datuak hiru kate
                           izango dira:
                                - 0 posizioko zutabean izena (teklatuz emanik),
                                - 1 posizioko zutabean abizena (teklatuz emanik) eta
                                - 2 posizioko zutabean nota (auzaz lortua)            */

// Taulatik abiatuta, notak bilduko dituen zenbakien arraya eskuratu eta eragiketa aritmetikoak
// burutu. Suspendituen notak inkrementatu. Ikasle baten izena/abizena bilatu eta nota berri bat gorde.
// Suspendituen notak inkrementatu, ikasle baten izena bilatu eta nota berri bat gorde.

#include <stdio.h>
#include <string.h>   // strcmp() funtziorako
#include <stdlib.h>   // srand() eta rand() funtzioetarako
#include <time.h>     // time() funtziorako

#define BEHEMUGA 0
#define GOIMUGA 39

typedef char tsKatea[21];               // 20+1 karaktereko katea (indizea 0tik 20ra)
typedef float tafNotak[GOIMUGA];        // 40 elementuko arraya (indizea 0tik 39ra)
typedef tsKatea tasDatuak[GOIMUGA][3];  // 40x3 elementuko taula (indizeak 0tik 39ra eta 0tik 2ra)


void DatuakLortu(tasDatuak asDatuak, int *iLuzera);
void DatuakIkusi(const tasDatuak asDatuak, int iLuzera);
void NotakLortu(const tasDatuak asDatuak,
                tafNotak afNotak,
                int iLuzera);
float fnfBatezbestekoaKalkulatu(const tafNotak afNotak, int iLuzera);
void NotakIkusi(const tafNotak afNotak, int iLuzera);
void NotakInkrementatu(tafNotak afNotak, int iLuzera);
int fniIkasleaBilatu(const tasDatuak asDatuak,
                     int iLuzera,
                     const tsKatea sGakoIzen,
                     const tsKatea sGakoAbizen);
void DatuenTaulaEguneratu(tasDatuak asDatuak,
                          float fNotaBerria,
                          int iPosizioa);

int main()
{
    tafNotak afNotak;
    tasDatuak asDatuak;
    int iLuzera;
    tsKatea sGakoIzen;
    tsKatea sGakoAbizen;
    int iPosizioa;
    float fBBA;


    DatuakLortu(asDatuak, &iLuzera);
    DatuakIkusi(asDatuak, iLuzera);

    NotakLortu(asDatuak, afNotak, iLuzera);
    NotakIkusi(afNotak, iLuzera);

    printf("Suspendituak inkrementatzen...\n");
    NotakInkrementatu(afNotak, iLuzera);
    NotakIkusi(afNotak, iLuzera);
    fBBA = fnfBatezbestekoaKalkulatu(afNotak, iLuzera);
    printf("Nota guztien media: %.3f\n\n", fBBA);

    printf("Ikasle baten nota aldatu\n");
    printf("Ikaslearen izena eman: ");
    scanf("%s", sGakoIzen);
    printf("Ikaslearen abizena eman: ");
    scanf("%s", sGakoAbizen);

    iPosizioa = fniIkasleaBilatu(asDatuak, iLuzera, sGakoIzen, sGakoAbizen);

    if (iPosizioa == -1)
        printf("'%s %s' ikaslerik ez dago\n", sGakoIzen, sGakoAbizen);
    else
    {
        printf("Nota berria eman: ");
        scanf("%f", &afNotak[iPosizioa]);
        printf("\n'%s %s' ikaslearen nota aldatu ondoren\n", sGakoIzen, sGakoAbizen);
        NotakIkusi(afNotak, iLuzera);
        DatuenTaulaEguneratu(asDatuak, afNotak[iPosizioa], iPosizioa);
        printf("\nTaula '%s %s' ikaslearen nota aldatu ondoren\n", sGakoIzen, sGakoAbizen);
        DatuakIkusi(asDatuak, iLuzera);
    }

    return 0;
}


void DatuakLortu(tasDatuak asDatuak, int *iLuzera)
{
    int iKont;
    float fNotaBat;
    tsKatea sNotaBat;

    do
    {
        printf("Zenbat ikasle dira? ");
        scanf("%d", iLuzera);
        fflush(stdin);
    } while (*iLuzera <= BEHEMUGA || *iLuzera > GOIMUGA);

    printf("\nDatuen arrayan %d posizio gordetzen...\n\n", *iLuzera);
    srand(time(NULL));  // ausazko zenbakiak sortzeko
    for (iKont = BEHEMUGA; iKont < *iLuzera; iKont++)
    {
        printf("Eman %02d posizioko izena: ", iKont);
        gets(asDatuak[iKont][0]);
        printf("Eman %02d posizioko abizena: ", iKont);
        gets(asDatuak[iKont][1]);
        fNotaBat = (rand() / (float)RAND_MAX) * 10;  // 0.0 eta 9.999 arteko balioak
        sprintf(sNotaBat, "%.4f", fNotaBat);
        strcpy(asDatuak[iKont][2], sNotaBat);
        printf("%02d posizioko ikaslearen nota: %s\n", iKont, asDatuak[iKont][2]);
    }
    printf("\n");
}


void DatuakIkusi(const tasDatuak asDatuak, int iLuzera)
{
    int iKont;

    printf("\nDatuen arrayaren edukia:\n");
    for (iKont = BEHEMUGA; iKont < iLuzera; iKont++)
        printf("%2d posizioko ikaslea = %s, %s --- %s\n", iKont, asDatuak[iKont][0], asDatuak[iKont][1], asDatuak[iKont][2]);
    printf("\n");
}


void NotakLortu(const tasDatuak asDatuak, tafNotak afNotak, int iLuzera)
{
    int iKont;

    printf("Noten arrayan %d datu gordetzen...\n", iLuzera);
    for (iKont = BEHEMUGA; iKont <= iLuzera; iKont++)
        afNotak[iKont] = atof(asDatuak[iKont][2]);  // 0.0 eta 9.999 arteko balio erreala
}


void NotakIkusi(const tafNotak afNotak, int iLuzera)
{
    int iKont;

    printf("Noten arrayaren edukia:\n");
    for (iKont = BEHEMUGA; iKont < iLuzera; iKont++)
        printf("%2d. nota = %.3f\n", iKont, afNotak[iKont]);
    printf("\n");
}


float fnfBatezbestekoaKalkulatu(const tafNotak afNotak, int iLuzera)
{
    int iKont;
    float rMetatua = 0.0;

    for (iKont = BEHEMUGA; iKont <= iLuzera; iKont++)
        rMetatua += afNotak[iKont];

    return rMetatua / iLuzera;
}


void NotakInkrementatu(tafNotak afNotak, int iLuzera)
{
    int iKont;

    for (iKont = BEHEMUGA; iKont < iLuzera; iKont++)
        if (afNotak[iKont] < 5.0)
            afNotak[iKont] += 1.0;
    printf("\n");
}


int fniIkasleaBilatu(const tasDatuak asDatuak, int iLuzera, const tsKatea sGakoIzen, const tsKatea sGakoAbizen)
{
    int iKont;

    for (iKont = BEHEMUGA; iKont < iLuzera; iKont++)
        if ((strcmp(asDatuak[iKont][0], sGakoIzen) == 0) &&
            (strcmp(asDatuak[iKont][1], sGakoAbizen) == 0))
            return iKont;

    return -1;  // Ikaslerik ez bada aurkitzen
}


void DatuenTaulaEguneratu(tasDatuak asDatuak, float fNotaBerria, int iPosizioa)
{
    sprintf(asDatuak[iPosizioa][2], "%.4f", fNotaBerria);
}

---

Ariketa-65_KateenTaula.cbp | main.c

 

Ariketa 64 | Bi array paralelo

ZER DAKIDAN: Arrayak ezagutzen ditut. ZER IKASIKO DUDAN: Kateen array baten eta zenbaki errealen array baten ariketa bat programatuko dut. Ariketa hau hobeto programatzen da laster ikusiko den erregistroen (edo struct datu-mota) array bat erabiliz.

Array batean ikasleen izenak ditugu eta beste array batean ikasleen notak gorderik daude. asIzenak arraya karaktere-kateak biltegitzen ditu, eta arNotak arrayak zenbaki errealak jasoko ditu. 

Array biren arteko lotura posizioetan datza, hau da, array baten lehen posizioko informazioa elkarturik dago beste arrrayaren lehen posizioko informazioarekin, eta horrela posizio guztiekin. Noski, luzera efektiboa bera delako, array bientzat lan egiten duen iLuzera aldagai bakarra erabiliko dugu. 

Adibidez:

asIzenak  0   'Klara'  1    'Pedro'   2    'Igone'   3   4   ...   39

iLuzera=3

arNotak  0   6.77  1     4.35   2    9.25   3   4   ...   39

/* Ariketa-64_BiArrayParalelo: bi array sortuko dira, bat izenekin teklatua erabiliz
                               eta bestea auzaz lortiriko zenbaki errealez osaturik. */

// Suspendituen notak inkrementatu, ikasle baten izena bilatu eta nota berri bat gorde.
// Ariketa hau erregistroen array baten kasuaren sarrera-adibidea izan daiteke.

#include <stdio.h>
#include <string.h>   // strcmp() funtziorako
#include <stdlib.h>   // srand() eta rand() funtzioetarako
#include <time.h>     // time() funtziorako

#define BEHEMUGA 0
#define GOIMUGA 39
#define MAXIMOA 30+1  // 30 karaktere gehi null mugatzailea

typedef char tsKatea[MAXIMOA];
typedef float tafNotak[GOIMUGA];
typedef tsKatea tasIzenak[GOIMUGA];


void IzenakLortu(tasIzenak asIzenak, int *iLuzera);
void NotakLortu(tafNotak afNotak, int iLuzera);
void IzenakIkusi(const tasIzenak asIzenak, int iLuzera);
void NotakIkusi(const tafNotak afNotak, int iLuzera);
void NotakInkrementatu(tafNotak afNotak, int iLuzera);
int fniIkasleaBilatu(const tasIzenak asIzenak, int iLuzera, const char *sGakoa);


int main()
{
    tafNotak afNotak;
    tasIzenak asIzenak;
    int iLuzera;
    char sGakoa[MAXIMOA];
    int iPosizioa;

    IzenakLortu(asIzenak, &iLuzera);
    IzenakIkusi(asIzenak, iLuzera);

    NotakLortu(afNotak, iLuzera);
    NotakIkusi(afNotak, iLuzera);

    printf("Suspendituak inkrementatzen...\n");
    NotakInkrementatu(afNotak, iLuzera);
    NotakIkusi(afNotak, iLuzera);

    printf("Ikasle baten nota aldatu\n");
    printf("Ikaslearen izena eman: ");
    scanf("%s", sGakoa);

    iPosizioa = fniIkasleaBilatu(asIzenak, iLuzera, sGakoa);

    if (iPosizioa == -1)
        printf("'%s' izena duen ikaslerik ez dago\n", sGakoa);
    else
    {
        printf("Nota berria eman: ");
        scanf("%f", &afNotak[iPosizioa]);
        printf("\n'%s' ikaslearen nota aldatu ondoren\n", sGakoa);
        NotakIkusi(afNotak, iLuzera);
    }

    return 0;
}


void IzenakLortu(tasIzenak asIzenak, int *iLuzera)
{
    int iKont;

    do
    {
        printf("Zenbat ikasle dira? ");
        scanf("%d", iLuzera);
    } while (*iLuzera <= BEHEMUGA || *iLuzera > GOIMUGA);

    printf("\nIzenen arrayan %d datu gordetzen\n", *iLuzera);
    for (iKont = BEHEMUGA; iKont < *iLuzera; iKont++)
    {
        printf("Eman %d. izena: ", iKont);
        scanf("%s", asIzenak[iKont]);
    }
}


void NotakLortu(tafNotak afNotak, int iLuzera)
{
    int iKont;

    printf("Noten arrayan %d datu gordetzen\n", iLuzera);
    srand(time(NULL));  // ausazko zenbakiak sortzeko
    for (iKont = BEHEMUGA; iKont <= iLuzera; iKont++)
        afNotak[iKont] = (rand() / (float)RAND_MAX) * 10;  // 0.0 eta 9.999 arteko balioak
}


void IzenakIkusi(const tasIzenak asIzenak, int iLuzera)
{
    int iKont;

    printf("\nIzenen arrayaren edukia:\n");
    for (iKont = BEHEMUGA; iKont < iLuzera; iKont++)
        printf("%2d. ikaslea = %s\n", iKont, asIzenak[iKont]);
    printf("\n");
}


void NotakIkusi(const tafNotak afNotak, int iLuzera)
{
    int iKont;

    printf("Noten arrayaren edukia:\n");
    for (iKont = BEHEMUGA; iKont < iLuzera; iKont++)
        printf("%2d. nota = %.3f\n", iKont, afNotak[iKont]);
    printf("\n");
}


void NotakInkrementatu(tafNotak afNotak, int iLuzera)
{
    int iKont;

    for (iKont = BEHEMUGA; iKont < iLuzera; iKont++)
        if (afNotak[iKont] < 5.0)
            afNotak[iKont] += 1.0;
    printf("\n");
}


int fniIkasleaBilatu(const tasIzenak asIzenak, int iLuzera, const char *sGakoa)
{
    int iKont;

    for (iKont = BEHEMUGA; iKont < iLuzera; iKont++)
        if (strcmp(asIzenak[iKont], sGakoa) == 0)
            return iKont;

    return -1;  // Ikaslerik ez bada aurkitzen
}

---

Ariketa-64_BiArrayParalelo.cbp | main.c

 

Ariketa 63 | Eratostenes-en bahea (I)

ZER DAKIDAN: Arrayak ezagutzen ditut. ZER IKASIKO DUDAN: Zenbaki osoen bi dimentsiotako array baten ariketa bat programatuko dut emaniko algoritmoa jarraituz. Ariketa hau hobeto programatzen da laster ikusiko den erregistroen (edo struct datu-mota) array bat erabiliz.

Galbahe (edo bahe) baten irudia. Galbaheri esker aleak sailka daitezkeen bezala, zenbaki zerrenda bati galbahe logikoren bat aplikatuz zenbakien segida desberdinak lor daitezke, adibidez: zenbaki lehenak identifikatzeko Eratostenes matematikari greziarrak asmatutakoa

Ariketa honi bi modutan ekingo diogu:

• Ariketa 63 | Eratostenes-en bahea (I) zenbaki osoen bi dimentsiotako array bat erabiliz
• Ariketa 69 | Eratostenes-en bahea (II) erregistroen dimentsio bakarreko array bat erabiliz

Eratostenes (antzinako grezieraz: Ἐρατοσθένης; K.a. 276 inguru - K.a. 195 inguru) matematikari, geografo, kirolari, poeta eta astronomo greziarra izan zen. Alexandriako Liburutegia famatuaren zuzendari izendatu zuten eta aurkikuntza ugari egin zituen, hala nola, latitude eta longitude sistema. Eratostenes ezaguna da Lurraren zirkunferentzia kalkulatzen lehen greziarra izan zelako, baita Lurraren ardatzak duen makurdura. Bestalde, garaiko ezagutza geografikoaren araberako mundu mapa eratu zuen ere.

 

Eratostenes-en bahea zenbaki lehenak aurkitzeko algoritmo bat da, emandako n zenbaki arrunt bat baino txikiagoak direnen artean.

Lehendabizi, taula bat egiten da 2 eta n arteko zenbaki arruntekin, jarraian multiploak markatzen dira hurrengo ordena jarraituz:

• 2tik hasita, haren multiplo guztiak markatzen dira, ostean, hurrengo zenbakiarekin jarraituko da baina bi egoera daude:
• Hurrengo zenbakia markaturik gabe dago, adibidez 3 zenbakia, eta lehen bezala bere multiplo guztiak markatzen dira
• Hurrengo zenbakia markaturik dago, adibidez 4 zenbakia, kasu honetan ez da ezer markatzen eta bere hurrengo zenbakia hartzen da
• 5ekin markatu beharko litzateke (goiko lehen kasua), 6kin ez litzateke ezer markatuko (goiko bigarren kasua), 7ekin markatu beharko litzateke (goiko lehen kasua), 8, 9 eta 10ekin ez litzateke ezer markatuko (goiko bigarren kasuak), e.a.
  Prozedura errepikatzen da hau betetzen den bitartean: (MarkatuGabekoZenbakia)² < n. Beste modu batez esanik, markatu gabeko zenbakiaren karratua n baino handiagoa denean eten prozesu errepikakorra

Eratostenes-en bahearen animazioa 120 baino gutxiagoko zenbaki lehenentzat:

SKopp at German Wikipedia, CC BY-SA 3.0, via Wikimedia Commons

Hona hemen datu-taularen irudia MAX konstanteak 21 balio duenean, non 0 markak zenbaki lehen adierazten duen eta 1 markak zenbaki zatigarri adierazten duen:

1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20	21	zenbakia
2	0	0	1	0	1	0	1	1	1	0	1	0	1	1	1	0	1	0	1	1	marka
	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20	21

/* Ariketa-63_EratostenesenBahea-1 */

/*
   Muga den kopuru arrunta emanez, muga hori baino txikiagoak diren
   "Zenbaki Lehenak" lortzeko metodo bat aurkitu zuen Eratostenesek.

   Algoritmoa:
   ----------
   2tik iMuga-rako zenbakiak zerrenda batean jartzen dira. Lehenengo, 2ren
   multiplo guztiak markatzen dira, eta 2 zenbakia emaitza den lehenen
   zerrendari gehituko zaio. Ondoren, 3ren multiplo guztiak markatuko dira,
   eta 3 zenbakia gehituko zaio lehenen zerrendari. Gero, 4ari begiratzen
   zaio, markatuta dagoela ikusten da, eta horrek esan nahi du 2rekin
   zatigarria dela, eta, beraz, ez da lehena. Ondoren, 5era iristen da;
   markatuta ez dagoenez, lehena da, bere multiplo guztiak markatzen dira
   eta lehenen zerrendara gehituko da.
   Prozesu errepikakorra bukatzeko baldintza: Une jakin batean aztertuko den
   zenbakiaren karratua iMuga-tik beherakoa bada, jarraitu beharra dago.
   Bestela, algoritmoa amaitu egiten da, eta markatu gabe geratu diren
   guztiak zenbaki lehenak dira (emaitza-zerrendari gehitu beharrekoak).

   Animazio hau ikusi:
   https://upload.wikimedia.org/wikipedia/commons/b/b9/Sieve_of_Eratosthenes_animation.gif

   Bi programa hauek aztertu:
      * Ariketa-63_EratostenesenBahea-1 zenbaki osoen bi dimentsiotako arraya
      * Ariketa-69_EratostenesenBahea_2 erregistroen dimentsio bakarreko arraya
*/

#include <stdio.h>

#define MAX 120

typedef int taiDatuak[2][MAX + 1];   // 2 errenkada eta MAX+1 zutabe
typedef int taiLehenak[MAX];         // zenbaki lehenak gordetzeko arraya

void DatuakLortu(taiDatuak aiDatuak, int *iLuzeraDatuak);
void DatuakIkusi(const taiDatuak aiDatuak, int iLuzeraDatuak);
void LehenakLortu(const taiDatuak aiDatuak, int iLuzeraDatuak, taiLehenak aiLehenak, int *iLuzeraLehenak);
void LehenakIkusi(const taiLehenak aiLehenak, int iLuzeraLehenak);


int main()
{
    taiDatuak aiDatuak;
    int iLuzeraDatuak;
    taiLehenak aiLehenak;
    int iLuzeraLehenak;
    int iIterazioa = 2;

    DatuakLortu(aiDatuak, &iLuzeraDatuak);
    printf("\nHasierako datuak:\n");
    DatuakIkusi(aiDatuak, iLuzeraDatuak);
    printf("\n1 zenbakia alde batera utzirik, prozesu errepikakorra 2 zenbakiarekin hasiko da\n\n");

    do
    {
        printf("================================================================================\n");
        if (aiDatuak[1][iIterazioa] == 0)
        {
            printf("%d zenbakia lehena da, ", iIterazioa);
            printf("%d zenbakiaren multiploak markatzen...\n", iIterazioa);
            for (int k = iIterazioa + 1; k <= MAX; k++)
            {
                if (aiDatuak[0][k] % iIterazioa == 0)
                {
                    aiDatuak[1][k] = 1;  // Es divisible, marca con 1
                    printf("%4d zenbakia markaturik zatigarria delako\n", aiDatuak[0][k]);
                }
            }
        }
        else
        {
            printf("%d zenbakia zatigarria da\n", iIterazioa);
        }

        printf("%d arteko datuak:\n", iIterazioa);
        DatuakIkusi(aiDatuak, iLuzeraDatuak);
        printf("================================================================================\n");

        iIterazioa++;
        if (iIterazioa * iIterazioa <= MAX)
        {
            printf(" %d x %d = %d <= %d   prozesu errepikakorrarekin jarraitu\n",
                   iIterazioa, iIterazioa, iIterazioa * iIterazioa, MAX);
        }
        else
        {
            printf(" %d x %d = %d > %d   prozesu errepikakorra amaitu\n",
                   iIterazioa, iIterazioa, iIterazioa * iIterazioa, MAX);
        }
        printf("\n\n");
    } while (iIterazioa * iIterazioa <= MAX);

    LehenakLortu(aiDatuak, iLuzeraDatuak, aiLehenak, &iLuzeraLehenak);
    printf("Lehenen zerrenda:\n");
    LehenakIkusi(aiLehenak, iLuzeraLehenak);

    printf("\n\nENTER sakatu exekuzioa amaitzeko... ");
    getchar(); // itxaron ENTER sakatu arte
    return 0;
}


void DatuakLortu(taiDatuak aiDatuak, int *iLuzeraDatuak)
{
    *iLuzeraDatuak = MAX;
    for (int k = 2; k <= *iLuzeraDatuak; k++)
    {
        aiDatuak[0][k] = k;
        aiDatuak[1][k] = 0;  // 0 (FALSE) lehena, 1 (TRUE) zatigarria
    }
}

void DatuakIkusi(const taiDatuak aiDatuak, int iLuzeraDatuak)
{
    int iKont_0 = 1;  // 1 lehena da, ez da prozesatzen
    int iKont_1 = 0;  // zatigarrien kontagailua

    printf("--------------------------------------------------------------------------------\n");
    printf("   1-LEHEN");
    for (int k = 2; k <= iLuzeraDatuak; k++)
    {
        printf("%4d", aiDatuak[0][k]);
        if (aiDatuak[1][k] == 0)
        {
            printf("-LEHEN");
            iKont_0++;
        } else
        {
            printf("__ZAT.");
            iKont_1++;
        }
    }
    printf("\n--------------------------------------------------------------------------------\n");
    printf(" Zenbakien kopurua = %d     Lehenen kopurua = %d     Zatigarrien kopurua = %d\n",
           iLuzeraDatuak, iKont_0, iKont_1);
}


void LehenakLortu(const taiDatuak aiDatuak, int iLuzeraDatuak, taiLehenak aiLehenak, int *iLuzeraLehenak)
{
    *iLuzeraLehenak = 1;
    aiLehenak[*iLuzeraLehenak] = 1;

    for (int k = 2; k <= iLuzeraDatuak; k++)
    {
        if (aiDatuak[1][k] == 0)
        {
            (*iLuzeraLehenak)++;
            aiLehenak[*iLuzeraLehenak] = aiDatuak[0][k];
        }
    }
}


void LehenakIkusi(const taiLehenak aiLehenak, int iLuzeraLehenak)
{
    printf("********************************************************************************\n");
    for (int k = 1; k <= iLuzeraLehenak; k++)
    {
        printf("%3d, ", aiLehenak[k]);
    }
    printf("\n********************************************************************************\n");
    printf("  iLuzeraLehenak = %d\n", iLuzeraLehenak);
}

---

Ariketa-63_EratostenesenBahea-1.cbp | main.c

 

Ariketa 62 | Zortearen Zenbakien Segida

ZER DAKIDAN: Arrayak ezagutzen ditut. ZER IKASIKO DUDAN: Zenbaki osoen array baten ariketa bat programatuko dut emaniko algoritmoa jarraituz.

Galbahe (edo bahe) baten irudia. Galbaheri esker aleak sailka daitezkeen bezala, zenbaki zerrenda bati galbahe logikoren bat aplikatuz zenbakien segida desberdinak lor daitezke, adibidez: "Zortearen Zenbakien Segida" delakoa

Galbahe (edo bahe) baten aplikatzearen aditza bahetu da. Artikulu honetan Zortearen Zenbakien Segida lortuko dugu baina ikusi ere 10. astea | Eratostenesen bahea (I) eta 11. astea | Eratostenesen bahea (II) artikuluak non zenbaki lehenak lantzen diren.

Zortearen Zenbakien Segida eskuratzeko zenbaki arruntei galbahe jakin bat aplikatuko zaie. Zenbaki arrunten zerrenda batean Zortearen Zenbakiak identifikatzeko, zenbakien posizioak aintzat hartuko dira bahetze prozesuan. Cuaderno de Cultura Científica web guneneko artikulu hau ikusi: Los números de la suerte.

Demagun 1etik hasita eta 99 arteko Zortearen Zenbakiak lortu nahi ditugula. Programaren irteerak aztertuz algoritmoa asma dezagun.

Hasierako datuek jarraian erakusten den zerrenda osatzen dute, hots, 1 eta 99 arteko zenbaki arruntek (biak barne) osatzen duten zerrenda:

1 eta 99 arteko zenbaki arruntak behin baino gehiagotan bahetuz Zortearen Zenbakiak lortuko ditugu. Zerrenda hau gordetzeko aiDatuak arraya erabil daiteke

Zerrenda horretako Zortearen Zenbakiak lor ditzagun urratsez-urrats...

Prozesu arrepikakor guztiek bezala, hasieraketa bat egin beharko da. Kasu honetan, repeat-until (edo while-do) agindura sartu aurretik zenbaki bikoitiak kenduko dira hasierako zerrendatik. Lehen bahetze jardun horren arabera emaitza-zerrenda hau osatuko da:

aiDatuak hasierako arraytik abiatuta aiEmaitza array hau lortzen da repeat-until (edo while-do) agindutik kanpo

Algoritmoaren oinarria Bi array izango ditugu aiDatuak arraya eta aiEmaitza arraya, une jakin bateko aiDatuak arrayari bahetze prozesua aplikatuz lortuko da une horri dagokion aiEmaitza arraya. Baina baheketa desberdinak behar direnez, baheketak errepikatu beharko dira (repeat-until edo while-do aginduaren bat beharko da). Prozesu errepikorraren aginduaren hasieran aiDatuak arraya aldatuko dugu eta bere balio berriak aurreko aiEmaitza arrayarenak izango dira, begiztaren barnean aiEmaitza arraya berkalkulatuko dugu. Iterazio batetik bestera, joku hau egingo dugu: n iterazio jakin batean lortu dugun aiEmaitza emaitza, n+1 iterazioan aiDatuak datua izango da eta honi esker aiEmaitza emaitza berria kalkulatuko dugu.

Prozesu errepikakorraren barnean, iIterazioa aldagaiak 2 balio du eta horren arabera, uneko aiDatuak arrayaren bigarren posizioko elementuaren balioa hartu behar da (ikusten denez, balio hori 3 da) eta 3., 6., 9. e.a. posizioko elementuak bahetuz aiEmaitza array berria lortuko da:

2. iterazioaren balioa 3 da, horregatik 3 posizioko jauziak egingo dira. Horrela: 3. posizioko 5 balioa kendu,
6. posizioko 11 balioa kendu, 9. posizioko 17 balioa kendu, 12. posizioko 23 balioa kendu, eta abar

2. iterazioa amaitzean uneko zerrendak 34 elementu izango ditu. Arraya hau izango litzateke non arrayaren 0 posizioa ez den erabiltzen:

?	1	3	7	9	13	15	19	21	25	27	31	33	37	39	43	45	49	51	55	57	61	63	67	69	...	99
0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20	21	22	23	24	...	34

iIterazioa aldagaiak 3 balio du eta horren arabera, uneko aiDatuak arrayaren hirugarren posizioko elementuaren balioa hartu behar da (ikusten denez, balio hori 7 da) eta zazpiko jauziak egingo dira 7., 14., 21. eta 28. posizioko elementuak bahetuz aiEmaitza array berria lortzeko:

3. iterazioaren balioa 7 da, horregatik 7 posizioko jauziak egingo dira. Horrela: 7. posizioko 19 balioa kendu,
14. posizioko 39 balioa kendu, 21. posizioko 61 balioa kendu eta 28. posizioko 81 balioa kendu

3. iterazioa amaitzean uneko zerrendak 30 elementu izango ditu. Arraya hau izango litzateke non arrayaren 0 posizioa ez den erabiltzen:

?	1	3	7	9	13	15	21	25	27	31	33	37	43	45	49	51	55	57	63	67	69	73	75	79	...	99
0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20	21	22	23	24	...	30

iIterazioa aldagaiak 4 balio du eta horren arabera, uneko aiDatuak arrayaren laugarren posizioko elementuaren balioa hartu behar da (ikusten denez, balio hori 9 da) eta bederatziko jauziak egingo dira 9., 18. eta 27. posizioko elementuak bahetuz aiEmaitza array berria lortzeko:

4. iterazioaren balioa 9 da, horregatik 9 posizioko jauziak egingo dira. Horrela: 9. posizioko 27 balioa kendu,
18. posizioko 57 balioa kendu eta 27. posizioko 91 balioa kendu

4. iterazioa amaitzean uneko zerrendak 27 elementu izango ditu. Arraya hau izango litzateke non arrayaren 0 posizioa ez den erabiltzen:

?	1	3	7	9	13	15	21	25	31	33	37	43	45	49	51	55	63	67	69	73	75	79	85	87	...	99
0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20	21	22	23	24	...	27

iIterazioa aldagaiak 5 balio du eta horren arabera, uneko aiDatuak arrayaren bosgarren posizioko elementuaren balioa hartu behar da (ikusten denez, balio hori 13 da) eta hamahiruko jauziak egingo dira 13. eta 26. posizioko elementuak bahetuz aiEmaitza array berria lortzeko:

5. iterazioaren balioa 13 da, horregatik 13 posizioko bi jauzi egingo dira.
Horrela: 13. posizioko 45 balioa kendu eta 26. posizioko 97 balioa kendu

5. iterazioa amaitzean uneko zerrendak 25 elementu izango ditu. Arraya hau izango litzateke non arrayaren 0 posizioa ez den erabiltzen:

?	1	3	7	9	13	15	21	25	31	33	37	43	49	51	55	63	67	69	73	75	79	85	87	93	99
0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20	21	22	23	24	25

iIterazioa aldagaiak 6 balio du eta horren arabera, uneko aiDatuak arrayaren seigarren posizioko elementuaren balioa hartu behar da (ikusten denez, balio hori 15 da) eta hamabosteko jauziak egingo dira 15. posizioko elementu bakarra bahetuz aiEmaitza array berria lortzeko:

6. iterazioaren balioa 15 da, horregatik 15 posizioko jauziak egingo dira.
Baina, 15. posizioko 55 balioa kendu ostean gehiagorik ezingo da kendu

6. iterazioa amaitzean uneko zerrendak 24 elementu izango ditu. Arraya hau izango litzateke non arrayaren 0 posizioa ez den erabiltzen:

?	1	3	7	9	13	15	21	25	31	33	37	43	49	51	63	67	69	73	75	79	85	87	93	99
0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20	21	22	23	24

iIterazioa aldagaiak 7 balio du eta horren arabera, uneko aiDatuak arrayaren zazpigarren posizioko elementuaren balioa hartu behar da (ikusten denez, balio hori 21 da) eta hogeita bateko jauziak egingo dira 21. posizioko elementu bakarra bahetuz aiEmaitza array berria lortzeko:

7. iterazioaren balioa 21 da, horregatik 21 posizioko jauziak egingo dira.
Baina, 21. posizioko 85 balioa kendu ostean gehiagorik ezingo da kendu

7. iterazioa amaitzean uneko zerrendak 23 elementu izango ditu. Arraya hau izango litzateke non arrayaren 0 posizioa ez den erabiltzen:

?	1	3	7	9	13	15	21	25	31	33	37	43	49	51	63	67	69	73	75	79	87	93	99
0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20	21	22	23

Ikusten den bezala, azken zerrendako 1. elementua 1 da, 2. elementua 3 da eta 23. elementua 99 da. Hurrengo iterazioan jauzien neurria 25ekoa da baina zerrendak 23 elementu dituenez ez da 8. iteraziorik izango:

8. iteraziorik ez da izango bere balioa 25 delako eta zerrendaren elementu kopurua 23 delako

Ariketaren balizko kode osoa ikusi:

/* Ariketa-62_ZortearenZenbakienSegida: zenbaki arruntak bahetzen */

//  "Zortearen Zenbakiak" ala "Josephus Flaviusen Baheketa"

//  Zortearen Zenbakien Segida lortzeko zenbaki arruntei galbahe jakin
//  bat aplikatuko zaie. Zortearen Zenbakiak zerrendan identifikatzeko
//  bahetze prozesuan zenbaki arrunten posizioak aintzat hartuko dira.
//  Web gune hau ikusi:

//  https://culturacientifica.com/2024/01/10/los-numeros-de-la-suerte/

#include <stdio.h>

#define MAX 100

void DatuakLortu(int aiDatuak[], int *iLuzeraDatuak);
void ZenbakiakIkusi(int aiZenbakiak[], int iLuzera);


int main()
{
    int aiDatuak[MAX];    // une jakin bateko datuak
    int aiEmaitza[MAX];   // une jakin bateko emaitza
    int iLuzeraDatuak;
    int iLuzeraEmaitza;
    int iIterazioa;
    int k;

    printf("\n\n");

    DatuakLortu(aiDatuak, &iLuzeraDatuak);
    printf("\nHasierako datuak:\n");
    ZenbakiakIkusi(aiDatuak, iLuzeraDatuak);
    printf("iLuzeraDatuak=%d\n\n", iLuzeraDatuak);

    iIterazioa = 2; // lehen baheketan bikoitiak kenduko dira
    printf("1. iterazioa kanpoan, jauzien neurria: %d = aiDatuak[%d]\n", aiDatuak[iIterazioa], iIterazioa);
    iLuzeraEmaitza = 0;

    for (k = 1; k <= iLuzeraDatuak; k++)
    {
        if (k % aiDatuak[iIterazioa] != 0)
        {
            iLuzeraEmaitza++;
            aiEmaitza[iLuzeraEmaitza] = aiDatuak[k];
        }
    }
    ZenbakiakIkusi(aiEmaitza, iLuzeraEmaitza);
    printf("iLuzeraEmaitza=%d\n\n", iLuzeraEmaitza);

    iIterazioa = 2; // bigarren iterazioan 2. posiziokoa eta hurrengoak kentzeko
    do
    {
        for (k = 1; k <= iLuzeraEmaitza; k++)
        {
            aiDatuak[k] = aiEmaitza[k];
        }
        iLuzeraDatuak = iLuzeraEmaitza;

        printf("%d. iterazioan jauzien neurria: %d = aiDatuak[%d]\n", iIterazioa, aiDatuak[iIterazioa], iIterazioa);
        iLuzeraEmaitza = 0;

        for (k = 1; k <= iLuzeraDatuak; k++)
        {
            if (k % aiDatuak[iIterazioa] != 0)
            {
                iLuzeraEmaitza++;
                aiEmaitza[iLuzeraEmaitza] = aiDatuak[k];
            }
            else
            {
                printf("%4d kenduta\n", aiDatuak[k]);
            }
        }

        ZenbakiakIkusi(aiEmaitza, iLuzeraEmaitza);
        printf("iLuzeraEmaitza=%d\n", iLuzeraEmaitza);
        if (iLuzeraEmaitza > 0)
        {
            printf("Hurrengo iterazioaren jauzien neurria: %d\n", aiEmaitza[iIterazioa + 1]);
        }

        printf("\n");
        iIterazioa++;
    } while (iLuzeraDatuak >= aiEmaitza[iIterazioa]);

    printf("\nENTER sakatu exekuzioa amaitzeko... ");
    getchar();

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


// programazioa errazteko arrayaren 0 posizioa ez da erabiliko
void DatuakLortu(int aiDatuak[], int *iLuzeraDatuak)
{
    *iLuzeraDatuak = MAX;
    for (int k = 1; k <= *iLuzeraDatuak; k++)
    {
        aiDatuak[k] = k;
    }
}


void ZenbakiakIkusi(int aiZenbakiak[], int iLuzera)
{
    printf("--------------------------------------------------------------------------------\n");
    for (int k = 1; k <= iLuzera; k++)
    {
        printf("%4d", aiZenbakiak[k]);
    }
    printf("\n--------------------------------------------------------------------------------\n");
}

---

Ariketa-62_ZortearenZenbakienSegida.cbp | main.c