| ZER DAKIDAN: Arrayak eta kateak ezagutzen ditut. ZER IKASIKO DUDAN: Kateen ariketa bat egingo dut. |
Teklatuaren bidez sartutako bi esaldietan gorderik dagoen informazioan bi zati daude, azpikate batean izena eta beste azpikate batean zenbakizko nota bat. Azpikateak banatu beharko dira.
Teklatuaren bidez sartutako bi esaldietan gorderik dagoen informazioak ondoko itxura du letrak#z.zletrak non z.z azpikatea zenbaki bat adierazten duen. Helburua da bi noten arteko batezbesteko aritmetikoa kalkulatzea.
Esaldi bat gets() bitartez irakurri ondoren zer dakigu: lehenik izenaren zatia adierazten duen azpikatea dagoela, gero # banatzailea, gero zenbakia adierazten duten 3 karaktere (zifra-puntu-zifra) daude, eta, bukatzeko izenaren bigarren zatia adierazten duen azpikatea dagoela dakigu.
Programaren kodean ikus daiteke datua hartzeko gets() funtzioari deia egiten zaiola KateaIrakurri() delako funtzio barruan. Katea teklatuz jaso ondoren KateaIrakurri() funtzioan datua aztertzen da bere formatuaren zuzentasuna bermatzeko. Ikus daiteke do-while agindu errepikakorretik irteteko datuak bete behar dituela formatuaren betekizunak: Letrak[#ZifraPuntuZifra]Letrak edo bestela Letrak[#ZifraPuntuZifra].
/* Ariketa-57a_BiNotenMedia: kate pare bat emanik bakoitzean dauden zifrak
banatu eta eragiketa aritmetiko bat burutu. */
// Datua gets() bitartez irakurri.
// Ariketaren funtsa # karakterean dago, hori baita izena eta nota banatzen dituena
// eta horrekin batera jakina dela zifrak 3 direla (unitatea, puntua eta hamarrekoa).
// Datu diren bi kateak teklatuz hartzen dira KateaIrakurri() funtzioan, non datuen
// zuzentasuna aztertzen eta ziurtatzen den.
#include <stdio.h>
#include <string.h> // strstr(), strlen(), strncpy() eta strncmp() funtzioetarako
#include <stdlib.h> // atof() funtzioarako
#define FALSE 0
#define TRUE 1
// sIkaslea katea teklatuz irakurri datuen zuzuentasuna kontrolatuz
void KateaIrakurri(char* sIkaslea);
// sIkaslea kate osotik, sNota nota ateratzen duen funtzioa
void NotaEskuratu(const char* sIkaslea, char* sNota);
int main()
{
char sIkasle1[21], sIkasle2[21];
char sNota1[4], sNota2[4];
float fNota1, fNota2;
printf("////////////////////////////////////////////////////\n");
/*
do
{
printf("Lehen ikaslearen datuak eman (adibidez: Ele#7.2onor): ");
fgets(sIkasle1, sizeof(sIkasle1), stdin); // katea irakurri bere neurria zainduz
//sIkasle1[strcspn(sIkasle1, "\n")] = 0; // Enter karakterea kentzeko
sIkasle1[strlen(sIkasle1)-1] = '\0'; // Enter karakterea kentzeko
} while (strcspn(sIkasle1, "#") == strlen(sIkasle1));
// # ez badago null karakterearen posizioa itzultzen du strcspn-k eta balio hori strlen-en emaitza da
*/
printf("\nLehen ikaslearen datuak eman (adibidez: Ele#7.2onor)...\n");
KateaIrakurri(sIkasle1);
/*
do
{
printf("Bigarren ikaslearen datuak eman (adibidez: #6.8Paul): ");
fgets(sIkasle2, sizeof(sIkasle2), stdin); // katea irakurri bere neurria zainduz
//sIkasle2[strcspn(sIkasle2, "\n")] = 0; // Enter karakterea kentzeko
sIkasle2[strlen(sIkasle2)-1] = '\0'; // Enter karakterea kentzeko
} while (strcspn(sIkasle2, "#") == strlen(sIkasle2));
// # ez badago null karakterearen posizioa itzultzen du strcspn-k eta balio hori strlen-en emaitza da
*/
printf("\nBigarren ikaslearen datuak eman (adibidez: #6.8Paul)...\n");
KateaIrakurri(sIkasle2);
printf("1 ===|%s|===\n", sIkasle1);
printf("2 ===|%s|===\n\n", sIkasle2);
// kate bakoitzatik nota atera
NotaEskuratu(sIkasle1, sNota1);
printf("1 nota ===|%s|===\n", sNota1);
NotaEskuratu(sIkasle2, sNota2);
printf("2 nota ===|%s|===\n\n", sNota2);
// katetik zenbaki errelera, errorerik ez dago datuak kontrolaturik egon direlako
fNota1 = atof(sNota1);
fNota2 = atof(sNota2);
printf("Batezbestekoa: (%.1f + %.1f)/2 = %.2f\n", fNota1, fNota2, (fNota1 + fNota2) / 2);
printf("\n////////////////////////////////////////////////////\n");
return 0;
}
// sIkaslea katea teklatuz irakurri datuen zuzuentasuna kontrolatuz
void KateaIrakurri(char* sIkaslea)
{
char *pErak;
int iUnitateaNon;
int iPuntuaNon;
int iHamarrekoaNon;
do
{
printf("Ikaslearen datuak eman (adibidez: Letrak#5.7Letrak): ");
gets(sIkaslea); // katea irakurri, neurria 20+1
pErak = strstr(sIkaslea, "#");
if (pErak == NULL)
printf("Errorea!!! '#' banatzailea falta da\n");
else
{
iUnitateaNon = pErak - sIkaslea + 1;
if (sIkaslea[iUnitateaNon] < '0' || sIkaslea[iUnitateaNon] > '9')
printf("Notaren lehen zifra desegokia, '%c' ez da onartzen\n", sIkaslea[iUnitateaNon]);
iPuntuaNon = pErak - sIkaslea + 2;
if (sIkaslea[iPuntuaNon] != '.')
printf("Notari puntua falta zaio, '%c' ez da onartzen\n", sIkaslea[iPuntuaNon]);
iHamarrekoaNon = pErak - sIkaslea + 3;
if (sIkaslea[iHamarrekoaNon] < '0' || sIkaslea[iHamarrekoaNon] > '9')
printf("Notaren azken zifra desegokia, '%c' ez da onartzen\n", sIkaslea[iHamarrekoaNon]);
}
} while ((pErak == NULL) ||
(sIkaslea[iUnitateaNon] < '0' || sIkaslea[iUnitateaNon] > '9') ||
(sIkaslea[iPuntuaNon] != '.') ||
(sIkaslea[iHamarrekoaNon] < '0' || sIkaslea[iHamarrekoaNon] > '9'));
}
// sIkaslea kate osotik, sNota nota ateratzen duen funtzioa
void NotaEskuratu(const char* sIkaslea, char* sNota)
{
char* pBanatzailea;
pBanatzailea = strchr(sIkaslea, '#'); // '#' karakterearen posizioa zehaztu
if (pBanatzailea != NULL) // if hau soberan egon daiteke ziurra delako # dagoela
{ // eta zenbakiarean azpikatea zifra-puntu-zifra dela
printf("'%s' datuan '#' %d. posizioan\n", sIkaslea, (int)(pBanatzailea - sIkaslea));
strncpy(sNota, pBanatzailea+1, 3); // #-ren hurrengo hiru karaktereak kopiatu
sNota[3] = '\0'; // azpikatea amaiarazi
}
}
Teklatuaren bidez sartutako bi esaldietan gorderik dagoen informazioak ondoko itxura du IzenaZ.Z non Z.Z azpikatea zenbaki bat adierazten duen. Helburua da bi noten arteko batezbesteko aritmetikoa kalkulatzea.
Esaldi bat gets() bitartez irakurri ondoren zer dakigu: lehenik izena adierazten duen azpikatea dagoela, gero zenbakia adierazten duten 3 karaktere (zifra-puntu-zifra) daudela.
Programan ikus daiteke datua hartzean gets() funtzioari deia egiten zaiola eta ez dela kode gehiagorik gehitu datuaren egokitasuna bermatzeko. Ondorioz, baliteke atof() funtzioak huts egitea edo zenbakia moztea. Horregatik, media kalkulatu aurretik konprobatzen da atof() funtzioak ez duela huts egin. Edozein kasutan, programa honek ahultasun nabaria du, adibidez "Jokin7.23" daturako, zenbakiari dagozkion azken hiru karaktereak hartzean ".23" katea geratzen da ("7" karakterea galduz), kasu honetan atof() funtzioak 0.23 zenbaki erreala emango du eta horrekin media kalkulatuko da.
/* Ariketa-57b_BiNotenMedia: kate pare bat emanik bakoitzean dauden zifrak
banatu eta eragiketa aritmetiko bat burutu. */
// Datua gets() bitartez irakurri ondoren.
// Ariketaren funtsa katea nota azpikatearen kokapenean eta tamainan dago, nota
// azpikatea jatorrizko katearen bukaeran dago eta beti 3 karaktere dira hauek:
// (zifra-puntu-zifra).
// Ariketa honetan, datuak irakurtzean, haien zuzuentasuna ez da kontrolatzen,
// hori dela eta, atof() funtzioak huts egin dezake eta horregatik batezbestekoa
// kalkulatu ala ez kalkulatu erabaki beharra dago.
// Kode hau ez da ondo ibiliko "Jokin7.23" daturako. Izan ere, nota-katea ".23"
// izango da (azken 3 karaktereak) non '7' karakterea galdu den, eta hortik
// abiatuta atof() funtzioak 0.23 zenbakia ematen du eta media kalkula daiteke
// baina emaitza txarto dago lehen zifra galdu delako.
#include <stdio.h>
#include <string.h> // strlen() funtziorako
#include <stdlib.h> // atof() funtzioarako
#define MAX_KATEA 20
#define FALSE 0
#define TRUE 1
// Nota ateratzeko funtzioa, ez du datuen zuzuentasuna aztertzen
char* NotaBakandu(const char* sIkaslea);
int main()
{
char sIkasle1[MAX_KATEA + 1];
char sIkasle2[MAX_KATEA + 1];
char *sNota1;
char *sNota2;
float fNota1, fNota2;
int iErrore1 = FALSE;
int iErrore2 = FALSE;
/*
do
{
printf("Lehen ikaslearen datuak eman (adibidez: Eleonor7.2): ");
fgets(sIkasle1, sizeof(sIkasle1), stdin); // katea irakurri bere neurria zainduz
//sIkasle1[strcspn(sIkasle1, "\n")] = 0; // Enter karakterea kentzeko
sIkasle1[strlen(sIkasle1)-1] = '\0'; // Enter karakterea kentzeko
} while (strcspn(sIkasle1, "#") == strlen(sIkasle1));
// # ez badago null karakterearen posizioa itzultzen du strcspn-k eta balio hori strlen-en emaitza da
*/
printf("\nLehen ikaslearen datuak eman (adibidez: Eleonor7.2): ");
gets(sIkasle1); // katea irakurri, neurria 20+1
printf("sIkasle1 = |%s| \n", sIkasle1);
/*
do
{
printf("Bigarren ikaslearen datuak eman (adibidez: Paul6.8): ");
fgets(sIkasle2, sizeof(sIkasle2), stdin); // katea irakurri bere neurria zainduz
//sIkasle2[strcspn(sIkasle2, "\n")] = 0; // Enter karakterea kentzeko
sIkasle2[strlen(sIkasle2)-1] = '\0'; // Enter karakterea kentzeko
} while (strcspn(sIkasle2, "#") == strlen(sIkasle2));
// # ez badago null karakterearen posizioa itzultzen du strcspn-k eta balio hori strlen-en emaitza da
*/
printf("\nBigarren ikaslearen datuak eman (adibidez: Paul6.8): ");
gets(sIkasle2); // katea irakurri, neurria 20+1
printf("sIkasle2 = |%s| \n\n", sIkasle2);
// Lehen ikaslearen nota bakandu eta balioa lortu
sNota1 = NotaBakandu(sIkasle1);
fNota1 = atof(sNota1);
printf("sNota1 = |%s| fNota1 = |%f|\n", sNota1, fNota1);
// errorea emaitza 0.0 bada eta jatorrizko katea "0.0" ez bada
if (fNota1 == 0.0 && strcmp(sNota1, "0.0") != 0)
{
printf("sIkasle1 ---|%s|--- datua ez da egokia\n", sIkasle1);
iErrore1 = TRUE;
}
// Bigarren ikaslearen nota bakandu eta balioa lortu
sNota2 = NotaBakandu(sIkasle2);
fNota2 = atof(sNota2);
printf("sNota2 = |%s| fNota2 = |%f|\n", sNota2, fNota2);
// errorea emaitza 0.0 bada eta jatorrizko katea "0.0" ez bada
if (fNota2 == 0.0 && strcmp(sNota2, "0.0") != 0)
{
printf("sIkasle2 ---|%s|--- datua ez da egokia\n", sIkasle2);
iErrore2 = TRUE;
}
// errorerik ez bada gertatu media kalkulatu
if (!iErrore1 && !iErrore2)
printf("\nBatezbestekoa: (%f + %f)/2 = %f\n", fNota1, fNota2, (fNota1 + fNota2) / 2);
else
printf("\nBatezbestekoa ezin izan da kalkulatu\n");
return 0;
}
// Nota ateratzeko funtzioa, ez du datuen zuzuentasuna aztertzen
char* NotaBakandu(const char* sIkaslea)
{
static char sNota[4]; // 3 digituko nota eta NULL amaiera
int len = strlen(sIkaslea);
// Kate nagusiaren azken hiru karaktereak ateratzen dira
sNota[0] = sIkaslea[len-3]; // Zifra osoa
sNota[1] = sIkaslea[len-2]; // Puntua
sNota[2] = sIkaslea[len-1]; // Dezimala
sNota[3] = '\0'; // Amaiera karakterea
return sNota;
}
Teklatuaren bidez sartutako bi esaldietan gorderik dagoen informazioak ondoko itxura du letrak#z.zzz non z.zzz azpikatea zenbaki bat adierazten duen eta dezimalen kopurua aldakorra izan daitekeen datu batetik bestera, baina alde osoak beti dauka zifra bakar bat. Helburua da bi noten arteko batezbesteko aritmetikoa kalkulatzea.
Esaldi bat gets() bitartez irakurri ondoren zer dakigu: lehenik izena adierazten duen azpikatea dagoela, gero # banatzailea, gero zifra bat, gero puntua eta bukatzeko hainbat hamartar. Noski, esaldiaren zenbakizko azpikatea lortu beharko da.
Programaren kodean ikus daiteke datua hartzeko gets() funtzioaren deia eta datuaren zuzentasuna main() fungzio nagusian editen direla. Horregatik, exekuzioaren fokoa atof() funtzioara heltzean ziurtatuta dago hutsik ez duela egingo eta zenbaki erreal egokia itzuliko duela.
/* Ariketa-57c_BiNotenMedia: kate pare bat emanik bakoitzean dauden zifrak
banatu eta eragiketa aritmetiko bat burutu. */
// Datua gets() bitartez irakurri.
// Izenaren azpikatea eta zenbakiaren azpikatea # karakterez banaturik datoz datuan.
// Zenbakia adierazten duen azpikatea datuaren bukaeran dagoela dakigu, baina zenbat
// dezimal dituen ez dakigu.
// Datu diren bi kateak teklatuz hartzen dira main() funtzio nagusian, eta funtzio
// nagusian bertan aztertzen da datuaren zuzentasuna. BOndorioz, atof() funtzioaren
// arrakasta ziurtatuta dago.
#include <stdio.h>
#include <string.h> // strstr(), strlen(), strncpy() eta strchr() funtzioetarako
#include <stdlib.h> // atof() funtzioarako
#define FALSE 0
#define TRUE 1
// sIkaslea kate osotik, sNota nota ateratzen duen funtzioa
void NotaEskuratu(const char* sIkaslea, char* sNota);
int main()
{
char sIkasle1[31], sIkasle2[31];
char sNota1[16], sNota2[16];
char *pErak;
int iUnitateaNon;
int iPuntuaNon;
int iHamarrekoakNondik;
int iHamarrekoakZenbat;
int iKont;
float fNota1, fNota2;
int iErrorea;
printf("///////////////////////////////////////////////////////\n");
do
{
printf("\nLehen ikaslearen datuak eman (adibidez: Helene#7.245): ");
gets(sIkasle1); // katea irakurri, neurria 30+1
pErak = strstr(sIkasle1, "#");
if (pErak == NULL)
printf("Errorea!!! '#' banatzailea falta da\n");
else
{
iUnitateaNon = pErak - sIkasle1 + 1;
if (sIkasle1[iUnitateaNon] < '0' || sIkasle1[iUnitateaNon] > '9')
printf("Notaren lehen zifra desegokia, '%c' ez da onartzen\n", sIkasle1[iUnitateaNon]);
iPuntuaNon = pErak - sIkasle1 + 2;
if (sIkasle1[iPuntuaNon] != '.')
printf("Notari puntua falta zaio, '%c' ez da onartzen\n", sIkasle1[iPuntuaNon]);
iHamarrekoakNondik = pErak - sIkasle1 + 3;
iHamarrekoakZenbat = strlen(sIkasle1) - iHamarrekoakNondik;
printf("iHamarrekoakNondik=%d\tiHamarrekoakZenbat=%d", iHamarrekoakNondik, iHamarrekoakZenbat);
iErrorea = FALSE;
for (iKont = 0; iKont < iHamarrekoakZenbat; iKont++)
{
printf("\niKont=%d \t sIkasle1[%2d]=%c", iKont, iKont+iHamarrekoakNondik, sIkasle1[iKont+iHamarrekoakNondik]);
if (sIkasle1[iKont+iHamarrekoakNondik] < '0' || sIkasle1[iKont+iHamarrekoakNondik] > '9')
iErrorea = TRUE;
}
if (iErrorea == TRUE)
printf("\nDezimaletan errorea dago\n");
}
} while ((pErak == NULL) ||
(sIkasle1[iUnitateaNon] < '0' || sIkasle1[iUnitateaNon] > '9') ||
(sIkasle1[iPuntuaNon] != '.') ||
(iErrorea == TRUE));
printf("\n");
printf("1. datua ===|%s|===\n", sIkasle1);
printf("1. '%s' datuak %d karaktere ditu\n", sIkasle1, (int)strlen(sIkasle1));
// katetik nota atera
NotaEskuratu(sIkasle1, sNota1);
printf("1. nota: sNota1===|%s|===\n", sNota1);
// katetik zenbaki errealera igaro
fNota1 = atof(sNota1);
printf("1. nota: fNota1=%f\n", fNota1);
printf("\n");
do
{
printf("\nBigarren ikaslearen datuak eman (adibidez: Paul#6.8): ");
gets(sIkasle2); // katea irakurri, neurria 30+1
pErak = strchr(sIkasle2, '#');
if (pErak == NULL)
printf("Errorea!!! '#' banatzailea falta da\n");
else
{
iUnitateaNon = pErak - sIkasle2 + 1;
if (sIkasle2[iUnitateaNon] < '0' || sIkasle2[iUnitateaNon] > '9')
printf("Notaren lehen zifra desegokia, '%c' ez da onartzen\n", sIkasle2[iUnitateaNon]);
iPuntuaNon = pErak - sIkasle2 + 2;
if (sIkasle2[iPuntuaNon] != '.')
printf("Notari puntua falta zaio, '%c' ez da onartzen\n", sIkasle2[iPuntuaNon]);
iHamarrekoakNondik = pErak - sIkasle2 + 3;
iHamarrekoakZenbat = strlen(sIkasle2) - iHamarrekoakNondik;
printf("\niHamarrekoakNondik=%d\tiHamarrekoakZenbat=%d", iHamarrekoakNondik, iHamarrekoakZenbat);
iErrorea = FALSE;
for (iKont = 0; iKont < iHamarrekoakZenbat; iKont++)
{
printf("\niKont=%d \t sIkasle2[%2d]=%c", iKont, iKont+iHamarrekoakNondik, sIkasle2[iKont+iHamarrekoakNondik]);
if (sIkasle2[iKont+iHamarrekoakNondik] < '0' || sIkasle2[iKont+iHamarrekoakNondik] > '9')
iErrorea = TRUE;
}
if (iErrorea == TRUE)
printf("\nDezimaletan errorea dago\n");
}
} while ((pErak == NULL) ||
(sIkasle2[iUnitateaNon] < '0' || sIkasle2[iUnitateaNon] > '9') ||
(sIkasle2[iPuntuaNon] != '.') ||
(iErrorea == TRUE));
printf("\n");
printf("2. datua ===|%s|===\n", sIkasle2);
printf("2. '%s' datuak %d karaktere ditu\n", sIkasle2, (int)strlen(sIkasle2));
// katetik nota atera
NotaEskuratu(sIkasle2, sNota2);
printf("2. nota: sNota2===|%s|===\n", sNota2);
// katetik zenbaki errealera igaro
fNota2 = atof(sNota2);
printf("2. nota: fNota2=%f\n", fNota2);
// errorerik ez da gertatu datuak kontrolatuak izan direlako haien irakurketan
printf("\nBatezbestekoa: (%f + %f)/2 = %f\n", fNota1, fNota2, (fNota1 + fNota2) / 2);
printf("\n///////////////////////////////////////////////////////\n");
return 0;
}
// sIkaslea kate osotik, sNota nota ateratzen duen funtzioa
void NotaEskuratu(const char* sIkaslea, char* sNota)
{
char* pBanatzaileaNon;
int iNonHastenDa;
int iLuzeraOsoa;
pBanatzaileaNon = strchr(sIkaslea, '#'); // '#' karakterearen posizioa zehaztu
iNonHastenDa = (int)(pBanatzaileaNon - sIkaslea) +1; // zenbakiaren azpikatea non hasten da
printf("'%s' datuan '#' ostekoa %d posizioan hasten da\n", sIkaslea, iNonHastenDa);
iLuzeraOsoa = strlen(sIkaslea);
printf("'%s' datuan %d karaktere daude\n", sIkaslea, iLuzeraOsoa);
printf("'%s' datuan zenbaki-azpikateak %d karaktere ditu\n", sIkaslea, iLuzeraOsoa-iNonHastenDa);
strncpy(sNota, pBanatzaileaNon + 1, iLuzeraOsoa-iNonHastenDa); // notaren karaktereak kopiatu
sNota[iLuzeraOsoa-iNonHastenDa] = '\0'; // azpikatea amaiarazi
}
Teklatuaren bidez sartutako bi esaldietan gorderik dagoen informazioak ondoko itxura du izenaZZZ.ZZZZ non ZZZ.ZZZZ azpikatea zenbaki bat adierazten duen. Kontutan izan, zati osoaren zifren kopurua eta dezimalen kopurua aldakorrak izan daitezkeela datu batetik bestera. Helburua da bi noten arteko batezbesteko aritmetikoa kalkulatzea.
Esaldi bat gets() bitartez irakurri ondoren zer dakigu: lehenik izena adierazten duen azpikatea dagoela eta ondoren zenbakia adierazten duen azpikatea dagoela. Noski, esaldiaren zenbakizko azpikatea lortu beharko da.
Programa honetan, datuak irakurtzean, haien zuzuentasuna ez da asko kontrolatzen, izenik dagoen ala ez frogatzen da, notarik dagoen ala ez frogatzen da ere (notari dagokiola, gutxienez zifra bat daukala frogatzen da), noski, lehen zifra horren ostean letrarik balego atof() funtzioak ez luke huts egingo baina ematen duen zenbakia ahal duena da (mozturik geratzen baita).
/* Ariketa-57d_BiNotenMedia: kate pare bat emanik bakoitzean dauden zifrak
banatu eta eragiketa aritmetiko bat burutu. */
// Datua gets() bitartez irakurri.
// Izenaren azpikatea eta zenbakiaren azpikatea banatzailerik ez daukate, zenbakiaren
// dezimal kopurua ezezaguna da ere. Hori bai, ziurtzat jo dezakegu, datuaren hasieran
// izenari dagokion azpikatea doala eta ondoren zenbakia adierazten duen azpikatea.
// Ariketa honetan, datuak irakurtzean, haien zuzuentasuna ez da asko kontrolatzen,
// izena dagoela frogatzen da, nota dagoela frogatzen da ere (nota, gutxienez zifra bat
// dagoela frogatzen da), lehen zifra horren ostean letrarik balego atof() funtzioak
// ez du huts egiten baina ematen duen zenbakia ahal duena da.
#include <stdio.h>
#include <string.h> // strlen() funtziorako
#include <stdlib.h> // atof() funtziorako
#define MAXIMOA 31
// sIkaslea katean notaren lehen zifrako (edo puntuaren) posizioa itzuli
int NotaAurkitu(const char* sIkaslea);
int main()
{
char sIkasle1[MAXIMOA], sIkasle2[MAXIMOA]; // 30+1
char sNota1[MAXIMOA/2+1], sNota2[MAXIMOA/2+1]; // 15+1
int iNotaNonHastenDa;
int iZenbatZifra;
int iKont;
int iIndizea;
float fNota1, fNota2;
printf("///////////////////////////////////////////////////////\n");
do
{
printf("\nLehen ikaslearen datuak eman (adibidez: Helene73.9245): ");
gets(sIkasle1); // katea irakurri, neurria 30+1
iNotaNonHastenDa = NotaAurkitu(sIkasle1);
if (iNotaNonHastenDa == -1)
printf("\nDatuari nota falta zaio\n");
if (iNotaNonHastenDa == 0)
printf("\nDatuari izena falta zaio, lehen letra bezala '%c' ez da onartzen\n", sIkasle1[iNotaNonHastenDa]);
if (iNotaNonHastenDa > 0)
printf("\niNotaNonHastenDa=%d \t sIkasle1[%d]=%c", iNotaNonHastenDa, iNotaNonHastenDa, sIkasle1[iNotaNonHastenDa]);
} while (iNotaNonHastenDa == 0 || iNotaNonHastenDa == -1);
iZenbatZifra = strlen(sIkasle1) - iNotaNonHastenDa;
printf("\niZenbatZifra=%d \t iAzkenaNon=%d \t sIkasle1[%d]=%c\n", iZenbatZifra, (int)strlen(sIkasle1)-1, (int)strlen(sIkasle1)-1, sIkasle1[(int)strlen(sIkasle1)-1]);
iIndizea = 0;
for (iKont=iNotaNonHastenDa; iKont < strlen(sIkasle1); iKont++)
{
sNota1[iIndizea] = sIkasle1[iKont];
iIndizea++;
}
sNota1[iIndizea] = '\0';
printf("\nsNota1 = |%s|", sNota1);
printf("\n");
printf("1. datua ===|%s|===\n", sIkasle1);
printf("1. '%s' datuak %d karaktere ditu\n", sIkasle1, (int)strlen(sIkasle1));
fNota1 = atof(sNota1);
printf("1. nota: %f\n", fNota1);
printf("\n");
do
{
printf("\nBigarren ikaslearen datuak eman (adibidez: Paul68.1): ");
gets(sIkasle2); // katea irakurri, neurria 30+1
iNotaNonHastenDa = NotaAurkitu(sIkasle2);
if (iNotaNonHastenDa == -1)
printf("\nDatuari nota falta zaio\n");
if (iNotaNonHastenDa == 0)
printf("\nDatuari izena falta zaio, lehen letra bezala '%c' ez da onartzen\n", sIkasle2[iNotaNonHastenDa]);
if (iNotaNonHastenDa > 0)
printf("\niNotaNonHastenDa=%d \t sIkasle2[%d]=%c", iNotaNonHastenDa, iNotaNonHastenDa, sIkasle2[iNotaNonHastenDa]);
} while (iNotaNonHastenDa == 0);
iZenbatZifra = strlen(sIkasle2) - iNotaNonHastenDa;
printf("\niZenbatZifra=%d \t iAzkenaNon=%d \t sIkasle2[%d]=%c\n", iZenbatZifra, (int)strlen(sIkasle2)-1, (int)strlen(sIkasle2)-1, sIkasle2[(int)strlen(sIkasle2)-1]);
iIndizea = 0;
for (iKont=iNotaNonHastenDa; iKont < strlen(sIkasle2); iKont++)
{
sNota2[iIndizea] = sIkasle2[iKont];
iIndizea++;
}
sNota2[iIndizea] = '\0';
printf("\nsNota2 = |%s|", sNota2);
printf("\n");
printf("2. datua ===|%s|===\n", sIkasle2);
printf("2. '%s' datuak %d karaktere ditu\n", sIkasle2, (int)strlen(sIkasle2));
fNota2 = atof(sNota2);
printf("2. nota: %f\n", fNota2);
// errorerik ez da gertatu datuak kontrolatuak izan direlako
printf("\nBatezbestekoa: (%f + %f)/2 = %f\n", fNota1, fNota2, (fNota1 + fNota2) / 2);
printf("\n///////////////////////////////////////////////////////\n");
return 0;
}
// sIkaslea katean notaren lehen zifrako (edo puntuaren) posizioa itzuli
int NotaAurkitu(const char* sIkaslea)
{
int iKont;
iKont = -1;
do
{
iKont++;
printf("\niKont=%d \t sIkaslea[%d]=%c", iKont, iKont, sIkaslea[iKont]);
} while ((sIkaslea[iKont] < '0' || sIkaslea[iKont] > '9') && (sIkaslea[iKont] != '.') &&
(iKont < MAXIMOA));
//printf("\niKont=%d \t sIkaslea[%d]=%c\n", iKont, iKont, sIkaslea[iKont]);
if (iKont == MAXIMOA)
return -1;
else
return iKont;
}
|
iruzkinik ez:
Argitaratu iruzkina