Ohiko deialdia:
Ez-ohiko deialdia:
2025eko Ekainaren deialdiko teoria
Galderei dagozkien programak:
2025eko Ekainaren deialdiko programa: Gorputz-Masaren Indizea
Azterketa ariketari lotutako informazioa. Proiektuak informazioa gordetzen duten bi datu-motako fitxategiak behar ditu:
Hona hemen main.c fitxategiaren kodea, non lehenik liburutegien sartzeak eta konstanteen deklarazioak egiten diren (include zuzentarauari esker eta define zuzentarauari esker, hurrenez hurren), gero estrukturen datu-motak definitzen dira, ondoren funtzioen prototipoak idazten dira eta jarraian main() funtzioa eta gainerako funtzioak garatzen dira:
/*=========================================================================================
Data: 2025eko ekainaren 5a
Deskribapena: Informatika azterketa
2024-25 ikasturteko ohiko deialdia
Bilbo, 2025eko ekainaren 27a
Graduak: - Industria Antolakuntzaren Ingeniaritzako Gradua
- Ingurumen Ingeniaritzako Gradua
Bertsioaren Ezaugarriak:
- "GMI-8_kategoriak.dat" datu-fitxategia aldez aurretik sortuta dago
- "Fundizio_langileak.dat" datu-fitxategia aldez aurretik sortuta dago
===========================================================================================*/
#include <stdio.h>
#include <conio.h> // getche()
#include <string.h>
#define TRUE 1
#define FALSE 0
//Estruktura, datu-mota orokorrak---------------------------------------------------
struct tstHeina
{
float fBehemuga;
float fGoimuga;
};
struct tstKategoria
{
char sKategoriaIzena[30];
struct tstHeina stHeina;
char sGomendioa[128];
};
struct tstLangilea
{
char sIdentif[20];
float fMasa;
float fAltuera;
float fGMI;
char sKategoria[30];
};
//Prototipoak-----------------------------------------------------------------------
char cMenua();
int iFitxategirikBada(const char *sFitxIzen);
void FitxategiArrayKategoriak(const char *sFitxIzenKategoriak,
struct tstKategoria astKategoriak[],
int *iZenbatKategoria);
void ArrayKategoriakErakutsi(const struct tstKategoria astKategoriak[],
int iZenbatKategoria);
void KategoriaBatErakutsi(const struct tstKategoria *stKategoriaBat, int iKont);
void LangileBatenDatuakJaso(struct tstLangilea *stLangileBat);
void LangileBatFitxategiraGehitu(const char *sFitxIzenLangileak,
const struct tstLangilea *stLangileBat);
void GMI_KategoriakKalkulatu(const char *sFitxIzenLangileak,
const struct tstKategoria astKategoriak[],
int iZenbatKategoria);
int GMI_PosizioaLortu(float fGMI_indizea,
const struct tstKategoria astKategoriak[],
int iZenbatKategoria);
int iBilatu(const char *sFitxIzenLangileak,
const char *sIdentifikadorea,
struct tstLangilea *stLangilea);
float fKiloakIrabazi(const struct tstLangilea *stLangileBat,
float fGoikoIndizea);
float fKiloakGaldu(const struct tstLangilea *stLangileBat,
float fBehekoIndizea);
void GMI_KategoriakGarbitu(const char *sFitxIzenLangileak);
void Mezua(const char *sKategorienIzena, int iZenbatKategoria);
void LangileBatErakutsi(const struct tstLangilea *stLangileBat,
int iKont);
void Langileak_FitxategiaIkusi(const char *sFitxIzenLangileak);
//Funtzio nagusia-------------------------------------------------------------------
int main()
{
char sKategorienIzena[20];
char sFitxIzenKategoriak[100];
char sFitxIzenLangileak[100];
char cAukera;
struct tstKategoria astKategoriak[10];
int iZenbatKategoria;
struct tstLangilea stLangileBat;
char sIdentifikadorea[20];
int iPosizioa;
struct tstLangilea stLangilea;
float fKiloak;
float fGoikoIndizea;
float fBehekoIndizea;
printf(" Kategorien fitxategiaren izena (adibidez, 'GMI-8'): ");
gets(sKategorienIzena);
strcpy(sFitxIzenKategoriak, sKategorienIzena);
strcat(sFitxIzenKategoriak, "_kategoriak.dat");
printf(" Langileen fitxategiaren izena (adibidez, 'Fundizio'): ");
gets(sFitxIzenLangileak);
strcat(sFitxIzenLangileak, "_langileak.dat");
if (iFitxategirikBada(sFitxIzenKategoriak) && iFitxategirikBada(sFitxIzenLangileak))
{
FitxategiArrayKategoriak(sFitxIzenKategoriak, astKategoriak, &iZenbatKategoria);
do
{
cAukera = cMenua();
switch (cAukera)
{
case '1': LangileBatenDatuakJaso(&stLangileBat);
LangileBatFitxategiraGehitu(sFitxIzenLangileak, &stLangileBat);
break;
case '2': GMI_KategoriakKalkulatu(sFitxIzenLangileak, astKategoriak, iZenbatKategoria);
break;
case '3': printf("\n Langilearen identifikadorea (025-Xabier adibidez): ");
gets(sIdentifikadorea);
if (iBilatu(sFitxIzenLangileak, sIdentifikadorea, &stLangilea) == FALSE)
printf("\n '%s' identifikadoreko langilerik ez dago!!!\a\n", sIdentifikadorea);
else
{
iPosizioa = GMI_PosizioaLortu(stLangilea.fGMI, astKategoriak, iZenbatKategoria);
printf("\n %s-(r)entzat gomendioa:", sIdentifikadorea);
printf("\n |%s|", astKategoriak[iPosizioa].sGomendioa);
printf("\n |%s|", astKategoriak[iPosizioa].sKategoriaIzena);
printf("\n |%c| da kategoriaren hasiera: ", astKategoriak[iPosizioa].sKategoriaIzena[0]);
if (astKategoriak[iPosizioa].sKategoriaIzena[0] == 'A')
{
printf("ARGALA!");
fGoikoIndizea = astKategoriak[iPosizioa].stHeina.fGoimuga;
fKiloak = fKiloakIrabazi(&stLangilea, fGoikoIndizea);
printf("\n %.2f Kg irabaziz zure GMI '%s' izango da\n", fKiloak, astKategoriak[iPosizioa+1].sKategoriaIzena);
}
else if (astKategoriak[iPosizioa].sKategoriaIzena[0] == '0' ||
astKategoriak[iPosizioa].sKategoriaIzena[0] == 'I')
{
printf("LODIA!");
fBehekoIndizea = astKategoriak[iPosizioa].stHeina.fBehemuga;
fKiloak = fKiloakGaldu(&stLangilea, fBehekoIndizea);
printf("\n %.2f Kg galduz zure GMI '%s' izango da\n", fKiloak, astKategoriak[iPosizioa-1].sKategoriaIzena);
}
else
printf("MASA NORMALA!");
}
break;
case '4': Langileak_FitxategiaIkusi(sFitxIzenLangileak);
break;
case '5': GMI_KategoriakGarbitu(sFitxIzenLangileak);
break;
case '6': Mezua(sKategorienIzena, iZenbatKategoria);
ArrayKategoriakErakutsi(astKategoriak, iZenbatKategoria);
break;
case '0': printf("\nProgramaren amaiera!");
break;
default: printf("\n\aERROREA! aukera hori desegokia da\n");
}
} while (cAukera!='0');
}
else
{
if (iFitxategirikBada(sFitxIzenKategoriak)==FALSE)
printf("\nERROREA! '%s' izeneko fitxategirik ez dago!", sFitxIzenKategoriak);
if (iFitxategirikBada(sFitxIzenLangileak)==FALSE)
printf("\nERROREA! '%s' izeneko fitxategirik ez dago!", sFitxIzenLangileak);
}
printf("\n\n");
return 0;
}
//Funtzioak-------------------------------------------------------------------------
char cMenua()
{
char cAukera;
printf("\n =============================================================");
printf("\n | PROGRAMAREN MENUA |");
printf("\n =============================================================");
printf("\n | 1. Langile berri baten datuak gehitu |");
printf("\n | 2. Langile guztientzat kategoriak kalkulatu |");
printf("\n | 3. Langile baten kategoria hobetzeko gomendioa erakutsi |");
printf("\n | 4. Langile guztien datuak pantailaratu |");
printf("\n | 5. Langile guztientzat kategoriak garbitu |");
printf("\n | 6. Kategoriak ikusi |");
printf("\n | 0. Irten |");
printf("\n =============================================================\n");
printf("\t Zure aukera: ");
cAukera = getche();
printf("\n");
return (cAukera);
}
int iFitxategirikBada(const char *sFitxIzen)
{
FILE *erakFitx;
int boBaiBada;
erakFitx=fopen(sFitxIzen,"rb");
if (erakFitx!=NULL)
{
boBaiBada=TRUE;
fclose(erakFitx);
}
else
boBaiBada=FALSE;
return boBaiBada;
}
void FitxategiArrayKategoriak(const char *sFitxIzenKategoriak,
struct tstKategoria astKategoriak[],
int *iZenbatKategoria)
{
FILE *fbKategFitx;
struct tstKategoria stKategoriaBat;
fbKategFitx = fopen(sFitxIzenKategoriak,"rb");
*iZenbatKategoria = -1;
while (fread(&stKategoriaBat, sizeof(stKategoriaBat), 1, fbKategFitx)==1)
{
(*iZenbatKategoria)++;
astKategoriak[*iZenbatKategoria] = stKategoriaBat;
}
(*iZenbatKategoria)++;
fclose(fbKategFitx);
}
/* Langile baten datuak lortu. */
void LangileBatenDatuakJaso(struct tstLangilea *stLangileBat)
{
printf("\n Langilearen identifikadorea eman: ");
gets(stLangileBat->sIdentif);
fflush(stdin);
printf(" Langilearen masa (Kg) eman: ");
scanf("%f", &stLangileBat->fMasa);
printf(" Langilearen altuera (m) eman: ");
scanf("%f", &stLangileBat->fAltuera);
fflush(stdin);
stLangileBat->fGMI = stLangileBat->fMasa / (stLangileBat->fAltuera*stLangileBat->fAltuera);
strcpy(stLangileBat->sKategoria, "");
}
void LangileBatFitxategiraGehitu(const char *sFitxIzenLangileak,
const struct tstLangilea *stLangileBat)
{
FILE *fbLangileFitx;
fbLangileFitx = fopen(sFitxIzenLangileak,"r+b");
fseek(fbLangileFitx, 0L, SEEK_END);
fwrite(stLangileBat, sizeof(struct tstLangilea), 1, fbLangileFitx);
fclose(fbLangileFitx);
}
void GMI_KategoriakKalkulatu(const char *sFitxIzenLangileak,
const struct tstKategoria astKategoriak[],
int iZenbatKategoria)
{
FILE *fbLangileFitx;
struct tstLangilea stLangileBat;
int iPosizioa;
fbLangileFitx = fopen(sFitxIzenLangileak,"r+b");
while (fread(&stLangileBat, sizeof(stLangileBat), 1, fbLangileFitx)!=0)
{
iPosizioa = GMI_PosizioaLortu(stLangileBat.fGMI, astKategoriak, iZenbatKategoria);
printf("\niPosizioa = %d Kategoriaren izena: [___%s___]", iPosizioa, astKategoriak[iPosizioa].sKategoriaIzena);
printf("\nAurrera egiteko edozein tekla sakatu...\n" );
getche(); // Itxaroteko
strcpy(stLangileBat.sKategoria, astKategoriak[iPosizioa].sKategoriaIzena);
fseek(fbLangileFitx, -1*(long)sizeof(stLangileBat), SEEK_CUR);
fwrite(&stLangileBat, sizeof(stLangileBat), 1, fbLangileFitx);
fseek(fbLangileFitx, 0L, SEEK_CUR); // Fitxategiko erakuslea eguneratu
}
fclose(fbLangileFitx);
}
int GMI_PosizioaLortu(float fGMI_indizea,
const struct tstKategoria astKategoriak[],
int iZenbatKategoria)
{
int k = 0;
do
{
printf("\nPosizioa lortzeko: k=%d fGMI=%5.2f fBehe=%5.2f fGoi=%5.2f",
k,
fGMI_indizea,
astKategoriak[k].stHeina.fBehemuga,
astKategoriak[k].stHeina.fGoimuga);
k = k + 1;
} while (fGMI_indizea >= astKategoriak[k].stHeina.fBehemuga &&
k < iZenbatKategoria);
return k-1;
}
int iBilatu(const char *sFitxIzenLangileak,
const char *sIdentifikadorea,
struct tstLangilea *stLangilea)
{
FILE *fbLangileFitx;
struct tstLangilea stLangileBat;
fbLangileFitx = fopen(sFitxIzenLangileak,"rb");
while (fread(&stLangileBat, sizeof(stLangileBat), 1, fbLangileFitx)==1)
{
if (strcmp(stLangileBat.sIdentif, sIdentifikadorea)==0)
{
fclose(fbLangileFitx);
*stLangilea = stLangileBat;
return TRUE;
}
}
fclose(fbLangileFitx);
return FALSE;
}
float fKiloakIrabazi(const struct tstLangilea *stLangileBat,
float fGoikoIndizea)
{
float fHelburukoMasa;
float fAkenKiloak;
fHelburukoMasa = fGoikoIndizea*stLangileBat->fAltuera*stLangileBat->fAltuera;
printf("\n (fKiloakIrabazi) fHelburukoMasa=%.2f Kg LangileMasa=%.2f Kg",
fHelburukoMasa,
stLangileBat->fMasa);
fAkenKiloak = fHelburukoMasa - stLangileBat->fMasa; // balio positiboa
return fAkenKiloak;
}
float fKiloakGaldu(const struct tstLangilea *stLangileBat,
float fBehekoIndizea)
{
float fHelburukoMasa;
float fAkenKiloak;
fHelburukoMasa = fBehekoIndizea*stLangileBat->fAltuera*stLangileBat->fAltuera;
printf("\n (fKiloakGaldu) fHelburukoMasa=%.2f Kg LangileMasa=%.2f Kg",
fHelburukoMasa,
stLangileBat->fMasa);
fAkenKiloak = stLangileBat->fMasa - fHelburukoMasa; // balio positiboa
return fAkenKiloak;
}
void GMI_KategoriakGarbitu(const char *sFitxIzenLangileak)
{
FILE *fbLangileFitx;
struct tstLangilea stLangileBat;
fbLangileFitx = fopen(sFitxIzenLangileak, "r+b");
while (fread(&stLangileBat, sizeof(stLangileBat), 1, fbLangileFitx)==1)
{
strcpy(stLangileBat.sKategoria, "");
fseek(fbLangileFitx, -1*(long)sizeof(stLangileBat), SEEK_CUR);
fwrite(&stLangileBat, sizeof(stLangileBat), 1, fbLangileFitx);
fseek(fbLangileFitx, 0L, SEEK_CUR); // Fitxategiko erakuslea eguneratu
}
fclose(fbLangileFitx);
}
/* Langileen fitxategia erakutsi. */
void Langileak_FitxategiaIkusi(const char *sFitxIzenLangileak)
{
FILE *fbLangileFitx;
struct tstLangilea stLangileBat;
int iKont;
fbLangileFitx = fopen(sFitxIzenLangileak, "rb");
iKont = 1;
printf("\n===============================================================================");
printf("\n%20s%11s%10s%10s%21s\n", "Langilea (NAN)", "Masa(Kg)", "Alt.(m)", "G-M Ind", "Kategoriaren izena");
printf(" -------------- -------- ------- ------- ------------------\n");
while (fread(&stLangileBat, sizeof(stLangileBat), 1, fbLangileFitx)==1)
{
LangileBatErakutsi(&stLangileBat, iKont);
iKont++;
}
printf("===============================================================================\n");
fclose(fbLangileFitx);
}
/* Langileen baten datuak pantailaratu. */
void LangileBatErakutsi(const struct tstLangilea *stLangileBat, int iKont)
{
printf("%4d", iKont);
printf(" %-11s", stLangileBat->sIdentif);
printf("%11.2f%10.2f%10.2f", stLangileBat->fMasa,
stLangileBat->fAltuera,
stLangileBat->fGMI);
printf(" %s\n", stLangileBat->sKategoria);
}
void Mezua(const char *sKategorienIzena, int iZenbatKategoria)
{
printf("\n///////////////////////////////////////////////////////////////////////////////");
printf("\n| '%s' kategorien sortan %d tarte daude |", sKategorienIzena, iZenbatKategoria);
printf("\n///////////////////////////////////////////////////////////////////////////////");
printf("\n| Kategoria Heina Gomendioa |");
printf("\n--------------------------- ------------- ---------------------------------\n");
}
void ArrayKategoriakErakutsi(const struct tstKategoria astKategoriak[],
int iZenbatKategoria)
{
int iKont;
for (iKont=0; iKont<iZenbatKategoria; iKont++)
{
KategoriaBatErakutsi(&astKategoriak[iKont], iKont);
}
printf("///////////////////////////////////////////////////////////////////////////////\n");
}
void KategoriaBatErakutsi(const struct tstKategoria *stKategoriaBat, int iKont)
{
char sGomendioZatia[128];
printf("|%3d", iKont);
printf(" %-24s", stKategoriaBat->sKategoriaIzena);
printf("%5.2f - %5.2f", stKategoriaBat->stHeina.fBehemuga,
stKategoriaBat->stHeina.fGoimuga);
strcpy(sGomendioZatia, stKategoriaBat->sGomendioa);
if (strlen(sGomendioZatia) > 30)
{
sGomendioZatia[28] = '.';
sGomendioZatia[29] = '.';
sGomendioZatia[30] = '.';
sGomendioZatia[31] = ' ';
sGomendioZatia[32] = '|';
sGomendioZatia[33] = '\0';
}
else
{
for (int i=strlen(sGomendioZatia); i<33; i++)
sGomendioZatia[i] = ' ';
sGomendioZatia[32] = '|';
sGomendioZatia[33] = '\0';
}
printf(" %-30s\n", sGomendioZatia);
}
GMI indizearen balioak mailakatu egiten dira obesitatearen arabera, eta jakina denez honek lotura estua dauka osasunarekin.
Enpresa bateko langileen obesitate-ikerketa egin nahi da, horretarako obesitatearen kategoria desberdinak fitxategi batean definiturik daude (adibidez, GMI-8_Kategoriak.dat izeneko fitxategian). Fitxategiaren elementuak estrukturak dira eta bakoitzak kategoria baten informazioa gordetzen du. Kategorien fitxategiaren oinarria den tstKategoria estruktura honela definiturik dago:
struct tstHeina
{
float fBehemuga;
float fGoimuga;
};
struct tstKategoria
{
char sKategoriaIzena[30]; // Kategoriaren izena
struct tstHeina stHeina; // Kategoria jakin batetarako GMI indizearen mugak
char sGomendioa[128]; // Osasuna hobetzeko kategoria honi dagokion gomendioa
};
Kategorien fitxategia ordenaturik dago stHeina eremuak duen behe mugaren arabera. Kategorien kopurua ez da finkoa (beraz, fitxategiaren elementuen kopurua ez da finkoa), erabilitako mailaketaren arabera kategorien kopurua aldakorra izan daitekeelako (goiko adibidean elementuak 8 dira). Jakina da kategorien kopurua gehien-gehienez 10 izango dela.
Hau izan daiteke GMI-8_Kategoriak.dat kategorien fitxategian biltzen den informazioa:
 |
