1. Beolvasunk két egész számot. A CSEREL eljárás (függvény) segítségével felcseréljük a két változó tartalmát, majd kiírjuk őket. #include <stdio.h> void cserel(int *,int *); /* cserel prototípusa */ int main(void) { int a,b; printf("\nKérem a két számot"); scanf("%d%d",&a,&b); cserel(&a,&b); /* cserel hívása */ printf("\n\nMegcserélve %d - %d",a,b); }
return 0;
void cserel(int *x,int *y) { int s; s=*x; *x = *y; *y = s; }
/* cserel definíciója */
2. Írjunk beolvasó rutint egy egész és egy valós szám beolvasására! A beolvasást egy függvény végezze el! A főprogramban írassuk ki a beolvasott számokat! #include <stdio.h> void beolv(int *a, float *b); int main(void) { int i; float f; beolv(&i,&f); printf("A beolvasott egész: %d , valós: %f",i,f); return 0; } void beolv(int *a, float *b) { printf("Kérem az egész számot!"); scanf("%d",a); printf("Kérem a valós számot!"); scanf("%f",b); }
3. Készítsen függvényt, amely ellenőrzött adat-bevitelt valósít meg egész típusú adatokra. A program olvasson be egy egész számot, de csak bizonyos határok közötti értéket fogadjunk el. #include <stdio.h> int egesz_bevitel (int, int, char *); int main(void) { int n; /* string deklarálás kezdeti értékadással */ char csop_str [] = "Kérem a csoport létszámát :"; n = egesz_bevitel (1, 20, csop_str); printf ("\nA csoportlétszám: %d", n); return 0; } int egesz_bevitel (int ah, int fh, char *szoveg) { int adat; do { puts (szoveg); scanf ("%d", &adat);
} while (adat < ah || adat > fh); return adat; }
4. Készítsen függvényt, amely egy tetszőleges stringben (pl. névben) ellenőrzi, hogy szerepel-e abban a “dr”, “Dr” vagy “DR” karakter-sorozat. #include <stdio.h> #include <string.h> int str_mi (char [], int *); int main (void) { char nev [31]; int dr_mutat; /* a dr poziciója a névben */ printf ("\nKérem a nevet: "); gets (nev); if (str_mi (nev, &dr_mutat)) printf ("\nA dr poziciója a névben: %d", dr_mutat); else printf ("\nNincs dr a névben."); return 0; } int str_mi (char szoveg [], int *pozicio) { int i=0, str_hossz, van = 0; str_hossz = strlen (szoveg); while (i < str_hossz-1 && van == 0) { if ( (szoveg [i] == 'd' || szoveg [i] == 'D') && (szoveg [i+1] == 'r' || szoveg [i+1] == 'R')) { van++; *pozicio = i; } i++; } return van; }
5. Készítsünk függvényt az nxm-es, valós típusú adatokat tartalmazó mátrix elemeinek beolvasására, egy másik függvényt az elemek táblázatos formában történő kiíratására. A mátrix statikusan deklarált. #include <stdio.h> void f_mx_be (float *, int, int); void f_mx_ki (float *, int, int); int egesz_bevitel (int, int, char *); int main(void) { const max_oszlop = 10; const max_sor = 10; char bes [] = "Kérem a sorok aktuális számát:"; char beo [] = "Kérem az oszlopok aktuális számát:"; float eredmeny_tablazat[max_sor][max_oszlop]; /* a táblázat aktuális sor, illetve oszlop-száma */ int sor, oszlop; oszlop = egesz_bevitel (1, max_oszlop, beo); sor = egesz_bevitel (1, max_sor, bes); /* a statikusan definialt matrix csak vektorkent adhato at fuggvenynek */ f_mx_be (&eredmeny_tablazat[0][0], sor, oszlop); f_mx_ki (&eredmeny_tablazat[0][0], sor, oszlop); }
return 0;
int egesz_bevitel (int ah, int fh, char * szoveg) { int adat; do { printf ("%s",szoveg); scanf ("%d", &adat); } while (adat < ah || adat > fh); } /*
return adat;
a függvény float típusú elemeket tartalmazó, sor sorból és oszlop oszlopból álló mátrix elemeinek beolvasását végzi el.
*/ void f_mx_be (float *mx, int sor, int oszl) { int i, j; for(i=0; i<sor; i++)
{
}
}
/*
printf ("\nKérem az %d. sor elemeit:", i+1); for(j = 0; j < oszl; j++) /* i-dik sor j-dik elem beolvasása */ scanf ("%f", mx + i * oszl + j);
a függvény float típusú elemeket tartalmazó, sor sorból és oszlop oszlopból álló mátrix elemeinek kiíratását végzi el.
*/ void f_mx_ki (float *mx, int sor, int oszl) { int i, j; printf ("\nA TÁBLÁZAT:\n"); for(i=0; i<sor; i++) { /* soremelés minden táblázatsor el•tt */ printf ("\n"); for (j = 0; j < oszl; j++) { /* i-dik sor j-dik elem kiírása */ printf ("%10.2f", *(mx + i * oszl + j)); } } }
6. Oldjuk meg az előző feladatot dinamikusan foglalt mátrix-al. #include <stdio.h> #include <stdlib.h> void f_mx_be (float *, int, int); void f_mx_ki (float *, int, int); int egesz_bevitel (int, int, char *); float **alloc_tomb(int sor, int oszlop); int main(void) { const max_oszlop = 10; const max_sor = 10; char bes [] = "Kérem a sorok aktuális számát:"; char beo [] = "Kérem az oszlopok aktuális számát:"; float **eredmeny_tablazat; /* a táblázat aktuális sor, illetve oszlop-száma */ int sor, oszlop; oszlop = egesz_bevitel (1, max_oszlop, beo); sor = egesz_bevitel (1, max_sor, bes); eredmeny_tablazat = alloc_tomb(sor, oszlop); f_mx_be(eredmeny_tablazat, sor, oszlop); f_mx_ki(eredmeny_tablazat, sor, oszlop); }
return 0;
float **alloc_tomb(int sor, int oszlop) { float **p; int j; p = (float **)calloc(sor, sizeof(float *)); for(j = 0; j < sor; j++) { p[j] = (float *)calloc(oszlop, sizeof(float)); } return p; } int egesz_bevitel (int ah, int fh, char *szoveg) { int adat; do { printf ("%s",szoveg);
scanf ("%d", &adat); } while (adat < ah || adat > fh); }
return adat;
void f_mx_be (float **mx, int sor, int oszl) { int i, j; for(i=0; i<sor; i++) { printf ("\nKérem az %d. sor elemeit:", i+1); for(j = 0; j < oszl; j++) { /* i-dik sor j-dik elem beolvasása */ scanf ("%f", &(mx[i][j])); } } } void f_mx_ki (float **mx, int sor, int oszl) { int i, j; printf ("\nA TÁBLÁZAT:\n"); for(i=0; i<sor; i++) { /* soremelés minden táblázatsor el•tt */ printf ("\n"); for (j = 0; j < oszl; j++) { /* i-dik sor j-dik elem kiírása */ printf ("%10.2f", mx[i][j]); } } }
7. Irjunk programot, amely beolvas egy long értéket, és a long változó négy byte-ját rendre egy-egy karakteres típusú változóban helyezi el !
#include <stdio.h> int main() { char a, b, c, d, *x; long l; printf("\nKérem a long változó értékét : ") ; scanf("%ld",&l); x = (char *) &l ; printf("\nx = %p", x ); a b c d
= = = =
*(x+0) *(x+1) *(x+2) *(x+3)
; ; ; ;
printf("\nl printf("\na printf("\nb printf("\nc printf("\nd return 0; }
= = = = =
%ld",l) ; %c", a ); %c", b ); %c", c ); %c", d );
8. Írjon programot melyben definiálunk egy új struktúrát. A struktúra elemei egy egész szám, egy valós szám és egy karakter. A program töltse fel értékkel a struktúra elemeit, majd nyomtassa ki azokat. #include <stdio.h> #include <stdlib.h> int main() { /* definiáljuk a struktúrát és rögtön egy változó típusa is lesz*/ struct valami { int egesz; double valos; char karakter; } elso; /* adjunk értékeket */ elso.egesz = 1; elso.valos = 2.2; elso.karakter = '3'; /* nyomtassuk ki az értékeket */ printf("egesz = %d : valos = %lf : karakter = %c", elso.egesz, elso.valos, elso.karakter); return 0; }
9. Írjon programot melyben definiálunk egy új struktúrát. A struktúra elemei egy egész szám, egy valós szám és egy karakter. A program töltse fel értékkel a struktúra elemeit, majd másoljuk át egy másik struktúrába az értékeket és nyomtassa ki az új struktúrát. #include <stdio.h> #include <stdlib.h> int main() { /* definiáljuk a struktúrát és rögtön egy változó típusa is lesz*/ struct valami { int egesz; double valos; char karakter; } elso; struct valami masodik; /* adjunk értékeket */ elso.egesz = 1; elso.valos = 2.2; elso.karakter = '3'; /* struktúrák esetén egyszerű a másolás, csak egy értékadást kell végrehajtani */ masodik = elso; /* nyomtassuk ki a 'masodik' értékeit */ printf("egesz = %d : valos = %lf : karakter = %c", masodik.egesz, masodik.valos, masodik.karakter); return 0; }
10. Írjon programot melyben definiálunk egy új struktúrát. A struktúra elemei egy egész szám, egy valós szám és egy karakter. A program töltse fel értékkel a struktúra elemeit, majd hívjunk meg egy függvényt ezzel a struktúrával. A függvényen belül változtassuk meg a struktúra értékeit. A függvénynek legyen visszatérési értéke is mely egy struktúra lesz. (Azt kell tapasztalnunk, hogy ahogy struktúrát lehet másolni is, úgy a függvény visszatérsi értékként is használható.) #include <stdio.h> #include <stdlib.h> /* definiáljuk a struktúrát globálisan */ struct valami { int egesz; double valos; char karakter; }; /* elso : lokális változó lesz */ struct valami fvg(struct valami elso) { elso.egesz = elso.egesz + 2; elso.valos = elso.valos + 2.2; elso.karakter = elso.karakter + 2; }
return elso;
int main() { struct valami elso, masodik; /* adjunk értékeket */ elso.egesz = 1; elso.valos = 2.2; elso.karakter = '3'; /* látni fogjuk, hogy elso értékei érintetlenek maradnak */ masodik = fvg(elso); /* nyomtassuk ki az 'elso' értékeit */ printf("egesz = %d : valos = %lf : karakter = %c", elso.egesz, elso.valos, elso.karakter); /* nyomtassuk ki a 'masodik' értékeit */ printf("egesz = %d : valos = %lf : karakter = %c", masodik.egesz, masodik.valos, masodik.karakter); return 0; }
11. Írjon programot melyben definiálunk egy új struktúrát. A struktúra elemei egy egész szám, egy valós szám és egy karakter. A program töltse fel értékkel a struktúra elemeit, majd hívjunk meg egy függvényt melynek egy argumentuma van egy struktúra mutató. A függvényen belül változtassuk meg a struktúra értékeit. #include <stdio.h> #include <stdlib.h> /* definiáljuk a struktúrát globálisan */ struct valami { int egesz; double valos; char karakter; }; /* elso : egy mutató, így valójában a globalis változót módosítjuk */ void fvg(struct valami *elso) { elso->egesz = elso->egesz + 2; elso->valos = elso->valos + 2.2; elso->karakter = elso->karakter + 2; } int main() { struct valami elso; /* adjunk értékeket */ elso.egesz = 1; elso.valos = 2.2; elso.karakter = '3'; /* látni fogjuk, hogy elso értékei módosulnak */ fvg(&elso); /* nyomtassuk ki az 'elso' értékeit */ printf("egesz = %d : valos = %lf : karakter = %c", elso.egesz, elso.valos, elso.karakter); return 0; }
12. Egy cég dolgozóinak fizetését kell meghatározni. Írjon programot mely a következőket teszi: • Kérje be egy cégnél dolgozó emberek adatait o Először azt hogy hány ember dolgozik a cégnél. o Maximum 10 személy. o Ha a felhasználó többet akar megadni, ne engedjük. o Olvassa be a személyek adatait. Egy személy adatait tároljuk egy struktúrában. A struktúrának az alábbi elemei vannak: Dolgozó személyi száma (egész szám) Dolgozó neve Ledolgozott órák száma (egész szám) • Kérje be az alapóra árát és a túlóra árát. • A beolvasás után nyomtasson ki egy listát o Egy sorba a dolgozó nevét és fizetését o A fizetést az alábbi módon lehet kiszámolni fizetes = alapórabér * órák száma 200-ig + túlórabér * 200 óra után #include <stdio.h> struct { int char int };
dolgozo szemelyi_szam; nev[50]; munka_ora;
int main() { struct dolgozo ember[10]; int nember; int i; double alapora; double tulora; double fizetes; do { printf("\nDolgozok szama [max 10]: "); scanf("%d", &nember); } while(nember > 10); for(i = 0; i < nember; i++) { printf("\nDolgozo neve: "); scanf("%s", ember[i].nev); printf("\nDolgozo szemelyi szama: "); scanf("%d", &(ember[i].szemelyi_szam)); printf("\nLedolgozott ora: ");
}
scanf("%d", &(ember[i].munka_ora));
printf("\nAlaporak ara: "); scanf("%lf", &alapora); printf("\nTulorak ara: "); scanf("%lf", &tulora); printf("\nFizetes Dolgozo"); for(i = 0; i < nember; i++) { if(ember[i].munka_ora < 200) { fizetes = ember[i].munka_ora * alapora; } else { fizetes = 200 * alapora + (ember[i].munka_ora - 200) * tulora; } }
printf("\n%7.2f
return 0; }
%s", fizetes, ember[i].nev);
13. Oldjuk meg az előző feladatot típus deklarálással #include <stdio.h> /* ez lesz az uj tipus */ typedef struct { int szemelyi_szam; char nev[50]; int munka_ora; } dolgozo; int main() { dolgozo ember[10]; /* lathato hogy uj tipus */ int nember; int i; double alapora; double tulora; double fizetes; do { printf("\nDolgozok szama [max 10]: "); scanf("%d", &nember); } while(nember > 10); for(i = 0; i < nember; i++) { /* beolvasas ugyanaz mint elobb */ printf("\nDolgozo neve: "); scanf("%s", ember[i].nev); printf("\nDolgozo szemelyi szama: "); scanf("%d", &(ember[i].szemelyi_szam)); printf("\nLedolgozott ora: "); scanf("%d", &(ember[i].munka_ora)); } printf("\nAlaporak ara: "); scanf("%lf", &alapora); printf("\nTulorak ara: "); scanf("%lf", &tulora); printf("\nFizetes Dolgozo"); for(i = 0; i < nember; i++) { if(ember[i].munka_ora < 200) {
fizetes = ember[i].munka_ora * alapora; } else { fizetes = 200 * alapora + (ember[i].munka_ora - 200) * tulora; } }
printf("\n%7.2f
return 0; }
%s", fizetes, ember[i].nev);
14. Oldjuk meg az előző feladatot dinamikus memória foglalással #include <stdio.h> #include <stdlib.h> /* memoria foglalashoz */ typedef struct { int szemelyi_szam; char nev[50]; int munka_ora; } dolgozo; int main() { dolgozo *ember; /* vektok lesz */ int nember; int i; double alapora; double tulora; double fizetes; do { printf("\nDolgozok szama [max 10]: "); scanf("%d", &nember); } while(nember > 10); /* csak annyi helyet foglalunk amennyi kell */ ember = (dolgozo *)calloc(nember, sizeof(dolgozo)); if(ember == NULL) { printf("Nem lehet memoriat allokalni\n"); exit(1); } for(i = 0; i < nember; i++) { printf("\nDolgozo neve: "); scanf("%s", ember[i].nev); printf("\nDolgozo szemelyi szama: "); scanf("%d", &(ember[i].szemelyi_szam)); printf("\nLedolgozott ora: "); scanf("%d", &(ember[i].munka_ora)); } printf("\nAlaporak ara: "); scanf("%lf", &alapora); printf("\nTulorak ara: ");
scanf("%lf", &tulora); printf("\nFizetes Dolgozo"); for(i = 0; i < nember; i++) { if(ember[i].munka_ora < 200) { fizetes = ember[i].munka_ora * alapora; } else { fizetes = 200 * alapora + (ember[i].munka_ora - 200) * tulora; } printf("\n%7.2f } return 0; }
%s", fizetes, ember[i].nev);
15. Egy kórház szülészeti osztályának statisztikáját kell elkészíteni. Írjon programot mely a következőket teszi: • Kérje be a gyermekek adatait o Először a gyerekek számát. o Maximum 12 gyerek. o Ha a felhasználó többet akar megadni, ne engedjük. o Olvassa be az adatokat. Egy gyerek adatait tároljuk egy struktúrában. A struktúrának az alábbi elemei vannak: Azonosító (egész szám) Csecsemő neve Koraszülött-e Születési súlya (valós szám) A beolvasás után a program határozza meg a fiúk és lányok számát, átlagos születési súlyukat és hány koraszülött fiú illetve lány született. Ezeket az adatokat nyomtassuk ki. #include <stdio.h> #include <stdlib.h> typedef struct { char nev[50]; int azonosito; int koraszulott; double suly; int neme; } csecsemo; int main() { csecsemo int int int int double int int
gyerek[12]; ngyerek; i; nfiu = 0; nlany = 0; atlag_suly = 0.0; nkorafiu = 0; nkoralany = 0;
do { printf("\nGyerekek szama [max 12]: "); scanf("%d", &ngyerek); } while(ngyerek > 12); for(i = 0; i < ngyerek; i++) { printf("\nCsecsemo neve: ");
}
scanf("%s", gyerek[i].nev); printf("\nCsecsemo azonosito szama: "); scanf("%d", &(gyerek[i].azonosito)); /* ezt akar ellenorizhetjuk is, hogy 0 vagy 1 a beadott adat */ printf("\nKoraszulott [1/0]: "); scanf("%d", &(gyerek[i].koraszulott)); printf("\nSulya: "); scanf("%lf", &(gyerek[i].suly)); printf("\nNeme [fiu = 0, lany = 1]: "); scanf("%d", &(gyerek[i].neme));
for(i = 0; i < ngyerek; i++) { atlag_suly += gyerek[i].suly; if(gyerek[i].neme == 0) { nfiu++; if(gyerek[i].koraszulott) nkorafiu++; } else { nlany++; if(gyerek[i].koraszulott) nkoralany++; } } atlag_suly /= ngyerek; printf("Atlag suly: %.2f\n", atlag_suly); printf("Fiuk szama: %d, ebbol koraszulott volt %d\n", nfiu, nkorafiu); printf("Lanyok szama: %d ebbol koraszulott volt %d\n", nlany, nkoralany); return 0; }
16. Implementáljon egy bináris fát. Készítsen függvényeket mely hozzáad egy elemet, és egy másikat ami kinyomtatja a teljes fát. A bináris fa egész számokat tárol. Egy elem egy struktúra, mely tárolja a számot és két pointert melyek a baloldali és jobboldali ágat tárolják. A program olvasson be számokat és tárolja a bináris fában, addig, amíg a bekért szám pozitív. Ha negatív számot adunk meg a bekérés véget ér és a program kinyomtatja a fa tartalmát (a számokat egymás alá, sorba rendezve). Végül kilép a program. #include <stdio.h> #include <stdlib.h> /* uj adat tipus: Figyeljuk meg, hogyan definialjuk a strukturat: ilyen modon a strukturan belul struktura pointert is letre tudunk hozni */ typedef struct _binaris_level { struct _binaris_level *bal; struct _binaris_level *jobb; int szam; } binaris_level; /* egy uj falevel letrehozasa, a lefoglalt strukturara mutato pointert adja vissza */ binaris_level *uj_level(int szam) { binaris_level *adat; adat = (binaris_level *)calloc(1,sizeof(binaris_level)); adat->szam = szam; return adat; } /* beilleszt egy szamot a binaris faba */ void beilleszt(int szam, binaris_level *root) { binaris_level *akt; akt = root; /* elvileg vegtelen ciklus, egy break fogja megszakitani */ while(1) { /* ha a szam kisebb, akkor balra megyunk */ if(szam < akt->szam) { /* ha a bal oldali level nem ures akkor az lesz az aktualis level es a ciklus folytatodik */ if(akt->bal != NULL) { akt = akt->bal; } else
{
}
}
/* a bal oldali level ures, igy ide illesztjuk be a szamot */ akt->bal = uj_level(szam); break;
} } /* ha aszam nagyobb, akkor a jobb oldali agon megyunk */ else { if(akt->jobb != NULL) { akt = akt->jobb; } else { akt->jobb = uj_level(szam); break; } }
/* rekurziv fuggvennyel nyomtatunk, igy a legegyszerubb megfogalmazni */ void nyomtat(binaris_level *akt) { if(akt == NULL) { ; /* NULL pointer, nem kell semmit se csinalni */ } else { nyomtat(akt->bal); printf("%d ", akt->szam); nyomtat(akt->jobb); } } int main() { binaris_level *root = NULL; int szam; while(1) { scanf("%d", &szam); /* ha negativ szamot adunk meg veget er a ciklus*/ if(szam < 0) break; /* figyelni kell, hogy van-e root */ if(root == NULL) { root = uj_level(szam); } else { beilleszt(szam, root);
}
}
/* nyomtatas */ nyomtat(root); }
return 0;
Összetett feladat: Készítsen játékprogramot a veremkezelés szemléltetésére. A játékszabályok: Legyen egy 100 elemet befogadni képes verem. Induláskor töltsünk be 20 elemet. Egy-egy elem egy 1 és 10 közötti véletlen szám és a hozzá tartozó súly, amely szintén egy véletlen szám 1 és 5 között. A játék: tippelni kell a verem tetején lévő számra. Ha eltaláltuk, akkor annyi véletlen számmal tölti tovább a program a vermet, amennyi a kitalált szám és a hozzá tartozó súly szorzata. (A játékos nem ismeri a súlyozó tényezőket, sem a számokat) Ha nem találtuk ki a számot, akkor a verem tetején lévő szám törlődik, s az alatta lévő (következő) számra lehet tippelni. A játékos nyert, ha a verem megtelt. A nyeremény a veremben letárolt véletlen számok súlyokkal szorzott összege. A játékos vesztett, ha a verem kiürült. A verem tárolására egy 100 elemű egydimenziós tömböt fogunk használni. A tömb elemei strukturák. #include <stdio.h> #include <stdlib.h> #define vm 100 struct elem { int szam; /* a szám, amit el kell találni */ int suly; /* súly, amivel szorozni kell a számot */ }; int egesz_bevitel (int, int, char int verem_start (struct elem [], int verem_jatek (struct elem [], long nyeremeny (struct elem [], int random(int max_value);
*); int m); int, int *, int); int);
int main (void) { int vt = 0; /* verem mutató, ha 0, üres a verem */ int menu = 1; struct elem verem[vm]; srand(12345); do { switch (menu)
{
case 1: vt = verem_start(verem, vm); break; case 2: switch (verem_jatek (verem, vm, &vt, 0)) { case -1: printf ("\nÖn vesztett ! Üres a verem"); break; case 0: printf ("\nGratulálok, Ön nyert !"); break; case 1: printf("\nMár volt egy nyertes játszmája !"); } break; case 3: printf("\nA nyeremény:%ld ezer Ft", nyeremeny(verem, vm)); break; case 4: switch (verem_jatek (verem, vm, &vt, 1)) { case -1: printf ("\nÖn vesztett ! Üres a verem"); break; case 0: printf ("\nGratulálok, Ön nyert !"); break; case 1: printf("\nMár volt egy nyertes játszmája !"); } break;
} printf("\n\n\n"); printf ("\nVerem kezelo játék-program"); printf ("\n 0 játék vége"); printf ("\n 1 verem kezdeti töltése"); printf ("\n 2 játék"); printf ("\n 3 nyeremény kiszámítása"); printf ("\n 4 nyílt játék");
menu = egesz_bevitel (0, 5, "\nKérem a kiválasztott menü számát: "); } while (menu > 0 && menu < 5); printf ("\nKöszönöm az együttmuködést !"); }
return 0;
int egesz_bevitel(int ah, int fh, char * szoveg) { int adat = 5; do { if(adat < ah || adat > fh)
{
printf("\nErvenytelen szam"); } printf("%s",szoveg); scanf("%d", &adat);
}
} while(adat < ah || adat > fh); return adat;
int verem_start(struct elem vv[], int m) { int i; for(i=0; i < 20; i++) { vv[i].szam = random (10) + 1; vv[i].suly = random ( 5) + 1; } for( ; i < m; i++) { vv[i].szam = 0; vv[i].suly = 0; } return 19; } int verem_jatek(struct elem vv[], int m, int *t, int ok) { char bes [] = "\nKérem a tippet:"; int tipp, i, n, k; if (*t == m) return 1; do { if(ok) { k = *t; printf ("\nA VEREM:\n"); while (k >= 0) { printf ("%2d/%2d - ",vv[k].szam,vv[k].suly); if (k%10 == 0) printf ("\n"); k--; } } tipp = egesz_bevitel (1, 10, bes); if (tipp == vv[*t].szam) /* eltalálta !! */ { printf ("\nEltalálta !"); n = vv [*t].szam * vv [*t].suly; for (i=0; i < n; i++) { (*t)++; if(*t >= m) break;
vv [*t].szam = random (10)+1; vv [*t].suly = random (5) +1;
} } else { printf ("\nNem találta el a számot.\n"); /*a verem mutató átállítása a következo elemre */ (*t)--; }
} while (*t > 0 && *t < m);
}
if (*t == 0) return -1; else return 0;
long nyeremeny(struct elem vv[], int m) { long ny = 0; int i; for (i=0; i< m; i++) ny = ny + vv[i].szam * vv[i].suly; return ny; } /* 0 es max_value-1 kozotti veletlen szamot general */ int random(int max_value) { int v, m; m = RAND_MAX; v = (int)((double)rand() / m * max_value); }
return(v);
