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. 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); void cserel(int *x,int *y) /* cserel definíciója */ int s; s=*x; *x = *y; *y = s;
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! 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); 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. 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); 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 <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."); 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. 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); 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 <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); 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! 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 = *(x+0) ; b = *(x+1) ; c = *(x+2) ; d = *(x+3) ; printf("\nl = %ld",l) ; printf("\na = %c", a ); printf("\nb = %c", b ); printf("\nc = %c", c ); printf("\nd = %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 <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);
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 <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);
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 <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);
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 <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);
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 struct dolgozo int szemelyi_szam; char nev[50]; int 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 %s", fizetes, ember[i].nev);
13. Oldjuk meg az előző feladatot típus deklarálással /* 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 %s", fizetes, ember[i].nev);
14. Oldjuk meg az előző feladatot dinamikus memória foglalással #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 %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 <stdlib.h> typedef struct char nev[50]; int azonosito; int koraszulott; double suly; int neme; csecsemo; int main() csecsemo gyerek[12]; int ngyerek; int i; int nfiu = 0; int nlany = 0; double atlag_suly = 0.0; int nkorafiu = 0; int 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);
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 <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);
Ö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 <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 m); int verem_jatek (struct elem [], int, int *, int); long nyeremeny (struct elem [], int); int random(int max_value); 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!"); 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 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);