| Munduko Osasun Erakundeak 8 kategoriako Gorputz-Masaren Indizeak erabiltzen ditu. |
Enpresako langileen obesitate-ikerketa burutzeko, langileen fitxategia prozesatuko da (adibidez, Langileak.dat izeneko fitxategia). Langileen fitxategiaren elementuak estrukturak dira ere eta tstLangilea estruktura honela definiturik dago:
struct tstLangilea
{
char sIdentif[20]; // Langilearen identifikadorea
float fMasa; // Langilearen masa kilogramoetan
float fAltuera; // Langilearen altuera edo garaiera metroetan.
float fGMI; // Gorpuz-Masaren Indizea da eta bere balioa lortu ahal izateko fMasa eta rfAltuera aintzat hartuko dira
char sKategoria[30]; // GMI indizeari dagokion kategoriaren izena, hasieran hutsik
};
Hau izan daiteke Langileak.dat enpresako fitxategian biltzen den informazioa prozesaketa baino lehen:
 |
| Langileen fitxategiak 12 elementu ditu hasieran eta sKategoria delako azken eremuan kate hutsa dago. |
Programak, hasieran, GMI kategorien fitxategiari dagokion izena eskatu du, eta langileen fitxategiari dagokion izena eskatuko du. Bi fitxategietako bat falta bada, programa amaituko litzateke mezu bat pantailaratuz; bestela, bi fitxategiak badaude, programak aurrera egingo du.
Bi fitxategiak daudela, programaren exekuzioa menu batek gidatuko du. Baina menura sartu aurretik kategorien fitxategiko informazioa array batera irauliko da. Ondoren programaren exekuzioak aurrera egingo du hurrengo menuaren gidaritzapean:
============================================================================= | MENUA | ============================================================================= | 1. Langile berri baten datuak gehitu | | 2. Langile guztientzat kategoria kalkulatu | | 3. Langile baten kategoria hobetzeko gomendioa erakutsi | |---------------------------------------------------------------------------| | 4. Langile guztien datuak erakutsi (2025EKO AZTERKETAN EZ ZEN ESKATU) | | 5. Kategoriak ikusi (2025EKO AZTERKETAN EZ ZEN ESKATU) | |
1. Langile berri baten datuak gehitu
Langile berriaren identifikadorea, masa eta altuera teklatuz eman ondoren, GMI indizea kalkulatzen da eta kate hutsarekin batera, bost datu horiek tstLangilea datu-motako estruktura batean jasotzen dira langileen datu-fitxategiaren amaieran gordetzeko.
Esate baterako, hona hemen hiru datu teklatuz harturik eta beste biak kalkulaturik:
 |
| Langileen fitxategian 016-Jare langilea gehitzean, 12 elementu izatetik 13 elementu izatera igaroko da. |
2. Langile guztien kategoria kalkulatu
Langileen fitxategi osoa prozesatzen da bere elementu guztien sKategoria eremuko kate hutsaren ordez, dagokion GMI indizearen sKategoriaIzena eremuko edukia gordez. Horretarako, Langileen fitxategiaz gain kategorien arraya beharko da.
Hona hemen kategorien kalkulua azaltzen duen irudia, non langilearen GMI indizea 27.62 den eta indize horren sKategoriaIzena eremuko edukia lortzeko arrayaren elementuaren 4 posizioa zehazten den:
 |
| Langile bakoitzeko bere GMI ezagutzen da, eta dagokion kategoriaren izena kategorien array-tik eskura daiteke. |
3. Langile baten kategoria hobetzeko gomendioa erakutsi
Langilearen identifikadorea teklatuz eman ondoren, bere bilaketa bururu behar da langileen fitxategian. Bilaketaren arabera bi egoera izango dira:
- Horrelako identifikadorea duen langilerik ez dago, mezu egoki bat pantailaratu eta menura itzuli.
- Horrelako identifikadorea duen langilearentzat dagokion GMI indizearen izena array-tik eskuratu, eta kate horren lehen karakterea aztertu. Kategoriaren lehen karakterea A bada kiloak irabazi beharko ditu, baina kategoriaren lehen karakterea 0 edo I bada kiloak galdu beharko ditu.
Hona hemen kategoria hobetzeko gomendioa azaltzen duen irudia, non 007-Leire langilearen GMI indizea 16.60 den eta indize horren sKategoriaIzena eremuko edukiaren hasiera A denez kiloak irabazi beharko dituen, zehazki 1.07 kilo:
 |
| Langilearen identifikadorea dugula, argala ala lodia den jakin behar da bere kategoriaren katea aztertuz. Langilearen kategoriako mugak aintzakotzat harturik helburuko kilo kopurua kalkula daiteke. |
4. Langile guztien datuak erakutsi
Menuaren aukera hau ez zen azterketan eskatu. Langile guztien datuak pantailaratzeko langileen fitxategia behar da, adibidez:
 |
| Ikusten denez 016-Jare langilea fitxategiaren bukaeran gehitu da. |
5. Kategoriak ikusi
Menuaren aukera hau ez zen azterketan eskatu. Kategorien datuak pantailaratzeko kategorien fitxategitik abiatuta edo kategorien fitxategitik abiatuta egin daiteke. Edozein kasutan, informazio bera aurkeztuko litzateke pantailan. Adibidez, hau da GMI-6_Kategoriak.dat kategorien fitxategian biltzen den informazioa:
 |
| Munduko Osasun Erakundeak ez bezala, irudiko programak 6 kategorietako banaketa erabiltzen du. |
Bi datu-fitxategiak aldez aurretik sorturik daudela suposatzen da azterketan, kategorien datu-fitxategia eta langileen datu-fitxategia. Bi fitxategiko bat edo beste falta bada, programa bukatuko da. Hona hemen, kategorien datu-fitxategiak sortzeko erabil daitekeen Kategorien_DatuakLortzen proiektuaren main.c fitxategiaren kodea:
/*=========================================================================================
Data: 2025eko ekainaren 5a
Deskribapena: Informatika azterketa
2024-25 ikasturteko ohiko deialdia
Bilbo, 2025eko ekainaren 27a
Graduak: - Industria Antolakuntzaren Ingeniaritzako Gradua
- Ingurumen Ingeniaritzako Gradua
Bertsioaren Ezaugarriak:
- "GMI-5" emanda "GMI-5_kategoriak.dat" datu-fitxategia sortuko da
===========================================================================================*/
#include <stdio.h>
#include <conio.h> // getche()
#include <string.h> // strcpy() eta strcat()
/* Deklarazio orokorra */
struct tstHeina
{
float fBehemuga;
float fGoimuga;
};
struct tstKategoria
{
char sKategoriaIzena[30];
struct tstHeina stHeina;
char sGomendioa[128];
};
/* Prototipoak */
void Kategoriak_FitxategiaSortu(const char *sFitxIzenKategoriak);
void Kategoriak_FitxategiaIkusi(const char *sFitxIzenKategoriak);
void DatuakJaso(struct tstKategoria *stKategoriaBat);
void DatuakErakutsi(const struct tstKategoria *stKategoriaBat);
/* Funtzio nagusia */
int main()
{
char sFitxIzenKategoriak[100];
/* Kategorien fitxategia sortu eta ikusi */
printf("\n Kategorien fitxategiaren izena (adibidez, 'GMI-8'): ");
gets(sFitxIzenKategoriak);
strcat(sFitxIzenKategoriak, "_kategoriak.dat");
//printf(" sFitxIzenKategoriak: '%s'", sFitxIzenKategoriak);
Kategoriak_FitxategiaSortu(sFitxIzenKategoriak);
Kategoriak_FitxategiaIkusi(sFitxIzenKategoriak);
printf("\n Amaitzeko edozein tekla sakatu...\n\n" );
getche(); // Itxaroteko
return 0;
}
/* Kategorien kopurua eskatu eta fitxategia sortu ondoren datuz bete. */
void Kategoriak_FitxategiaSortu(const char *sFitxIzen)
{
FILE *fbErakFitx;
struct tstKategoria stKategoriaBat;
int iKont;
int iZenbatKategoria;
do
{
printf("\nZenbat elementu izango dira (3 eta 8 arteko kopurua): ");
scanf("%d", &iZenbatKategoria);
fflush(stdin);
} while (iZenbatKategoria < 3 || iZenbatKategoria > 8);
fbErakFitx = fopen(sFitxIzen, "wb");
for (iKont=0; iKont<iZenbatKategoria; iKont++)
{
printf("\n%d. kategoriaren datuak eman:", iKont+1);
printf("\n----------------------------");
DatuakJaso(&stKategoriaBat);
fwrite(&stKategoriaBat, sizeof(stKategoriaBat), 1, fbErakFitx);
}
fclose(fbErakFitx);
}
/* Kategoria baten datuak lortu. */
void DatuakJaso(struct tstKategoria *stKategoriaBat)
{
char cAukera;
do
{
printf("\n 1. Argaltasun Larria");
printf("\n 2. Argaltasun Ertaina");
printf("\n 3. Argaltasun Txikia");
printf("\n 4. Masa Normala");
printf("\n 5. 0 Motako Obesitatea");
printf("\n 6. I Motako Obesitatea");
printf("\n 7. II Motako Obesitatea");
printf("\n 8. III Motako Obesitatea");
printf("\n 9. Kategoria berri baten izena");
printf("\n Kategoriaren zenbakia aukeratu: ");
scanf("%c", &cAukera);
fflush(stdin);
} while (cAukera < '1' || cAukera > '9');
switch (cAukera)
{
case '1': strcpy(stKategoriaBat->sKategoriaIzena, "Argaltasun Larria");
break;
case '2': strcpy(stKategoriaBat->sKategoriaIzena, "Argaltasun Ertaina");
break;
case '3': strcpy(stKategoriaBat->sKategoriaIzena, "Argaltasun Txikia");
break;
case '4': strcpy(stKategoriaBat->sKategoriaIzena, "Masa Normala");
break;
case '5': strcpy(stKategoriaBat->sKategoriaIzena, "0 Motako Obesitatea");
break;
case '6': strcpy(stKategoriaBat->sKategoriaIzena, "I Motako Obesitatea");
break;
case '7': strcpy(stKategoriaBat->sKategoriaIzena, "II Motako Obesitatea");
break;
case '8': strcpy(stKategoriaBat->sKategoriaIzena, "III Motako Obesitatea");
break;
case '9': printf("\nKategoria berriaren izena idatzi: ");
gets(stKategoriaBat->sKategoriaIzena);
fflush(stdin);
}
printf("\nKategoriak duen heinaren behemuga eman: ");
scanf("%f", &stKategoriaBat->stHeina.fBehemuga);
fflush(stdin);
printf("Kategoriak duen heinaren goimuga eman: ");
scanf("%f", &stKategoriaBat->stHeina.fGoimuga);
fflush(stdin);
switch (cAukera)
{
case '1': strcpy(stKategoriaBat->sGomendioa, "Dietista-nutrizionista baten laguntza behar duzu");
break;
case '2': strcpy(stKategoriaBat->sGomendioa, "Sarriago jan beharra daukazu eta dieta aldatu");
break;
case '3': strcpy(stKategoriaBat->sGomendioa, "Sarriago jan behar duzu");
break;
case '4': strcpy(stKategoriaBat->sGomendioa, "Ohiturak mantendu");
break;
case '5': strcpy(stKategoriaBat->sGomendioa, "Gutxiago jan");
break;
case '6': strcpy(stKategoriaBat->sGomendioa, "Gutxiago jan eta ariketa gehiago egin");
break;
case '7': strcpy(stKategoriaBat->sGomendioa, "Gutxiago jan eta egunero ariketa egin");
break;
case '8': strcpy(stKategoriaBat->sGomendioa, "Zure medikuaren eta dietistaren laguntza behar duzu");
break;
case '9': printf("\nKategoria berriaren gomendioa idatzi: ");
gets(stKategoriaBat->sGomendioa);
}
}
/* Kategorien fitxategia erakutsi. */
void Kategoriak_FitxategiaIkusi(const char *sFitxIzen)
{
FILE *fbErakFitx;
struct tstKategoria stKategoriaBat;
fbErakFitx = fopen(sFitxIzen, "rb");
printf("\n =============================================================");
while (fread(&stKategoriaBat, sizeof(stKategoriaBat), 1, fbErakFitx)==1)
{
DatuakErakutsi(&stKategoriaBat);
}
printf(" =============================================================\n");
fclose(fbErakFitx);
}
/* Kategorien baten datuak pantailaratu. */
void DatuakErakutsi(const struct tstKategoria *stKategoriaBat)
{
printf("\n%30s%16s%16s\n", "Kategoriaren izena", "Behemuga", "Goimuga");
printf(" ------------------ -------- -------\n");
printf("%30s", stKategoriaBat->sKategoriaIzena);
printf("%16.2f%16.2f", stKategoriaBat->stHeina.fBehemuga,
stKategoriaBat->stHeina.fGoimuga);
printf("\n Gomendioa: %s\n", stKategoriaBat->sGomendioa);
}
ESan bezala, bi datu-fitxategiak (kategorien fitxategia eta langileen fitxategia) aldez aurretik sorturik daudela suposatzen da azterketan. Bi fitxategiko bat edo beste falta bada, programa bukatuko da. Hona hemen, langileen datu-fitxategiak sortzeko erabil daitekeen Langileen_DatuakLortzen proiektuaren main.c fitxategiaren kodea:
/*=========================================================================================
Data: 2025eko ekainaren 5a
Deskribapena: Informatika azterketa
2024-25 ikasturteko ohiko deialdia
Bilbo, 2025eko ekainaren 27a
Graduak: - Industria Antolakuntzaren Ingeniaritzako Gradua
- Ingurumen Ingeniaritzako Gradua
Bertsioaren Ezaugarriak:
- "Fundizio" emanda "Fundizio_langileak.dat" datu-fitxategia sortuko da
===========================================================================================*/
#include <stdio.h>
#include <conio.h> // getche()
#include <string.h> // strcpy() eta strcat()
#include <time.h> // time()
#include <stdlib.h> // rand() eta srand()
/* Deklarazio orokorra */
struct tstLangilea
{
char sIdentif[20];
float fMasa;
float fAltuera;
float fGMI;
char sKategoria[30];
};
struct tstDatua
{
char sIzenNAN[20];
float fKiloak;
float fMetroak;
};
/* Prototipoak */
void Langileak_FitxategiaSortu(const char *sFitxIzenLangileak);
void Langileak_FitxategiaIkusi(const char *sFitxIzenLangileak);
void DatuakJaso(struct tstLangilea *stLangileBat);
void DatuakErakutsi(const struct tstLangilea *stLangileBat, int iKont);
/* Funtzio nagusia */
int main()
{
char sFitxIzenLangileak[100];
/* Langileen fitxategia sortu eta ikusi */
printf("\n Langileen fitxategiaren izena (adibidez, 'Fundizio'): ");
gets(sFitxIzenLangileak);
strcat(sFitxIzenLangileak, "_langileak.dat");
//printf(" sFitxIzenLangileak: '%s'", sFitxIzenLangileak);
Langileak_FitxategiaSortu(sFitxIzenLangileak);
Langileak_FitxategiaIkusi(sFitxIzenLangileak);
printf("\n Amaitzeko edozein tekla sakatu...\n\n" );
getche(); // Itxaroteko
return 0;
}
/* Langileen kopurua eskatu eta fitxategia sortu ondoren datuz bete. */
void Langileak_FitxategiaSortu(const char *sFitxIzen)
{
FILE *fbErakFitx;
struct tstLangilea stLangileBat;
int iKont;
int iZenbatLangile;
int iLehenLangilerenIndizea;
static struct tstDatua astLangileenZerrenda[] =
{
{"001-Luisa" , 55.06 , 1.65} , // 1
{"002-Eva" , 40.50 , 1.72} , // 2
{"003-Carlos" , 60.52 , 1.85} ,
{"004-Janire" , 70.70 , 1.60} ,
{"005-Itsaso" , 57.75 , 1.71} ,
{"006-Jon" , 90.02 , 1.65} ,
{"007-Leire" , 45.75 , 1.66} ,
{"008-Gorka" , 99.73 , 1.62} ,
{"009-Koldo" , 87.99 , 1.59} ,
{"010-Gemma" , 76.70 , 1.55} , // 10
{"011-Manuela" , 45.01 , 1.61} , // 11
{"012-Andoni" , 68.50 , 1.90} , // 12
{"013-Helene" , 37.50 , 1.78} , // 13
{"014-Pedro" , 70.56 , 1.73} ,
{"015-Anne" , 60.51 , 1.65} ,
{"016-Ainoa" , 39.50 , 1.64} ,
{"017-Kepa" , 69.95 , 1.61} ,
{"018-Teresa" , 88.95 , 1.58} ,
{"019-Silvia" , 60.95 , 1.75} ,
{"020-Juan" , 55.11 , 1.77} , // 20
{"021-Marina" , 56.05 , 1.67} , // 21
{"022-Julen" , 80.07 , 1.84} , // 22
{"023-Mario" , 95.80 , 1.54} ,
{"024-Miren" , 41.01 , 1.69} ,
{"025-Xabier" , 59.59 , 1.95} ,
{"026-Iker" , 68.01 , 1.78} ,
{"027-Nuria" , 55.21 , 1.76} ,
{"028-Belen" , 64.99 , 1.58} ,
{"029-Martin" , 80.08 , 1.66} ,
{"030-Patxi" , 79.01 , 1.84} // 30
};
srand(time(NULL));
iZenbatLangile = (rand() % (20 - 10 + 1)) + 10; // 20 eta 10 arteko kopurua
iLehenLangilerenIndizea = rand() % (30 - iZenbatLangile + 1); // hortik hasita jarraian
fbErakFitx = fopen(sFitxIzen, "wb");
//printf("\n iZenbatLangile = %d", iZenbatLangile);
//printf("\niLehenLangilerenIndizea = %d", iLehenLangilerenIndizea);
for (iKont=iLehenLangilerenIndizea; iKont<iLehenLangilerenIndizea+iZenbatLangile; iKont++)
{
//printf("\n%d. Langilearen datuak hartzen:", iKont);
strcpy(stLangileBat.sIdentif, astLangileenZerrenda[iKont].sIzenNAN);
stLangileBat.fMasa = astLangileenZerrenda[iKont].fKiloak;
stLangileBat.fAltuera = astLangileenZerrenda[iKont].fMetroak;
stLangileBat.fGMI = stLangileBat.fMasa / (stLangileBat.fAltuera*stLangileBat.fAltuera);
strcpy(stLangileBat.sKategoria, "");
fwrite(&stLangileBat, sizeof(stLangileBat), 1, fbErakFitx);
}
fclose(fbErakFitx);
}
/* Langileen fitxategia erakutsi. */
void Langileak_FitxategiaIkusi(const char *sFitxIzen)
{
FILE *fbErakFitx;
struct tstLangilea stLangileBat;
int iKont;
fbErakFitx = fopen(sFitxIzen, "rb");
iKont = 1;
printf("\n =====================================================================");
printf("\n%21s%12s%11s%11s%13s\n", "Langilea (NAN)", "Masa(Kg)", "Alt.(m)", " GMI", "Kategoria");
printf(" -------------- -------- ------- ------- ---------\n");
while (fread(&stLangileBat, sizeof(stLangileBat), 1, fbErakFitx)==1)
{
DatuakErakutsi(&stLangileBat, iKont);
iKont++;
}
printf(" =====================================================================\n");
fclose(fbErakFitx);
}
/* Langileen baten datuak pantailaratu. */
void DatuakErakutsi(const struct tstLangilea *stLangileBat, int iKont)
{
printf("%5d", iKont);
printf(" %-12s", stLangileBat->sIdentif);
printf("%12.2f%11.2f%11.2f", stLangileBat->fMasa,
stLangileBat->fAltuera,
stLangileBat->fGMI);
printf(" |%s|\n", stLangileBat->sKategoria);
}
|
2025eko Maiatzaren deialdiko teoria
Galderei dagozkien programak:
2025eko Maiatzaren deialdiko programa: Ur kalitatea
Azterketa ariketari lotutako informazioa. Proiektuak bi fitxategi behar ditu eta bien oinarrizko datu-mota estruktura bera da. Bi fitxategietatik bat aldez aurretik sorturik dagoela suposatzen da. Bi fitxategiak hauek dira:
Hona hemen main.c fitxategiaren kodea, non lehenik liburutegien sartzeak eta konstanteen deklarazioak egiten diren (include zuzentarauari esker eta define zuzentarauari esker, hurrenez hurren), gero estrukturen datu-motak definitzen dira, ondoren funtzioen prototipoak idazten dira eta jarraian main() funtzioa eta gainerako funtzioak garatzen dira:
/*======================================================================================
Data: 2025eko maiatzaren 22a
Deskribapena: Informatika azterketa
2024-25 ikasturteko ohiko deialdia
Bilbo, 2025eko maiatzaren 29a
Graduak: - Industria Antolakuntzaren Ingeniaritzako Gradua
- Ingurumen Ingeniaritzako Gradua
Bertsioaren Ezaugarriak:
- "Neurriak_2025.dat" datu-fitxategia aldez aurretik sortuta dago
- "uuuuhhee" data bat emanda "Neurketak_uuuuhhee.da" datu-fitxategia
aldez aurretik sortuta dagoela frogatu ondoren prozesatu
=======================================================================================*/
#include <stdio.h>
#include <string.h>
#include <conio.h> // getche()
#define iLUZERAMAX 100
#define TRUE 1
#define FALSE 0
//Estruktura, datu-mota orokorra----------------------------------------------------
struct tstEstazioa
{
char sEstazioa[11];
char sData[11];
float fOxigenoa;
float fSolidoak;
float fKutsatzaileak;
float fKOI;
int iKI;
};
//Prototipoak-----------------------------------------------------------------------
char cMenua();
void FitxategitikNeurketakErakutsi(const char *sFitxIzen);
void EstazioBatErakutsi_Errenkada(const struct tstEstazioa *stEstazioBat);
void EstazioBatErakutsi_Zutabea(const struct tstEstazioa *stEstazioBat);
int iFitxategirikBada(const char *sFitxIzen);
int iIndizeakKalkulaturikDaude(const char *sFitxIzen);
void FitxategitikArrayra(const char *sFitxIzen,
struct tstEstazioa astEstazioBat[],
int *iLuz);
void IndizeakKalkulatu(struct tstEstazioa astEstazioBat[], int iLuz);
void ArraytikFitxategira(const char *sFitxIzen,
const struct tstEstazioa astEstazioBat[],
int iLuz);
void KOI_IndizeaKalkulatu(struct tstEstazioa *stEstazioBat);
void KI_IndizeaKalkulatu(struct tstEstazioa *stEstazioBat);
void EgunaGehituHistorikora(const char *sFitxIzen,
const struct tstEstazioa astEstazioBat[],
int iLuz);
int boBilatuIzenezDataz(const char *sFitxIzen,
const char *sEstazioaAztertu,
const char *sDataAztertu,
struct tstEstazioa *stEstazioBat);
struct tstEstazioa stBilatuIzenezDataz(const char *sFitxIzen,
const char *sEstazioaAztertu,
const char *sDataAztertu);
//Funtzio nagusia-------------------------------------------------------------------
int main()
{
char sFitxIzen[100];
char sData[9];
char cAukera;
char sEstazioaAztertu[11];
char sDataAztertu[11];
struct tstEstazioa stEstazioIzenaData;
struct tstEstazioa astEgunBatekoNeurketak[iLUZERAMAX];
int iZenbatNeurketa;
printf("Gaurko eguna eman (uuuuhhee formatuan): ");
gets(sData);
strcpy(sFitxIzen,"Neurketak_");
strcat(sFitxIzen,sData);
strcat(sFitxIzen,".dat");
if (iFitxategirikBada(sFitxIzen))
{
do
{
cAukera = cMenua();
switch (cAukera)
{
case '1': if (iIndizeakKalkulaturikDaude(sFitxIzen)==FALSE)
{
FitxategitikArrayra(sFitxIzen, astEgunBatekoNeurketak, &iZenbatNeurketa);
IndizeakKalkulatu(astEgunBatekoNeurketak, iZenbatNeurketa);
ArraytikFitxategira(sFitxIzen, astEgunBatekoNeurketak, iZenbatNeurketa);
EgunaGehituHistorikora("Neurriak_2025.dat", astEgunBatekoNeurketak, iZenbatNeurketa);
}
else
printf("\n\aKalitate-indizeak kalkulaturik daude dagoeneko!\n");
break;
case '2': FitxategitikNeurketakErakutsi(sFitxIzen);
break;
case '3': FitxategitikNeurketakErakutsi("Neurriak_2025.dat");
printf("Aztertuko den behaketa-estazioaren izena: ");
gets(sEstazioaAztertu);
strcpy(sEstazioaAztertu, strupr(sEstazioaAztertu));
printf("Aztertuko den data (uuuu/hh/ee formatuz): ");
gets(sDataAztertu);
if (boBilatuIzenezDataz("Neurriak_2025.dat",
sEstazioaAztertu,
sDataAztertu,
&stEstazioIzenaData)==TRUE)
EstazioBatErakutsi_Zutabea(&stEstazioIzenaData);
else
printf("\n\a%s behaketa-estazioaren daturik ez da aurkitu %s datan\n", sEstazioaAztertu, sDataAztertu);
break;
case '0': printf("\nProgramaren amaiera!\n\n");
break;
default: printf("\n\aERROREA! aukera hori desegokia da\n");
}
} while (cAukera!='0');
}
else
printf("\nERROREA! '%s' izeneko fitxategirik ez dago!\n\n", sFitxIzen);
return 0;
}
//Funtzioak-------------------------------------------------------------------------
char cMenua()
{
char cAukera;
printf("\n PROGRAMAREN MENUA \n");
printf(" =================================================================\n");
printf(" 1. KOI eta KI indizeak kalkulatu\n");
printf(" 2. Eguneroko neurketen fitxategiaren edukia taula bezala erakutsi\n");
printf(" 3. Data jakin baterako estazio zehatz baten informazioa erakutsi\n");
printf(" 0. Irten\n");
printf(" =================================================================\n");
printf("\t Zure aukera: ");
cAukera = getche();
printf("\n");
return (cAukera);
}
int iFitxategirikBada(const char *sFitxIzen)
{
FILE *erakFitx;
int boBaiBada;
erakFitx=fopen(sFitxIzen,"rb");
if (erakFitx!=NULL)
{
boBaiBada=TRUE;
fclose(erakFitx);
}
else
boBaiBada=FALSE;
return boBaiBada;
}
void EstazioBatErakutsi_Errenkada(const struct tstEstazioa *stEstazioBat)
{
printf("%10s", stEstazioBat->sEstazioa);
printf("%13s", stEstazioBat->sData);
printf("%8.1f%12.1f%13.1f", stEstazioBat->fOxigenoa,
stEstazioBat->fSolidoak,
stEstazioBat->fKutsatzaileak);
printf("%12.1f%5d", stEstazioBat->fKOI,
stEstazioBat->iKI);
printf("\n");
}
void FitxategitikNeurketakErakutsi(const char *sFitxIzen)
{
FILE *erakFitx;
struct tstEstazioa stEstazioBat;
erakFitx=fopen(sFitxIzen,"rb");
printf("\n =========================================================================");
printf("\n%10s%13s%11s%11s%16s%7s%5s\n", "Estazioa", "Data", "Oxigenoa", "Solidoak", "Kutsatzaileak", "KOI", "KI");
printf(" -------- ---------- -------- -------- ------------- ---- --\n");
while (fread(&stEstazioBat, sizeof(stEstazioBat), 1, erakFitx)==1)
{
EstazioBatErakutsi_Errenkada(&stEstazioBat);
}
printf(" =========================================================================\n");
fclose(erakFitx);
}
// Ariketa bezala, fitxategiko azken elementua irakurriz egiaztatzen da. Errazago da
// lehen elementua irakurriz egitea fseek() funtzioaren deirik ez litzatekeelako behar
int iIndizeakKalkulaturikDaude(const char *sFitxIzen)
{
FILE *erakFitx;
struct tstEstazioa stEstazioBat;
int boKalkulaturikDaude;
erakFitx=fopen(sFitxIzen,"rb");
fseek(erakFitx, (-1)*(long)sizeof(stEstazioBat), SEEK_END);
fread(&stEstazioBat, sizeof(stEstazioBat), 1, erakFitx);
if (stEstazioBat.fKOI==-1)
boKalkulaturikDaude=FALSE;
else
boKalkulaturikDaude=TRUE;
fclose(erakFitx);
return boKalkulaturikDaude;
}
void FitxategitikArrayra(const char *sFitxIzen,
struct tstEstazioa astEstazioBat[],
int *iLuz)
{
FILE *erakFitx;
struct tstEstazioa stEstazioBat;
*iLuz=0;
erakFitx=fopen(sFitxIzen,"rb");
while (fread(&stEstazioBat, sizeof(stEstazioBat), 1, erakFitx)==1)
{
astEstazioBat[*iLuz]=stEstazioBat;
*iLuz = *iLuz + 1;
}
fclose(erakFitx);
}
void KOI_IndizeaKalkulatu(struct tstEstazioa *stEstazioBat)
{
stEstazioBat->fKOI = stEstazioBat->fOxigenoa*4 +
stEstazioBat->fSolidoak*2 +
stEstazioBat->fKutsatzaileak*4;
}
void KI_IndizeaKalkulatu(struct tstEstazioa *stEstazioBat)
{
if (stEstazioBat->fKOI<50)
stEstazioBat->iKI=1;
else if (stEstazioBat->fKOI<65)
stEstazioBat->iKI=2;
else if (stEstazioBat->fKOI<75)
stEstazioBat->iKI=3;
else if (stEstazioBat->fKOI<85)
stEstazioBat->iKI=4;
else if (stEstazioBat->fKOI<=100)
stEstazioBat->iKI=5;
else
stEstazioBat->iKI=-1;
}
void IndizeakKalkulatu(struct tstEstazioa astEstazioBat[],int iLuz)
{
for (int i=0; i<iLuz; i++)
{
KOI_IndizeaKalkulatu(&astEstazioBat[i]);
KI_IndizeaKalkulatu(&astEstazioBat[i]);
}
}
void ArraytikFitxategira(const char *sFitxIzen,
const struct tstEstazioa astEstazioBat[],
int iLuz)
{
FILE *erakFitx;
erakFitx=fopen(sFitxIzen,"wb");
fwrite(astEstazioBat,sizeof(astEstazioBat[0]),iLuz,erakFitx);
fclose(erakFitx);
}
void EgunaGehituHistorikora(const char *sFitxIzen,
const struct tstEstazioa astEstazioBat[],
int iLuz)
{
FILE *erakFitx;
erakFitx=fopen(sFitxIzen,"ab");
if (erakFitx!=NULL)
{
fwrite(astEstazioBat,sizeof(astEstazioBat[0]),iLuz,erakFitx);
fclose(erakFitx);
}
else
printf("\aERROREA! '%s' izeneko fitxategia ezin izan da ireki EgunaGehituHistorikora() funtzioan", sFitxIzen);
}
int boBilatuIzenezDataz(const char *sFitxIzen,
const char *sEstazioaAztertu,
const char *sDataAztertu,
struct tstEstazioa *stEstazioBat)
{
FILE *erakFitx;
erakFitx=fopen(sFitxIzen,"rb");
while (fread(stEstazioBat, sizeof(*stEstazioBat), 1, erakFitx)==1)
{
if ((strcmp(stEstazioBat->sEstazioa, sEstazioaAztertu)==0) &&
(strcmp(stEstazioBat->sData, sDataAztertu)==0))
{
fclose(erakFitx);
return TRUE;
}
}
fclose(erakFitx);
return FALSE;
}
void EstazioBatErakutsi_Zutabea(const struct tstEstazioa *stEstazioBat)
{
printf("\n Oxigenoaren indizea: %.1f", stEstazioBat->fOxigenoa);
printf("\n Solidoen indizea: %.1f", stEstazioBat->fSolidoak);
printf("\n Kutsatzaileen indizea: %.1f", stEstazioBat->fKutsatzaileak);
printf("\n KIO indizea: %.1f", stEstazioBat->fKOI);
printf("\n KI indizea: %d\n", stEstazioBat->iKI);
}
Jarraian erakusten da Neurriak_2025.dat datu-fitxategiaren balizko edukia. Ikus daitekeen bezala, Neurriak_2025.dat fitxategiak datuen historikoa gordetzen du, behaketa-estazio bakoitzeko eta data bakoitzeko estruktura bat. Neurriak_2025.dat fitxategiaren datuetan KOI eta KI indizeak kalkulaturik daude.
 |
| Neurriak_2025.dat fitxategiak gordetzen dituen balio historikoetan KOI eta KI indizeak kalkulaturik daude. Neurriak_2025.dat fitxategia aldez aurretik sortuta dago. |
Jarraian erakusten da Neurketak_20250529.dat datu-fitxategiaren edukia. Ikus daitekeen bezala, adibide honetan, Neurketak_20250529.dat fitxategiak 6 elementu ditu eta oraindik KOI eta KI indizeak ez dira kalkulatu. Kalkulu horiek egiteko, ariketan suposa daiteke Neurketak_20250529.dat fitxategiaren elementu guztiak arrayan sar daitezkeela:
 |
| Neurketak_20250529.dat fitxategiaren estrukturek zazpi eremu dituzte: estazioaren izena, data eta bost indize. Erabiltzaileak data UUUUHHEE formatuan sartuko du eta fitxategiaren izena konposatu ondoren bere existentzia egiaztatuko da. |
Hona hemen, datu-fitxategiak sortzeko erabil daitekeen DatuenFitxategiakSortu proiektuaren main.c fitxategiaren kodea. Non lehenik UUUUHHEE formatuko data bat eskatzen den Neurketak_UUUHHEE.dat fitxategiaren datuak auzaz lortzeko. Bestalde, erabiltzaileak urte bat teklatuz emanik, auzaz eskuratzen den hilabete jakin bateko hainbat egunetako datu historikoak bilduko dira Neurriak_2025.dat datu-fitxategian:
/*=========================================================================================
Data: 2025eko maiatzaren 22a
Deskribapena: Informatika azterketa
2024-25 ikasturteko ohiko deialdia
Bilbo, 2025eko maiatzaren 29a
Graduak: - Industria Antolakuntzaren Ingeniaritzako Gradua
- Ingurumen Ingeniaritzako Gradua
Bertsioaren Ezaugarriak:
- "Neurriak_2025.dat" datu-fitxategia historikoa sortuko da
- "uuuuhhee" data bat emanda "Neurketak_uuuuhhee.da" datu-fitxategia
sortuko da
===========================================================================================*/
#include <stdio.h>
#include <conio.h> // getche()
#include <string.h> // strcpy() eta strcat()
#include <time.h> // time()
#include <stdlib.h> // rand() eta srand()
#define iLUZERAMAX 100
#define sFITX_HISTORIKOA "Neurriak_2025.dat"
/* Deklarazio orokorra */
struct tstEstazioa
{
char sEstazioa[11];
char sData[11];
float fOxigenoa;
float fSolidoak;
float fKutsatzaileak;
float fKOI;
int iKI;
};
/* Prototipoak */
void Neurketak_FitxategiaSortu(const char *sFitxIzenNeurketak, const char *sData);
void Neurketak_FitxategiaIkusi(const char *sFitxIzenNeurketak);
void FitxategiHistorikoaSortu(const char *sFitxIzenHistorikoa);
void FitxategitikArrayra(const char *sFitxIzenHistorikoa,
struct tstEstazioa astEstazioBat[],
int *iLuz);
void IndizeakKalkulatu(struct tstEstazioa astEstazioBat[], int iLuz);
void ArraytikFitxategira(const char *sFitxIzenHistorikoa,
const struct tstEstazioa astEstazioBat[],
int iLuz);
/* Funtzio nagusia */
int main()
{
char sData8[11]; // 10 karaktere gehi null karakterea, adibidez: 2025/05/29
char sFitxIzenNeurketak[100];
struct tstEstazioa astEgunBatekoNeurketak[iLUZERAMAX];
int iZenbatNeurketa;
/* Egun bateko neurketak, fitxategia sortu eta ikusi */
printf("\n Sartu data (adibidez, 20250529): ");
fflush(stdin);
gets(sData8);
strcpy(sFitxIzenNeurketak, "Neurketak_");
strcat(sFitxIzenNeurketak, sData8);
strcat(sFitxIzenNeurketak, ".dat");
//printf(" sFitxIzenNeurketak: '%s'", sFitxIzenNeurketak);
Neurketak_FitxategiaSortu(sFitxIzenNeurketak, sData8);
Neurketak_FitxategiaIkusi(sFitxIzenNeurketak);
printf("\n Aurrera egiteko edozein tekla sakatu...\n\n" );
getche(); // Itxaroteko
/* Fitxategi historikoaa sortu eta ikusi */
FitxategiHistorikoaSortu(sFITX_HISTORIKOA);
Neurketak_FitxategiaIkusi(sFITX_HISTORIKOA);
printf("\n Aurrera egiteko edozein tekla sakatu...\n\n" );
getche(); // Itxaroteko
FitxategitikArrayra(sFITX_HISTORIKOA, astEgunBatekoNeurketak, &iZenbatNeurketa);
IndizeakKalkulatu(astEgunBatekoNeurketak, iZenbatNeurketa);
ArraytikFitxategira(sFITX_HISTORIKOA, astEgunBatekoNeurketak, iZenbatNeurketa);
Neurketak_FitxategiaIkusi(sFITX_HISTORIKOA);
printf("\n Aurrera egiteko edozein tekla sakatu...\n\n" );
getche(); // Itxaroteko
return 0;
}
/* Egun bateko neurketen fitxategia sortu. */
void Neurketak_FitxategiaSortu(const char *sFitxIzen, const char *sDataTrinkoa)
{
FILE *fbErakFitx;
struct tstEstazioa stEstazioBat;
char sData[11] = ""; //10 karaktere gehi null karakterea, adibidez: 2025/05/07
int iKont;
int iZbk;
int iZenbatEstazio;
char sEstazioIzena[11];
fbErakFitx = fopen(sFitxIzen, "wb");
for (iKont=0; iKont<4; iKont++)
sData[iKont] = sDataTrinkoa[iKont];
sData[iKont++] = '/';
sData[iKont++] = sDataTrinkoa[4];
sData[iKont++] = sDataTrinkoa[5];
sData[iKont++] = '/';
sData[iKont++] = sDataTrinkoa[6];
sData[iKont++] = sDataTrinkoa[7];
//printf("\n sData: '%s'", sData);
strcpy(stEstazioBat.sData, sData);
srand(time(NULL));
iZenbatEstazio = rand() % 4 + 5; // 5 eta 8 artekoa
for (int i=0; i<iZenbatEstazio; i++)
{
iZbk = rand() % 1000000; // 0 eta 99999 artekoa
sprintf(sEstazioIzena, "BI-%05d", iZbk);
//printf("\n sEstazioIzena: '%s'", sEstazioIzena);
strcpy(stEstazioBat.sEstazioa, sEstazioIzena);
stEstazioBat.fOxigenoa = (float)rand()/RAND_MAX*10.0; // 0.0 eta 1.0 artekoa | 0.0 eta 10.0 artekoa
stEstazioBat.fSolidoak = (float)rand()/RAND_MAX*10.0; // 0.0 eta 1.0 artekoa | 0.0 eta 10.0 artekoa
stEstazioBat.fKutsatzaileak = (float)rand()/RAND_MAX*10.0; // 0.0 eta 1.0 artekoa | 0.0 eta 10.0 artekoa
stEstazioBat.fKOI = -1.0;
stEstazioBat.iKI = -1;
fwrite(&stEstazioBat, sizeof(stEstazioBat), 1, fbErakFitx);
}
fclose(fbErakFitx);
}
/* Egun bateko neurketen fitxategia erakutsi. */
void Neurketak_FitxategiaIkusi(const char *sFitxIzen)
{
FILE *fbErakFitx;
struct tstEstazioa stEstazioBat;
fbErakFitx = fopen(sFitxIzen, "rb");
printf("\n\n =========================================================================");
printf("\n%10s%13s%11s%11s%16s%7s%5s\n", "Estazioa", "Data", "Oxigenoa", "Solidoak", "Kutsatzaileak", "KOI", "KI");
printf(" -------- ---------- -------- -------- ------------- ---- --\n");
while (fread(&stEstazioBat, sizeof(stEstazioBat), 1, fbErakFitx)==1)
{
printf("%10s", stEstazioBat.sEstazioa);
printf("%13s", stEstazioBat.sData);
printf("%8.1f%12.1f%13.1f", stEstazioBat.fOxigenoa,
stEstazioBat.fSolidoak,
stEstazioBat.fKutsatzaileak);
printf("%12.1f%5d", stEstazioBat.fKOI,
stEstazioBat.iKI);
printf("\n");
}
printf(" =========================================================================\n");
fclose(fbErakFitx);
}
/* Hainbat egunetako fitxategi historikoa sortu. */
void FitxategiHistorikoaSortu(const char *sFitxIzenHistorikoa)
{
FILE *fbErakFitx;
struct tstEstazioa stEstazioBat;
char sEguna[3]; // 2 karaktere gehi null, adibidez: 07
char sData[11]; //10 karaktere gehi null, adibidez: 2025/05/07
char sUrteaHilea[11]; //10 karaktere gehi null, adibidez: 2025/05/
int iHileBetea;
int iZenbatEgun;
int iZenbatErrepikapen;
int iZbk;
char sEstazioIzena[11];
fbErakFitx = fopen(sFitxIzenHistorikoa, "wb");
srand(time(NULL));
iHileBetea = rand() % 12 + 1; // 1 eta 12 artekoa
sprintf(sUrteaHilea, "2025/%02d/", iHileBetea);
//printf("\n uuuu/hh/: '%s'", sUrteaHilea);
iZenbatEgun = rand() % 4 + 6; // 6 eta 9 artekoa
for (int iKont=5; iKont<iZenbatEgun+5; iKont++)
{
iZenbatErrepikapen = rand() % 3 + 1; // 1 eta 3 artekoa
for (int iErrepik=0; iErrepik<iZenbatErrepikapen; iErrepik++)
{
strcpy(sData, sUrteaHilea);
sprintf(sEguna, "%02d", iKont);
strcat(sData, sEguna);
//printf("\n sData: '%s'", sData);
strcpy(stEstazioBat.sData, sData);
iZbk = rand() % 1000000; // 0 eta 99999 artekoa
sprintf(sEstazioIzena, "BI-%05d", iZbk);
//printf("\n sEstazioIzena: '%s'", sEstazioIzena);
strcpy(stEstazioBat.sEstazioa, sEstazioIzena);
stEstazioBat.fOxigenoa = (float)rand()/RAND_MAX*10.0; // 0.0 eta 1.0 artekoa | 0.0 eta 10.0 artekoa
stEstazioBat.fSolidoak = (float)rand()/RAND_MAX*10.0; // 0.0 eta 1.0 artekoa | 0.0 eta 10.0 artekoa
stEstazioBat.fKutsatzaileak = (float)rand()/RAND_MAX*10.0; // 0.0 eta 1.0 artekoa | 0.0 eta 10.0 artekoa
stEstazioBat.fKOI = -1.0;
stEstazioBat.iKI = -1;
fwrite(&stEstazioBat, sizeof(stEstazioBat), 1, fbErakFitx);
}
}
fclose(fbErakFitx);
}
void FitxategitikArrayra(const char *sFitxIzen,
struct tstEstazioa astEstazioBat[],
int *iLuz)
{
FILE *erakFitx;
struct tstEstazioa stEstazioBat;
*iLuz=0;
erakFitx=fopen(sFitxIzen,"rb");
while (fread(&stEstazioBat, sizeof(stEstazioBat), 1, erakFitx)==1)
{
astEstazioBat[*iLuz]=stEstazioBat;
*iLuz = *iLuz + 1;
}
fclose(erakFitx);
}
void KOI_IndizeaKalkulatu(struct tstEstazioa *stEstazioBat)
{
stEstazioBat->fKOI = stEstazioBat->fOxigenoa*4 +
stEstazioBat->fSolidoak*2 +
stEstazioBat->fKutsatzaileak*4;
}
void KI_IndizeaKalkulatu(struct tstEstazioa *stEstazioBat)
{
if (stEstazioBat->fKOI<50)
stEstazioBat->iKI=1;
else if (stEstazioBat->fKOI<65)
stEstazioBat->iKI=2;
else if (stEstazioBat->fKOI<75)
stEstazioBat->iKI=3;
else if (stEstazioBat->fKOI<85)
stEstazioBat->iKI=4;
else if (stEstazioBat->fKOI<=100)
stEstazioBat->iKI=5;
else
stEstazioBat->iKI=-1;
}
void IndizeakKalkulatu(struct tstEstazioa astEstazioBat[],int iLuz)
{
for (int i=0; i<iLuz; i++)
{
KOI_IndizeaKalkulatu(&astEstazioBat[i]);
KI_IndizeaKalkulatu(&astEstazioBat[i]);
}
}
void ArraytikFitxategira(const char *sFitxIzen,
const struct tstEstazioa astEstazioBat[],
int iLuz)
{
FILE *erakFitx;
erakFitx=fopen(sFitxIzen,"wb");
fwrite(astEstazioBat,sizeof(astEstazioBat[0]),iLuz,erakFitx);
fclose(erakFitx);
}
|
2024ko Maiatzaren deialdiko programa: Jatetxea
Azterketa ariketari lotutako informazioa. Proiektuan bost fitxategietan banaturik dago:
 |
| Irudian erakusten da nola agertzen diren 5 fitxategi horiek Code::Blocks ingurunean. Alde batetik iturburu-kodearen 3 fitxategiak eta beste aldetik 2 liburutegi-fitxategiak (irudia handiago ikusteko bere gainean klik egin) |
Bi datu-fitxategi behar dira: Mahaiak.dat eta MenuakEgunezEgun.dat. Biak estrukturak gordetzen dituzten fitxategien izenak izango dira:
Hau da 2024-05-22_Jatetxea proiektuaren porgrama gidatzeko erabiliko den menua:
============================================================================= | MENUA | ============================================================================= | 1. Erakutsi jatetxeko mahaien egoera | | 2. Pantailaratu gaurko (ASTEAZKEN) menuak | | 3. Mahaia erreserbatu | |---------------------------------------------------------------------------| | 4. Erreserba ezeztatu (2024KO AZTERKETAN EZ ZEN ESKATU) | |---------------------------------------------------------------------------| | 5. Jatekoa eskatu | | 6. Kontua eskatu | |---------------------------------------------------------------------------| | 7. Gaurko kutxa osoa erakutsi (2024KO AZTERKETAN EZ ZEN ESKATU) | |
Goian ikusten denez, menuak hamar aukera ditu. Urdinez idazten direnak ez ziren azterketan eskatu. Deskriba ditzagun labur-labur aukera bakoitzaren helburua.
Azken aukeran, programatik irtetekoan, irabazien arrayaren informazioarekin eta sAsteguna aldagaiak duen katearekin Irabaziak_[sAsteguna].dat zenbaki errealen fitxategia sortu eta datuz betetzen da.
DatuMotak.h liburutegian konstanteak definitzen dira #define klausulari esker, eta, ondoren, behar diren bi estrukturen datu-motak definitzen dira ere. Gero, proiektuaren beste fitxategietan (main.c fitxategian, DatuFitxategiakSortu.c fitxategian eta IkaslearenKodea.c fitxategian) derrigorrezkoa izango da liburutegi honen #include egitea.
Hona hemen DatuMotak.h liburutegian jasotzen dena:
/*====================================================================
Programatzailea: Jesus Romo Uriarte
Data: 2025eko apirilaren 14a
Deskribapena: Informatika azterketa
2023-24 ikasturteko ohiko deialdia
Bilbo, 2024ko maiatzaren 22a
Ezaugarriak: Programak erabiltzen dituen datu-egituren eta
konstanteen definizioak biltzen dira hemen
=====================================================================*/
#define TRUE 1
#define FALSE 0
#define iMAHAIEN_MAX 10
#define iAULKI_KOP_MAX 6
#define iAULKI_KOP_MIN 2
#define iMENUEN_MAX 5
#define iZAZPI_EGUN 7
#define iFITX_IZEN_MAX 150
#define iDATU_IZEN_MAX 100
#define iASTEGUNAREN_LUZERA 15
#define MENUEN_FITX_IZEN "MenuakEgunezEgun.dat"
/*----------------Programaren datu-moten deklarazioa----------------*/
//Estrukturen deklarazio orokorra
struct tstMahaia
{
int iMahaiZbk;
int iAulkiKop;
int boLibre;
char sErreserbaIzena[iDATU_IZEN_MAX];
int iMahaikideKop;
};
struct tstMenua
{
char sIzen[iDATU_IZEN_MAX];
float fPrezioa;
char sEguna[iASTEGUNAREN_LUZERA];
};
Programaren funtzioei dagozkien prototipo guztiak liburutegi honetan jasoko dira. Gero, proiektuaren beste fitxategietan (main.c fitxategian, DatuFitxategiakSortu.c fitxategian eta IkaslearenKodea.c fitxategian) derrigorrezkoa izango da liburutegi honen #include egitea.
Hona hemen Prototipoak.h liburutegian jasotzen dena:
/*====================================================================
Programatzailea: Jesus Romo Uriarte
Data: 2025eko apirilaren 14a
Deskribapena: Informatika azterketa
2023-24 ikasturteko ohiko deialdia
Bilbo, 2024ko maiatzaren 22a
Ezaugarriak: Programak erabiltzen dituen funtzio guztien
prototipoak biltzen dira hemen
=====================================================================*/
/*----------Funtzioen prototipoak-------------*/
int iFitxategirikBada(const char *sMahaienFitxIzen);
int iEgunaTxartoEmanda(const char sAsteguna[]);
int iMahaienFitxategianDatuakKargatu(const char sMahaienFitxIzen[]);
int iMenuenFitxategianDatuakKargatu(const char sMenuenFitxIzen[]);
void MenuakFitxategitikArrayra(const char *sMahaienFitxIzen,
struct tstMenua astMenuak[],
int *iLuz,
const char *sAsteEguna);
char cMenuarenAukeraHautatu(const char sAsteguna[]);
void MahaiBatErakutsi(const struct tstMahaia *stMahai);
void MahaiakErakutsi(const char *sMahaienFitxIzen);
void EgunekoMenuakPantailaratu(const struct tstMenua astMenuak[],
int iLuzM);
void MahaiaErreserbatu(const char* sFitxIzenMahaiak,
const char* sBezeroIzena,
int iMahaikideak);
void ErreserbaAldatu(const char *sMahaienFitxIzen,
int iMahaiZbk,
const char *sIzen,
int iZenbatMahaikide);
int iMahaikideKopuruaLortu(const char *sMahaienFitxIzen,
int iMahaiZbk);
void IrabaziakFitxategiBateanGorde1(const float afGaurkoIrabaziak[], // 10 idazketa
const char *sIrabazienFitxIzen);
void IrabaziakFitxategiBateanGorde2(const float afGaurkoIrabaziak[], // idazketa bakarra
const char *sIrabazienFitxIzen);
void MahaiaLibratu(const char *sMahaienFitxIzen,
int iMahaiZbk);
void IrabazienFitxategiaPantailaratu(const char *sIrabazienFitxIzen);
/*------------"Prototipoak.h" liburutegi-fitxategiaren amaiera------------*/
main.c fitxategian programaren logika nagusia kodetzen da, hona hemen bere kodea:
/*======================================================================================
Programatzailea: Jesus Romo Uriarte
Data: 2025eko apirilaren 14a
Deskribapena: Informatika azterketa
2023-24 ikasturteko ohiko deialdia
Bilbo, 2024ko maiatzaren 22a
Bertsioaren Ezaugarriak:
- Datu-motak eta konstanteak "DatuMotak.h" liburutegian definitu dira
- Funtzioen goiburuak "Prototipoak.h" liburutegian definitu dira
- Mahaien fitxategia sortzeko kodea eta menuen fitxategia sortzeko
kodea "DatuFitxategiakSortu.c" fitxategian idatzi dira
=======================================================================================*/
#include <stdio.h>
#include <stdlib.h> // system() funtzioarako
#include <string.h>
#include <conio.h> // getch() eta getche()
#include "DatuMotak.h"
#include "Prototipoak.h"
/*------------- Funtzioen prototipoak "Prototipoak.h" liburutegian -------------*/
/*------- Funtzio nagusia -------------*/
int main()
{
char sMahaienFitxIzen[iFITX_IZEN_MAX];
char sAsteguna[iASTEGUNAREN_LUZERA];
char sIrabazienFitxIzen[iFITX_IZEN_MAX];
char sBezeroIzen[iFITX_IZEN_MAX];
char cAukera;
struct tstMenua astKarta[iZAZPI_EGUN];
int iErrorea;
int iKartarenLuzera;
int iZenbatMahaikide;
int iMahaiZbk;
int iMenuaKartan;
float afGaurkoIrabaziak[iMAHAIEN_MAX] = {0.0}; // 0tik 9ra, posizio guztietan 0.0 euro
printf("\n -------------------------------------------------------------------");
printf("\n -------- Jatetxe bateko ERRESERBAK eta MANDATUAK kudeatzen --------");
printf("\n -------------------------------------------------------------------\n");
printf("\n\n Jatetxeko mahaien datuak gordetzen dituen\n fitxategiaren izen laburra eman (Mahaiak): ");
gets(sMahaienFitxIzen);
strcat(sMahaienFitxIzen, ".dat");
// Mahaien fitxategia lehendik existitzen bada, bere informazioa mantendu
if (iFitxategirikBada(sMahaienFitxIzen) == FALSE)
{
printf("\n\a ERROREA! '%s' fitxategia ez da existitzen oraintxe sortu da!\n", sMahaienFitxIzen);
iErrorea = iMahaienFitxategianDatuakKargatu(sMahaienFitxIzen);
if (iErrorea != 0)
return iErrorea;
}
do
{
printf(" Gaurko asteko eguna? (Astelehen, Astearte, ... Igande): ");
gets(sAsteguna);
strupr(sAsteguna);
if (iEgunaTxartoEmanda(sAsteguna) == TRUE)
printf("\a");
} while (iEgunaTxartoEmanda(sAsteguna) == TRUE);
// Menuen fitxategia beti berria sortuko da
iErrorea = iMenuenFitxategianDatuakKargatu(MENUEN_FITX_IZEN);
if (iErrorea != 0)
return iErrorea;
MenuakFitxategitikArrayra(MENUEN_FITX_IZEN, astKarta, &iKartarenLuzera, sAsteguna);
do
{
cAukera = cMenuarenAukeraHautatu(sAsteguna);
printf("\n");
switch (cAukera)
{
case '1': //printf("\n 1 - Erakutsi jatetxeko mahaien egoera");
MahaiakErakutsi(sMahaienFitxIzen);
break;
case '2': //printf("\n 2 - Pantailaratu gaurko (%s) menuak", sAsteguna);
EgunekoMenuakPantailaratu(astKarta, iKartarenLuzera);
break;
case '3': //printf("\n 3 - Mahaia erreserbatu";
MahaiakErakutsi(sMahaienFitxIzen);
printf(" Erreserba egiten...\n Bezeroaren izena sartu: ");
gets(sBezeroIzen);
fflush(stdin);
printf(" Mahaikiden kopurua sartu: ");
scanf("%d", &iZenbatMahaikide);
fflush(stdin);
MahaiaErreserbatu(sMahaienFitxIzen, sBezeroIzen, iZenbatMahaikide);
break;
case '4': //printf("\n 4 - Erreserba ezeztatu);
//hemen idatzi "ErreserbaEzeztatu()" funtzioaren deia
printf(" Mahaien fitxategitik abiatuta, erreserba bat ezeztatzen da\n");
break;
case '5': //printf("\n 5 - Jatekoa eskatu");
do
{
printf(" Jatekoa eskatzen... Mahai-zenbakia (1..%d): ", iMAHAIEN_MAX);
scanf("%d",&iMahaiZbk);
fflush(stdin);
} while (iMahaiZbk < 1 || iMahaiZbk > iMAHAIEN_MAX);
iZenbatMahaikide = iMahaikideKopuruaLortu(sMahaienFitxIzen,iMahaiZbk);
printf(" Egin beharreko eskaera-kopurua: %d\n",iZenbatMahaikide);
for (int i=1; i<=iZenbatMahaikide; i++)
{
EgunekoMenuakPantailaratu(astKarta, iKartarenLuzera);
do
{
printf(" %d. mahaikidearen menua aukeratu (1 eta %d artekoa): ", i, iKartarenLuzera);
scanf("%d", &iMenuaKartan);
fflush(stdin);
} while (iMenuaKartan < 1 || iMenuaKartan > iKartarenLuzera);
afGaurkoIrabaziak[iMahaiZbk-1] = afGaurkoIrabaziak[iMahaiZbk-1] + astKarta[iMenuaKartan-1].fPrezioa;
printf(" Batura egin ondoren, %d. mahaiaren kontua %.2f Eurotakoa izango da\n", iMahaiZbk, afGaurkoIrabaziak[iMahaiZbk-1]);
}
break;
case '6': //printf("\n 6 - Kontua eskatu eta ordaindu");
do
{
printf(" Kontua eskatzen... Mahai-zenbakia (1..%d): ", iMAHAIEN_MAX);
scanf("%d",&iMahaiZbk);
fflush(stdin);
} while (iMahaiZbk < 1 || iMahaiZbk > iMAHAIEN_MAX);
printf(" %d. mahaiak %.2f Euro ordaindu behar ditu\n", iMahaiZbk, afGaurkoIrabaziak[iMahaiZbk-1]);
printf(" %d. mahaia libratzen...\n", iMahaiZbk);
if (afGaurkoIrabaziak[iMahaiZbk-1] != 0)
MahaiaLibratu(sMahaienFitxIzen, iMahaiZbk);
else
{
printf(" %d. mahaia ezin daiteke bihurtu eskuragarri, dagoeneko libre\n", iMahaiZbk);
printf(" dagoelako edo bezeroek oraindik ez dutelako kontua ordaindu\n");
}
break;
case '7': //printf("\n 7 - Gaurko kutxa osoa erakutsi");
//hemen idatzi "KontuakPantailaratu()" funtzioaren deia
printf(" Irabazien arraytik abiatuta, hamar mahaietan\n gaur jaso diren euroak erakusten dira\n");
break;
case '8': //printf("\n 8 - Zeregin berri bat");
printf(" 8. aukerako zeregina\n");
break;
case '9': //printf("\n 9 - Zeregin berri bat");
printf(" 9. aukerako zeregina\n");
break;
case '0': //printf("\n 0 - Irabaziak eguneratu eta programatik irten");
strcpy(sIrabazienFitxIzen, "Irabaziak_");
strcat(sIrabazienFitxIzen, sAsteguna);
strcat(sIrabazienFitxIzen, ".dat");
IrabaziakFitxategiBateanGorde1(afGaurkoIrabaziak, sIrabazienFitxIzen);
IrabazienFitxategiaPantailaratu(sIrabazienFitxIzen);
IrabaziakFitxategiBateanGorde2(afGaurkoIrabaziak, sIrabazienFitxIzen);
IrabazienFitxategiaPantailaratu(sIrabazienFitxIzen);
printf("\n Programaren amaiera\n");
break;
}
if (cAukera != '0')
{
printf("\n Aurrera egiteko edozein tekla sakatu... ");
getche(); // itxaroteko
}
} while (cAukera!='0');
return 0;
}
/*--------- Mahaien fitxategia existitzen den konprobaketa ------------*/
int iFitxategirikBada(const char *sMahaienFitxIzen)
{
FILE *fbErakMahaiak;
int iBaiBada;
fbErakMahaiak = fopen(sMahaienFitxIzen, "rb");
if (fbErakMahaiak == NULL)
iBaiBada = FALSE; // 0
else
{
fclose(fbErakMahaiak);
iBaiBada = TRUE; // 1
}
return iBaiBada;
}
/*----------------iEgunaTxartoEmanda------------------*/
int iEgunaTxartoEmanda(const char sAsteguna[])
{
int iErantzuna;
iErantzuna = TRUE;
if (strcmp(sAsteguna, "ASTELEHEN") == 0)
{
iErantzuna = FALSE;
return iErantzuna;
}
if (strcmp(sAsteguna, "ASTEARTE") == 0)
{
iErantzuna = FALSE;
return iErantzuna;
}
if (strcmp(sAsteguna, "ASTEAZKEN") == 0)
{
iErantzuna = FALSE;
return iErantzuna;
}
if (strcmp(sAsteguna, "OSTEGUN") == 0)
{
iErantzuna = FALSE;
return iErantzuna;
}
if (strcmp(sAsteguna, "OSTIRAL") == 0)
{
iErantzuna = FALSE;
return iErantzuna;
}
if (strcmp(sAsteguna, "LARUNBAT") == 0)
{
iErantzuna = FALSE;
return iErantzuna;
}
if (strcmp(sAsteguna, "IGANDE") == 0)
{
iErantzuna = FALSE;
return iErantzuna;
}
return iErantzuna;
}
/*------ Egun bateko menuak fitxategitik arrayra iraultzea------*/
void MenuakFitxategitikArrayra(const char *sMenuenFitxIzen,
struct tstMenua astMenuak[],
int *iLuz,
const char *sAsteEguna)
{
FILE *fbErakMenuak;
struct tstMenua stMenuBat;
*iLuz = 0;
fbErakMenuak = fopen(sMenuenFitxIzen, "rb");
while (fread(&stMenuBat, sizeof(stMenuBat), 1, fbErakMenuak) == 1)
{
if (strcmp(stMenuBat.sEguna, sAsteEguna) == 0)
{
astMenuak[*iLuz] = stMenuBat;
*iLuz = *iLuz + 1;
}
}
fclose(fbErakMenuak);
}
/*---------Menua------------*/
char cMenuarenAukeraHautatu(const char sAsteguna[])
{
char cAukera;
system("cls");
printf("\n ===================MENUA===================");
printf("\n 1 - Erakutsi jatetxeko mahaien egoera");
printf("\n 2 - Pantailaratu gaurko (%s) menuak", sAsteguna);
printf("\n 3 - Mahaia erreserbatu");
printf("\n 4 - ... Erreserba ezeztatu");
printf("\n 5 - Jatekoa eskatu");
printf("\n 6 - Kontua eskatu eta ordaindu");
printf("\n 7 - ... Gaurko kutxa osoa erakutsi");
printf("\n 8 - ... Zeregin berri bat");
printf("\n 9 - ... Zeregin berri bat");
printf("\n 0 - Programatik irten");
printf("\n ===========================================\n");
do
{
printf("\n Zure aukera hautatu: ");
cAukera = getche();
if (cAukera < '0' || cAukera > '9')
printf("\a");
} while (cAukera < '0' || cAukera > '9');
printf("\n");
return cAukera;
}
/*-------Mahai estruktura erakutsi---------------*/
void MahaiBatErakutsi(const struct tstMahaia *stMahaiBat)
{
printf("%10d", stMahaiBat->iMahaiZbk);
printf("%12d", stMahaiBat->iAulkiKop);
printf("%16d", stMahaiBat->iMahaikideKop);
if (stMahaiBat->boLibre)
printf(" Libre\n");
else
printf(" Erreserbatuta: %s\n", stMahaiBat->sErreserbaIzena);
}
/*--------Jatetxe estruktura erakutsi ---------*/
void MahaiakErakutsi(const char *sMahaienFitxIzen)
{
FILE *fbErakMahaiak;
struct tstMahaia stMahaiBat;
fbErakMahaiak = fopen(sMahaienFitxIzen, "rb");
printf(" --------------------------------------------------------------------\n");
printf("%10s%12s%16s%22s\n","MAHAIA","AULKIAK","MAHAIKIDEAK","ESKURAGARRITASUNA" );
printf(" --------------------------------------------------------------------\n");
while (fread(&stMahaiBat, sizeof(stMahaiBat), 1, fbErakMahaiak) == 1)
MahaiBatErakutsi(&stMahaiBat);
printf(" --------------------------------------------------------------------\n");
fclose(fbErakMahaiak);
}
/*----------Menuak erakutsi-------------*/
void EgunekoMenuakPantailaratu(const struct tstMenua astMenuak[],
int iLuzMenuZerrenda)
{
int i;
printf(" ----------------------------------------------------------------------\n");
printf("%13s%20s%19s%16s\n", "MENU ZBK.", "MENUA", "PREZIOA", "EGUNA");
printf(" ----------------------------------------------------------------------");
for (i=0; i<iLuzMenuZerrenda; i++)
printf("\n %8d%24s%14.2f euro %15s", i + 1, astMenuak[i].sIzen, astMenuak[i].fPrezioa, astMenuak[i].sEguna);
printf("\n ----------------------------------------------------------------------\n");
}
/*----------Mahai informazioa aldatu-------------*/
void ErreserbaAldatu(const char *sMahaienFitxIzen,
int iMahaiZbk,
const char *sIzen,
int iZenbatMahaikide)
{
FILE *fbErakMahaiak;
struct tstMahaia stMahaiBat;
fbErakMahaiak = fopen(sMahaienFitxIzen, "r+b");
fseek(fbErakMahaiak, (iMahaiZbk-1)*(long)sizeof(stMahaiBat), SEEK_SET);
fread(&stMahaiBat, sizeof(stMahaiBat), 1, fbErakMahaiak);
stMahaiBat.boLibre = 0;
strcpy(stMahaiBat.sErreserbaIzena, sIzen);
stMahaiBat.iMahaikideKop = iZenbatMahaikide;
fseek(fbErakMahaiak, (iMahaiZbk-1)*(long)sizeof(stMahaiBat), SEEK_SET);
fwrite(&stMahaiBat, sizeof(stMahaiBat), 1, fbErakMahaiak);
fclose(fbErakMahaiak);
}
/*----- Mahaikide zenbakia lortu-----------*/
int iMahaikideKopuruaLortu(const char *sMahaienFitxIzen,
int iMahaiZbk)
{
FILE *fbErakMahaiak;
struct tstMahaia stMahaiBat;
fbErakMahaiak = fopen(sMahaienFitxIzen, "rb");
fseek(fbErakMahaiak, (iMahaiZbk-1)*(long)sizeof(stMahaiBat), SEEK_SET);
fread(&stMahaiBat, sizeof(stMahaiBat), 1, fbErakMahaiak);
fclose(fbErakMahaiak);
return stMahaiBat.iMahaikideKop;
}
/*-----------Irabaziak fitxategira irauli, 10 idazketak banan-banan eginez-----------*/
void IrabaziakFitxategiBateanGorde1(const float afGaurkoIrabaziak[],
const char *sIrabazienFitxIzen)
{
FILE *fbErakKutxa;
fbErakKutxa = fopen(sIrabazienFitxIzen, "wb");
for (int iKont=0; iKont<iMAHAIEN_MAX; iKont++)
{
fwrite(&afGaurkoIrabaziak[iKont], sizeof(float), 1, fbErakKutxa);
}
fclose(fbErakKutxa);
printf(" 10 idazketa...\n");
}
/*-----------Irabaziak fitxategira irauli, 10 zenbakiak idazketa bakarrean hartuz-----------*/
void IrabaziakFitxategiBateanGorde2(const float afGaurkoIrabaziak[],
const char *sIrabazienFitxIzen)
{
FILE *fbErakKutxa;
fbErakKutxa = fopen(sIrabazienFitxIzen, "wb");
fwrite(afGaurkoIrabaziak, sizeof(afGaurkoIrabaziak[0]), iMAHAIEN_MAX, fbErakKutxa);
fclose(fbErakKutxa);
printf("\n Idazketa bakarra...\n");
}
/*-----------Mahaia eskuragarri ipini-----------*/
void MahaiaLibratu(const char *sMahaienFitxIzen,
int iMahaiZbk)
{
FILE *fbErakMahaiak;
struct tstMahaia stMahaiBat;
fbErakMahaiak = fopen(sMahaienFitxIzen, "r+b");
fseek(fbErakMahaiak, (iMahaiZbk-1)*(long)sizeof(stMahaiBat), SEEK_SET);
fread(&stMahaiBat, sizeof(stMahaiBat), 1, fbErakMahaiak);
stMahaiBat.boLibre = 1;
strcpy(stMahaiBat.sErreserbaIzena, "");
stMahaiBat.iMahaikideKop = 0;
fseek(fbErakMahaiak, (iMahaiZbk-1)*(long)sizeof(stMahaiBat), SEEK_SET);
fwrite(&stMahaiBat, sizeof(stMahaiBat), 1, fbErakMahaiak);
fclose(fbErakMahaiak);
}
/*-----------Irabaziak, float diren 10 elementuko fitxategi bat-----------*/
void IrabazienFitxategiaPantailaratu(const char *sIrabazienFitxIzen)
{
FILE *fbErakEuroak;
float fEuroak;
int iMahaiZenbakia = 0;
fbErakEuroak = fopen(sIrabazienFitxIzen, "rb");
printf(" -----------------------------------------------------------\n");
printf(" GAURKO IRABAZIAK (EUROAK)\n");
printf(" -----------------------------------------------------------\n");
printf(" '%s' fitxategiaren edukia:", sIrabazienFitxIzen);
while (fread(&fEuroak, sizeof(float), 1, fbErakEuroak) == 1)
{
iMahaiZenbakia++;
printf("\n %2d zenbakiko mahaian %8.2f euro irabazi dira", iMahaiZenbakia, fEuroak);
}
printf("\n -----------------------------------------------------------\n");
fclose(fbErakEuroak);
}
/*------------Mahai bat erreserbatu mahaikide kopuru jakin batentzat--------------*/
void MahaiaErreserbatu(const char* sFitxIzenMahaiak, const char* sBezeroIzena, int iMahaikideak)
{
FILE *f;
struct tstMahaia rdMahaiBat;
int iAulkiKopurua = iMahaikideak;
int boMahaiaErreserbatua = FALSE;
f = fopen(sFitxIzenMahaiak, "r+b");
do
{
printf(" sBezeroIzena = %s, iMahaikideak = %d, iAulkiKopurua = %d\n",
sBezeroIzena, iMahaikideak, iAulkiKopurua);
fseek(f, 0L, SEEK_SET); // fitxategia hasierara
while (fread(&rdMahaiBat, sizeof(struct tstMahaia), 1, f) == 1 && !boMahaiaErreserbatua)
{
if (rdMahaiBat.iAulkiKop == iAulkiKopurua && rdMahaiBat.boLibre)
{
rdMahaiBat.boLibre = FALSE;
strcpy(rdMahaiBat.sErreserbaIzena, sBezeroIzena);
rdMahaiBat.iMahaikideKop = iMahaikideak;
fseek(f, (-1)*(long)sizeof(struct tstMahaia), SEEK_CUR); // posizio egokira
fwrite(&rdMahaiBat, sizeof(struct tstMahaia), 1, f);
printf(" Erreserba gauzatu da, mahai zenbakia: %d\n", rdMahaiBat.iMahaiZbk);
boMahaiaErreserbatua = TRUE;
}
}
iAulkiKopurua++;
} while (iAulkiKopurua <= iAULKI_KOP_MAX && !boMahaiaErreserbatua);
if (!boMahaiaErreserbatua)
printf(" Eskatutako mahaikide kopururako tokirik ez dago.\n");
fclose(f);
}
Jarraian ikus daitekeen bezala, datu-fitxategiak sortzeko funtzioak DatuFitxategiakSortu.c barnean garatu dira:
/*====================================================================
Programatzailea: Jesus Romo Uriarte
Data: 2025eko apirilaren 14a
Deskribapena: Informatika azterketa
2023-24 ikasturteko ohiko deialdia
Bilbo, 2024ko maiatzaren 22a
Ezaugarriak: Fitxategiak sortzeko funtzioak garatzen dira
=====================================================================*/
/*-------------------------------------------------------------------
Mahaien eta menuen datu-fitxategiekin lan egiteko funtzioen
garapenak biltzen dira fitxategi honetan.
- Mahaien fitxategi bitarra sortu datuak kargatuz
- Menuen fitxategi bitarra sortu datuak kargatuz
---------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h> // rand() eta srand()
#include <string.h> // strcpy()
#include <time.h> // time()
#include "DatuMotak.h"
#include "Prototipoak.h"
/*------------- Funtzioen prototipoak "Prototipoak.h" liburutegian -------------*/
/*----------Array konstante batetik mahaien datuak hartu eta fitxategira kargatu------------*/
#define iMAX_IZENAK 23
static char asIzenenZerrenda[][iDATU_IZEN_MAX] =
{ "Luisa", "Eva", "Janire", "Itsaso", "Jon", // 5+
"Leire", "Gorka", "Koldo", "Iesus", "Andoni", // 10+
"Helene", "Pedro", "Anne", "Ainhoa", "Kepa", // 15+
"Juan", "Gemma", "Marina", "Carmen", "Mario", // 20+
"Belen", "Nuria", "Carlos" // 23
};
int iMahaienFitxategianDatuakKargatu(const char sMahaienFitxIzen[])
{
FILE *fbErakFitx;
char *sModua = "wb"; // Fitxategi bitarra sortu
struct tstMahaia stMahaia;
srand(time(NULL));
fbErakFitx = fopen(sMahaienFitxIzen, sModua);
for (int i=0; i<iMAHAIEN_MAX; i++)
{
stMahaia.iMahaiZbk = i + 1;
/* Aulkiak 2 eta 6 artean auzaz */
stMahaia.iAulkiKop = (rand() % (iAULKI_KOP_MAX - iAULKI_KOP_MIN + 1)) + iAULKI_KOP_MIN;
if (rand() % 2 == 0)
{
stMahaia.boLibre = TRUE;
strcpy(stMahaia.sErreserbaIzena, "");
stMahaia.iMahaikideKop = 0;
}
else
{
stMahaia.boLibre = FALSE;
strcpy(stMahaia.sErreserbaIzena, asIzenenZerrenda[rand() % iMAX_IZENAK]);
stMahaia.iMahaikideKop = rand() % (stMahaia.iAulkiKop) + 1;
}
if (fwrite (&stMahaia, sizeof(struct tstMahaia), 1, fbErakFitx) != 1)
{
printf("\n\a ERROREA: Ezin izan da idatzi fitxategiaren bukaeran\n");
return -11;
}
} // for
fclose(fbErakFitx);
return 0;
};
/*----------Array konstante batetik menuen datuak hartu eta fitxategira kargatu------------*/
#define iMENUEN_LUZERA 41
static struct tstMenua astMenuenZerrenda[] =
{
{"Menu 1" , 18.00 , "ASTELEHEN"} , // 1
{"Menu 1" , 20.50 , "OSTEGUN"} , // 2
{"Menu 2" , 22.5 , "ASTELEHEN"} ,
{"Menu 3" , 18.00 , "ASTEARTE"} ,
{"Menu 4" , 22.75 , "ASTEAZKEN"} ,
{"Menu 5" , 50.0 , "OSTEGUN"} ,
{"Menu 5" , 22.75 , "ASTEARTE"} ,
{"Menu 6" , 23.00 , "ASTEAZKEN"} ,
{"Menu 7" , 20.00 , "ASTEAZKEN"} ,
{"Menu 8" , 45.0 , "OSTIRAL"} , // 10
{"Menu 9" , 19.50 , "OSTIRAL"} , // 11
{"Menu 10" , 21.50 , "OSTIRAL"} , // 12
{"Menu 11" , 23.50 , "ASTELEHEN"} ,
{"Menu 11" , 23.50 , "LARUNBAT"} ,
{"Menu 11" , 23.50 , "IGANDE"} ,
{"Menu 12" , 18.95 , "OSTEGUN"} ,
{"Menu 12" , 18.95 , "LARUNBAT"} ,
{"Menu 12" , 18.95 , "IGANDE"} ,
{"Begano 1" , 18.00 , "ASTELEHEN"} ,
{"Begano 1" , 20.00 , "ASTEAZKEN"} , // 20
{"Begano 2" , 21.00 , "ASTELEHEN"} , // 21
{"Begano 2" , 19.00 , "ASTEARTE"} , // 22
{"Begano 3" , 22.00 , "ASTEARTE"} ,
{"Begano 3" , 18.0 , "OSTEGUN"} ,
{"Begano 3" , 19.0 , "OSTIRAL"} ,
{"Begano 3" , 19.0 , "LARUNBAT"} ,
{"Begano 3" , 19.0 , "IGANDE"} ,
{"Begano 4" , 24.0 , "OSTIRAL"} ,
{"Begano 4" , 24.0 , "LARUNBAT"} ,
{"Begano 4" , 24.0 , "IGANDE"} , // 30
{"Begetariano 1" , 19.0 , "ASTELEHEN"} , // 31
{"Begetariano 1" , 21.75 , "ASTEAZKEN"} , // 32
{"Begetariano 1" , 21.75 , "LARUNBAT"} ,
{"Begetariano 1" , 21.75 , "IGANDE"} ,
{"Begetariano 2" , 19.25 , "ASTEARTE"} ,
{"Begetariano 2" , 19.25 , "LARUNBAT"} ,
{"Begetariano 2" , 19.25 , "IGANDE"} ,
{"Piszitariano" , 35.25 , "OSTEGUN"} ,
{"Piszitariano" , 35.25 , "OSTIRAL"} ,
{"Piszitariano" , 35.25 , "LARUNBAT"} , // 40
{"Piszitariano" , 35.25 , "IGANDE"} // 41
};
int iMenuenFitxategianDatuakKargatu(const char sMenuenFitxIzen[])
{
FILE *fbstKarta;
char *sModua = "wb"; // Fitxategi bitarra sortu
int i;
fbstKarta = fopen(sMenuenFitxIzen, sModua);
for (i=0; i<iMENUEN_LUZERA; i++)
{
/* Programa honetan konprobazio hau ez da guztiz beharrezkoa */
if (fwrite (&astMenuenZerrenda[i], sizeof(struct tstMenua), 1, fbstKarta) != 1)
{
printf("\n\a ERROREA: Ezin izan zaio gehitu fitxategiari elementua\n");
return -21;
}
} // for
fclose(fbstKarta);
return 0;
}
Ikasleak idatzi beharko duen gehiena fitxategi honetan jasoko du:
/*====================================================================
Ikaslearen izena-abizena: _______________________
Lanak Zure kode gehiena hemen idatziko duzu. Esate baterako,
----- demagun 10 mahaietan lortu diren euroak pantailaratu
nahi direla: 7. aukerako KontuakPantailaratu() funtzioa.
Urratsak Hiru fitxategitan idatzi beharko duzu:
--------
- "main.c" fitxategian 7. aukera editatu KontuakPantailaratu()
funtzioaren deia egiteko
- "Prototipoak.h" liburutegian KontuakPantailaratu() funtzioaren
goiburua idatzi
- "IkaslearenKodea.c" fitxategi honetan KontuakPantailaratu()
funtzioa garatu
=====================================================================*/
#include <stdio.h>
#include "DatuMotak.h"
#include "Prototipoak.h"
/*-----4. aukera-------Mahaia baten erreserba ezeztatu-------------------*/
// Idatzi hemen "ErreserbaEzeztatu()" funtzioaren kodea
/*-----7. aukera-------Mahaien uneko irabaziak pantailaratu--------------*/
// Idatzi hemen "KontuakPantailaratu()" funtzioaren kodea
/*-----8. aukera-------Zeregin berria, adibidez media bat kalkulatu------*/
// Idatzi hemen media kalkulatzen duen funtzioaren kodea
/*-----9. aukera-------Zeregin berria, adibidez bilaketa bat egin--------*/
// Idatzi hemen bilaketa burutzen duen funtzioaren kodea
/*---------------"IkaslearenKodea.c" fitxategiaren amaiera---------------*/
|
Proiektuak behar dituen 5 fitxategi horiek Code::Blocks ingurune grafikoan nola agertzen diren jakiteko, ikusi blogeko 3. kontroleko proiektua izena duen orrialdea.