Programozás 1. példatár

Országok listájaHungaryDebreceni EgyetemInformatikai KarProgramtervező informatikusMagas Szintű Programozási Nyelvek 1.JegyzetekProgramozás 1. példatár

Kósa Márk Pánovics János

Példatár a Programozás 1 tárgyhoz
Juhász István

feladatsoraiból

mobiDIÁK könyvtár

Kósa Márk Pánovics János

Példatár a Programozás 1 tárgyhoz
Juhász István

feladatsoraiból

mobiDIÁK könyvtár

SOROZATSZERKESZT Fazekas István

Kósa Márk Pánovics János

Példatár a Programozás 1 tárgyhoz
Juhász István

feladatsoraiból

Egyetemi jegyzet elso kiadás

mobiDIÁK könyvtár
Debreceni Egyetem Informatikai Intézet

Lektor Juhász István Debreceni Egyetem

Copyright c Kósa Márk, Pánovics János, 2004 Copyright c elektronikus közlés

mobiDIÁK könyvtár,

2004

mobiDIÁK könyvtár
Debreceni Egyetem Informatikai Intézet 4010 Debrecen, Pf. 12

http://mobidiak.unideb.hu

A mu egyéni tanulmányozás céljára szabadon letöltheto. Minden egyéb felhasználás csak a szerzok elozetes írásbeli engedélyével történhet. A mu a készült.
A mobiDIÁK önszervezo mobil portál

(IKTA, OMFB-00373/2003) és a

GNU

Iterátor, a legújabb generációs portál szoftver

(ITEM, 50/2003) projektek keretében

Tartalomjegyzék
Eloszó 1. Példák tematikus csoportosításban
1.1. 1.2. 1.3. 1.4. 1.5. 1.6. 1.7. A legegyszerubb feladatok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Egydimenziós tömbök . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Sztringek . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Kétdimenziós tömbök . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fák . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Kifejezések

7 8
8 12 21 27 34 38 59

Állományok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

2. Feladatsorok
2.1. 2.2. 2.3. 2.4. 2.5. 2.6. 2.7. 2.8. 2.9. 1994. május 16., nappali tagozat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1995. május 15., nappali tagozat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Idopontja ismeretlen, nappali tagozat Idopontja ismeretlen, nappali tagozat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

82
82 82 84 86 87 88 88 89 90 90 91 91 92 92 93 93 94 94 94 95 95 96 96 96 97 97 97 98 98 98 99 99

1996. május 18., nappali tagozat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1996. június 13., nappali tagozat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1996. december 14., nappali tagozat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1997. május 26., nappali tagozat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1997. június 10., nappali tagozat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

2.10. 1997. június 16., nappali tagozat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.11. 1998. május 18., nappali tagozat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.12. 1998. május 29., nappali tagozat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.13. 1998. június 2., nappali tagozat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.14. 1998. december 12., nappali tagozat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.15. 1999. május 17., nappali tagozat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.16. 1999. május 21., esti tagozat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.17. 1999. december 10., levelezo tagozat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.18. 2000. január 12., levelezo tagozat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.19. 2000. május 10., levelezo tagozat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.20. 2000. május 20., nappali tagozat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.21. 2000. augusztus 21., esti tagozat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.22. 2000. december 1., nappali tagozat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.23. 2001. január 3., levelezo tagozat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.24. 2001. április 28., nappali tagozat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.25. 2001. május 14., nappali tagozat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.26. 2001. augusztus 21., esti tagozat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.27. 2001. október 26., levelezo tagozat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.28. 2001. november 30., levelezo tagozat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.29. 2001. december 17., nappali tagozat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.30. 2001. december 18., levelezo tagozat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.31. 2002. január 2., levelezo tagozat 2.32. 2002. január 2., nappali tagozat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

2.33. 2002. április 20., levelezo tagozat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100 2.34. 2002. május 13., nappali tagozat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100 2.35. 2002. május 23., nappali tagozat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100

6

Tartalomjegyzék

2.36. 2002. augusztus 21., esti tagozat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101 2.37. 2002. november 29., levelezo tagozat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101 2.38. 2003. január 6., esti tagozat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101 2.39. 2003. január 6., levelezo tagozat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102 2.40. 2003. május 17., levelezo tagozat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102 2.41. 2003. május 23., nappali tagozat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103 2.42. 2003. május 28., nappali tagozat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103 2.43. 2003. augusztus 25., esti tagozat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103 2.44. 2003. december 5., levelezo tagozat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104 2.45. 2004. január 9., levelezo tagozat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104

Eloszó
A

Programozás 1

tárgy gyakorlatainak keretében a 2001/2002-es tanévtol kezdve mindhárom képzési

formában (nappali, levelezo és esti tagozaton) a C programozási nyelvet tanulják hallgatóink. A félév végi beugrókon is e nyelven kell kódolniuk a feladataikat. Természetes az igény, hogy mindenki számára hozzáférheto módon rendelkezésre álljon egy feladatgyujtemény, amely a feladatok szövege mellett tartalmazza azok lehetséges megoldásait is. Ez a gyujtemény egy válogatás a tárgy eloadójának, Juhász Istvánnak a beugrókon íratott feladatsoraiból, az 1994-es nyári vizsgaidoszaktól kezdodoen egészen napjainkig. A korai feladatsorok egy konkrét programozási nyelvhez (Turbo Pascalhoz vagy C-hez) kapcsolódtak, míg az újabbak tetszoleges nyelven megoldhatók. Igazodva azonban a tantárgy gyakorlati követelményeihez, ebben a példatárban csak C nyelvu programkódokat adunk közre. A feladatokat témakörönként csoportosítottuk, minden témakörön belül igyekeztünk egy nehézségi sorrendet is felállítani. A legtöbb feladatnak csak egy lehetséges megoldását közöltük, ám ahol több, egymástól valamilyen lényeges szempontból különbözo megoldás is létezett, ott azok közül többet is megadtunk. Ugyanakkor az is elképzelheto és ettol szép a programozás , hogy az olvasó fog kitalálni az itt leírtaktól eltéro, esetleg egyszerubb megoldást egyik-másik feladatra. A példatárban közreadott programkódokat Linux operációs rendszer alatt GNU C fordítóval teszteltük, de bármely ANSI C fordítóval lefordíthatók. A feladatgyujtemény végén megtalálható az összes beugró feladatsor idorendi sorrendben 1994. május 16-tól kezdve. Ezekbol az olvasó képet kaphat arról, hogy milyen nehézségu feladatsorokat kellett megoldaniuk a hallgatóknak az elmúlt években, és egyúttal tesztelheti saját tudását is. Sikeres felkészülést kívánnak a szerzok, akik a feladatgyujteményben esetleg benne maradt apróbb hibákért elnézést kérnek, és minden javító szándékú kritikát szívesen vesznek a következo címek valamelyikén:

mkosa@inf.unideb.hu

vagy

panovics@inf.unideb.hu.

Debrecen, 2004. január 18.

Kósa Márk Pánovics János

1. fejezet

Példák tematikus csoportosításban
1.1. A legegyszerubb feladatok

programot, amely billentyuzetrol látható karaktereket olvas mindaddig, amíg képernyore a beolvasott különbözo karaktereket és azok gyakoriságát!
1.1. feladat. Írjon

a

@

karaktert meg nem kapja. A program határozza meg és írja

Egy tetszoleges karakterrol a

ctype.h-ban

deniált

isprint()

függvény segítségével tudjuk eldönteni,

hogy látható-e (nyomtatható-e). Azonban mivel most kizárólag látható karaktereket olvasunk, ezért ez az ellenorzés elhagyható. Így egy lehetséges megoldás a következo:

#include main() { int c; int gyak[ 256 ] = { 0 }; while ( ( c = getchar() ) != '@' ) ++gyak[ c ]; for ( c = 0; c < 256; ++c ) if ( gyak[ c ] != 0 ) printf( "%c: %d\n", c, gyak[ c ] ); }
1.2. feladat. Írjon

ram írja

programot, amely billentyuzetrol egész értékeket olvas be a 0 végjelig. A progképernyore azokat az értékeket, amelyek megegyeznek az elozo két érték összegével.

#include #define FALSE 0 #define TRUE !FALSE main() { int t[ 3 ], idx = -1, megvolt = FALSE; for ( ; ; ) { scanf( "%d", &t[ idx = ( idx + 1 ) % 3 ] ); if ( !t[ idx ] ) break; if ( idx == 2 ) megvolt = TRUE; if ( megvolt && t[ idx ] == t[ ( idx + 1 ) % 3 ] + t[ ( idx + 2 ) % 3 ] ) printf( "%d\n", t[ idx ] ); } }
1.3. feladat. Írjon

0 végjelig. maximális.
a

A program határozza meg és írja

programot, amely nullától különbözo egész értékeket olvas be a billentyuzetrol képernyore azt a három értéket, amelynek átlaga

1.1.

A legegyszerubb feladatok

9

A feladat megfogalmazása csalanta, gyakorlatilag a három legnagyobb értéket kell kiválasztani a begépelt számok közül, hiszen ezek átlaga lesz maximális. Háromnál kevesebb beolvasott érték esetén a programok csak egy gyelmezteto üzenetet írnak a képernyore. (a) Az elso megoldás tárolja az összes beolvasott értéket, majd a 0 érték beolvasása után csökkeno sorrendbe rendezi oket, és kiírja közülük az elso hármat (ha van legalább három érték).

#include void rendez_csok( int t[], int meret ) { int i, j; for ( i = meret - 2; i >= 0; --i ) for ( j = 0; j <= i; ++j ) if ( t[ j ] < t[ j + 1 ] ) { int seged = t[ j ]; t[ j ] = t[ j + 1 ]; t[ j + 1 ] = seged; } } main() { int *tomb = NULL, meret = 0; for ( ; ; ) { tomb = ( int * )realloc( tomb, ( meret + 1 ) * sizeof( int ) ); scanf( "%d", &tomb[ meret ] ); if ( tomb[ meret ] == 0 ) break; ++meret; } if ( meret < 3 ) puts( "Nincs három érték." ); else { rendez_csok( tomb, meret ); printf( "%d, %d, %d\n", tomb[ 0 ], tomb[ 1 ], tomb[ 2 ] ); } free( tomb ); }
(b) A második megoldás csak a három legnagyobb értéket tárolja úgy, hogy mindig a legkisebb tárolt értéket írja felül, ha egy nála nagyobb értéket olvas.

#include main() { int tomb[ 3 ], meret = 0, szam; for ( ; ; ) { scanf( "%d", &szam ); if ( szam == 0 ) break; if ( meret < 3 ) tomb[ meret++ ] = szam; else

10

1.

Példák tematikus csoportosításban

{

}

} } if ( meret < 3 ) puts( "Nincs három érték." ); else printf( "%d, %d, %d\n", tomb[ 0 ], tomb[ 1 ], tomb[ 2 ] );

int index = tomb[ 0 ] < tomb[ 1 ] ? tomb[ 0 ] < tomb[ 2 ] ? 0 : 2 : tomb[ 1 ] < tomb[ 2 ] ? 1 : 2; if ( szam > tomb[ index ] ) tomb[ index ] = szam;

(c) A harmadik megoldás a második megoldáshoz hasonlóan a három legnagyobb értéket tárolja, amelyek sorrendje azonban a beolvasás szerinti sorrend marad.

#include #define N 3 main() { int tomb[ N ], meret = 0, szam; scanf( "%d", &szam ); while ( szam ) { if ( meret < N ) tomb[ meret++ ] = szam; else { int index = 0, i; for ( i = 1; i < N; ++i ) if ( tomb[ i ] < tomb[ index ] ) index = i; if ( tomb[ index ] < szam ) { while ( index < N - 1 ) { tomb[ index ] = tomb[ index + 1 ]; ++index; } tomb[ N - 1 ] = szam; } } scanf( "%d", &szam ); } if ( meret < N ) printf( "Nem volt %d érték\n", N ); else { int i; printf( "%d", tomb[ 0 ] ); for ( i = 1; i < N; ++i ) printf( ", %d", tomb[ i ] ); putchar( '\n' ); } }

1.1.

A legegyszerubb feladatok

11

programot, amely a billentyuzetrol pozitív egész számokat olvas mindaddig, míg legkisebbeket és a legnagyobbakat (lehetnek azonos értékuek is, de legfeljebb 3-3), írja azok értékét a képernyore, és adja meg, hogy hányadikként
1.4. feladat. Írjon

0-t nem adunk. A program válassza ki a számok közül a

olvastuk be oket!

#include main() { int szam, i, legk, legn, min[ 3 ], max[ 3 ], mindb = 0, maxdb; for ( i = 1; ; ++i ) { scanf( "%d", &szam ); if ( szam == 0 ) break; if ( i == 1 ) { legk = legn = szam; min[ 0 ] = max[ 0 ] = 1; mindb = maxdb = 1; } else { if ( szam < legk ) { legk = szam; mindb = 1; min[ 0 ] = i; } else if ( szam > legn ) { legn = szam; maxdb = 1; max[ 0 ] = i; } else { if ( szam == legk ) min[ mindb++ ] = i; if ( szam == legn ) max[ maxdb++ ] = i; } } } if ( mindb == 0 ) puts( "Nem volt egy érték sem." ); else { printf( "A legkisebb érték: %d.\nElofordulásai: ", legk ); for ( i = 0; i < mindb; ++i ) printf( "%d ", min[ i ] ); printf( "\nA legnagyobb érték: %d.\nElofordulásai: ", legn ); for ( i = 0; i < maxdb; ++i ) printf( "%d ", max[ i ] ); putchar( '\n' ); } }

12

1.

Példák tematikus csoportosításban

1.2.

Egydimenziós tömbök

eljárást, amely paraméterként megkap egy karaktereket tartalmazó, tetszoleges méretu egydimenziós tömböt, és a tömb nem betu karaktereit kicseréli szóközre.
1.5. feladat. Írjon

#include void nembetu( char t[], int meret ) { int i; for ( i = 0; i < meret; ++i ) if ( !isalpha( t[ i ] ) ) t[ i ] = ' '; }
1.6. feladat. Írjon

talmazó

eljárást, amely paraméterként megkap egy tetszoleges méretu, egészeket taregydimenziós tömböt. Az eljárás határozza meg a tömbben lévo pozitív, negatív és nulla elemek darabszámát! Az eljárás nem írhat a képernyore!
A feladat többféleképpen is megoldható. (a) Nézzük eloször azt a megoldást, amikor az eljárás globális változókban határozza meg a pozitív, negatív és nulla elemek darabszámát:

int pozitiv, negativ, nulla; void poznegnull( int *t, int meret ) { int i; pozitiv = negativ = nulla = 0; for ( i = 0; i < meret; ++i ) if ( t[ i ] > 0 ) ++pozitiv; else if ( t[ i ] < 0 ) ++negativ; else ++nulla; }
(b) Egy másik megoldási lehetoség, ha az eljárásnak átadunk még három paramétert, azoknak a memóriaterületeknek a címét, ahol a keresett értékeket tárolni szeretnénk:

void poznegnull( int *t, int meret, int *pozitiv, int *negativ, int *nulla ) { int i; *pozitiv = *negativ = *nulla = 0; for ( i = 0; i < meret; ++i ) if ( t[ i ] > 0 ) ++*pozitiv; else if ( t[ i ] < 0 ) ++*negativ; else ++*nulla; }
1.7. feladat. Írjon

eljárást, amely paraméterként megkap egy tetszoleges méretu, sztringeket tarvektort, és eloállít egy olyan vektort, amelymek elemei rendre a paraméterként kapott vektor elemeinek annyiadik karakterét tartalmazzák, amennyi az adott elem indexe, illetve a @ karaktert, ha nem létezik ilyen elem. Egy sztring karaktereit 0-tól sorszámozzuk. Az eljárásban nem lehet semmilyen I/O muvelet!
talmazó

1.2.

Egydimenziós tömbök

13

#include #include char *vektor; void kukacvektor( char *tomb[], int meret ) { int i; vektor = ( char * )malloc( meret * sizeof( char ) ); for ( i = 0; i < meret; ++i ) vektor[ i ] = strlen( tomb[ i ] ) <= i ? '@' : tomb[ i ][ i ]; }

táblázat, amelynek kulcsa egész, érték része sztring típusú és maximum függvényt, amely paraméterként megkapja a táblázatot, az aktuális elemszámot és egy egészet. A függvény bináris kereséssel keresse meg az adott egész által meghatározott kulcsú elemet és adja vissza annak érték részét! Ha nincs ilyen elem, a függvény az üres sztringgel
1.8. feladat. Adva van egy

500 elem fér el benne. Írjon

térjen vissza!

typedef struct tablaelem { int kulcs; char *ertek; } TABLA[ 500 ]; char *binkeres( TABLA t, int elemszam, int kulcs ) { int also = 0, felso = elemszam - 1; while ( also <= felso ) { int kozepso = ( also + felso ) / 2; if ( t[ kozepso ].kulcs == kulcs ) return t[ kozepso ].ertek; if ( t[ kozepso ].kulcs > kulcs ) felso = kozepso - 1; else also = kozepso + 1; } return ""; }
1.9. feladat. Írjon egy

maximum

programot, amely a billentyuzetrol beolvas egy pozitív egész számot (értéke 110 lehet), majd a billentyuzetrol beolvas ennyi darab valós számot és közülük képernyore írja azokat, amelyek értékének a beolvasott számok átlagától való eltérése az átlag felénél nagyobb!

#include #include main() { double tomb[ 110 ], atlag = 0; int i, meret; printf( "Méret: " ); scanf( "%d", &meret ); for ( i = 0; i < meret; ++i ) { scanf( "%lf", &tomb[ i ] ); atlag += tomb[ i ]; } atlag /= meret; for ( i = 0; i < meret; ++i )

14

1.

Példák tematikus csoportosításban

}

if ( fabs( tomb[ i ] - atlag ) > atlag / 2 ) printf( "%lf\n", tomb[ i ] );

1.10. feladat. Írjon

programot, amely billentyuzetrol pozitív valós számokat olvas be mindaddig, nullát nem adunk (tudjuk, hogy maximum 100 szám lehet). A program írja egy most létrehozott szöveges állományba azokat a beolvasott számokat, amelyeknek a számok átlagától való eltérése nagyobb, mint az átlag fele!
amíg

#include #include #define MERET 100 main() { FILE *fout; double tomb[ MERET ], atlag = 0, szam; int darab = 0, i; fout = fopen( "atlagfel.txt", "w" ); scanf( "%lf", &szam ); while ( szam != 0 ) { atlag += tomb[ darab++ ] = szam; scanf( "%lf", &szam ); } if ( darab > 0 ) { atlag /= darab; for ( i = 0; i < darab; ++i ) if ( fabs( tomb[ i ] - atlag ) > atlag / 2 ) fprintf( fout, "%lf\n", tomb[ i ] ); } fclose( fout ); }
1.11. feladat. Írjon

dimenziós
vannak!

karaktereket tartalmazó egyamelyben azonos karakterek Több ilyen esetén válassza ki azt, amelyben a karakterek száma maximális!
amely egy paraméterként megkapott, tömbben meghatározza azon rész

eljárást,

kezdo-

és

végindexét,

void azonosresz( char t[], int meret, int *kezdo, int *veg ) { int k = 0, v; *kezdo = *veg = 0; for ( v = 1; v < meret; ++v ) if ( t[ v ] != t[ v - 1 ] ) k = v; else if ( v - k > *veg - *kezdo ) { *kezdo = k; *veg = v; } }
1.12. feladat. Írjon

amíg a amely a

-1

képernyore a beolvasott leghosszabb szigorúan monoton csökkeno sorozatot alkotja!
értéket nem kapja. A program írja

programot,

amely billentyuzetrol egyenként beolvas egész értékeket addig, számok azon szekvenciáját,

#include #include

1.2.

Egydimenziós tömbök

15

main() { int i, *sorozat = NULL, kezdo = 0, veg = -1, maxkezdo = 0, maxveg = 0; do { sorozat = ( int * )realloc( sorozat, ( ++veg + 1 ) * sizeof( int ) ); scanf( "%d", &sorozat[ veg ] ); if ( veg != 0 && ( sorozat[ veg ] >= sorozat[ veg - 1 ] || sorozat[ veg ] == -1 ) ) { if ( veg - 1 - kezdo > maxveg - maxkezdo ) { maxkezdo = kezdo; maxveg = veg - 1; } kezdo = veg; } } while ( sorozat[ veg ] != -1 ); for ( i = maxkezdo; i <= maxveg && sorozat[ i ] != -1; ++i ) printf( "%d ", sorozat[ i ] ); putchar( '\n' ); }
1.13. feladat. Írjon

mazó egydimenziós tömbben meghatározza a legnagyobb összegu résztömb output paraméterében! A feladatot többféleképpen is meg lehet oldani.

eljárást, amely egy paraméterként kapott tetszoleges méretu, egészeket tartalkezdo- és végindexét két

(a) Álljon itt eloször a mezítlábas (brute force) megoldás, amelyben három egymásba ágyazott ciklust futtatunk: egyet a kezdoindexre, egyet a végindexre és egyet a részösszegek kiszámítására.

void maxosszresz( int t[], int meret, int *kezdo, int *veg ) { int k, v, i; long maxosszeg = t[ 0 ]; *kezdo = *veg = 0; for ( k = 0; k < meret; ++k ) for ( v = k; v < meret; ++v ) { long osszeg = 0; for ( i = k; i <= v; ++i ) osszeg += t[ i ]; if ( osszeg > maxosszeg ) { maxosszeg = osszeg; *kezdo = k; *veg = v; } } }
(b) A második megoldásban a részösszegek kiszámítását nem ciklussal végezzük, hanem egy tömb segítségével. Igy elegendo lesz két egymásba ágyazott for-ciklus az eredmény kiszámításához.

void maxosszresz( int t[], int meret, int *kezdo, int *veg ) { int k, v, i, *reszosszeg = ( int * )malloc( ( meret + 1 ) * sizeof( int ) ); long maxosszeg = t[ 0 ];

16

1.

Példák tematikus csoportosításban

}

*kezdo = *veg = 0; reszosszeg[ 0 ] = 0; for ( i = 1; i <= meret; ++i ) reszosszeg[ i ] = reszosszeg[ i - 1 ] + t[ i - 1 ]; for ( k = 0; k < meret; ++k ) for ( v = k; v < meret; ++v ) if ( reszosszeg[ v + 1 ] - reszosszeg[ k ] > maxosszeg ) { maxosszeg = reszosszeg[ v + 1 ] - reszosszeg[ k ]; *kezdo = k; *veg = v; } free( reszosszeg );

(c) Végül lássuk azt a megoldást, amely egyetlen for-ciklussal határozza meg a legnagyobb összegu résztömb kezdo- és végindexét.

void maxosszresz( int t[], int meret, int *kezdo, int *veg ) { int reszosszeg, maxosszeg, i, k; maxosszeg = reszosszeg = *t; *kezdo = *veg = k = 0; for ( i = 1; i < meret; ++i ) { if ( reszosszeg >= 0 ) reszosszeg += t[ i ]; else { reszosszeg = t[ i ]; k = i; } if ( reszosszeg > maxosszeg ) { maxosszeg = reszosszeg; *kezdo = k; *veg = i; } } }
1.14. feladat. Írjon

ziós tömböt

eljárást, amely egy paraméterként megadott, sztringeket tartalmazó egydimenelemeinek hossza szerint csökkeno sorrendbe rendez!
qsort()
könyvtári függvényt használjuk. A rendezést követoen az azonos

A feladat megoldásához a

hosszúságú sztringek egymáshoz viszonyított elhelyezkedése implementációfüggo.

#include #include

/* qsort() */

int rendezo( const void *egyik, const void *masik ) { return strlen( *( char ** )masik ) - strlen( *( char ** )egyik ); } void quickcsoksztring( char *t[], int meret ) { qsort( t, meret, sizeof( char * ), rendezo ); }

1.2.

Egydimenziós tömbök

17

Lásd még a 1.15. feladat megoldását!
1.15. feladat. Írjon egy

geket

eljárást,

amely a paraméterként megkapott,

tartalmazó, egydimenziós tömböt a sztringek

tetszoleges méretu, sztrinhosszának csökkeno sorrendjébe teszi! Azonos
Egy ilyen algoritmus a

hosszak esetén a sztringek sorrendje az eredeti sorrend legyen! A feladatban leírt egydimenziós tömb rendezésére bármely olyan rendezo algoritmus alkalmas, amely nem változtatja meg a tömb azonos hosszúságú elemeinek relatív sorrendjét. közvetlen beszúró rendezés:

#include void csoksztringhossz( char *t[], int meret ) { int j; for ( j = 1; j < meret; ++j ) { char *kulcs = t[ j ]; int i = j - 1; while ( i >= 0 && strlen( t[ i ] ) < strlen( kulcs ) ) { t[ i + 1 ] = t[ i ]; --i; } t[ i + 1 ] = kulcs; } }
Lásd még a 1.14. feladat megoldását!
1.16. feladat. Írjon

tartalmazó,

eljárást, amely paraméterként megkap egy azonos hosszúságú sztringeket tetszoleges méretu egydimenziós tömböt, továbbá egy karaktert és egy pozitív egész számot, és a képernyore írja azokat a tömbelemeket, amelyekben a karakter pontosan az adott számszor fordul elo. A szélsoséges eseteket vizsgálni kell!

#include #include void azonos( char *t[], int meret, char kar, int szam ) { int i; if ( szam > strlen( t[ 0 ] ) || strlen( t[ 0 ] ) == 0 ) return; for ( i = 0; i < meret; ++i ) { int db = 0; char *p; for ( p = t[ i ]; *p; ++p ) if ( *p == kar ) ++db; if ( db == szam ) puts( t[ i ] ); } }
1.17. feladat. Írjon

menziós tömbben meghatározza és

eljárást, amely egy paraméterként megkapott, angol szavakat tartalmazó egydiképernyore írja a szavak gyakoriságát!

#include #include

18

1.

Példák tematikus csoportosításban

void sztringtombgyak( char *t[], int meret ) { int i; for ( i = 0; i < meret; ++i ) { int j; for ( j = 0; j < i; ++j ) if ( strcmp( t[ i ], t[ j ] ) == 0 ) break; if ( j == i ) /* ha nem szerepelt korábban */ { int darab = 1; for ( j = i + 1; j < meret; ++j ) if ( strcmp( t[ i ], t[ j ] ) == 0 ) ++darab; printf( "%s: %d\n", t[ i ], darab ); } } }
1.18. feladat. Írjon

függvényt, amely paraméterként megkap egy olyan tetszoleges méretu egydimenziós tömböt, amely angol szavakat tartalmaz. A függvény visszatérési értéke adja meg a szavak gyakoriságát.
A feladat többféleképpen is megoldható, attól függoen, hogy milyen adatszerkezetben, illetve hogyan tároljuk és adjuk vissza a szavak gyakoriságát. (a) Nézzük eloször azt a megoldást, amikor egy táblázatot adunk vissza, amelyet egy dinamikusan lefoglalt tárterület kezdocímével, valamint az ott elhelyezkedo elemek darabszámával reprezentálunk:

#include #include typedef struct { char *szo; int gyakorisag; } ELEM; typedef struct { ELEM *tomb; int meret; } GYAK; GYAK gyakszo( char *t[], int meret ) { GYAK gy = { NULL, 0 }; int i; for ( i = 0; i < meret; ++i ) { int j; for ( j = 0; j < gy.meret && strcmp( gy.tomb[ j ].szo, t[ i ] ); ++j ) ; if ( j < gy.meret ) ++gy.tomb[ j ].gyakorisag; else { gy.tomb = ( ELEM * )realloc( gy.tomb, ( gy.meret + 1 ) * sizeof( ELEM ) );

1.2.

Egydimenziós tömbök

19

}

} } return gy;

gy.tomb[ gy.meret ].szo = t[ i ]; gy.tomb[ gy.meret++ ].gyakorisag = 1;

(b) A következo megoldás egy egyirányban láncolt listában adja meg a keresett adatokat:

#include #include typedef struct listaelem { char *szo; int gyakorisag; struct listaelem *kov; } LISTAELEM; LISTAELEM *gyakszo( char *t[], int meret ) { LISTAELEM *lista = NULL; int i; for ( i = 0; i < meret; ++i ) { LISTAELEM *seged = lista, *elozo = NULL; while ( seged && strcmp( seged->szo, t[ i ] ) ) { elozo = seged; seged = seged->kov; } if ( seged ) ++seged->gyakorisag; else { seged = ( LISTAELEM * )malloc( sizeof( LISTAELEM ) ); seged->szo = t[ i ]; seged->gyakorisag = 1; seged->kov = NULL; if ( elozo ) elozo->kov = seged; else lista = seged; } } return lista; }
(c) Lássuk végül a keresofás megoldást:

#include #include typedef struct faelem { char *szo; int gyakorisag; struct faelem *bal, *jobb; } FAELEM;

20

1.

Példák tematikus csoportosításban

FAELEM *beszur( FAELEM *fa, char *szo ) { if ( !fa ) { fa = ( FAELEM * )calloc( 1, sizeof( FAELEM ) ); fa->szo = szo; fa->gyakorisag = 1; } else if ( strcmp( fa->szo, szo ) > 0 ) fa->bal = beszur( fa->bal, szo ); else if ( strcmp( fa->szo, szo ) < 0 ) fa->jobb = beszur( fa->jobb, szo ); else ++fa->gyakorisag; return fa; } FAELEM *gyakszo( char *t[], int meret ) { FAELEM *fa = NULL; int i; for ( i = 0; i < meret; ++i ) fa = beszur( fa, t[ i ] ); return fa; }
1.19. feladat. Írjon

menziós tömb

azonos hosszúságúra (a maximális hozza úgy, hogy a sztringek elejére megfelelo számú szóközt szúr be!
minden elemét

eljárást,

amely egy paraméterként megkapott,

sztringeket

tartalmazó

egydi-

hosszúságú elem hosszúságára)

#include #include void eloretolt( char *t[], int meret ) { int i, maxhossz = 0; for ( i = 0; i < meret; ++i ) if ( strlen( t[ i ] ) > maxhossz ) maxhossz = strlen( t[ i ] ); for ( i = 0; i < meret; ++i ) { int j, akthossz = strlen( t[ i ] ); t[ i ] = realloc( t[ i ], ( maxhossz + 1 ) * sizeof( char ) ); for ( j = maxhossz; akthossz >= 0; --j, --akthossz ) t[ i ][ j ] = t[ i ][ akthossz ]; for ( ; j >= 0; --j ) t[ i ][ j ] = ' '; } }

függvényt, amely egy egydimenziós, sztringeket tartalmazó tömböt kap paraméterként, és annak minden elemét csonkítja a legrövidebb elem hosszára, és visszaadja az új tömböt!
1.20. feladat. Írjon

#include #include char **sztringcsonkolo( char *t[], int meret ) {

1.3.

Sztringek

21

}

char **uj = ( char ** )malloc( meret * sizeof( char * ) ); int i, min = strlen( t[ 0 ] ); for ( i = 1; i < meret; ++i ) if ( strlen( t[ i ] ) < min ) min = strlen( t[ i ] ); for ( i = 0; i < meret; ++i ) { uj[ i ] = ( char * )malloc( ( min + 1 ) * sizeof( char ) ); strncpy( uj[ i ], t[ i ], min ); uj[ i ][ min ] = '\0'; } return uj;

eljárást, amely egy paraméterként kapott, sztringeket tartalmazó egydimenziós tömb minden elemét az elején és a végén egyenletesen elosztott szóközökkel kiegészíti olyan hosszúságúra, mint a leghosszabb elem hossza! Az eredeti tömb nem módosulhat!
1.21. feladat. Írjon

#include #include void eloszt( char *t[], int meret, char ***uj ) { int maxhossz = 0, i; for ( i = 0; i < meret; ++i ) if ( strlen( t[ i ] ) > maxhossz ) maxhossz = strlen( t[ i ] ); *uj = ( char ** )malloc( meret * sizeof( char * ) ); for ( i = 0; i < meret; ++i ) { int j; ( *uj )[ i ] = ( char * )malloc( ( maxhossz + 1 ) * sizeof( char ) ); strcpy( ( *uj )[ i ], "" ); for ( j = 0; j < ( maxhossz - strlen( t[ i ] ) ) / 2; ++j ) strcat( ( *uj )[ i ], " " ); strcat( ( *uj )[ i ], t[ i ] ); for ( j = strlen( ( *uj )[ i ] ); j < maxhossz; ++j ) strcat( ( *uj )[ i ], " " ); } }
1.3. Sztringek

1.22. feladat. Írjon

ad vissza, ha a sztring

logikai függvényt, amely egy paraméterként megkapott sztringnél igaz értéket tükörszimmetrikus (pl. görög, kosarasok)!
amely egy paraméterként megkapott

A feladat a következo megfogalmazásban is szerepelt a beugrókon: Írjon

logikai függvényt, ma-e!

sztringrol eldönti,

hogy az

palindró-

#include int tukorszo( char *s ) { int i, j; for ( i = 0, j = strlen( s ) - 1; i < j; ++i, --j ) if ( s[ i ] != s[ j ] ) return 0; return 1;

22

1.

Példák tematikus csoportosításban

}
1.23. feladat. Írjon egy

értékkel tér vissza, ha a sztringben a betuk (angol ábécé!) száma száma, és

hamissal tér vissza egyébként!

logikai függvényt, amely egy paraméterként megkapott sztring esetén igaz nagyobb, mint a nem-betu karakterek

#include int tobb_betu( char *s ) { int betu = 0; while ( *s ) { if ( isalpha( *s ) ) ++betu; else --betu; s++; } return betu > 0; }
1.24. feladat. Írjon egy

lülírja a

függvényt, amely egy paraméterként megkapott sztringben szóközzel fenem betu karaktereket és visszaadja az új sztringet!
/* isalpha() */ /* malloc() */ /* strlen() */

#include #include #include

char *nembetu( char *s ) { char *uj = ( char * )malloc( ( strlen( s ) + 1 ) * sizeof( char ) ); int i; for ( i = 0; s[ i ]; ++i ) uj[ i ] = isalpha( s[ i ] ) ? s[ i ] : ' '; uj[ i ] = '\0'; return uj; }
1.25. feladat. Írjon

tér vissza, ha a szóban

logikai függvényt, amely egy paraméterként megkapott angol szó esetén igazzal nincs egymás mellett két mássalhangzó!

#include #include int nincsketmsh( char *s ) { char *msh = "bcdfghjklmnpqrstvwxyz"; int i; for ( i = 0; i + 1 < strlen( s ); ++i ) if ( strchr( msh, tolower( s[ i ] ) ) && strchr( msh, tolower( s[ i+1 ] ) ) ) return 0; return 1; }
1.26. feladat. Írjon

ad vissza, ha a sztringben van olyan

logikai függvényt, amely egy paraméterként megkapott sztringnél igaz értéket 4 elemu részsztring, amely legalább háromszor ismétlodik.

A feladat többféleképpen is értelmezheto, és többféleképpen is megoldható.

1.3.

Sztringek

23

(a) Az elso megoldásban karakterenként végezzük az összehasonlítást, és megengedjük a részsztringek közötti átfedést:

#include int negyismet( char *s ) { int i; for ( i = 0; i + 5 < strlen( s ); ++i ) { int j, darab = 1; for ( j = i + 1; j + 5 - darab < strlen( s ); ++j ) if ( s[ i ] == s[ j ] && s[ i+1 ] ==s [ j+1 ] && s[ i+2 ] == s[ j+2 ] && s[ i+3 ] == s[ j+3 ] && ++darab == 3 ) return 1; } return 0; }
(b) A második megoldásban a részsztringek összehasonlítását az zuk, és nem engedjük meg a részsztringek között az átfedést:

strncmp()

könyvtári függvényre bíz-

#include int negyismet( char *s ) { int i; for ( i = 0; i + 11 < strlen( s ); ++i ) { int j, darab = 1; for ( j = i + 4; j + 11 - 4 * darab < strlen( s ); ++j ) if ( !strncmp( s + i, s + j, 4 ) ) { if ( ++darab == 3 ) return 1; j += 3; } } return 0; }
1.27. feladat. Írjon logikai

van-e benne olyan

függvényt, amely egy paraméterként kapott sztringrol részsztring, amely pontosan 4 azonos karakterbol áll!

eldönti, hogy

#include int pontnegy( char *s ) { int i; for ( i = 0; i + 3 < strlen( s ); ++i ) if ( s[ i ] == s[ i+1 ] && s[ i ] == s[ i+2 ] && s[ i ] == s[ i+3 ] ) return 1; return 0; }
1.28. feladat. Írjon

álló

függvényt, amely egy paraméterként megkapott sztringben az egymás mellett szóközök közül csak egyet hagy meg, és visszatér az új sztringgel!

#include

24

1.

Példák tematikus csoportosításban

#include char *szokoztelenito( char *s ) { char *uj = ( char * )malloc( ( strlen( s ) + 1 ) * sizeof( char ) ); int i, j; for ( i = 0, j = 0; i < strlen( s ); ++i ) if ( i == 0 || s[ i ] != ' ' || s[ i-1 ] != ' ' ) uj[ j++ ] = s[ i ]; uj[ j ] = '\0'; return uj; }
1.29. feladat. Írjon egy

függvényt, amelynek elso paramétere egy sztring, második paramétere egy pozitív egész szám, és a függvény adja vissza azt a sztringet, amely az eredetibol úgy keletkezik, hogy azt az elején és a végén kiegészítjük szóközökkel (egyenletesen elosztva azokat) úgy, hogy az új sztring

hossza a második paraméter értéke legyen!

#include #include char *eloszt( char *s, int hossz ) { char *uj; if ( strlen( s ) >= hossz ) { uj = ( char * )malloc( ( strlen( s strcpy( uj, s ); } else { int i; uj = ( char * )malloc( ( hossz + 1 for ( i = 0; i < ( hossz - strlen( uj[ i ] = ' '; uj[ i ] = '\0'; strcat( uj, s ); for ( i = strlen( uj ); i < hossz; uj[ i ] = ' '; uj[ i ] = '\0'; } return uj; }
1.30. feladat. Írjon

) + 1 ) * sizeof( char ) );

) * sizeof( char ) ); s ) ) / 2; ++i )

++i )

kapott

logikai függvényt, amely sztring szabványos C egész literál.

akkor tér vissza igaz értékkel, ha a paraméterként

A feladatot többféleképpen is meg lehet oldani. (a) Elso megoldásunkban állapotátmenet-gráfot használunk.

#include int egeszliteral( char *s ) { enum { START, JO, ROSSZ, DECIMALIS, OKT_HEXA, OKTALIS, HEXA_ELSO, HEXA, L, U, LU } allapot = START; while ( allapot != JO && allapot != ROSSZ ) { switch ( allapot )

1.3.

Sztringek

25

{

case START:

if ( *s == '0' ) allapot = OKT_HEXA; else if ( isdigit( *s ) ) allapot = DECIMALIS; else allapot = ROSSZ; break; case DECIMALIS: if ( !*s ) allapot = JO; else if ( tolower( *s ) == 'u' ) allapot = U; else if ( tolower( *s ) == 'l' ) allapot = L; else if ( !isdigit( *s ) ) allapot = ROSSZ; break; case OKT_HEXA: if ( !*s ) allapot = JO; else if ( tolower( *s ) == 'x' ) allapot = HEXA_ELSO; else if ( *s >= '0' && *s <= '7' ) allapot = OKTALIS; else if ( tolower( *s ) == 'u' ) allapot = U; else if ( tolower( *s ) == 'l' ) allapot = L; else allapot = ROSSZ; break; case OKTALIS: if ( !*s ) allapot = JO; else if ( tolower( *s ) == 'u' ) allapot = U; else if ( tolower( *s ) == 'l' ) allapot = L; else if ( !( *s >= '0' && *s <= '7' ) ) allapot = ROSSZ; break; case HEXA_ELSO: if ( !*s ) allapot = JO; else if ( isxdigit( *s ) ) allapot = HEXA; else allapot = ROSSZ; break; case HEXA: if ( !*s ) allapot = JO; else if ( tolower( *s ) == 'u' ) allapot = U; else if ( tolower( *s ) == 'l' ) allapot = L; else if ( !isxdigit( *s ) ) allapot = ROSSZ; break; case L: if ( !*s ) allapot = JO; else if ( tolower( *s ) == 'u' )

26

1.

Példák tematikus csoportosításban

case U:

case LU:

}

} return allapot == JO;

} ++s;

allapot = LU; else allapot = ROSSZ; break; if ( !*s ) allapot = JO; else if ( tolower( *s ) == 'l' ) allapot = LU; else allapot = ROSSZ; break; if ( !*s ) allapot = JO; else allapot = ROSSZ; break;

(b) A második megoldásban egyszeru sztringkezelést használunk.

#include #define FALSE 0 #define TRUE !FALSE int egeszliteral( char *s ) { int i; if ( !isdigit( s[ 0 ] ) ) return FALSE; if ( s[ 0 ] == '0' ) if ( tolower( s[ 1 ] ) == 'x' ) { if ( !isxdigit( s[ 2 ] ) ) return FALSE; for ( i = 3; isxdigit( s[ i ] ; } else for ( i = 1; s[ i ] >= '0' && ; else for ( i = 0; isdigit( s[ i ] ); ; if ( !s[ i ] ) return TRUE; if ( tolower( s[ i ] ) == 'u' ) return !s[ i+1 ] || tolower( s[ if ( tolower( s[ i ] ) == 'l' ) return !s[ i+1 ] || tolower( s[ return FALSE; }

); ++i )

s[ i ] <= '7'; ++i ) ++i )

i+1 ] ) == 'l' && !s[ i+2 ]; i+1 ] ) == 'u' && !s[ i+2 ];

1.4.

Kétdimenziós tömbök

27

1.4.

Kétdimenziós tömbök

1.31. feladat. Írjon

négyzetes mátrixról eldönti, hogy

logikai függvényt, amely egy paraméterként megkapott, sztringeket tartalmazó szimmetrikus-e!

#include int negyzetes( char *s[], int meret ) { int i, j; for ( i = 0; i < meret - 1; ++i ) for ( j = i + 1; j < meret; ++j ) if ( strcmp( s[ i * meret + j ], s[ j * meret + i ] ) ) return 0; return 1; }
1.32. feladat. Írjon

talmazó kvadratikus mátrixot

eljárást, amely paraméterként megkapott, tetszoleges méretu, tükröz a mellékátlójára!

egészeket tar-

void tukroz( int *t, int meret ) { int i, j; for ( i = 0; i < meret - 1; ++i ) for ( j = 0; j < meret - 1 - i; ++j ) { int seged = t[ i * meret + j ]; t[ i * meret + j ] = t[ ( meret - j - 1 ) * meret + ( meret - i - 1 ) ]; t[ ( meret - j - 1 ) * meret + ( meret - i - 1 ) ] = seged; } }
1.33. feladat. Írjon

a bitmátrix minden oszlopa és a bitvektor között a továbbiakban nincs szükség.

eljárást, amely paraméterként megkap egy bitmátrixot és egy bitvektort, majd kizáró vagy muveletet végez! Az eredeti bitmátrixra

void xor( int *m, int *v, int sor, int oszlop ) { int i, j; for ( j = 0; j < oszlop; ++j ) for ( i = 0; i < sor; ++i ) m[ i * oszlop + j ] ^= v[ i ]; }
1.34. feladat. Írjon

függvényt, amely tetszoleges méretu, valós értékeket tartalmazó kétdimenziós tömböt kap paraméterként. A függvény határozza meg azon oszlop indexét, amelyben van olyan elem, amelynek az értéke megegyezik az oszlop elemeinek átlagával! Ha több ilyen oszlop is van, akkor a legnagyobb indexértéket adja vissza!

int atlagindex( double *t, int sor, int oszlop ) { int j; for ( j = oszlop - 1; j >= 0; --j ) { double atlag = 0; int i; for ( i = 0; i < sor; ++i ) atlag += t[ i * oszlop + j ]; atlag /= sor; for ( i = 0; i < sor; ++i ) if ( t[ i * oszlop + j ] == atlag )

28

1.

Példák tematikus csoportosításban

}

return j; } return -1; t[ i * oszlop + j ] == atlag
kifejezés értéke az oszlopátlag lebegopontos

Megjegyezzük, hogy a

ábrázolásának pontatlansága miatt igen gyakran akkor is hamis, ha matematikailag megegyezik vele a tömbelem értéke. Ezért a következo megoldást javasoljuk:

#include #include

/* fabs() */ /* DBL_EPSILON */

int atlagindex( double *t, int sor, int oszlop ) { int j; for ( j = oszlop - 1; j >= 0; --j ) { double atlag = 0; int i; for ( i = 0; i < sor; ++i ) atlag += t[ i * oszlop + j ]; atlag /= sor; for ( i = 0; i < sor; ++i ) if ( fabs( t[ i * oszlop + j ] - atlag ) < DBL_EPSILON ) return j; } return -1; }
1.35. feladat. Írjon

függvényt, amely egy paraméterként kapott, egészeket tartalmazó kétdimenziós tömb azon oszlopának indexét adja vissza, amelyben a legkevesebb pozitív elem van!
Amennyiben több oszlopban is annyi pozitív elem van, mint abban, amelyikben a legkevesebb pozitív elem található, akkor az alábbi függvény a legelso ilyen oszlop indexét határozza meg.

int kevespozoszlop( int *t, int sor, int oszlop ) { int j, min = sor, minoszlop = 0; for ( j = 0; j < oszlop; ++j ) { int i, poz = 0; for ( i = 0; i < sor; ++i ) if ( t[ i * oszlop + j ] > 0 ) ++poz; if ( poz < min ) { min = poz; minoszlop = j; } } return minoszlop; }
1.36. feladat. Írjon egy

függvényt, amely egy paraméterként megkapott, egészeket tartalmazó kétdimenziós tömb esetén megadja azon oszlopok számát, amelyekben egy szintén paraméterként megadott értéknél csak nagyobb értékek szerepelnek!

int csaknagyobb( int *t, int sor, int oszlop, int ertek ) { int j, db = 0; for ( j = 0; j < oszlop; ++j )

1.4.

Kétdimenziós tömbök

29

{

}

} return db;

int i; for ( i = 0; i < sor; ++i ) if ( t[ i * oszlop + j ] <= ertek ) break; if ( i == sor ) ++db;

1.37. feladat. Írjon

talmazó

eljárást, amely paraméterként megkap egy tetszoleges méretu, valósakat tarkétdimenziós tömböt, és eloállít egy olyan egydimenziós tömböt, amely a sorok átlagát tartalmazza. Az eljárás a képernyore nem írhat!

#include double *soratlagok( double *t, int sor, int oszlop ) { double *soratl = ( double * )calloc( sor, sizeof( double ) ); int i; for ( i = 0; i < sor; ++i ) { int j; for ( j = 0; j < oszlop; ++j ) soratl[ i ] += t[ i * oszlop + j ]; soratl[ i ] /= oszlop; } return soratl; }
1.38. feladat. Írjon

ziós tömb
elemeit:

oszlopait úgy rendezi át, hogy az elso sor elemei nagyság szerint

eljárást, amely egy paraméterként megkapott, egészeket tartalmazó kétdimencsökkeno sorrendben

legyenek! Feltehetjük, hogy az elso sor elemei különbözoek. A feladatot többféle módon is meg lehet oldani, itt buborékrendezéssel rendeztük a tömb elso sorának

void csokelsosor( int *a, int sor, int oszlop ) { int korlat = oszlop - 1, t; do { int j; t = -1; for ( j = 0; j < korlat; ++j ) if ( a[ j ] < a[ j + 1 ] ) { int i; for ( i = 0; i < sor; ++i ) /* az oszlopok minden elemét cseréljük */ { int seged = a[ i * oszlop + j ]; a[ i * oszlop + j ] = a[ i * oszlop + j + 1 ]; a[ i * oszlop + j + 1 ] = seged; } t = j; } korlat = t; } while ( t != -1 ); }

30

1.

Példák tematikus csoportosításban

1.39. feladat. Írjon

talmazó kétdimenziós tömb legyenek!

eljárást, amely egy paraméterként megkapott, tetszoleges méretu, valósakat tarsorait úgy rendezi át, hogy az utolsó oszlop értékei csökkeno sorrendben

A feladatot többféle módon is meg lehet oldani, itt maximumkiválasztásos rendezéssel rendeztük a tömb utolsó oszlopának elemeit:

void atrendez( double *t, int sor, int oszlop ) { int i; for ( i = 0; i < sor - 1; ++i ) { int j, k, index = i; for ( k = i + 1; k < sor; ++k ) if ( t[ index * oszlop + oszlop - 1 ] < t[ k * oszlop + oszlop - 1 ] ) index = k; for ( j = 0; j < oszlop; ++j ) /* a sorok minden elemét cseréljük */ { double seged = t[ index * oszlop + j ]; t[ index * oszlop + j ] = t[ i * oszlop + j ]; t[ i * oszlop + j ] = seged; } } }
1.40. feladat. Írjon

talmazó kétdimenziós tömb

eljárást, amely egy paraméterként megkapott, tetszoleges méretu, egészeket taroszlopátlagai közül meghatározza a legnagyobbat (több ilyen is lehet)! Az eljárás nem írhat képernyore és állományba!
Vegyük észre, hogy a feladat megfogalmazása csalanta: hiába van esetleg több azonos legnagyobb oszlopátlag, az eljárásnak csak ezek egyikét, egyetlen értéket kell meghatároznia. A feladat többféleképpen is megoldható. (a) Lássuk eloször azt a megoldást, amikor az eljárás egy globális változóban határozza meg a keresett (legnagyobb) oszlopátlagot:

double atlag; void atlagol( int *t, int sor, int oszlop ) { int i, j; atlag = 0.0; for ( i = 0; i < sor; ++i ) atlag += t[ i * oszlop ]; for ( j = 1; j < oszlop; ++j ) { double seged = 0.0; for ( i = 0; i < sor; ++i ) seged += t[ i * oszlop + j ]; if ( seged > atlag ) atlag = seged; } atlag /= sor; }
(b) Egy másik megoldási lehetoség, ha az eljárásnak átadunk még egy paramétert, annak a memóriaterületnek a címét, ahol a keresett átlagértéket tárolni szeretnénk:

void atlagol( int *t, int sor, int oszlop, double *atlag ) {

1.4.

Kétdimenziós tömbök

31

}

int i, j; *atlag = 0.0; for ( i = 0; i < sor; ++i ) *atlag += t[ i * oszlop ]; for ( j = 1; j < oszlop; ++j ) { double seged = 0.0; for ( i = 0; i < sor; ++i ) seged += t[ i * oszlop + j ]; if ( seged > *atlag ) *atlag = seged; } *atlag /= sor;

tartalmazó

függvényt, amely paraméterként megkap egy tetszoleges méretu, egészeket kvadratikus mátrixot, és visszaadja a foátló maximális és minimális elemét. A képernyore nem írunk!
1.41. feladat. Írjon

typedef struct { int max, min; } MAXMIN; MAXMIN foatlo( int *m, int meret ) { MAXMIN mm = { *m, *m }; int i; for ( i = 1; i < meret; ++i ) if ( m[ i * ( meret + 1 ) ] > mm.max ) mm.max = m[ i * ( meret + 1 ) ]; else if ( m[ i * ( meret + 1 ) ] < mm.min ) mm.min = m[ i * ( meret + 1 ) ]; return mm; }

függvényt, amely paraméterként megkap egy tetszoleges méretu, valósakat kétdimenziós tömböt, és visszatérési értékként meghatározza a sorok átlagának minimumát és az oszlopok átlagának maximumát.
1.42. feladat. Írjon

tartalmazó

typedef struct { double min, max; } MINMAX; MINMAX sorminoszmax( double *m, int sor, int oszlop ) { MINMAX mm; int i, j; for ( i = 0; i < sor; ++i ) { double osszeg = 0; for ( j = 0; j < oszlop; ++j ) osszeg += m[ i * oszlop + j ]; if ( i == 0 || osszeg < mm.min ) mm.min = osszeg; } mm.min /= oszlop; for ( j = 0; j < oszlop; ++j ) { double osszeg = 0; for ( i = 0; i
32

1.

Példák tematikus csoportosításban

}

} mm.max /= sor; return mm;

osszeg += m[ i * oszlop + j ]; if ( j == 0 || osszeg > mm.max ) mm.max = osszeg;

1.43. feladat. Írjon

eljárást, amely egy paraméterként megkapott, egészeket tartalmazó kétdimenziós tömbben meghatározza azon oszlopok indexét (akárhány ilyen lehet), amelyekben a negatív elemek száma legalább kétszerese a nulla értéku elemek számának! A tömb mérete tetszoleges.
A feladat többféleképpen is megoldható. (a) Eloször is lássuk azt a megoldást, amely két globális változót használ: egyik a feltételnek megfelelo oszlopok darabszámát fogja tartalmazni, a másik pedig arra a memóriaterületre mutat, ahol a keresett oszlopindexeket tároljuk.

#include int *dupneg; int darab; void negketszer( int *t, int sor, int oszlop ) { int j; dupneg = NULL; darab = 0; for ( j = 0; j < oszlop; ++j ) { int i, negativ = 0, nulla = 0; for ( i = 0; i < sor; ++i ) if ( t[ i * oszlop + j ] < 0 ) ++negativ; else if ( t[ i * oszlop + j ] == 0 ) ++nulla; if ( negativ >= 2 * nulla ) { dupneg = ( int * )realloc( dupneg, darab + 1 ); dupneg[ darab++ ] = j; } } }
(b) Az eljárás természetesen paraméterlistán keresztül is kommunikálhat a hívó programegységgel. Ekkor a megoldás a következo lehet:

#include void negketszer( int *t, int sor, int oszlop, int *darab, int **dupneg ) { int j; *dupneg = NULL; *darab = 0; for ( j = 0; j < oszlop; ++j ) { int i, negativ = 0, nulla = 0; for ( i = 0; i < sor; ++i ) if ( t[ i * oszlop + j ] < 0 ) ++negativ;

1.4.

Kétdimenziós tömbök

33

}

}

else if ( t[ i * oszlop + j ] == 0 ) ++nulla; if ( negativ >= 2 * nulla ) { *dupneg = ( int * )realloc( *dupneg, *darab + 1 ); ( *dupneg )[ ( *darab )++ ] = j; }

(c) Álljon itt végül az a megoldást, amely egy globális mutatóval dolgozik: a mutató egy olyan memóriaterületre mutat, amelynek elso eleme az ezt követo elemek (a keresett oszlopindexek) darabszámát adja meg.

#include int *dupneg; void negketszer( int *t, int sor, int oszlop ) { int j; dupneg = ( int * )malloc( sizeof( int ) ); *dupneg = 0; for ( j = 0; j < oszlop; ++j ) { int i, negativ = 0, nulla = 0; for ( i = 0; i < sor; ++i ) if ( t[ i * oszlop + j ] < 0 ) ++negativ; else if ( t[ i * oszlop + j ] == 0 ) ++nulla; if ( negativ >= 2 * nulla ) { dupneg = ( int * )realloc( dupneg, *dupneg + 2 ); dupneg[ ++*dupneg ] = j; } } }
1.44. feladat. Írjon

mazó tömb azon egy ilyen van)!

eljárást, amely egy paraméterként megadott kétdimenziós, egészeket tartaloszlopát határozza meg, amelyben benne van az egész tömb legnagyobb eleme (csak

#include #include void legoszlop( int *t, int sor, int oszlop, int **oszl ) { int i, j, maxelem = *t, maxoszlop = 0; *oszl = ( int * )malloc( sor * sizeof( int ) ); for ( i = 0; i < sor; ++i ) for ( j = 0; j < oszlop; ++j ) if ( t[ i * oszlop + j ] > maxelem ) { maxelem = t[ i * oszlop + j ]; maxoszlop = j; } for ( i = 0; i < sor; ++i ) ( *oszl )[ i ] = t[ i * oszlop + maxoszlop ]; }

34

1.

Példák tematikus csoportosításban

1.45. feladat. Írjon egy

ket tartalmazó kvadratikus mátrix

eljárást, amely egy paraméterként megkapott, tetszoleges méretu, egészefoátlójában elhelyezi soronként a foátló fölötti elemek összegét!

#include void atlossz( int *t, int meret ) { int j; for ( j = 0; j < meret; ++j ) { int i; t[ j * meret + j ] = 0; for ( i = 0; i < j; ++i ) t[ j * meret + j ] += t[ i * meret + j ]; } }
1.46. feladat. Írjon

eljárást, amely egy paraméterként megkapott, egészeket tartalmazó, tetszoleges méretu kétdimenziós tömb minden olyan elemének a 0 értéket adja, amelynek a tömb elemeinek átlagától való eltérése az átlag felénél nagyobb! Az eredeti tömböt változatlanul kell hagyni.

#include #include void nullaz( int *t, int sor, int oszlop, int **ujtomb ) { *ujtomb = ( int * )malloc( sor * oszlop * sizeof( int ) ); int i, j; double atlag; for ( i = 0; i < sor; ++i ) for ( j = 0; j < oszlop; ++j ) atlag += t[ i * oszlop + j ]; atlag /= sor * oszlop; for ( i = 0; i < sor; ++i ) for ( j = 0; j < oszlop; ++j ) if ( fabs( t[ i * oszlop + j ] - atlag ) > atlag / 2 ) ( *ujtomb )[ i * oszlop + j ] = 0; else ( *ujtomb )[ i * oszlop + j ] = t[ i * oszlop + j ]; }
1.5. Fák

logikai függvényt, amely egy paraméterként megkapott, egészeket tartalmazó, szigorú értelemben vett bináris fáról eldönti, hogy tökéletesen kiegyensúlyozott-e!
1.47. feladat. Írjon

typedef struct faelem { int adat; struct faelem *bal, *jobb; } FAELEM; int elemszam( FAELEM *fa ) { return fa ? elemszam( fa->bal ) + elemszam( fa->jobb ) + 1 : 0; } int tokkiegy( FAELEM *fa ) {

1.5.

Fák

35

}

return !fa || tokkiegy( fa->bal ) && tokkiegy( fa->jobb) && abs( elemszam( fa->bal ) - elemszam( fa->jobb ) ) <= 1;

eljárást, amely egy paraméterként megkapott, karaktereket tartalmazó bináris fában a kisbetuket nagybeture cseréli!
1.48. feladat. Írjon egy

#include typedef struct faelem { char kar; struct faelem *bal, *jobb; } FAELEM; void nagybetu( FAELEM *fa ) { if ( fa ) { fa->kar = toupper( fa->kar ); nagybetu( fa->bal ); nagybetu( fa->jobb ); } }
1.49. feladat. Adva van egy

paraméterként megkapja a bináris fa

tetszoleges egészeket tartalmazó bináris fa. Írjon függvényt, amely gyökérmutatóját, a fában elhelyezett értékekbol felépít egy keresofát, és visszaadja annak gyökérmutatóját! Az új fa elemeinek szerkezete: kulcs (a különbözo egész értékek), gyakoriság (az eredeti fában az adott kulcs hányszor fordult elo).

#include typedef struct binfa { int ertek; struct binfa *bal, *jobb; } BINFA; typedef struct keresofa { int kulcs; int gyakorisag; struct keresofa *bal, *jobb; } KERESOFA; KERESOFA *keresofa_bovit( KERESOFA *k, int ertek ) { if ( !k ) { k = ( KERESOFA * )calloc( 1, sizeof( KERESOFA ) ); k->kulcs = ertek; k->gyakorisag = 1; } else if ( k->kulcs > ertek ) k->bal = keresofa_bovit( k->bal, ertek ); else if ( k->kulcs < ertek ) k->jobb = keresofa_bovit( k->jobb, ertek ); else k->gyakorisag++; return k; }

36

1.

Példák tematikus csoportosításban

KERESOFA *binfa_inorder( KERESOFA *k, BINFA *b ) { if ( b ) { k = binfa_inorder( k, b->bal ); k = keresofa_bovit( k, b->ertek ); k = binfa_inorder( k, b->jobb ); } return k; } KERESOFA *keresofa_epito( BINFA *b ) { return binfa_inorder( NULL, b ); }
1.50. feladat. Írjon

fából

eljárást,

amely egy paraméterként megkapott,

kitöröl egy szintén paraméterként megadott

értéket!

egészeket

tartalmazó

kereso-

Az eljárás írjon megfelelo hibaüzenetet a

képernyore, ha a törlés valamilyen okból nem hajtható végre! Egy elem törlésénél a következo lehetoségek fordulhatnak elo:

· · · ·

A törlendo elem nincs benne a keresofában. Ekkor hibaüzenetet kell a képernyore írni. A törlendo elem levélelem, azaz nincs egyetlen rákövetkezoje sem. A törlendo elemnek csak egy rákövetkezoje van. A törlendo elemnek két rákövetkezoje van. Az alábbiakban három

A fentieket gyelembe véve a feladat rekurzívan és iteratívan is megoldható. megoldást adunk meg.

(a) Az elso megoldás rekurzívan oldja meg a feladatot. Egy külön rekurzív eljárásban kezeltük benne azt az esetet, amikor a törlendo elemnek két rákövetkezoje van.

#include #include typedef struct faelem { int adat; struct faelem *bal, *jobb; } FAELEM; void torol_2rakov( FAELEM *torlendo, FAELEM **legjobb ) { if( ( *legjobb )->jobb ) torol_2rakov( torlendo, &( *legjobb )->jobb ); else { FAELEM *seged = *legjobb; torlendo->adat = ( *legjobb )->adat; *legjobb = ( *legjobb )->bal; free( seged ); } } void torol( FAELEM **gym, int ertek ) { if( !*gym ) fputs( "Nincs ilyen érték a fában!\n", stderr );

1.5.

Fák

37

}

else if( ( *gym )->adat != ertek ) torol( ( *gym )->adat < ertek ? &( *gym )->jobb : &( *gym )->bal, ertek ); else if( !( *gym )->bal || !( *gym )->jobb ) { FAELEM *torlendo = *gym; *gym = ( *gym )->bal ? ( *gym )->bal : ( *gym )->jobb; free( torlendo ); } else torol_2rakov( *gym, &( *gym )->bal );

(b) Másodikként lássuk az iteratív megoldást:

#include #include typedef struct faelem { int adat; struct faelem *bal, *jobb; } FAELEM; void torol( FAELEM **gym, int ertek ) { FAELEM *akt = *gym, *szulo = NULL; while ( akt != NULL && akt->adat != ertek ) { szulo = akt; akt = akt->adat > ertek ? akt->bal : akt->jobb; } if ( !akt ) fputs( "Nincs ilyen érték a fában!\n", stderr ); else if ( !akt->bal || !akt->jobb ) { if( !szulo ) *gym = akt->bal ? akt->bal : akt->jobb; else if ( akt->adat < szulo->adat ) szulo->bal = akt->bal ? akt->bal : akt->jobb; else szulo->jobb = akt->bal ? akt->bal : akt->jobb; free( akt ); } else { FAELEM *seged = akt->jobb; szulo = akt; while ( seged->bal ) { szulo = seged; seged = seged->bal; } if ( szulo != akt ) szulo->bal = seged->jobb; else szulo->jobb = seged->jobb; akt->adat = seged->adat; free( seged ); } }

38

1.

Példák tematikus csoportosításban

(c) Végül álljon itt egy olyan rekurzív megoldás, amely iteratív elemeket is tartalmaz (azoknál az elemeknél, amelyeknek két rákövetkezojük is van):

#include #include typedef struct faelem { int adat; struct faelem *bal, *jobb; } FAELEM; void torol( FAELEM **gym, int ertek ) { if( !*gym ) fputs( "Nincs ilyen érték a fában!\n", stderr ); else if( ( *gym )->adat != ertek ) torol( ( *gym )->adat < ertek ? &( *gym )->jobb : &( *gym )->bal, ertek ); else if( !( *gym )->bal || !( *gym )->jobb ) { FAELEM *torlendo = *gym; *gym = ( *gym )->bal ? ( *gym )->bal : ( *gym )->jobb; free( torlendo ); } else { FAELEM *seged = ( *gym )->jobb; while ( seged->bal ) seged = seged->bal; ( *gym )->adat = seged->adat; torol( &( *gym )->jobb, seged->adat ); } }
1.6. Kifejezések

1.51. feladat. Írjon

függvényt, amely paraméterként egy olyan sztringet kap, amely egy szabályos, teljesen zárójelezett inx kifejezést tartalmaz, és meghatározza a kifejezés fájának magasságát! A
kifejezésben csak a elo.

+, -, , / bináris operátorok és maximum 3 jegyu egész szám operandusok fordulnak

int infixmagas( char *s ) { int magas = 1, max = 0; while ( *s ) { if ( *s == '(' ) ++magas; else if ( *s == ')' ) --magas; if ( magas > max ) max = magas; s++; } return max; }

programot, amely billentyuzetrol beolvas egy szabályos, teljesen zárójelezett C kifejezést, amely operandusként csak konstansokat és változókat tartalmaz, és a képernyore írja azt a részkifejezést, amelyet eloször kell kiértékelni!
1.52. feladat. Írjon

1.6.

Kifejezések

39

#include main() { char kif[ 200 ], *p; printf( "Kérem a kifejezést: " ); gets( kif ); for ( p = kif; *p && *p != ')'; ++p ) ; if ( *p ) { while ( *--p != '(' ) ; while ( *++p != ')' ) putchar( *p ); putchar( '\n' ); } else puts( kif ); }
1.53. feladat. Írjon

A program írja karakterbol áll.

programot, amely billentyuzetrol megkap egy szabályos prex alakú kifejezést. képernyore az elsonek kiértékelento részkifejezést inx alakban! A kifejezés csak a +,
amelyek neve egyetlen

-, , / kétoperandusú operátorokat és operandusként olyan változókat tartalmaz,

#include #include #include #define FALSE 0 #define TRUE !FALSE main() { char *op = "+-*/", kif[ 3 ]; int megvan = FALSE, ch; while ( ( ch = getchar() ) != EOF ) if ( !megvan && !isspace( ch ) ) { kif[ 0 ] = kif[ 1 ]; kif[ 1 ] = kif[ 2 ]; kif[ 2 ] = ch; if ( !strchr( op, kif[ 1 ] ) && !strchr( op, kif[ 2 ] ) ) megvan = TRUE; } if ( megvan ) printf( "%c%c%c\n", kif[ 1 ], kif[ 0 ], kif[ 2 ] ); else printf( "%c\n", kif[ 2 ] ); }
1.54. feladat. Adott egy csak a

postorder
egymástól.

+, -, /, * bináris operátorokat tartalmazó szabályos kifejezés fájának
Írjon

bejárásával kapott sorozat. Az operátorokat és az operandusokat A sorozatot billentyuzetrol kapjuk.

prex alakját!

programot,

egy szóköz

választja el

amely képernyore írja a kifejezés

#include #include #include

40

1.

Példák tematikus csoportosításban

typedef struct faelem { char *op; struct faelem *bal, *jobb; } FAELEM; typedef struct veremelem { FAELEM *elem; struct veremelem *kov; } VEREMELEM; VEREMELEM *verem; /* NULL értékkel inicializálódik */

void push( FAELEM *elem ) { VEREMELEM *ujelem = ( VEREMELEM * ) malloc( sizeof( VEREMELEM ) ); ujelem->elem = elem; ujelem->kov = verem; verem = ujelem; } FAELEM *pop() { FAELEM *seged = verem->elem; VEREMELEM *torlendo = verem; verem = verem->kov; free( torlendo ); return seged; } void preorder( FAELEM *gyoker ) { if ( gyoker ) { printf( "%s ", gyoker->op ); free( gyoker->op ); preorder( gyoker->bal ); preorder( gyoker->jobb ); free( gyoker ); } } main() { char kif[ 256 ]; puts( "Kérem a postfix kifejezést:" ); while ( scanf( "%s", kif ) != EOF ) { FAELEM *uj = ( FAELEM * )malloc( sizeof( FAELEM ) ); uj->op = ( char * )malloc( ( strlen( kif ) + 1 ) * sizeof( char ) ); strcpy( uj->op, kif ); if ( strlen( kif ) == 1 && strchr( "+-*/", *kif ) ) { uj->jobb = pop(); uj->bal = pop(); } else

1.6.

Kifejezések

41

}

} preorder( pop() ); putchar( '\n' );

uj->bal = uj->jobb = NULL; push( uj );

1.55. feladat. Írjon

kifejezést,

programot,

mely csak a

nevében csak

betu szerepel!

+, -, , /

billentyuzetrol beolvas egy olyan teljesen zárójelezett változó operandusokat tartalmaz, amelyek Tudjuk, hogy a kifejezésben zárójelhiba van. A program írja képernyore
amely operátorokat és olyan

a kifejezést, és jelölje meg a hiba helyét! A feladat többféleképpen is megoldható. (a) Az elso megoldásban karakterenként végighaladunk a kifejezésen, és minden karakterrol eldöntjük, hogy állhat-e az adott helyen. A szóközöket átugorva, a vizsgált és az azt megelozo karakter alapján állítjuk be a

hiba

változó értékét, ha kell.

#include #include #include typedef enum { OK, OPERANDUS, OPERATOR, NYITO, ZARO, ERVENYTELEN, SOKZARO, KEVESZARO } HIBAOK; char operatorok[] = "+-*/"; main() { int zarojel = 0, operandus[ 1000 ] = { 0 }, i = 0; HIBAOK hiba = OK; char kif[ 1000 ], elozo = '\0';; printf( "A kifejezés: " ); fgets( kif, 1000, stdin ); while ( kif[ i ] != '\n' && kif[ i ] != '\0' ) { while ( kif[ i ] == ' ' || kif[ i ] == '\t' ) ++i; if ( isalpha( kif[ i ] ) ) { if ( isalpha( elozo ) || elozo == ')' ) { hiba = OPERANDUS; break; } elozo = kif[ i ]; while ( isalpha( kif[ i ] ) ) ++i; ++operandus[ zarojel ]; } else if ( strchr( operatorok, kif[ i ] ) ) { if ( strchr( operatorok, elozo ) || elozo == '(' || operandus[ zarojel ] == 2 || zarojel == 0 ) { hiba = OPERATOR; break; } elozo = kif[ i++ ]; }

42

1.

Példák tematikus csoportosításban

} puts( kif ); if ( hiba == OK && zarojel > 0 ) hiba = KEVESZARO; if ( hiba == OK ) puts( "Nincs hiba a kifejezésben." ); else { int j; for ( j = 0; j < i; ++j ) putchar( ' ' ); printf( "^\n" ); switch ( hiba ) { case OPERANDUS: puts( "Itt nem állhat operandus!" ); break; case OPERATOR: puts( "Itt nem állhat operátor!" ); break; case NYITO: puts( "Itt nem állhat nyitó zárójel!" ); break; case ZARO: puts( "Itt nem állhat záró zárójel!" ); break; case ERVENYTELEN: puts( "Érvénytelen karakter!" );

else if ( kif[ i ] == '(' ) { if ( isalpha( elozo ) || elozo == ')' ) { hiba = NYITO; break; } operandus[ ++zarojel ] = 0; elozo = kif[ i++ ]; } else if ( kif[ i ] == ')' ) { if ( strchr( operatorok, elozo ) || elozo == '(' ) { hiba = ZARO; break; } if ( --zarojel < 0 ) { hiba = SOKZARO; break; } ++operandus[ zarojel ]; elozo = kif[ i++ ]; } else { hiba = ERVENYTELEN; break; }

1.6.

Kifejezések

43

}

}

}

break; case SOKZARO: puts( "Túl sok a záró zárójel!" ); break; case KEVESZARO: puts( "Hiányzó záró zárójel!" ); break;

(b) A következo megoldásban állapotátmenet-gráfot használtunk a kifejezés feldolgozására.

#include #include #include #include



#define HIBA 100 #define VEGE 101 enum { KEZDO, OPERATOR, OPERANDUS, NYITO, ZARO, PARATLANZARO, ERVENYTELEN, BETU, NYITOVEG, OPERANDUSVEG, OPERATORVEG, KETOPERATOR, HIANYZOZARO, SOKOPERATOR }; main() { char kif[ 1000 ]; int i, allapot = 1, muvjel, *verem = NULL, darab = 0, hibakod = -1; printf( "A kifejezés: " ); fgets( kif, 1000, stdin );

if ( kif[ strlen( kif ) - 1 ] == '\n' ) kif[ strlen( kif ) - 1 ] = '\0'; i = 0; while ( allapot != VEGE ) { char ch = kif[ i ]; switch ( allapot ) { case 1: if ( ch == '\0' ) allapot = VEGE; else if ( isspace( ch ) ) putchar( ch ); else if ( isalpha( ch ) || ch == '_' ) { putchar( ch ); allapot = 2; } else if ( ch == '(' ) { putchar( ch ); muvjel = 0; allapot = 4; } else { printf( "%c", ch );

44

1.

Példák tematikus csoportosításban

case 2:

case 3:

case 4:

} break; if ( ch == '\0' ) allapot = VEGE; else if ( isalpha( ch ) || ch == '_' ) putchar( ch ); else if ( isspace( ch ) ) { putchar( ch ); allapot = 3; } else { printf( "%c", ch ); if ( strchr( "+-*/", ch ) ) hibakod = OPERATOR; else if ( ch == '(' ) hibakod = NYITO; else if ( ch == ')' ) hibakod = ZARO; else hibakod = ERVENYTELEN; allapot = HIBA; } break; if ( ch == '\0' ) allapot = VEGE; else if ( isspace( ch ) ) putchar( ch ); else { printf( "%c", ch ); if ( strchr( "+-*/", ch ) ) hibakod = OPERATOR; else if ( ch == '(' ) hibakod = NYITO; else if ( ch == ')' ) hibakod = PARATLANZARO; else if ( isalpha( ch ) || ch == '_' ) hibakod = BETU; else hibakod = ERVENYTELEN; allapot = HIBA; } break; if ( ch == '\0' ) { printf( "" ); hibakod = NYITOVEG; allapot = VEGE; } else if ( isspace( ch ) ) putchar( ch ); else if ( ch == '(' ) { putchar( ch );

hibakod = KEZDO; allapot = HIBA;

1.6.

Kifejezések

45

case 5:

case 6:

} else if ( isalpha( ch ) || ch == '_' ) { putchar( ch ); allapot = 5; } else { printf( "%c", ch ); if ( ch == ')' ) hibakod = ZARO; else if ( strchr( "+-*/", ch ) ) hibakod = OPERATOR; else hibakod = ERVENYTELEN; allapot = HIBA; } break; if ( ch == '\0' ) { printf( "" ); hibakod = OPERANDUSVEG; allapot = VEGE; } else if ( isalpha( ch ) || ch == '_' ) putchar( ch ); else if ( isspace( ch ) ) { putchar( ch ); allapot = 6; } else if ( strchr( "+-*/", ch ) != NULL ) { putchar( ch ); muvjel = 1; allapot = 7; } else { printf( "%c", ch ); if ( ch == '(' ) hibakod = NYITO; else if ( ch == ')' ) hibakod = ZARO; else hibakod = ERVENYTELEN; allapot = HIBA; } break; if ( ch == '\0' ) { printf( "" ); hibakod = OPERANDUSVEG; allapot = VEGE; }

++darab; verem = ( int * )realloc( verem, darab * sizeof( int ) ); verem[ darab - 1 ] = muvjel;

46

1.

Példák tematikus csoportosításban

case 7:

case 8:

else if ( isspace( ch ) ) putchar( ch ); else if ( strchr( "+-*/", ch ) != NULL ) { putchar( ch ); muvjel = 1; allapot = 7; } else { printf( "%c", ch ); if ( isalpha( ch ) || ch == '_' ) hibakod = OPERANDUS; else if ( ch == '(' ) hibakod = NYITO; else if ( ch == ')' ) hibakod = ZARO; else hibakod = ERVENYTELEN; allapot = HIBA; } break; if ( ch == '\0' ) { printf( "" ); hibakod = OPERATORVEG; allapot = VEGE; } else if ( ch == '(' ) { putchar( ch ); ++darab; verem = ( int * )realloc( verem, darab * sizeof( int ) ); verem[ darab - 1 ] = muvjel; allapot = 4; } else if ( isspace( ch ) ) putchar( ch ); else if ( isalpha( ch ) || ch == '_' ) { putchar( ch ); allapot = 8; } else { printf( "%c", ch ); if ( ch == ')' ) hibakod = ZARO; else if ( strchr( "+-*/", ch ) ) hibakod = KETOPERATOR; else hibakod = ERVENYTELEN; allapot = HIBA; } break; if ( ch == '\0' ) { printf( "" );

1.6.

Kifejezések

47

case 9:

} else if ( isalpha( ch ) || ch putchar( ch ); else if ( isspace( ch ) ) { putchar( ch ); allapot = 9; } else if ( ch == ')' ) { putchar( ch ); if ( verem != NULL ) { muvjel = verem[ darab - 1 --darab; verem = ( int * )realloc( allapot = muvjel ? 9 : 6; } else allapot = 3; } else { printf( "%c", ch ); if ( strchr( "+-*/", ch ) ) hibakod = SOKOPERATOR; else if ( ch == '(' ) hibakod = NYITO; else hibakod = ERVENYTELEN; allapot = HIBA; } break; if ( ch == '\0' ) { printf( "" ); hibakod = HIANYZOZARO; allapot = VEGE; } else if ( isspace( ch ) ) putchar( ch ); else if ( ch == ')' ) { putchar( ch ); if ( verem != NULL ) { muvjel = verem[ darab - 1 --darab; verem = ( int * )realloc( if ( muvjel == 0 ) allapot = 6; } else allapot = 3; } else

hibakod = HIANYZOZARO; allapot = VEGE;

== '_' )

]; verem, darab * sizeof( int ) );

]; verem, darab * sizeof( int ) );

48

1.

Példák tematikus csoportosításban

{

} putchar( '\n' ); switch ( hibakod ) { case KEZDO:

} ++i;

} break; case HIBA: if ( ch == '\0' ) allapot = VEGE; else putchar( ch ); break;

printf( "%c", ch ); if ( strchr( "+-*/", ch ) ) hibakod = SOKOPERATOR; else if ( ch == '(' ) hibakod = NYITO; else if ( isalpha( ch ) || ch == '_' ) hibakod = OPERANDUS; else hibakod = ERVENYTELEN; allapot = HIBA;

}

puts( "Szabálytalan kezdokarakter." ); break; case OPERATOR: puts( "Itt nem állhat operátor." ); break; case OPERANDUS: puts( "Itt nem állhat operandus." ); break; case NYITO: puts( "Itt nem állhat nyitó zárójel." ); break; case ZARO: puts( "Itt nem állhat záró zárójel." ); break; case PARATLANZARO: puts( "Nincs nyitó párja ennek a záró zárójelnek." ); break; case ERVENYTELEN: puts( "Érvénytelen karakter." ); break; case BETU: puts( "Itt nem állhat betu." ); break; case NYITOVEG: puts( "A kifejezés nem végzodhet nyitó zárójellel." ); break; case OPERANDUSVEG: puts( "Félbehagyott kifejezés, hiányzó operátor." ); break; case OPERATORVEG: puts( "Félbehagyott kifejezés, hiányzó operandus." ); break; case KETOPERATOR: puts( "Két operátor nem állhat egymás mellett." ); break; case HIANYZOZARO: puts( "Hiányzó záró zárójel." ); break; case SOKOPERATOR: puts( "Itt nem állhat újabb operátor." ); break; default: puts( "Szabályos." ); break;

free( verem );

1.6.

Kifejezések

49

}
1.56. feladat. Írjon

kifejezést, amely csak a

programot, amely billentyuzetrol megkap egy olyan teljesen zárójelezett - és a + egy- és kétoperandusú operátorokat, operandusként pedig olyan Cbeli változókat tartalmaz, melyek neve maximum két karakterbol áll. Ellenorizze le, hogy a kifejezés szabályos-e. A képernyore írjon értelemszeru hibaüzeneteket.
A feladat többféleképpen is megoldható. (a) A következo program egy környezetfüggetlen generatív grammatika segítségével eldönti, hogy a kifejezés szabályos-e vagy sem. esetén). Az algoritmus meglehetosen lassú (elsosorban hosszú kifejezések

#include #include #include #include



#define MERET 1000 char minta[ MERET + 1 ]; int szabalyos; void keres( char *s ) { int i; if ( !strcmp( s, minta ) ) szabalyos = 1; for ( i = 0; i < strlen( s ); ++i ) { if ( s[ i ] == 'S' ) { char uj[ MERET + 1 ]; /* S -> b szabály */ strcpy( uj, s ); uj[ i ] = 'b'; keres( uj ); /* S -> S_ szabály */ if ( strlen( s ) < strlen( minta ) ) { strncpy( uj, s, i + 1 ); uj[ i + 1 ] = '\0'; strcat( uj, " " ); strcat( uj, s + i + 1 ); keres( uj ); } /* S -> _S szabály */ if ( strlen( s ) < strlen( minta ) ) { strncpy( uj, s, i ); uj[ i ] = '\0'; strcat( uj, " " ); strcat( uj, s + i ); keres( uj ); } /* S -> bA szabály */ if ( strlen( s ) < strlen( minta ) ) { strncpy( uj, s, i );

50

1.

Példák tematikus csoportosításban

}

}

} else if ( s[ i ] == 'A' ) { char uj[ MERET + 1 ]; /* A -> b szabály */ strcpy( uj, s ); uj[ i ] = 'b'; keres( uj ); /* A -> s szabály */ strcpy( uj, s ); uj[ i ] = 's'; keres( uj ); } else if ( s[ i ] == 'M' ) { char uj[ MERET + 1 ]; /* M -> _M szabály */ if ( strlen( s ) < strlen( minta ) ) { strncpy( uj, s, i ); uj[ i ] = '\0'; strcat( uj, " " ); strcat( uj, s + i ); keres( uj ); } /* M -> m szabály */ strcpy( uj, s ); uj[ i ] = 'm'; keres( uj ); }

} /* S -> (MS) szabály */ if ( strlen( s ) + 2 < strlen( minta ) ) { strncpy( uj, s, i ); uj[ i ] = '\0'; strcat( uj, "(MS)" ); strcat( uj, s + i + 1 ); keres( uj ); } /* S -> (SmS) szabály */ if ( strlen( s ) + 3 < strlen( minta ) ) { strncpy( uj, s, i ); uj[ i ] = '\0'; strcat( uj, "(SmS)" ); strcat( uj, s + i + 1 ); keres( uj ); }

uj[ i ] = '\0'; strcat( uj, "bA" ); strcat( uj, s + i + 1 ); keres( uj );

main() {

1.6.

Kifejezések

51

char kif[ MERET + 1 ], szo[ MERET + 1 ]; int i; printf( "A kifejezés: " ); gets( kif );

for ( i = 0; i < strlen( kif ); ++i ) if ( kif[ i ] == '(' || kif[ i ] == ')' ) minta[ i ] = kif[ i ]; else if ( isspace( kif[ i ] ) ) minta[ i ] = ' '; else if ( isalpha( kif[ i ] ) || kif[ i ] == '_' ) minta[ i ] = 'b'; else if ( isdigit( kif[ i ] ) ) minta[ i ] = 's'; else if ( kif[ i ] == '+' || kif[ i ] == '-' ) minta[ i ] = 'm'; else minta[ i ] = 'x'; minta[ i ] = '\0'; strcpy( szo, "S" ); szabalyos = 0; keres( szo ); printf( "kifejezés: *%s*\n", kif ); printf( "minta: *%s*\n", minta ); if ( szabalyos ) puts( "A kifejezés szabályos." ); else puts( "A kifejezés nem szabályos." );

}

(b) A második megoldásban a levezetési szabályok Chomsky-féle normálalakúak, így alkalmazhatjuk a CockeYoungerKasami-féle algoritmust annak eldöntésére, hogy a begépelt kifejezés eleme-e a grammatika által generált nyelvnek.

#include #include #include #include



const char *szabaly[] = { "SSK", "SKS", "SBA", "SNE", "EKE", "EMF", "FSZ", "SNG", "GSE" }; const int meret = sizeof szabaly / sizeof( char * ); char **tomb, n; void inicializal( char *s ) { int i; n = strlen( s ); tomb = ( char ** )malloc( n * ( n + 1 ) * sizeof( char * ) / 2 ); for ( i = 0; i < n * ( n + 1 ) / 2; ++i ) tomb[ i ] = ( char * )calloc( 1, sizeof( char ) ); } char *get( int i, int j ) { return tomb[ n * ( n+1 ) / 2 - ( n-i-1 ) * ( n-i ) / 2 - ( n-i-j ) ];

52

1.

Példák tematikus csoportosításban

} void set( int i, int j, char ch ) { char *p = tomb[ n * ( n+1 ) / 2 - ( n-i-1 ) * ( n-i ) / 2 - ( n-i-j ) ]; int hossz = strlen( p ); p = ( char * )realloc( p, hossz + 2 ); p[ hossz ] = ch; p[ hossz + 1 ] = '\0'; } void felszabadit() { int i; for ( i = 0; i < n * ( n + 1 ) / 2; ++i ) free( tomb[ i ] ); free( tomb ); } main() { char kif[ 1000 ]; int i, j, min = 0; printf( "A kifejezés: " ); inicializal( kif ); for ( i = 0; i < n; ++i ) { if ( isspace( kif[ i ] ) ) set( n - 1 - i, i, 'K' ); /* else if ( kif[ i ] == '(' ) set( n - 1 - i, i, 'N' ); /* else if ( kif[ i ] == ')' ) set( n - 1 - i, i , 'Z' ); /* else if ( strchr( "+-", kif[ i ] ) ) set( n - 1 - i, i, 'M' ); /* else if ( isdigit( kif[ i ] ) ) set( n - 1 - i, i, 'A' ); /* else if ( isalpha( kif[ i ] ) || kif[ i ] == '_' ) { set( n - 1 - i, i, 'A' ); /* set( n - 1 - i, i, 'B' ); /* set( n - 1 - i, i, 'S' ); /* } } gets( kif );

K -> space N -> ( Z -> ) M -> {+,-} A -> {számjegy} A -> {_,betu} B -> {_,betu} S -> {_,betu}

*/ */ */ */ */ */ */ */

for ( i = n - 2; i >= 0; --i ) for ( j = n - 2 - i; j >= 0; --j ) { int k; for ( k = 1; k < n - i - j; ++k ) { int m; for ( m = 0; m < meret; ++m ) if ( strchr( get( i + k, j ), szabaly[ m ][ 1 ] ) && strchr( get( i, n - i - k ), szabaly[ m ][ 2 ] ) &&

1.6.

Kifejezések

53

} } for ( i = 0; i < n; ++i ) for ( j = 0; j < n - i; ++j ) if ( strlen( get( i, j ) ) > min ) min = strlen( get( i, j ) ); printf( "A kifejezés%s szabályos.\n", n && strchr( *tomb,'S' ) ? "" : " nem" ); } felszabadit();

!strchr( get( i, j ), szabaly[ m ][ 0 ] ) ) set( i, j, szabaly[ m ][ 0 ] );

(c) Állapotátmenet-gráfot használva hibás kifejezés esetén a hiba okát is meg tudjuk határozni.

#include #include #include #include



#define VEGE 100 #define HIBA 101 enum { KEZDO, OPERATOR, OPERANDUS, NYITO, ZARO, PARATLANZARO, ERVENYTELEN, BETU, NYITOVEG, SZAMJEGY, OPERANDUSVEG, OPERATORVEG, KETOPERATOR, HIANYZOZARO, SOKOPERATOR, NEMSZAM }; main() { char kif[ 1000 ]; int i, allapot = 1, muvjel, *verem = NULL, darab = 0, hibakod = -1; printf( "A kifejezés: " ); gets( kif );

i = 0; while ( allapot != VEGE ) { char ch = kif[ i ]; switch ( allapot ) { case 1: if ( ch == '\0' ) allapot = VEGE; else if ( isalpha( ch ) || ch == '_' ) { putchar( ch ); allapot = 2; } else if ( isspace( ch ) ) putchar( ch ); else if ( ch == '(' ) { putchar( ch ); muvjel = 0; allapot = 4; } else { printf( "%c", ch ); allapot = HIBA;

54

1.

Példák tematikus csoportosításban

case 2:

case 3:

case 4:

hibakod = KEZDO; } break; if ( ch == '\0' ) allapot = VEGE; else if ( isspace( ch ) || isalnum( ch ) || ch == '_') { putchar( ch ); allapot = 3; } else { printf( "%c", ch ); switch ( ch ) { case '+': case '-': hibakod = OPERATOR; break; case '(': hibakod = NYITO; break; case ')': hibakod = ZARO; break; default: hibakod = ERVENYTELEN; break; } allapot = HIBA; } break; if ( ch == '\0' ) allapot = VEGE; else if ( isspace( ch ) ) putchar( ch ); else { printf( "%c", ch ); switch ( ch ) { case '+': case '-': hibakod = OPERATOR; break; case '(': hibakod = NYITO; break; case ')': hibakod = PARATLANZARO; break; default: if ( isalnum( ch ) || ch == '_' ) hibakod = BETU; else hibakod = ERVENYTELEN; break; } allapot = HIBA; } break; if ( ch == '\0' ) { printf( "" ); hibakod = NYITOVEG; allapot = VEGE; } else if ( isspace( ch ) ) putchar( ch ); else if ( ch == '(' ) { putchar( ch ); ++darab; verem = ( int * )realloc( verem, darab * sizeof( int ) );

1.6.

Kifejezések

55

case 5:

case 6:

verem[ darab - 1 ] = muvjel; } else if ( isalpha( ch ) || ch == '_' ) { putchar( ch ); allapot = 5; } else if ( strchr( "+-", ch ) != NULL ) { putchar( ch ); muvjel = 1; allapot = 7; } else { printf( "%c", ch ); if ( ch == ')' ) hibakod = ZARO; else if ( isdigit( ch ) ) hibakod = SZAMJEGY; else hibakod = ERVENYTELEN; allapot = HIBA; } break; if ( ch == '\0' ) { printf( "" ); hibakod = OPERANDUSVEG; allapot = VEGE; } else if ( isspace( ch ) || isalnum( ch ) || ch { putchar( ch ); allapot = 6; } else if ( strchr( "+-", ch ) != NULL ) { putchar( ch ); muvjel = 1; allapot = 7; } else { printf( "%c", ch ); switch ( ch ) { case '(': hibakod = NYITO; case ')': hibakod = ZARO; default: hibakod = ERVENYTELEN; } allapot = HIBA; } break; if ( ch == '\0' ) { printf( "" ); hibakod = OPERANDUSVEG;

== '_')

break; break; break;

56

1.

Példák tematikus csoportosításban

case 7:

allapot = VEGE; } else if ( isspace( ch ) ) putchar( ch ); else if ( strchr( "+-", ch ) != NULL ) { putchar( ch ); muvjel = 1; allapot = 7; } else { printf( "%c", ch ); switch ( ch ) { case '(': hibakod = NYITO; break; case ')': hibakod = ZARO; break; default: if ( isalpha( ch ) || ch == '_' ) hibakod = OPERANDUS; else if ( isdigit( ch ) ) hibakod = NEMSZAM; else hibakod = ERVENYTELEN; break; } allapot = HIBA; } break; if ( ch == '\0' ) { printf( "" ); hibakod = OPERATORVEG; allapot = VEGE; } else if ( isspace( ch ) ) putchar( ch ); else if ( ch == '(' ) { putchar( ch ); ++darab; verem = ( int * )realloc( verem, darab * sizeof( int ) ); verem[ darab - 1 ] = muvjel; allapot = 4; } else if ( isalpha( ch ) || ch == '_' ) { putchar( ch ); allapot = 8; } else { printf( "%c", ch ); if ( ch == ')' ) hibakod = ZARO; else if ( isdigit( ch ) ) hibakod = SZAMJEGY; else if ( strchr( "+-", ch ) )

1.6.

Kifejezések

57

case 8:

case 9:

} break; if ( ch == '\0' ) { printf( "" ); hibakod = HIANYZOZARO; allapot = VEGE; } else if ( isspace( ch ) || isalnum( ch ) || ch == '_' ) { putchar( ch ); allapot = 9; } else if ( ch == ')' ) { putchar( ch ); if ( darab > 0 ) /* a verem nem üres */ { muvjel = verem[ --darab ]; verem = realloc( verem, darab * sizeof( int ) ); allapot = muvjel ? 9 : 6; } else allapot = 3; } else { printf( "%c", ch ); switch ( ch ) { case '+': case '-': hibakod = SOKOPERATOR; break; case '(': hibakod = NYITO; break; default: hibakod = ERVENYTELEN; break; } allapot = HIBA; } break; if ( ch == '\0' ) { printf( "" ); hibakod = HIANYZOZARO; allapot = VEGE; } else if ( isspace( ch ) ) putchar( ch ); else if ( ch == ')' ) { putchar( ch ); if ( darab > 0 ) /* a verem nem üres */ { muvjel = verem[ --darab ]; verem = realloc( verem, darab * sizeof( int ) ); if ( !muvjel ) allapot = 6;

hibakod = KETOPERATOR; else hibakod = ERVENYTELEN; allapot = HIBA;

58

1.

Példák tematikus csoportosításban

} putchar( '\n' ); switch ( hibakod ) { case KEZDO:

} ++i;

} else { printf( "%c", ch ); switch ( ch ) { case '(': hibakod = NYITO; break; case '+': case '-': hibakod = SOKOPERATOR; break; default: if ( isalpha( ch ) || ch == '_' ) hibakod = OPERANDUS; else if ( isdigit( ch ) ) hibakod = NEMSZAM; else hibakod = ERVENYTELEN; break; } allapot = HIBA; } break; case HIBA: if ( ch == '\0' ) allapot = VEGE; else putchar( ch ); break;

} else allapot = 3;

puts( "Szabálytalan kezdokarakter." ); break; case OPERATOR: puts( "Itt nem állhat operátor." ); break; case OPERANDUS: puts( "Itt nem állhat operandus." ); break; case NYITO: puts( "Itt nem állhat nyitó zárójel." ); break; case ZARO: puts( "Itt nem állhat záró zárójel." ); break; case PARATLANZARO: puts( "Nincs nyitó párja ennek a záró zárójelnek." ); break; case ERVENYTELEN: puts( "Érvénytelen karakter." ); break; case BETU: puts( "Itt nem állhat betu vagy számjegy." ); break; case NYITOVEG: puts( "A kifejezés nem végzodhet nyitó zárójellel." ); break; case SZAMJEGY: puts( "A változónév nem kezdodhet számjeggyel." ); break; case OPERANDUSVEG: puts( "Félbehagyott kifejezés, hiányzó operátor." ); break; case OPERATORVEG: puts( "Félbehagyott kifejezés, hiányzó operandus." );

1.7.

Állományok

59

case KETOPERATOR: case HIANYZOZARO: case SOKOPERATOR: case NEMSZAM: default: } free( verem );

break; puts( "Két operátor nem állhat egymás mellett." ); break; puts( "Hiányzó záró zárójel." ); break; puts( "Itt nem állhat újabb operátor." ); break; puts( "Itt nem állhat számjegy." ); break; puts( "Szabályos." ); break;

}
1.7.

Állományok

1.57. feladat. Írjon

egy

programot, amely angol szavakat kér be billentyuzetrol *** végjelig, és kiírja szöveges állományba közülük azokat, amelyek tartalmazzák a b, c, x, y karaktereket!

#include #include main() { FILE *f = fopen( "ki.txt", "w" ); char szo[ 100 ]; scanf( "%s", szo ); while ( strcmp( szo, "***" ) ) { if ( strchr( szo, 'b' ) && strchr( szo, 'c' ) && strchr( szo, 'x' ) && strchr( szo, 'y' ) ) fprintf( f, "%s\n", szo ); scanf( "%s", szo ); } fclose( f ); }
1.58. feladat. Írjon

üres sztringet

billentyuzetrol angol szavakat olvas mindaddig, amíg szöveges állományba azokat a szavakat, amelyekben egymás mellett van legalább három mássalhangzó.
amely a nem kap. A program írja egy

programot,

#include #include #include #define angmsh( c ) ( strchr( "bcdfghjklmnpqrstvwxyz", tolower( c ) ) ) main() { FILE *f = fopen( "szavak.txt", "w" ); char szo[ 100 ]; for ( ; ; ) { char szo[ 100 ]; int i; gets( szo ); if ( szo[ 0 ] == '\0' ) break;

60

1.

Példák tematikus csoportosításban

}

} fclose( f );

for ( i = 0; i + 2 < strlen( szo ); ++i ) if ( angmsh( szo[ i ] ) && angmsh( szo[ i + 1 ] ) && angmsh( szo[ i + 2 ] ) ) { fprintf( f, "%s\n", szo ); break; }

1.59. feladat. Adva van egy

szöveges állomány, amely egymástól egy szóközzel elválasztott különprogramot, amely képernyore írja azokat a szavakat (ezekbol akármennyi lehet), amelyekben a legtöbb magánhangzó van. bözo angol
szavakat tartalmaz. Írjon

#include #include #include int mghdarab( char *s ) { int darab = 0; while ( *s ) { if ( strchr( "aeiou", tolower( *s ) ) != NULL ) ++darab; s++; } return darab; } int main() { FILE *fin; char input[ 256 ], szo[ 100 ]; int max = 0; printf( "Az input állomány: " ); scanf( "%s", input ); fin = fopen( input, "r" ); while ( fscanf( fin, "%s", szo ) != EOF ) { int mgh = mghdarab( szo ); if ( mgh > max ) max = mgh; } fclose( fin ); fin = fopen( input, "r" ); while ( fscanf( fin, "%s", szo ) != EOF ) { int mgh = mghdarab( szo ); if ( mgh == max ) printf( "%s\n", szo ); } fclose( fin ); }

szöveges állomány, amelyben magyar szavak vannak, minden szó után szóköz áll. Írjon eljárást, amely képernyore írja azon sorokat (több ilyen is lehet), amelyekben a legkevesebb szó van!
1.60. feladat. Adott egy

egy

Feltételezve, hogy a feldolgozandó állomány neve

be.txt,

és az állomány egyetlen sora sem tartalmaz

2000-nél több karaktert, egy lehetséges megoldás a következo:

1.7.

Állományok

61

#include void kevesszosorok() { FILE *f = fopen( "be.txt", "r" ); char sor[ 2000 ]; int i, min = 2000; while ( fgets( sor, 2000, f ) ) { int szoszam = 0; for ( i = 0; sor[ i ]; ++i ) if ( sor[ i ] == ' ' ) ++szoszam; if ( szoszam < min ) min = szoszam; } f = freopen( "be.txt", "r", f ); while ( fgets( sor, 2000, f ) ) { int szoszam = 0; for ( i = 0; sor[ i ]; ++i ) if ( sor[ i ] == ' ' ) ++szoszam; if ( szoszam == min ) printf( sor ); } fclose( f ); }

szöveges állomány, amely soraiban egymástól egyetlen szóközzel elmagyar szavak állnak. Írjon eljárást, amely meghatározza az állományban eloforduló szavak gyakoriságát! Feltételezhetjük, hogy maximum 200 különbözo szó fordul elo.
1.61. feladat. Adva van egy

választott

#include #include #include typedef struct tablaelem { char *kulcs; int gyakorisag; } TABLA[ 200 ]; int darab; TABLA tomb; void gyakszamolo( char *allomany ) { FILE *f; char szo[ 30 ]; darab = 0; f = fopen( allomany, "r" ); while ( fscanf( f, "%s", szo ) != EOF ) { int i; for ( i = 0; i < darab; ++i ) if ( strcmp( tomb[ i ].kulcs, szo ) == 0 ) break; if ( i == darab )

62

1.

Példák tematikus csoportosításban

{

}

} fclose( f );

} else ++tomb[ i ].gyakorisag;

++darab; tomb[ i ].kulcs = ( char * )malloc( ( strlen( szo ) + 1 ) * sizeof( char ) ); strcpy( tomb[ i ].kulcs, szo ); tomb[ i ].gyakorisag = 1;

1.62. feladat. Adva van egy olyan

angol szavakat tartalmaznak. Írjon eloforduló szavak

gyakoriságát!

szöveges állomány, amely sorai egyetlen szóközzel elválasztott programot, amely meghatározza és képernyore írja a szövegben

Vegyük észre, hogy a feladat nagyon hasonlít a 1.61. feladatban megfogalmazottakhoz, mindössze anynyi a különbség, hogy most nem ismerjük a szöveges állományban található, egymástól különbözo szavak maximális darabszámát. Ezért a szavakat és a gyakoriságukat tartalmazó táblázatot dinamikusan célszeru létrehozni.

#include #include #include typedef struct tablaelem { char *kulcs; int gyakorisag; } TABLA; main() { FILE *fin; char input[ 256 ], szo[ 30 ]; TABLA *tabla = NULL; int darab = 0, i; printf( "Az input állomány: " ); scanf( "%s", input );

fin = fopen( input, "r" ); while ( fscanf( fin, "%s", szo ) != EOF ) { for ( i = 0; i < darab; ++i ) if ( strcmp( tabla[ i ].kulcs, szo ) == 0 ) break; if ( i == darab ) /* még nem szerepelt a szó a táblázatban */ { ++darab; tabla = ( TABLA * )realloc( tabla, darab * sizeof( TABLA ) ); tabla[ i ].kulcs = ( char * )malloc( ( strlen( szo ) + 1 ) * sizeof( char ) ); strcpy( tabla[ i ].kulcs, szo ); tabla[ i ].gyakorisag = 1; } else /* a szó benne volt a táblázatban */ ++tabla[ i ].gyakorisag; } fclose( fin ); for ( i = 0; i < darab; ++i )

1.7.

Állományok

63

printf( "%s: %d\n", tabla[ i ].kulcs, tabla[ i ].gyakorisag ); } free( tabla );

1.63. feladat. Írjon

sztringet,

eljárást,

amely paraméterként megkap

majd az elso állomány azon sorait, melyeknek a

két szöveges állomány nevet és egy vége azonos a sztringgel, átírja a másik

állományba! Az elso állomány létezik, a másodikat most kell létrehozni. A feladatot többféleképpen is meg lehet oldani. Azonban minden megoldáshoz érdemes felhasználni a következo függvényt, amely meghatározza, hogy egy (létezo) állománynak milyen hosszú a leghosszabb sora:

#include int sorhossz( char *allomany ) { int hossz = 0, maxhossz = 0, ch; FILE *f = fopen( allomany, "r" ); while ( ( ch = fgetc( f ) ) != EOF ) { if ( ch == '\n' ) { if ( hossz > maxhossz ) maxhossz = hossz; hossz = 0; } else ++hossz; } if ( hossz > maxhossz ) maxhossz = hossz; fclose( f ); } return maxhossz;

A fenti függvény segítségével pontosan akkora memóriaterületet foglalhatunk le egy állománybeli sor beolvasásához, amennyire ahhoz maximálisan szükség lehet. (a) Ezek után lássuk azt a megoldást, amely az állományból beolvasott sorokat karakterenként hátulról elorefelé haladva dolgozza fel:

#include #include void sorvegir( char *innev, char *outnev, char *s ) { int hossz = sorhossz( innev ); char *sor = ( char * )malloc( ( hossz + 2 ) * sizeof( char ) ); FILE *in = fopen( innev, "r" ), *out = fopen( outnev, "w" ); while ( fgets( sor, hossz + 2, in ) ) { char *sorp = sor + strlen( sor ) - 1, *sp = s + strlen( s ) - 1; if ( *sorp == '\n' ) --sorp; while ( sorp >= sor && sp >= s && *sorp == *sp )

64

1.

Példák tematikus csoportosításban

{

}

} fclose( in ); fclose( out ); free( sor );

} if ( sp < s ) fputs( sor, out );

--sorp; --sp;

(b) Most pedig következzék az a megoldás, amely a sorokat a karaktersorozatok összehasonlítására használt

strcmp()

és

strncmp()

könyvtári függvények segítségével dolgozza fel:

#include #include void sorvegir( char *innev, char *outnev, char *s ) { int hossz = sorhossz( innev ); char *sor = ( char * )malloc( ( hossz + 2 ) * sizeof( char ) ); FILE *fin = fopen( innev, "r" ), *fout = fopen( outnev, "w" ); while ( fgets( sor, hossz + 2, fin ) ) { int sorh = strlen( sor ), szth = strlen( s ), diff = sorh - szth; if ( sor[ sorh-1 ] == '\n' && diff > 0 && !strncmp( s, sor + diff - 1, szth ) || sor[ sorh-1 ] != '\n' && diff >= 0 && !strcmp( s, sor + diff ) ) fputs( sor, fout ); } fclose( fin ); fclose( fout ); free( sor ); }
1.64. feladat. Írjon

hosszúságúra

programot, amely egy létezo szöveges állomány minden sorát 80 karakter egészíti ki szóközökkel, ha rövidebbek a sorok 80 karakternél, és csonkítja a végén a sorokat, ha azok hosszabbak 80 karakternél! Az új sorokat egy új szöveges állományba kell írni.
A 80 karakternél rövidebb sorokat sok helyen ki lehet egészíteni szóközökkel, a leglátványosabb (és legkönnyebben ellenorizheto) módon a sorok elején, ahogy azt a következo program is csinálja:

#include #define HATAR 80 int main() { FILE *fin, *fout; char input[ 256 ], output[ 256 ], sor[ HATAR + 1 ]; enum { BELUL, TUL, VEGE } allapot = BELUL; int darab = 0; printf( "Az input állomány: " ); printf( "Az output állomány: " ); fin = fopen( input, "r" ); fout = fopen( output, "w" ); scanf( "%s", input ); scanf( "%s", output );

1.7.

Állományok

65

}

while ( allapot != VEGE ) { int ch = fgetc( fin ); switch ( allapot ) { case BELUL: if ( ch == EOF ) { sor[ darab ] = '\0'; if ( darab != 0 ) { int i; for ( i = 0; i < HATAR - darab; ++i ) fputc( ' ', fout ); fprintf( fout, "%s", sor ); } allapot = VEGE; } else if ( ch == '\n' ) { int i; sor[ darab ] = '\0'; for ( i = 0; i < HATAR - darab; ++i ) fputc( ' ', fout ); fprintf( fout, "%s\n", sor ); darab = 0; } else { sor[ darab++ ] = ch; if ( darab == HATAR ) { sor[ darab ] = '\0'; allapot = TUL; } } break; case TUL: if ( ch == EOF ) { fprintf( fout, "%s", sor ); allapot = VEGE; } else if ( ch == '\n' ) { fprintf( fout, "%s\n", sor ); allapot = BELUL; darab = 0; } break; } } fclose( fout ); fclose( fin );

programot, amely egy létezo szöveges állomány sorainak mindegyikét 100 hoszszúságúra egészíti ki a sorok végén szóközöket szúrva be, ha rövidebb, illetve elhagyva a fölösleges karaktereket, ha hosszabb. Az új sorokat egy most létrehozott szöveges állományba kell elhelyezni.
1.65. feladat. Írjon

A feladatot többféleképpen is meg lehet oldani.

66

1.

Példák tematikus csoportosításban

(a) Elso megoldásunkban állapotátmenet-gráfot használunk, hasonlóan a 1.64. feladatban szereplo megoldáshoz.

#include #define HATAR 100 int main() { FILE *fin, *fout; char input[ 256 ], output[ 256 ], sor[ HATAR + 1 ]; enum { BELUL, TUL, VEGE } allapot = BELUL; int darab = 0; printf( "%s\n", __func__ ); printf( "Az input állomány: " ); printf( "Az output állomány: " ); fin = fopen( input, "r" ); fout = fopen( output, "w" ); scanf( "%s", input ); scanf( "%s", output );

while ( allapot != VEGE ) { int ch = fgetc( fin ); switch ( allapot ) { case BELUL: if ( ch == EOF ) { sor[ darab ] = '\0'; if ( darab != 0 ) { int i; fprintf( fout, "%s", sor ); for ( i = 0; i < HATAR - darab; ++i ) fputc( ' ', fout ); } allapot = VEGE; } else if ( ch == '\n' ) { int i; sor[ darab ] = '\0'; fprintf( fout, "%s", sor ); for ( i = 0; i < HATAR - darab; ++i ) fputc( ' ', fout ); fputc( '\n', fout ); darab = 0; } else { sor[ darab++ ] = ch; if ( darab == HATAR ) { sor[ darab ] = '\0'; allapot = TUL; } } break; case TUL: if ( ch == EOF )

1.7.

Állományok

67

{

}

} } fclose( fout ); fclose( fin );

} else if ( ch == '\n' ) { fprintf( fout, "%s\n", sor ); allapot = BELUL; darab = 0; } break;

fprintf( fout, "%s", sor ); allapot = VEGE;

(b) Második megoldásunk a 1.63. feladathoz hasonlóan eloször meghatározza az input állomány leghosszabb sorának hosszát, majd ezt az adatot felhasználva soronként olvassa végig újra a feldolgozandó állományt.

#include #include #include #define max( a, b ) #define HATAR 100 int sorhossz( char *allomany ) { int hossz = 0, maxhossz = 0, ch; FILE *f = fopen( allomany, "r" ); while ( ( ch = fgetc( f ) ) != EOF ) { if ( ch == '\n' ) { if ( hossz > maxhossz ) maxhossz = hossz; hossz = 0; } else ++hossz; } if ( hossz > maxhossz ) maxhossz = hossz; fclose( f ); return maxhossz; ( ( ( a ) > ( b ) ) ? ( a ) : ( b ) )

}

main() { char input[ 256 ], output[ 256 ], *sor; int hossz; FILE *fin, *fout; printf( "Az input állomány: " ); scanf( "%s", input ); printf( "Az output állomány: " ); scanf( "%s", output );

68

1.

Példák tematikus csoportosításban

hossz = sorhossz( input ); sor = ( char * )malloc( max( hossz + 2, HATAR + 2 ) * sizeof( char ) ); fin = fopen( input, "r" ); fout = fopen( output, "w" ); while ( fgets( sor, hossz + 2, fin ) ) { int sorh = strlen( sor ); int utolso = sor[ sorh - 1 ] != '\n'; if ( !utolso ) sor[ --sorh ] = '\0'; if ( sorh < HATAR ) { int i; for ( i = 0; i < HATAR - sorh; ++i ) strcat( sor, " " ); } else sor[ HATAR ] = '\0'; if ( !utolso ) strcat( sor, "\n" ); fputs( sor, fout ); } free( sor ); fclose( fout ); fclose( fin );

}

1.66. feladat. Írjon

ábécé sorrendben írja át egy

programot, amely egy magyar szavakat tartalmazó szöveges állomány szavait másik állományba!

#include #include #include #include



char *kodol( const char *s ) { char *kod = ( char * )malloc( ( strlen( s ) + 1 ) * sizeof( char ) ), *k = kod; while ( *s ) { switch ( *s ) { case 'a': case 'A': *k++ = 1; break; case 'á': case 'Á': *k++ = 2; break; case 'b': case 'B': *k++ = 3; break; case 'c': case 'C': if ( tolower( *( s + 1 ) ) == 's' ) {

1.7.

Állományok

69

} else if ( tolower( { *k++ = 5; *k++ = 5; s += 2; } else *k++ = 4; break; case 'd': case 'D': if ( tolower( *( s { *k++ = 7; ++s; } else if ( tolower( { *k++ = 7; *k++ = 7; s += 2; } else if ( tolower( { *k++ = 8; s += 2; } else if ( tolower( tolower( { *k++ = 8; *k++ = 8; s += 3; } else *k++ = 6; break; case 'e': case 'E': *k++ = 9; break; case 'é': case 'É': *k++ = 10; break; case 'f': case 'F': *k++ = 11; break; case 'g': case 'G': if ( tolower( *( s { *k++ = 13; ++s; } else if ( tolower( { *k++ = 13; *k++ = 13;

*k++ = 5; ++s;

*( s + 1 ) ) == 'c' && tolower( *( s + 2 ) ) == 's' )

+ 1 ) ) == 'z' )

*( s + 1 ) ) == 'd' && tolower( *( s + 2 ) ) == 'z' )

*( s + 1 ) ) == 'z' && tolower( *( s + 2 ) ) == 's' )

*( s + 1 ) ) == 'd' && tolower( *( s + 2 ) ) == 'z' && *( s + 3 ) ) == 's' )

+ 1 ) ) == 'y' )

*( s + 1 ) ) == 'g' && tolower( *( s + 2 ) ) == 'y' )

70

1.

Példák tematikus csoportosításban

s += 2; } else *k++ = 12; break; case 'h': case 'H': *k++ = 14; break; case 'i': case 'I': *k++ = 15; break; case 'í': case 'Í': *k++ = 16; break; case 'j': case 'J': *k++ = 17; break; case 'k': case 'K': *k++ = 18; break; case 'l': case 'L': if ( tolower( *( s { *k++ = 20; ++s; } else if ( tolower( { *k++ = 20; *k++ = 20; s += 2; } else *k++ = 19; break; case 'm': case 'M': *k++ = 21; break; case 'n': case 'N': if ( tolower( *( s { *k++ = 23; ++s; } else if ( tolower( { *k++ = 23; *k++ = 23; s += 2; } else *k++ = 22; break; case 'o': case 'O': *k++ = 24; break; case 'ó': case 'Ó': *k++ = 25;

+ 1 ) ) == 'y' )

*( s + 1 ) ) == 'l' && tolower( *( s + 2 ) ) == 'y' )

+ 1 ) ) == 'y' )

*( s + 1 ) ) == 'n' && tolower( *( s + 2 ) ) == 'y' )

1.7.

Állományok

71

break; case 'ö': case 'Ö': *k++ = 26; break; case 'o': case '': *k++ = 27; break; case 'p': case 'P': *k++ = 28; break; case 'q': case 'Q': *k++ = 29; break; case 'r': case 'R': *k++ = 30; break; case 's': case 'S': if ( tolower( *( s { *k++ = 32; ++s; } else if ( tolower( { *k++ = 32; *k++ = 32; s += 2; } else *k++ = 31; break; case 't': case 'T': if ( tolower( *( s { *k++ = 34; ++s; } else if ( tolower( { *k++ = 34; *k++ = 34; s += 2; } else *k++ = 33; break; case 'u': case 'U': *k++ = 35; break; case 'ú': case 'Ú': *k++ = 36; break; case 'ü': case 'Ü': *k++ = 37; break; case 'u': case '': *k++ = 38; break;

+ 1 ) ) == 'z' )

*( s + 1 ) ) == 's' && tolower( *( s + 2 ) ) == 'z' )

+ 1 ) ) == 'y' )

*( s + 1 ) ) == 't' && tolower( *( s + 2 ) ) == 'y' )

72

1.

Példák tematikus csoportosításban

}

} *k = '\0'; return kod;

} ++s;

case 'v': case 'V': *k++ = 39; break; case 'w': case 'W': *k++ = 40; break; case 'x': case 'X': *k++ = 41; break; case 'y': case 'Y': *k++ = 42; break; case 'z': case 'Z': if ( tolower( *( s + 1 ) ) == 's' ) { *k++ = 44; ++s; } else if ( tolower( *( s + 1 ) ) == 'z' && tolower( *( s + 2 ) ) == 's' ) { *k++ = 44; *k++ = 44; s += 2; } else *k++ = 43; break;

void ekezettelenit( char *kod ) { while ( *kod ) { switch ( *kod ) { case 2: *kod = 1; break; case 10: *kod = 9; break; case 16: *kod = 15; break; case 25: *kod = 24; break; case 27: *kod = 26; break; case 36: *kod = 35; break;

1.7.

Állományok

73

}

}

} ++kod;

case 38: *kod = 37; break;

int strcmphun( const char *s1, const char *s2 ) { char *kod1 = kodol( s1 ), *kod2 = kodol( s2 ); int elteres = strcmp( kod1, kod2 ), ujelteres; if ( elteres == 0 ) { free( kod1 ); free( kod2 ); return 0; } ekezettelenit( kod1 ); ekezettelenit( kod2 ); ujelteres = strcmp( kod1, kod2 ); free( kod1 ); free( kod2 ); return ujelteres == 0 ? elteres : ujelteres; } main() { FILE *in = fopen( "be.txt", "r" ), *out = fopen( "ki.txt", "w" ); char szo[ 100 ], **tomb = NULL; int meret = 0, i, j; while ( fscanf( in, "%s", szo ) != EOF ) { tomb = ( char ** )realloc( tomb, ++meret * sizeof( char * ) ); tomb[ meret - 1 ] = ( char * )malloc( ( strlen( szo ) + 1 ) * sizeof( char ) ); strcpy( tomb[ meret - 1 ], szo ); } fclose( in ); for ( i = meret - 2; i >= 0; --i ) for ( j = 0; j <= i; ++j ) if ( strcmphun( tomb[ j ], tomb[ j + 1 ] ) > 0 ) { char *seged = tomb[ j ]; tomb[ j ] = tomb[ j + 1 ]; tomb[ j + 1 ] = seged; } for ( i = 0; i < meret; ++i ) fprintf( out, "%s\n", tomb[ i ] ); fclose( out ); }
1.67. feladat. Írjon

programot, amely egy szöveges állományban elhelyezett, szintaktikailag helyes

Pascal (C) forrásprogram szövegét úgy másolja át egy másik szöveges állományba, hogy közben kihagyja belole a

megjegyzéseket!

#include #include #include

74

1.

Példák tematikus csoportosításban

main() { char input[ 256 ], output[ 256 ], *szoveg = NULL; FILE *fin, *fout; int allapot = 1; printf( "Az input állomány: " ); printf( "Az output állomány: " ); fin = fopen( input, "r" ); fout = fopen( output, "w" ); while ( allapot != 11 ) { int ch = fgetc( fin ), hossz; switch ( allapot ) { case 1: if ( ch == EOF ) allapot = 11; else if ( ch == '\'' ) { fputc( ch, fout ); allapot = 2; } else if ( ch == '\"' ) { fputc( ch, fout ); allapot = 4; } else if ( ch == '/' ) { szoveg = malloc( 2 * sizeof( char ) ); strcpy( szoveg, "/" ); allapot = 6; } else fputc( ch, fout ); break; case 2: fputc( ch, fout ); if ( ch == '\'' ) allapot = 1; else if ( ch == '\\' ) allapot = 3; break; case 3: fputc( ch, fout ); allapot = 2; break; case 4: fputc( ch, fout ); if ( ch == '\"' ) allapot = 1; else if ( ch == '\\' ) allapot = 5; break; case 5: fputc( ch, fout ); allapot = 4; break; case 6: if ( ch == '*' ) { gets( input ); gets( output );

1.7.

Állományok

75

case case

case

case }

} else if ( ch == '\\' ) { hossz = strlen( szoveg ); szoveg = realloc( szoveg, ( hossz + 2 ) * sizeof( char ) ); strcat( szoveg, "\\" ); allapot = 9; } else if ( ch == '/' ) fputc( ch, fout ); else { fprintf( fout, "%s%c", szoveg, ch ); free( szoveg ); szoveg = NULL; allapot = 1; } break; 7: if ( ch == '*' ) allapot = 8; break; 8: if ( ch == '/' ) { fputc( ' ', fout ); allapot = 1; } else if ( ch == '\\' ) allapot = 10; else allapot = 7; break; 9: hossz = strlen( szoveg ); szoveg = realloc( szoveg, ( hossz + 2 ) * sizeof( char ) ); szoveg[ hossz ] = ch; szoveg[ hossz + 1 ] = '\0'; if ( ch != ' ' ) allapot = 6; break; 10: if ( ch != ' ' ) allapot = 8; break;

free( szoveg ); allapot = 7;

}

}

fclose( fin ); fclose( fout );

1.68. feladat. Adva van egy

szöveges állomány, amely egy C foprogramot tartalmaz. Írjon programot, amely az összes azonosítót nagybetusre írja át, és az új foprogramot elhelyezi egy másik szöveges állományba!
Ha feltételezzük, hogy a feldolgozandó szöveges állomány nem tartalmaz az elofordítónak szóló (#-tel kezdodo) sorokat, akkor egy lehetséges megoldás a következo:

#include #include #include

76

1.

Példák tematikus csoportosításban

#include const char *kulcstomb[] = { "auto", "double", "int", "struct", "break", "else", "long", "switch", "case", "enum", "register", "typedef", "char", "extern", "return", "union", "const", "float", "short", "unsigned", "continue", "for", "signed", "void", "default", "goto", "sizeof", "volatile", "do", "if", "static", "while" }; const int kulcsdarab = sizeof( kulcstomb ) / sizeof( char * ); int kulcsszo( char *s ) { int i; for ( i = 0; i < kulcsdarab; ++i ) if ( !strcmp( kulcstomb[ i ], s ) ) return 1; return 0; } char *pertelenito( char *s ) { char *uj = ( char * )malloc( ( strlen( s ) + 1 ) * sizeof( char ) ); int i, j; for ( i = j = 0; i < strlen( s ); ++i ) if ( isalnum( s[ i ] ) || s[ i ] == '_' ) uj[ j++ ] = s[ i ]; uj[ j ] = '\0'; return uj; } int main() { FILE *fin, *fout; char input[ 256 ], output[ 256 ], *szo; int allapot = 1; printf( "Az input állomány: " ); printf( "Az output állomány: " ); fin = fopen( input, "r" ); fout = fopen( output, "w" ); while ( allapot != 13 ) { int ch = fgetc( fin ), hossz; switch( allapot ) { case 1: if ( ch == EOF ) allapot = 13; else if ( ch == '\"' ) { fputc( ch, fout ); allapot = 2; } else if ( ch == '\'' ) { gets( input ); gets( output );

1.7.

Állományok

77

case 2:

case 3: case 4:

case 5: case 6:

case 7:

case 8:

case 9:

} else if ( ch == '/' ) { fputc( ch, fout ); allapot = 6; } else if ( isalpha( ch ) || ch == '_' ) { szo = ( char * )calloc( 2, sizeof( char ) ); szo[ 0 ] = ch; allapot = 11; } else fputc( toupper( ch ), fout ); break; fputc( ch, fout ); if ( ch == '\"' ) allapot = 1; else if ( ch == '\\' ) allapot = 3; break; fputc( ch, fout ); allapot = 2; break; fputc( ch, fout ); if ( ch == '\'' ) allapot = 1; else if ( ch == '\\' ) allapot = 5; break; fputc( ch, fout ); allapot = 4; break; fputc( ch, fout ); if ( ch == '\\' ) allapot = 7; else if ( ch == '*' ) allapot = 8; else if ( ch != '/' ) allapot = 1; break; fputc( ch, fout ); if ( ch != ' ' ) allapot = 6; break; fputc( ch, fout ); if ( ch == '*' ) allapot = 9; break; fputc( ch, fout ); if ( ch == '/' ) allapot = 1; else if ( ch == '\\' ) allapot = 10; else allapot = 8;

fputc( ch, fout ); allapot = 4;

78

1.

Példák tematikus csoportosításban

}

}

break; case 10: fputc( ch, fout ); if ( ch != ' ' ) allapot = 9; break; case 11: if ( ch == '\\' ) { hossz = strlen( szo ); szo = ( char * )realloc( szo, ( hossz + 2 ) * sizeof( char ) ); strcat( szo, "\\" ); allapot = 12; } else if ( isalnum( ch ) || ch == '_' ) { hossz = strlen( szo ); szo = ( char * )realloc( szo, ( hossz + 2 ) * sizeof( char ) ); szo[ hossz ] = ch; szo[ hossz + 1 ] = '\0'; } else { char *uj = pertelenito( szo ); if ( kulcsszo( uj ) ) fprintf( fout, "%s", szo ); else { int i; for ( i = 0; i < strlen( szo ); ++i ) fputc( toupper( szo[ i ] ), fout ); } free( szo ); free( uj ); fputc( ch, fout ); allapot = 1; } break; case 12: hossz = strlen( szo ); szo = ( char * )realloc( szo, ( hossz + 2 ) * sizeof( char ) ); szo[ hossz ] = ch; szo[ hossz + 1 ] = '\0'; if ( ch == '\n' ) allapot = 11; break;

}

fclose( fin ); fclose( fout );

értékkel rendelkezo C

egész visszatérési függvényt tartalmaz. Írjon programot, amely meghatározza, hogy a függvény rekurzív-e! Az eredmény a képernyon jelenjen meg!
1.69. feladat. Adva van egy szöveges állomány, amely egy szintaktikailag helyes,

A feladat a következo megfogalmazásokban is szerepelt a beugrókon: Adva van egy C (Pascal)

szöveges állomány, amely egy szintaktikailag helyes, valós visszatérési értékkel rendelkezo függvényt tartalmaz. Írjon programot, amely eldönti, hogy a függvény rekurzív-e! Az eredmény jelenjen meg a képernyon!

1.7.

Állományok

79

(1) formális paramétere van. rekurzív!
#include #include #include #include

Adva van egy szöveges állomány, amely egy olyan szabályos Írjon egy

C függvényt tartalmaz, amelynek egy logikai függvényt, amely akkor ad igaz értéket, ha a függvény

#define FALSE 0 #define TRUE !FALSE void betolt( FILE *f, char *puffer ) { int sztringben, karban, megjben, perperben, marad; char c, elozo = '\0', elozoelotti = '\0'; sztringben = karban = megjben = perperben = marad = FALSE; for ( ; ; ) { if ( ( c = fgetc( f ) ) == EOF ) break; switch ( c ) { case '*': if ( !sztringben && !megjben ) if ( elozo == '/' ) megjben = TRUE; else if ( elozo == '*' ) *puffer++ = elozo; break; case '/': if ( elozo == '*' ) { if ( megjben && !perperben ) megjben = FALSE; } else if ( elozo == '/' ) if ( !megjben && elozoelotti != '*' ) megjben = perperben = TRUE; break; case '\n': if ( elozo == '*' && !sztringben && !megjben ) *puffer++ = elozo; *puffer++ = c; if ( perperben ) megjben = perperben = FALSE; break; case '"': if ( elozo == '*' && !sztringben && !megjben ) *puffer++ = elozo; if ( elozo != '\\' && !karban && !megjben ) sztringben = !sztringben; break; case '\'': if ( elozo == '*' && !sztringben && !karban && !megjben ) *puffer++ = elozo; if ( elozo != '\\' && !sztringben && !megjben ) karban = !karban; break;

80

1.

Példák tematikus csoportosításban

}

} *puffer = '\0';

} if ( !marad ) { elozoelotti = elozo; elozo = c; } else marad = FALSE;

case '\\': if ( !sztringben && !karban && !megjben ) { if ( elozo == '*' ) *puffer++ = elozo; while ( ( c = fgetc( f ) ) == ' ' || c == '\t' ) elozo = c; if ( c != '\n' ) { ungetc( c, f ); *puffer++ = c = elozo; } else marad = TRUE; } break; default: if ( !sztringben && !karban && !megjben ) { if ( elozo == '/' && elozoelotti != '*' || elozo == '*' ) *puffer++ = elozo; *puffer++ = c; }

char *fvnev_keres( char *puffer ) { char *fvnev = ( char * )malloc( 256 * sizeof( char ) ), *pufmut, *nevmut; for ( pufmut = puffer; *pufmut != '('; ++pufmut ) ; while ( strchr( " \t\n", *--pufmut ) ) ; while ( --pufmut >= puffer && ( isalnum( *pufmut ) || *pufmut == '_' ) ) ; for ( nevmut = fvnev; !strchr( " \t\n(", *nevmut = *++pufmut ); ++nevmut ) ; *nevmut = '\0'; return fvnev; } int rekurziv( char *puffer, char *fvnev ) { char *pufmut = puffer, *nevmut; long int pufhossz = strlen( puffer ), nevhossz = strlen( fvnev ); while ( *++pufmut != '{' ) ; while ( pufmut <= puffer + pufhossz - nevhossz ) {

1.7.

Állományok

81

}

} return FALSE;

for ( nevmut = fvnev; *nevmut && *pufmut == *nevmut; ++pufmut, ++nevmut ) ; if ( !*nevmut ) { char *seged = pufmut; while ( strchr( " \t\n", *seged++ ) ) ; if ( *--seged == '(' ) { seged = pufmut - nevhossz; if ( !isalnum( *--seged ) && *seged != '_' ) return TRUE; } } pufmut -= nevmut - fvnev - 1;

main() { FILE *fajl; long int meret; char allnev[ 256 ], *puffer, *fvnev; printf( "Kérem az állomány nevét: " ); scanf( "%s", allnev ); fajl = fopen( allnev, "r" ); if ( !fajl ) { fprintf( stderr, "Hiba az állomány megnyitásánál!\n" ); exit( 1 ); } fseek( fajl, 0, SEEK_END ); meret = ftell( fajl ); fseek( fajl, 0, SEEK_SET ); puffer = ( char * )malloc( meret + 1 ); if ( !puffer ) { fprintf( stderr, "Hiba a memóriafoglalásnál!\n" ); fclose( fajl ); exit( 2 ); } betolt( fajl, puffer ); fclose( fajl ); puts( puffer ); fvnev = fvnev_keres( puffer ); printf( "Függvénynév: *%s*\n", fvnev ); if ( rekurziv( puffer, fvnev ) ) puts( "Rekurzív." ); else puts( "Nem rekurzív." ); free( fvnev ); free( puffer ); }

2. fejezet

Feladatsorok
2.1. 1994. május 16., nappali tagozat
1. Készítsen

eljárást,

amely a standard bemenetrol beolvas egy legfeljebb

10×10-es

méretu, egész

elemekbol álló négyzetes mátrixot, és eldönti, hogy az háromszög mátrix-e! paramétere, amely akkor igaz, ha a mátrix háromszögmátrix. 2. Adva van egy

Az eljárásnak van

egy input paramétere, amely a mátrix aktuális méretét adja meg, és egy logikai típusú output

szoveg.txt nevu szöveges állomány, amely soraiban magyar szavak állnak egymástól

egy szóközzel elválasztva. következik. Írjon

programot, amely végigolvassa az állományt, és

Az utolsó szó után nem áll szóköz, hanem közvetlenül a sorvége jel

(a) megszámolja az állományban lévo szavakat; (b) létrehoz egy másik szöveges állományt, amelybe a

magas, mély, vegyes szavak valamelyikét

helyezi el annak megfeleloen, hogy az adott szó milyen hangrendu. Az új állományban annyi sor és minden sorban annyi szó legyen, mit az eredetiben volt. 3. Adva van egy egészeket tartalmazó típusos állomány. A mérete akkora, hogy nem fér be a tárba. Rendezze az állományt a saját helyén. Segédállományt nem használhat, segédváltozókat igen. 4. Írjon egy olyan logikai

függvényt, amely programozási nyelvek (Pascal, C, Ada, LISP, COBOL,

ALGOL, . . . ) egy halmazát deniálja, majd eldönti, hogy a paramétereként megadott programozási nyelv benne van-e a halmazban. Használjon felsorolásos típust! 5. Adott egy állomány, amelyben az egyes rekordok különbözo típusú adatokat tartalmaznak. rekordok szerkezete a következo: 1. bájt: a tartalmazott adatok típusa 0: integer 1: real 2: boolean 3: char 2. bájt: az adott típusú adatok száma (max. 255), 3. és további bájtok: az adatok. Válogassuk le az állományból a karaktereket tartalmazó rekordokat és hozzunk létre belolük egy szöveges állományt A

szo.txt

néven. Ha már létezik ilyen nevu állomány, akkor bovítsük azt.

2.2.

1995. május 15., nappali tagozat

1. Tekintsük az alábbi láncolt listát, amely

node

típusú elemekbol áll:

type node_m = ^node; node = record value: real; next: node_m; end;

2.2.

1995. május 15., nappali tagozat

83

Írjon olyan Turbo Pascal függvényt, amely két ilyen listán kompozíciós szorzást végez, azaz az eredménye egy olyan lista, amelyben az elso elem a két lista elso elemének szorzata, a második elem a két második elem szorzata stb. Ha az egyik lista rövidebb, mint a másik, akkor feltételezzük, hogy a hátralévo elemei nullák. A függvény egy mutatót adjon vissza a szorzatlista elso elemére (fej). A függvény két paramétere mutató az elso, illetve a második lista elso elemére (fej):

function listmult( list1, list2: node_m ): node_m;
2. Írjon olyan hash függvényt, amely egy paraméterként átvett sztringre eloállít egy számot (címet) 1 és

N

között. A függvény vegye gyelembe a sztringben eloforduló konkrét karaktereket és a sztring

hosszát. A függvény elso paramétere a sztring, a második az pedig a cím:

N

szám legyen, a visszaadott érték

function hash( key: string; N: longint ): longint;
3. Tekintsünk egy keresofát az alábbi csomópont-szerkezettel:

type node_m = ^node; node = record value: integer; left: node_m; right: node_m; end;
A

left

a bal oldali, a

right

a jobb oldali részfára mutat.

A bal oldali részfában lévo elemek kisebbek a gyökérben lévo elemnél (value), a jobb oldali részfában lévo elemek nagyobbak. Írjon olyan függvényt, amely meghatározza, hogy a paraméterként kapott egész hányadik szinten van a fában. A gyökér szintje legyen 0. A visszaadott érték a szintszám. Ha a keresett érték nem fordul elo a fában, a visszaadott érték legyen

-1.

function depth( x: integer ): integer;
4. Egy valós polinomot a következoképpen ábrázolunk láncolt listában: a lista elemei a következo típusúak:

type element_m = ^element; element = record coeff: real; ind: integer; next: element_m; end;
Az

ind a kitevot, a coeff az adott taghoz tartozó együtthatót jelenti.

Például a

2x2 + 1 polinomot

a következoképpen ábrázoljuk:

coeff: 2.0 ind: 2

coeff: 1.0 ind: 0

nil

Írjon olyan függvényt, amelyik a polinom helyettesítési értékét kiszámolja! A függvény elso paramétere mutató az elso elemre (fej), a második pedig pedig az a hely, ahol a helyettesítési értéket venni kell.

function value( head: element_m; x: real ): real;
5. Készítsen egy függvényt, amely kiértékel egy kifejezésfát! A kifejezésfa levélelemei tartalmazzák a numerikus konstansokat, míg a további csomópontok a muveleti jeleket (négy alapmuvelet:

'-', '*', '/').

'+',

A függvény paraméterként egy mutatót kap a fa gyökérelemére, függvényértékként

pedig a kifejezés értékét szolgáltatja. Feltesszük, hogy a megadott kifejezés helyes.

84

2.

Feladatsorok

type pnode = ^node; node = record left: pnode; right: pnode; case boolean of true: ( value: real; ); false: ( opcode: char; ); end; function eval( root: pnode ): real;
6. Készítsen egy függvényt, amely eldönti egy négyzetes mátrixról, hogy háromszögmátrix-e, illetve hogy diagonális mátrix-e! A függvény paraméterként egy mutatót és egy méretet kap. A méret paraméter a mátrix sorainak (és oszlopainak) a számát tartalmazza, a mutató pedig egy egydimenziós egész elemu tömbre mutat. A mátrix elemei ezen tömbben helyezkednek el sorfolytonosan.

const maxmatrix = 100; type mtipus = ( also_haromszog, felso_haromszog, diagonalis, egyeb ); pmatrix = ^array[ 1..maxmatrix*maxmatrix ] of integer; function matrix_teszt( matrix: pmatrix; meret: integer ): mtipus;
7. Készítsen egy függvényt, amely egy egész számot átalakít egy adott számrendszerbeli sztringgé! A függvény elso paramétere az átalakítandó szám, második paramétere a számrendszer alapja, a visszatérési érték pedig az eredmény sztring. A számrendszer alapszáma a esik.

2, . . . , 35

intervallumba

function konvertal( mit: longint; alap: integer ): string;
2.3. Idopontja ismeretlen, nappali tagozat

1. Tekintsük az alábbi szerkezettel adott rendezett bináris fát!

type str node_m node

= string[ 20 ]; = ^node; = record job_nev: str; memory: longint; next: node_m; end; joblist_m = ^joblist; joblist = record job_nev: str; next: joblist_m; end; job_nev
mezo alapján van rendezve növekvo sorrendben.

A fa a

job_nev értékeket, amelyekre a memory értéke egy adott x értéknél nagyobb vagy egyenlo. x. A visszaadott lista szerkezete: joblist.
azokat a A függvény elso paramétere a fa gyökere, a második paramétere pedig az

Írjon olyan Turbo Pascal függvényt, amely egy láncolt listában növekvo sorrendben visszaadja

function usage( root: node_m; x: longint): joblist_m;

2.3.

Idopontja ismeretlen, nappali tagozat

85

2. Írjon olyan eljárást, amely az alábbi szerkezetu listával megvalósított veremben csak a benne eloforduló legnagyobb számot hagyja meg. A veremben különbözo számok vannak.

type stack_m = ^stack; stack = record x: longint; next: stack_m; end;
Az eljárás paramétere: mutató a verem tetejére.

procedure max( top: stack_m );
3. Mutasson a

ptr nevu mutató egy 52 elemu integer típusú elemekbol álló memóriaterületre.

Te-

kintsük az alábbi szerkezetu láncolt listát!

type lapt = 1..52; node_m = ^node; node = record mit : lapt; mivel: lapt; next : node_m; end;
E lista elemei egy cserét határoznak meg a fenti (ptr) tömbben. cserélni a

mivel

A

mit

indexu elemet fel kell

indexuvel.

Írjon egy olyan eljárást, amely az összes, a listában felsorolt cserét

elvégzi a megadott tömbben.

Az eljárás elso paramétere mutató a tömb (ptr) elso elemére, a

második paraméter pedig mutató a lista elso elemére.

procedure csere( ptr: ^integer; list: node_m );
4. Adva van egy szövegfájlban egy valósakból álló zárt intervallumsorozat. sorban van, a két végpont pedig vesszovel van elválasztva. Például: Minden intervallum új

12.45, 12.55 1.0, 2.5
Írjon olyan Turbo Pascal eljárást, amely a képernyore kiírja azt a legbovebb intervallumot, amely egy adott pontot tartalmaz, de nincs a felsorolt intervallumokkal egyetlen közös pontja sem. Az eljárás elso paramétere a szövegfájl neve, a második paramétere pedig a kérdéses pont.

procedure maxi( fnev: string; point: real );
5. Készítsen egy olyan függvényt, amely egy tárban ábrázolt, eldönti, hogy szimmetrikus-e! Ha szimmetrikus, a visszaadott érték

integer típusú elemekbol álló mátrixról true, ellenkezo esetben false.

A mátrix egy összefüggo memóriaterületen van sorfolytonosan tárolva. A függvény paramétere a mátrix elso sorában lévo elso elemnek a címe.

function szimmetrikus( mx: ^integer ): boolean;
6. Adva van a memóriában egy bináris keresési fa az alábbi csomópont-szerkezettel:

type key_t = integer; node_m = ^node; node = record key: key_t; next: node_m; end;

86

2.

Feladatsorok

Írjon olyan Turbo Pascal eljárást, amely minden csomópont bal és jobb oldali gyermekét felcseréli és ugyanakkor a

key

mezoben található egészeket kicseréli a

-1-szeresükre (-key).

(Az eredmény

szintén egy bináris fa.) Az eljárás paramétere a fa gyökere.

procedure swaptree( root: node_m );
Példa:

20

-20

13

40

-40

-13

8

16

-16

-8

2.4.

Idopontja ismeretlen, nappali tagozat

1. Írjon az alábbi prototípussal megegyezo függvényt:

char *concat( int db, ... );
A függvény muködése: az elso változóban megadott darabszámú

char *

típusként átvett változók

által meghatározott karakterláncokat fuzze össze, és az új karakterlánc kezdocímét adja vissza. 2. Írjon az alábbi prototípussal megegyezo függvényt:

int include( FILE *inp, FILE *out );
A függvény muködése: a preprocesszor hasonló funkcióját látja el. adott állományból a tartalmával.

#include <állománynév>

Az elso paraméterben meg-

alakú sorokat helyettesíti a megadott állomány Az így kifejtett szöveg a második

Az új állomány is tartalmazhat hivatkozásokat.

paraméterben megadott állományba kerüljön. A függvény visszatérési értéke 0, ha sikeres volt a végrehajtás; 1, ha megnyitási hiba történt; 2, ha újból meg akarunk nyitni egy már használatban lévo állományt (végtelen ciklus). 3. Írjon olyan függvényt, amely egy paraméterben megkapott fájlról eldönti, hogy 8 bites-e, azaz a bájtjainak legmagasabb helyiértéku bitje magas-e vagy nem. (Ha egy bájt 8 bites, akkor az egész fájl 8 bites.) Ha a fájl 8 bites, akkor 1-et, különben 0-t ad vissza. Prototípus:

int eight( FILE *fp );
4. Készítsen függvényt, amely beolvas egy X11 bitmap fájlt a memóriába. függvény foglaljon helyet. A függvény prototípusa: A bitmap számára a

void *readxbm( FILE * );
Az X11 bitmap formátum: a fájl tartalmaz két

#define

sort, amelyek a bitmap szélességét és

magasságát adják meg. Ezt követi egy C szintaktikájú kezdoértékkel ellátott tömb deklaráció. A bitmap minden pontot egy biten ábrázol, soronként bájthatárra igazítva. Elnevezések:

#define filename _width 100 #define filename _height 150 static char filename _bits[] = { 0x12, 0x34, ... };

2.5.

1996. május 18., nappali tagozat

87

5. Készítsen függvényt, amely veremkalkulátort valósít meg! A függvény bemeno paramétere az input állomány, visszatérési értéke egy valós szám, a muveletek eredménye. Amennyiben a fájlból számot olvas a függvény, az bekerül egy verembe, amennyiben muveleti jelet, úgy azt végre kell hajtani a verem tetején található két értékkel, és az eredmény visszakerül a verembe. A függvény visszatérési értéke az a szám, amely az input fájl végének elérésekor a verem tetején található. Minimálisan a négy alapmuveletet kell implementálni, s tekintettel kell lenni a negatív számokra.

float scale( FILE * );
6. Készítsen függvényt, amely paraméterben megkapott bitképbe téglalapot rajzol. képpont 1 bites, 0 vagy 1 értéku lehet. a kép mérete képpontokban A képben egy

A téglalap rajzolása során a téglalap oldalaihoz tartozó

pontokat 1 értékure kell állítani. A függvény elso paramétere a kép címe a memóriában, a második

x

irányban, a harmadik az

y

irányú méret, a negyedik és ötödik a bal

felso sarok, a hatodik és hetedik a téglalap jobb alsó sarkának koordinátái.

Rec( char *kep, int xw, int yw, int x1, int x2, int y1, int y2 );
2.5. 1996. május 18., nappali tagozat

1. Egy

bináris fa tükrözésének nevezzük a következot:

a fa gyökerétol indulva, szintenként meg-

cseréljük minden elem bal és jobb oldali részfáját. Írjon egy

gyökerét címzo

logikai függvényt, amely paraméterként megkap egy egészeket tartalmazó bináris fa mutatót, tükrözi a fát, és eldönti, hogy a tükrözés után kapott fa megegyezik-e postx alakú kifejezések vannak adva. A kifejezésekben a egész számok mint operandusok szerepelnek. A muveleti

az induló fával! 2. Egy szöveges állományban a sorokban

+, -, , /
Írjon egy

muveleti jelek és elojel nélküli

jeleket és az operandusokat egy-egy szóköz választja el egymástól.

seket, ezek értékét pedig elhelyezi egy 3. Adva van egy

eljárást, amely paraméterként megkapja az állomány nevét, és kiértékeli a kifejezétípusos állományban! típusos állomány a következo rekordszerkezettel:
kulcs név lakcím egész szöveges szöveges

Írjon egy

eljárást,

amely bemeno paraméterként megkapja az

rekordjaiból hozzon létre egy 4. Adva van egy

keresofát!

Kimeno paraméter legyen a

állomány nevét! Az állomány fa gyökerét címzo mutató!

álló, egymástól

szöveges állomány, amely maximum 10 hosszúságú, az angol ábécé betuibol 1 szóközzel elválasztott szavakat tartalmaz. Írjon programot, amely a szavakat egy egyirányban láncolt rendezett listában helyezi el! Írassa ki képernyore azt a szót és az elofordulás számát, amely a leggyakrabban fordul elo az
állományban (vigyázat, több ilyen is lehet)!

5. Írjon egy

eljárást, amely bemeno paraméterként kap egy valós elemekbol felépített bináris fa mutatót! A bináris fához készítse el a hierarchikus listánál megismert zárójeles reprezentációt, és helyezze el azt egy szöveges állományban!
gyökerét címzo rendezi át, hogy azok a sorokban elhelyezett elemek

6. Írjon egy

eljárást, amely egy valósakat tartalmazó tetszoleges kétdimenziós tömb sorait úgy átlaga szerint növekvoen helyezkedjenek el!

7. Írjon egy

hash függvényt, amelynek bemeno paraméterei egy sztring és egy egész szám. A függegy számot 1 és az egész szám között, a meghatározásnál vegye gyelembe a sztring hosszát és a sztringben eloforduló konkrét karaktereket!
vény határozzon meg

88

2.

Feladatsorok

2.6.

1996. június 13., nappali tagozat

1. Egy

bináris fa tükrözésének nevezzük a következot:

a fa gyökerétol indulva, szintenként meg-

cseréljük minden elem bal és jobb oldali részfáját. Írjon egy

gyökerét címzo

logikai függvényt, amely paraméterként megkap egy egészeket tartalmazó bináris fa mutatót, tükrözi a fát, és eldönti, hogy a tükrözés után kapott fa megegyezik-e postx alakú kifejezések vannak adva. A kifejezésekben a egész számok mint operandusok szerepelnek. A muveleti

az induló fával! 2. Egy szöveges állományban a sorokban

+, -, , /
Írjon egy

muveleti jelek és elojel nélküli

jeleket és az operandusokat egy-egy szóköz választja el egymástól.

3.

eljárást, amely paraméterként megkapja az állomány nevét, és minden kifejezéshez felépíti a megfelelo (szétszórt módon ábrázolt) bináris fát, továbbá a fák gyökereinek címét elhelyezi egy egyirányban láncolt listában. Az eljárás kimeno paramétere a lista elso elemét címzo mutató legyen. Adva van egy típusos állomány a következo rekordszerkezettel:
kulcs név lakcím Írjon egy meinek egész szöveges szöveges

eljárást,

4.

5.

száma és mutató! Adva van egy szöveges állomány, amely maximum 10 hosszúságú, az angol ábécé betuibol álló, egymástól 1 szóközzel elválasztott szavakat tartalmaz. Írjon programot, amely meghatározza, hogy az állományban hány különbözo szó van, és ezekhez megállapítja az elofordulásuk gyakoriságát is! A különbözo szavakat a gyakoriságokkal együtt egy típusos állományban kell elhelyezni! Írjon egy függvényt, amely bemeno paraméterként kap egy valós elemekbol felépített keresofa gyökerét címzo mutatót és egy valós értéket! A függvény határozza meg, hogy az adott érték a fa hányadik szintjén fordul elo! A gyökér szint a 0. szint. Ha az érték nincs a fában, a visszaadott
érték:

rekordjaiból hozzon létre egy

állomány nevét! Az állomány rendezett táblázatot! Kimeno paraméter legyen a táblázat ele(reprezentációtól függoen) a táblázat vagy a táblázat elso elemét címzo
amely bemeno paraméterként megkapja az

-1.

6. Írjon egy

7.

jobb).

valósakat tartalmazó kvadratikus mátrix foátló alatti, foátló összegét határozza meg! Adva van egy bináris fa folytonos reprezentációja három egydimenziós tömbben (adat, bal,
amely egy feletti és foátlóban álló elemeinek az Az elso elem a gyökérelem.

eljárást,

eljárást, amely bemeno paraméterként megkapja a fa elemeinek számát és a három tömböt. Az eljárás állítsa elo a fa szétszórt reprezentációját, és kimeno paraméterként adja meg a gyökér címét!
Írjon egy

2.7.

1996. december 14., nappali tagozat

1. Írjon olyan programot, amely két állomány tartalmát hasonlítja össze, és az elso különbség pozícióját a standard hibakimenetre írja! gumentumként). Amennyiben a két állomány tartalma azonos, a program nem ír ki semmit. A program egy vagy két állománynevet kaphat futásideju paraméterként (arHa egy paramétert kapott, akkor a standard bemenetet kell tekinteni a másik hasonlítandó állományként. 2. Írjon olyan programot, amely egy állománynevet kap futásideju paraméterként (argumentumként). Ezen állomány tartalmát olvassa be egy kétirányban láncolt listába. Ezután jelenítse meg a listába felolvasott állomány 24 sorát a képernyon úgy, hogy a 'B' billentyu lenyomására egy sorral visszafelé, az 'N' hatására egy sorral elorefelé lehessen lapozni. Kilépés a 'Q' billentyuvel. Megjegyzés: az állomány sorai maximum 80 karakter hosszúak.

2.8.

1997. május 26., nappali tagozat

89

3. Írjon olyan függvényt, amely két állománynevet kap paraméterként. állomány) alkalmazottak adatait tárolja rendezetlenül.

Az egyik állomány (alap-

A másik állomány (indexállomány) egy-

egy rekordja az alapállomány rekordjainak elsodleges azonosítóját és az adott alaprekord zikai pozícióját tartalmazza. A függvény feladata az indexállomány felhasználásával az alapállomány rekordjainak rendezett kiíratása a képernyore. Az alapállomány rekordszerkezete:

struct { char char long };

employee name[ 50 ]; pid[ 12 ]; /* személyi azonosító, elsodleges kulcs */ salary;

Az indexállomány rekordszerkezete:

struct employee { char pid[ 12 ]; long pos; };
4. Írjon olyan függvényt, amelynek prototípusa a következo:

char *char_dup( char *str, char c );
A függvény feladata a kapott karakterláncban a második paraméterként megadott karakter összes elofordulásának megduplázása, s az eredmény elhelyezése egy megfelelo méretu, a függvény által allokált karakterláncban. A paraméterként kapott karakterlánc tartalma maradjon változatlan. A függvény visszatérési értéke a létrehozott karakterlánc címe legyen, illetve a memóriafoglalás! 5. Írjon olyan függvényt, amely egy bináris fában megadott kifejezést értékel ki! csak a négy alapmuveletre (+, A kifejezésekben

NULL, ha nem sikerült

-, , /) kell számítani.

A kifejezésekben szereplo numerikus értékek

elojeles egész számok. A kifejezés megadására szolgáló fa egy csomópontjának típusa:

struct node { char operator; int value; struct node *right; struct node *left; };
A struktúra

operator

nevu mezojében vagy a muveleti jel ('+',

szerepel, ez utóbbi esetben a struktúra

value

'-', '*', '/'),

vagy egy szóköz

mezojének tartalma egy egész szám (ekkor a csomó-

pont levélelem). A függvény visszatérési értéke a fában megadott kifejezés értéke legyen! A függvény prototípusa:

float evaluate( struct node *expression );
2.8. 1997. május 26., nappali tagozat

1. Adva van egy

szöveges állomány, amelynek soraiban magyar szavak helyezszóköz. Az állomány sorainak száma tetszoleges, egy sorban akárhány szó lehet, a szavak maximális hossza 15. Írjon programot, amely meghatározza az állományban eloforduló különbözo szavak elofordulási gyakoriságát! Feltesszük, hogy legfeljebb 500 különbözo szó lehet. Az eredményt szo, gyak felépítésu rekordokban helyezze el a feladat2.dat nevu típusos állományban!
feladat1.txt
nevu kednek el úgy, hogy minden szó után áll egy

90

2.

Feladatsorok

2. Az elozo feladat eredmény állományát felhasználva írjon olyan

gyakoribb szavakat!
sorrendben

függvényt, amely megadja a leg-

3. Az elso feladat eredmény állományát felhasználva írjon olyan

legnagyobb szót!

függvényt, amely megadja az ábécé

4. Adva van a

feladat3.txt szöveges állomány, amely egy Pascal programot tartalmaz. Írjon eljárást, amely a program szövegébol eltávolítja a megjegyzéseket, és az eredményt helyezze a feladat4.txt
szöveges állományba!

5. Billentyuzetrol megadunk egy azonosítójú változókat és a kívül. Írjon

teljesen zárójelezett kifejezést, amely csak egyetlen betubol álló
kétoperandusú operátorokat tartalmazhatja a zárójeleken

programot, amely beolvassa a kifejezést, és ha az szintaktikusan helyes, akkor felépíti a hozzátartozó bináris fát, ha pedig hibás, akkor képernyore írja azt a részkifejezést, amely még
hibátlan volt, és ezután megjelöli a hiba okát! Feltesszük, hogy redundáns zárójelek nincsenek. 6. Írjon egy

+, -, , /

jelöli azt az operátort, amely

eljárást, amely az elozo feladat szintaktikusan helyes kifejezését képernyore írja és megutoljára lesz végrehajtva a kifejezés kiértékelésénél!

2.9.

1997. június 10., nappali tagozat

1. Írjon egy és egy

eljárást, amely bemeno paraméterként megkap egy létezo szöveges állomány nevet sztringet. Az állomány sorainak száma tetszoleges, egy sor maximálisan 999 karakterbol állhat. Az eljárás határozza meg a legrövidebb és leghosszabb sorokat, és ezeket írja egy szövegállományba, továbbá döntse el, hogy van-e az állományban olyan sor, amely megegyezik
a megadott sztringgel!

2. Adva van egy egészeket tartalmazó bemeno

egyirányban láncolt lista. Írjon eljárást, amely megkapja paraméterként a lista fejét és egy verembe helyezi (a listabeli elofordulás sorrendjében)

azokat at elemeket, melyeknek a listaelemek átlagától való eltérése kisebb mint 2! 3. Adva van egy ja el. Írjon

Pascal azonosítókat tartalmazó szöveges állomány. Az azonosítókat vesszo választprogramot, amely az azonosítókból létrehoz egy olyan keresofát, ahol a csomópontok szerkezete: azonosító, gyakoriság. Adja meg a leggyakrabban eloforduló azonosítót! logikai függvényt, amely egy billentyuzetrol megadott karaktersorozatról eldönti, hogy szabályos Pascal valós konstans-e! szöveges állományban az egyes sorokban szabályos prex alakú kifejezések vannak, ame+, -, , /
operátorok és egész számok mint operandusok szerepelnek. Az operátorokat

4. Írjon egy az

5. Egy

lyekben a

és operandusokat egymástól egy

szóköz

választja el.

jezéseket, és ezek eredményét elhelyezi egy

Írjon programot, típusos állományban!

amely kiértékeli a kife-

2.10.

1997. június 16., nappali tagozat

1. Írjon egy

gyökerét címzo mutatót, és eloállítja a kifejezés 2. Írjon egy és egy

sztring típusú függvényt, amely bemeno paraméterként megkapja egy kifejezés fájának teljesen zárójelezett alakját!

eljárást, amely bemeno paraméterként megkap egy létezo szöveges állomány nevet sztringet! Az állomány sorainak száma tetszoleges, egy sor maximálisan 512 karakterbol állhat. Az eljárás hozzon létre egy egyirányban láncolt listát azon sorokból, amelyeknek a vége megegyezik a megadott sztringgel! A további sorokat írja egy másik szöveges állományba! típusos állomány a következo rekordszerkezettel:
SOR OSZLOP ERTEK byte byte real

3. Adva van egy

2.11.

1998. május 18., nappali tagozat

91

Az állomány egy ritka mátrix háromsoros oszlopfolytonos reprezentációját tartalmazza. Az elso rekord SOR és OSZLOP értéke a mátrix méretét adja meg. Írjon eljárást, amely bemeno paraméterként megkapja az állomány nevét, és képernyore írja a mátrix azon sorát, amely a legtöbb nem-nulla elemet tartalmazza (feltesszük, hogy csak egy ilyen van)! 4. Írjon

az elemeket, amelyek 5. Egy

függvényt, amely egy string[12] típusú elemeket tartalmazó verembol eltávolítja azokat nem Pascal azonosítók!
fa elemeit reprezentáljuk egy

sztring típusú adatelemmel és egy ötelemu mutató típusú függvényt, amely paraméterként megkapja a fa gyökérmutatóját, és eloállítja annak bináris reprezentációját! A visszaadott érték a bináris fa gyökerét
mutatóvektorral. Írjon címezi.

nem bináris

2.11.

1998. május 18., nappali tagozat

1. Adva van egy szövegállomány, amely egy szintaktikusan helyes Pascal programot tartalmaz. programban alprogramok nincsenek, és egyetlen amely megadja, hogy a deklarált output a 2. Írjon egy

változókra mely sorokban történik hivatkozás a szövegben. képernyon keletkezzen! A sorokat 1-tol kezdodoen sorszámozza!

var

utasítás szerepel benne. Írjon

programot,
Az

A

és visszaadja, hogy melyik a

függvényt, amely paraméterként egy nemüres bináris fa gyökérmutatóját kapja meg, legalacsonyabb szintszámú olyan elem, amelynek nincs baloldali

rákövetkezoje! A gyökér szintszáma 0. 3. Írjon

programot, amely billentyuzetrol megadott kifejezésekrol eldönti, hogy szabályos Pascal kifejezések-e! Minden kifejezést egy Enter zár le, benne szóköz nem lehet. A kifejezés sorainak végét egy szóköz Enter sor begépelése jelzi. A kifejezés operandusai egybetus azonosítók és elojel nélküli egész számok lehetnek. Operátorok: +, -, , /. Zárójelek tetszolegesen alkalmazhatók. A program írja a képernyore a kifejezést, ha az szabályos, akkor adja ezt az üzenetet, egyébként jelölje meg azt az elemet, ami a hibát okozza és írjon ki hibaüzenetet!

4. Adva van egy szövegállomány, benne

szavak.

egy szóközzel elválasztott

(nem feltétlenül különbözo)

Két szó hangzási távolságán értjük a következot: a szavakat az elejükön kezdve össze-

hasonlítjuk karakterenként. Eltéro karakterek esetén a résztávolság értéke 1, ha azonos pozíción azonos mássalhangzó van, akkor összege adja.

0.5, azonos magánhangzó esetén 0.1.

A távolságot a résztávolságok

eljárást, amely paraméterként megkapja az állomány nevét, és egy szót, majd egy output tíz szót, amely legközelebb van a megadott szóhoz! A szavak mellett szerepeljen a távolság is.
Írjon állományban elhelyezi azt a 5. Adva van egy szöveges állomány, amely egymástól

egy szóközzel elválasztott különbözo szavakat tartalmaz. Írjon programot, amely feldolgozza az állományt úgy, hogy a szavakból egy hash függvény segítségével 1000 elemu táblázatot állít elo. A hash függvényt tessék úgy
megválasztani, hogy az vegye gyelembe a szavak hosszát is! A szinonimákat láncolni kell.

6. Egy rendezett nembináris fát, amelyben minden elemnek legfeljebb zentáljunk úgy, hogy minden elem mellé felveszünk egy amely úgy járja be a fát, hogy eloször feldolgozza a vetkezoit! 7. Egy operációs rendszerben a memória szabad helyeit

eljárást, gyökérelemet, majd jobbról balra a ráköK
elemu mutatóvektort. Írjon

K

rákövetkezoje lehet, repre-

egyirányban láncolt listával kezeljük, méret, következo szabad hely címe formában, a cím szerint növekvoen. Készítsen egy olyan eljárást, amely paraméterként megkapja a lista fejét és egy tartomány címét és méretét, és
Ha a tartomány összeér egy másik tartománnyal (folytonos

ezt a tartományt felfuzi a listába.

tárterület!), akkor azokat össze kell olvasztani és a listában csak egyszer kell szerepeltetni oket.

2.12.

1998. május 29., nappali tagozat

1. Adva van egy szövegállomány, amely egy szintaktikusan helyes Pascal programot tartalmaz. foprogramban egyetlen

const utasítás van, amelyben skalár nevesített konstansokat deklaráltunk.

A

92

2.

Feladatsorok

Írjunk programot, értékükre!

amely a program szövegében a nevesített konstansok

neveit kicseréli az

2. Adva van egy szövegállomány, amely

után egy szóköz programot, amely egy másik szövegállományba másolja azokat a sorokat, amelyekben nem fordul elo a leggyakoribb szó (több ilyen is lehet)!
Minden szó áll. A sorokban maximum 30 szó lehet. Egy szó maximum 10 karakterbol áll. Írjon amely megkapja a fa

magyar szavakat tartalmaz.

3. Adva van egy szabályos Pascal kifejezés

lezett alakját!

fája, az elemek sztringek. Írjon egy olyan függvényt, gyökérmutatóját, és sztringként visszaadja a kifejezés teljesen záróje-

4. Egy operációs rendszerben a memória szabad helyeit

egyirányban láncolt listával kezeljük, méret, következo szabad hely címe formájában, a cím szerint növekvoen. Készítsen egy olyan eljárást, amely megkapja a lista fejét és egy méretet, és megadja annak a szabad helynek a címét, amelyik a méretet felülrol leginkább megközelíti! Ha több ilyen van, akkor válasszuk a legnagyobb címut! Ha a megtalált szabad hely mérete 2K-nál kevesebbel tér el a megadott mérettol, akkor töröljük a listából az ot reprezentáló elemet, egyébként maradjon a listában egy megfeleloen csökkentett méretu elem! kvadratikus ritka mátrixok négysoros reprezentációját tartalmazza (a mátrix elemei valósak, a standard elem a nulla). Írjon olyan logikai függvényt, amely tetszoleges ilyen állomány esetén eldönti, hogy a mátrix foátlója alatti elemek között van-e nem nulla elem!
1998. június 2., nappali tagozat

5. Adva van egy tipizált állomány, amely

2.13.

1. Adva van egy szövegállomány, amely egy szintaktikusan helyes Pascal programot tartalmaz. Írjon

programot,

amely meghatározza, hogy az

programban! Az eredményt egy

alapszavak milyen gyakorisággal szövegállományban helyezze el! magyar szavakat tartalmaz.
Minden szó

fordulnak elo a

2. Adva van egy szövegállomány, amely amely egy másik lyekben

áll. A sorokban maximum 30 szó lehet. Egy szó maximum 10 karakterbol áll. Írjon

szövegállományba másolja át azokat a szavakat (utánuk egy szóközzel), ametöbb a magánhangzó, mint a mássalhangzó! Az output állományban ne legyenek sorok!
a fa

után egy szóköz programot,

3. Adva van egy szabályos Pascal kifejezés

fája. Írjon egy olyan függvényt, amely megkapja gyökérmutatóját és meghatározza, hogy hány egyoperandusú operátor van benne!

4. Egy operációs rendszerben a memória szabad helyeit

egyirányban láncolt listával kezeljük, méret, cím formában, a cím szerint növekvoen. Készítsen egy olyan eljárást, amely paraméterként megkapja a lista fejét és egy méretet, és meghatározza azon két szabad hely címét, amelyek mérete együttesen a megadott méretet felülrol a legjobban közelíti (a megadott méret
nagyobb bármely listabeli elem méreténél).

5. Adva vannak

tipizált állományok, amelyek mindegyike egy-egy kvadratikus ritka mátrix négysoros reprezentációját tartalmazza (a mátrix elemei egészek, a standard elem a nulla), Az állomány elso eleme a mátrix méretét tartalmazza 0, 0, méret, 0 formában. Írjon olyan logikai függvényt, amely tetszoleges ilyen állomány esetén eldönti, hogy a mátrix szimmetrikus-e!
1998. december 12., nappali tagozat

2.14.

1. Adva van egy szövegállomány, amely egy szintaktikusan helyes Pascal programot tartalmaz, amelyben vannak

függvénydeklarációk. Írjon eljárást, amely paraméterként megkapja az állomány nevét, és egy másik szövegállományba átírja a foprogram elso függvényének a szövegét!

2. Adva van egy

egészeket tartalmazó keresofa, és tudjuk, hogy az elemek között van olyan, amelyátlagával. Írjon függvényt, amely paraméterként megkapja a fa gyökerét címzo mutatót, és meghatározza, hogy a rendezett elemsorozatban hányadik a fenti
nek értéke megegyezik az elemek elem!

2.15.

1999. május 17., nappali tagozat

93

3. Írjon

lyos Pascal kifejezés-e! A kifejezés operandusai

programot, amely egy billentyuzetrol megadott karaktersorozatról eldönti, hogy az szabákétkarakteres azonosítók, illetve háromjegyu elojel nélküli egész számok lehetnek. Operátorok: +, -, , /. Zárójelek tetszolegesen szerepelhetnek. A program írja képernyore a beolvasott karaktersorozatot. Adja a szabályos kifejezés üzenetet,
ha szabályos, és adjon értelmes hibaüzenetet, ha nem szabályos!

4. Adva van egy

sztringeket tartalmazó multilista két mutatóval. Az egyik lánc a bekerülés sorrendjében fuzi fel az elemeket, tehát mindig a végén bovítünk. A másik lánc a sztringeket hosszuk szerint csökkeno sorrendben tartalmazza. Azonos hosszak esetén szintén a bekerülési sorrendet kell tartani. Írjon eljárást, amely paraméterként megkapja a két láncfejet és egy sztringet, és a sztringet beilleszti a multilistába! egész értékpárokat programot, amely

5. Adva van egy szövegállomány, amely soronként egymástól vesszovel elválasztott tartalmaz. Tekintsük ezeket intervallumoknak. Maximum ezer sor van. Írjon

képernyore írja azt az intervallumot (több ilyen is lehet), amely a legtöbb másik intervallumot
tartalmazza!

2.15.

1999. május 17., nappali tagozat

1. Írjon egy olyan

elo! A nembináris fában minden elemnek legfeljebb

függvényt, amely egy nemüres, nembináris fa bináris reprezentációját állítja 5 rákövetkezoje lehet. dene makrókkal.
Írjon

2. Adva van egy C forrásállomány, a forrásszöveg elején paraméter nélküli

programot, amely elvégzi a makróhelyettesítést! függvényt,
amelyeknek nincs

3. Írjon

amely egy tetszoleges bináris fában jobb oldali rákövetkezojük!

megadja azon elemek

darabszámát,
A kifejezésHa a kifeakkor írja

4. Írja meg azt a

blokkot, amely kiértékel egy billentyuzetrol megadott prex kifejezést!
+, -, , /

ben csak a kétoperandusú jezés

szerepelnek. Az operátorokat és operandusokat egy-egy

szóköz választja el egymástól. szabályos, akkor a képernyon jelenjen meg az értéke! Ha nem szabályos, képernyore a kifejezést, és jelölje meg a hiba helyét és okát! programot,

operátorok és elojel nélküli egész számok mint operandusok

5. Írjon

amely egy szöveges állományból leválogatja és képernyore írja azokat a sza-

vakat, amelyek egy billentyuzetrol megadott szó anagrammái (pontosan ugyanazokat a betuket tartalmazzák)! Az állományban a szavakat egy szóköz választja el. A szavak az angol ábécé betuit tartalmazzák. A kis- és nagybetuket nem különböztetjük meg.

2.16.

1999. május 21., esti tagozat

1. Írjon egy

amelyeknek

függvényt, amely tetszoleges bináris fában két rákövetkezojük van!
+, -, , /

megadja azon elemek

darabszámát,
A kife-

2. Írja meg azt a

blokkot, amely kiértékel egy billentyuzetrol megadott postx kifejezést!

jezésben csak a kétoperandusú a kifejezés

operátorok és elojel nélküli egész számok mint operanHa nem szabályos, akkor írja

dusok szerepelnek. Az operátorokat és operandusokat egy-egy szóköz választja el egymástól. Ha képernyore a

szabályos, akkor a képernyon jelenjen meg az értéke. kifejezést és a Hiba! üzenetet! szavakat
tartalmazó szöveges állomány. A szavakat egy-egy szóköz választja el egymástól.

3. Adva van egy szerepelnek.

Írjon programot, amely egy szövegállományba írja azokat a szavakat, amelyek többször is elofordulnak az állományban!

A szavakban csak az angol ábécé betui

4. Írjon

meg, amelyekben az elemek 5. Írjon

függvényt, amely egy valósakat tartalmazó kétdimenziós tömb azon sorainak indexét adja összege a legkisebb! programot, amely egy szöveges állomány azon sorait, amelyek megegyeznek a fordítottjuk-

kal, egy másik szöveges állományba másolja át!

94

2.

Feladatsorok

2.17.

1999. december 10., levelezo tagozat

1. Adva van egy

szavak.txt

Minden szó után

egy szóköz áll.

nevu szöveges állomány, amelyben különbözo

angol

szavak vannak.

Két szó távolságán értsük a következot: a szavakat karakterrol karakterre összehasonlítjuk. Eltéro karakter esetén a résztávolság

1,

azonos mássalhangzó esetén

0.5,

azonos magánhangzó esetén

0.1.
Írjon

A távolságot a résztávolságok összege adja. Ebbol le kell vonni még annyiszor

0.1-et,

ahány

karakterrel különbözik a két szó hossza.

programot,

amely a

képernyore írja azt az

öt

billentyuzetrol

beolvas egy

szót,

majd az állomány szavai közül a A szavak mellett

szót, amely a legközelebb van a beolvasott szóhoz!

szerepeljen a távolság is! 2. Írjon egy olyan

menziós tömb azon

legkisebb!

függvényt, amely egy paraméterként megadott, valósakat tartalmazó kétdisorának indexét adja meg (egy ilyen van), amelyben az elemek összege a eljárást,
amely egy

3. Írjon egy olyan

paraméterként

megadott,

egészeket

tartalmazó vektor

elemeit úgy rendezi át, hogy elöl álljanak a negatívak, aztán a pozitívak, aztán a nulla értékuek! Az elemek az egymáshoz viszonyított relatív sorrendjüket tartsák meg! 4. Írjon egy

programot,

amely billentyuzetrol beolvas egy

eldönti, hogy van-e olyan eleme, amelynek értéke jelenjen meg! 5. Írjon

egészeket tartalmazó vektort, majd megegyezik az elemek átlagával! Az ilyen

elem(ek) indexét írassa ki a képernyore, vagy ha nincs ilyen elem, akkor egy ilyen értelmu szöveg

programot, amely egy szöveges állomány azon sorait, amelyek megegyeznek a fordítottjuk-

kal, egy másik szöveges állományba másolja át!

2.18.

2000. január 12., levelezo tagozat
megadott,

1. Írjon egy olyan

dimenziós tömb azon

függvényt, amely egy paraméterként oszlopának az indexét adja meg legtöbb pozitív elem szerepel!

egészeket

tartalmazó két-

(csak egyetlen ilyen van), amelyben a

2. Írjon egy olyan

programot, amely a billentyuzetrol magyar szavakat olvas be a +++ végjelig,

majd egy szövegállományba kiírja a szavakat ábécé sorrendbe rendezve! 3. Írjon

eljárást, amely egy paraméterként megadott szöveges állomány legrövidebb sorait (több eljárást, amely paraméterként egy olyan egydimenziós tömböt kap, amelynek elemei Az eljárás írja egy globális (már létezo) szövegállomány végére függvényt, amely egy paraméterként megadott, különbözo egészeket tartalmásodik legkisebb elemét határozza meg!

ilyen is lehet) a képernyore írja! 4. Írjon egy

angol

szavakat tartalmaznak!

azokat a szavakat, amelyekben a magánhangzók száma megegyezik a mássalhangzók számával! 5. Írjon egy olyan

mazó egydimenziós tömb

2.19.

2000. május 10., levelezo tagozat

1. Írjon egy olyan van)! 2. Írjon

függvényt, amely egy paraméterként megkapott, egészeket tartalmazó kétdimenziós tömb azon sorának indexét adja vissza, amely sorösszeg nulla (pontosan egy ilyen sor

eljárást, amely egy paraméterként megkapott, karaktereket tartalmazó egydimenziós rész kezdo- és végindexét, amelyben azonos karakterek vannak! Több ilyen rész esetén válassza ki azt, amelyben a karakterek száma maximális!
tömbben meghatározza azon írja azokat a szavakat, amelyekben a

3. Írjon

programot, amely a billentyuzetrol angol szavakat olvas be a végjelig, majd képernyore magánhangzók száma több, mint a mássalhangzók száma!

2.20.

2000. május 20., nappali tagozat

95

4. Adva van egy solja egy mellett! 5. Írjon egy

szöveges állomány. Írjon programot, amely végigolvassa az állományt, és átmámásik szöveges állományba azokat a sorokat, amelyekben valahol két szóköz áll egymás
megkapott,

függvényt, amely egy paraméterként mátrix esetén a következo értékkel tér vissza:
1, 2, 3,

egészeket

tartalmazó

négyzetes

ha a mátrix szimmetrikus, ha a mátrix alsó háromszög mátrix, ha a mátrix felso háromszög mátrix.

2.20.

2000. május 20., nappali tagozat
megkapott

1. Írjon egy

függvényt, amely paraméterként hangrendu! A visszatérési érték:
1, 0, -1,

magyar

szóról eldönti, hogy az

milyen

ha magas, ha mély, ha vegyes.

2. Adva van egy olyan egy olyan hogy a

szöveges állomány, amelyben a sorok hossza maximum 80 karakter. Írjon programot, amely minden sort szóközök segítségével 80 hosszúságúra egészít ki úgy, szóközöket a szövegelemek között egyenletesen osztja szét (sorkizárás)! Az új sorokat

helyezze el egy másik szöveges állományban! 3. Adott egy csak

bináris operátorokat tartalmazó szabályos kifejezés fájának postorder bejárásáAz operátorokat és az operandusokat egy szóköz választja el. A sorozatot billentyuzetrol kapjuk. Írjon programot, amely képernyore írja az adott kifejezés preorder
val kapott sorozat. alakját!

4. Írjon egy olyan szám értékét 5.

eljárást, amely egy paraméterként megkapott maximum négyjegyu pozitív egész betuvel a képernyore írja! (Például 615 esetén hatszáztizenötöt.) Adva van egy teljesen zárójelezett szabályos kifejezés. Írjon egy olyan függvényt, amely meghatározza a kifejezés fájának magasságát!

6. Írjon egy olyan

függvényt, amely egy sztringrol eldönti, hogy az egy szabályos C-beli felsorolásos

típusú deníciót tartalmaz-e!

2.21.
1. Írjon

2000. augusztus 21., esti tagozat

programot, amely egy C forrásprogram elso utasításaként megadott nevesített konstans logikai függvényt,
amely egy paraméterként megkapott

deníciót gyelembe véve a forrásszövegben a nevet mindenütt helyettesíti a konstanssal! 2. Írjon egy

magyar szóról eldönti,

hogy

magánhangzóra vagy mássalhangzóra végzodik-e! 3. Írjon egy

programot, amely egy szöveges állomány soraiból eltávolítja a fölösleges (egymás mellett

álló) szóközöket! 4. Adott egy csak

bináris operátorokat tartalmazó szabályos kifejezés fájának postorder bejárásáAz operátorokat és az operandusokat egy szóköz választja el. A sorozatot billentyuzetrol kapjuk. Írjon programot, amely képernyore írja az adott kifejezés preorder
val kapott sorozat. alakját!

5. A felvételi után adott a felvételizok eredményeit tartalmazó

egyirányban láncolt lista,

amely

elemei a nevet, értesítési címet és az elért pontszámot tartalmazzák. Az adatelemek rendezettek

pontszám szerint csökkenoleg. Adott a biztos felvétel ponthatára és a fellebbezési lehetoség alsó ponthatára. Írjon eljárást, amely megadja a fellebbezésre jogosultak adatait, és azt névsor szerint
rendezve elhelyezi egy másik egyirányban láncolt listában! 6. Írjon egy ilyen is lehet) az

függvényt, amely egészeket tartalmazó kétdimenziós tömb azon oszlopainak (több indexét adja meg, amelyekben a pozitív elemek száma nagyobb a negatívakénál!

96

2.

Feladatsorok

2.22.

2000. december 1., nappali tagozat

1. Adva van egy olyan

magyar szavakat tartalmaznak (legegyetlen szóköz áll. Írjon programot, amely képernyore írja azokat a sorokat (több ilyen is lehet), amelyekben a legkevesebb szó van!
amelynek sorai alább egyet és legfeljebb nyolcat), minden szó után értékeket tartalmazó egydimenziós tömb

szöveges állomány,

2. Írjon egy olyan

logikai függvényt, amely igaz értéket ad, ha a paraméterként megadott, valós utolsó elemének értéke megegyezik az elemek átlagának értékével, egyébként pedig hamis értékkel tér vissza. programot, amely egy szöveges állomány azon sorait, amelyekben a legtöbb azonos kafüggvényt, amely egy paraméterként megkapott, egészeket tartalmazó kétdimendarabszámát adja meg, ahol az elemek értéke megegyezik az adott elem
amely egy elso paraméterként megkapott,

3. Írjon

rakter van, egy másik szöveges állományba írja át! 4. Írjon egy olyan

ziós tömb azon elemeinek

indexeinek szorzatával (az indexek típusa egész)! 5. Írjon

eljárást,

tömb minden elemében a második paraméterként megkapott átírja a harmadik paraméterként megkapott

karakterre!

sztringeket tartalmazó egydimenziós karakterrel megegyezo karaktereket

2.23.

2001. január 3., levelezo tagozat

1. Adva van egy szöveges állomány, amelynek minden sora tartalmaz. A sorokban mindig van legalább

vesszovel elválasztott angol szavakat programot, amely egy másik szöveges állományba másolja át azokat a sorokat, amelyeknek utolsó szava magánhangzóval kezdodik! két szó.
Írjon

2. Írjon egy olyan

függvényt, amely a paraméterként megkapott, egészeket tartalmazó kétdimenziós tömb azon oszlopának az indexét adja meg, amely oszlopban a legtöbb 0 elem van! Feltételezzük, hogy csak egyetlen ilyen oszlop létezik. eljárást, amely egy paraméterként megkapott sztringet megfordít!
áll. Írjon

3. Írjon olyan

4. Adva van egy olyan szöveges állomány, amely egy olyan Pascal (C) programot tartalmaz, amelyik csak

foprogramból

függvényt,

amely megadja, hogy a programban hány

változót

deklaráltak! 5. Írjon egy olyan elhelyezi azt egy

programot,

amely billentyuzetrol

sztringet nem adunk meg, majd ezekbol a sztringekbol

új szöveges állományban!

sztringeket olvas mindaddig, amíg egy üres hármasával összeállít egy-egy sort, és

2.24.
1. Írjon

2001. április 28., nappali tagozat

programot, amely egy létezo szöveges állományból, amelynek soraiban egyetlen szóközzel elválasztott angol szavak vannak, egy másik, még nem létezo szöveges állományba írja át a magánhangzóra végzodo szavakat! A sorok száma ne változzon! függvényt, amely egy paraméterként megkapott, egészeket tartalmazó egydimenziós tömbben megszámolja azon elemek számát, amelyek egy szintén paraméterként megadott értéknél nagyobbak! eljárást, amely a billentyuzetrol beolvas egy magyar mondatot, és a benne szereplo szavak kezdobetujét nagybetusre írja át, majd a képernyore írja a mondatot! eljárást, amely egy paraméterként megkapott sztringben megkeresi az összes sorszámot (pl. 1., 2., 5.), és azokat lecseréli a betuzött alakjukra (elso, második, ötödik)!
ziós tömb elemeit rendezi nagyság szerint

2. Írjon egy

3. Írjon egy

4. Írjon egy

5. Írjon egy

eljárást, amely egy paraméterként megkapott, angol szavakat tartalmazó egydimencsökkeno sorrendbe a végük szerint!

2.25.

2001. május 14., nappali tagozat

97

2.25.

2001. május 14., nappali tagozat

1. Az Elektronikus Tanulmányi Osztály két szöveges állományt használ a nyilvántartásban. Az egyik

állomány soronként tartalmazza a tantárgykódot 5 karakteren és a tantárgy megnevezését maximum 35 karakteren. Az állomány a tantárgykódokat növekvo sorrendben tartalmazza. A másik állomány soronként tartalmazza a hallgató nevét pontosan 25 karakteren, a szakot és évfolyamot 4 karakteren és a hallgató által az adott félévben felvett maximum 7 tantárgy kódját és jegyét. Írjon programot, amely egy szöveges állomány soraiba írja azon tantárgyak nevét, amelyeket az adott félévben senki sem vett fel! Tudjuk, hogy 77 tantárgy van.

2. Írjon egy

eljárást, amely egy paraméterként megkapott sztringben megkeresi az összes sorszámot (pl. 351.), és azokat lecseréli a betuzött alakjukra (pl. háromszázötvenegyedik)! A sorszámok 350 és 399 közé esnek. logikai függvényt, amely egy paraméterként megadott, egészeket tartalmazó kétdimenziós tömb esetén igaz értéket ad, ha van a tömbben legalább két olyan oszlop, amelynek átlaga megegyezik! 3
formális paramétere van. Írjon

3. Írjon egy

4. Adva van egy szöveges állomány, amely egy olyan szabályos paraméterekre a függvény mely egy utasítás áll. 5. Írjon egy

C függvényt tartalmaz, amelynek programot, amely képernyore írja, hogy az egyes formális soraiban történik hivatkozás! Feltehetjük, hogy minden sorban
visszaadja azt a

függvényt, amely paraméterként egy kifejezés fáját kapja meg, és sztringet, amely a kifejezés teljesen zárójelezett inx alakját tartalmazza!
2001. augusztus 21., esti tagozat

2.26.

1. Írjon egy

tömb esetén megadja azon

függvényt, amely egy paraméterként megkapott, egészeket tartalmazó kétdimenziós oszlopok számát, amelyekben egy szintén paraméterként megadott értéknél csak nagyobb értékek szerepelnek! (1.36.) programot,
amely egy szöveges állomány sorait úgy írja át egy másik szöveges ál-

2. Írjon egy

lományba, hogy megkeresi a

leghosszabb sort, és az összes többi sort az elején kiegészíti annyi szóközzel, hogy minden sor hossza azonos legyen! egy (1) formális paramétere van. a függvény rekurzív!
Írjon egy

3. Adva van egy szöveges állomány, amely egy olyan szabályos

C függvényt tartalmaz, amelynek logikai függvényt, amely akkor ad igaz értéket, ha
(1.69.)

4. Írjon egy

eljárást, amely egy paraméterként megkapott, karaktereket tartalmazó bináris fában
(1.48.)

a kisbetuket nagybeture cseréli! 5. Adva van két szöveges állomány. Az egyikben a

tantárgykódok (5 karakteren) és a tantárgyak nevei (maximum 35 karakteren) vannak. A másikban a hallgatók neve (pontosan 25 karakteren) és az általa felvett maximum 12 tantárgy kódja szerepel. Írjon programot, amely egy szöveges állományba írja azon tantárgy(ak) nevét, amelyet a legtöbben vettek fel!
2001. október 26., levelezo tagozat

2.27.
1. Írjon

programot,

amely egy

sorrendben írja át egy 2. Írjon

magyar szavakat másik állományba!

tartalmazó

szöveges állomány

szavait ábécé (1.66.)

azon oszlopának 3. Adott egy Írjon

függvényt, amely egy paraméterként kapott, egészeket tartalmazó kétdimenziós tömb indexét adja vissza, amelyben a legkevesebb pozitív elem van! (1.35.)

szó van!

szöveges állomány, amelyben magyar szavak vannak, minden szó után egy szóköz áll. eljárást, amely képernyore írja azon sorokat (több ilyen is lehet), amelyekben a legkevesebb
(1.60.)

98

2.

Feladatsorok

4. Írjon

karaktereket tartalmazó egydimenziós kezdo- és végindexét, amelyben azonos karakterek vannak! Több ilyen esetén válassza ki azt, amelyben a karakterek száma maximális! (1.11.)
amely egy paraméterként megkapott, tömbben meghatározza azon rész

eljárást,

5. Írjon

programot, amely angol szavakat kér be billentyuzetrol *** végjelig, és kiírja egy szöveges állományba közülük azokat, amelyek tartalmazzák a b, c, x, y karaktereket! (1.57.)
2001. november 30., levelezo tagozat

2.28.

1. Írjon egy

függvényt, amely egy paraméterként megkapott sztringben szóközzel felülírja a nem betu karaktereket és visszaadja az új sztringet! (1.24.) eljárást,
amely paraméterként megkap

2. Írjon

majd az elso állomány azon sorait, melyeknek a

két szöveges állomány nevet és egy sztringet, vége azonos a sztringgel, átírja a másik állományba!
(1.63.)

Az elso állomány létezik, a másodikat most kell létrehozni. 3. Írjon egy

programot, amely a billentyuzetrol beolvas egy pozitív egész számot (értéke maximum 110 lehet), majd a billentyuzetrol beolvas ennyi darab valós számot és közülük képernyore írja azokat, amelyek értékének a beolvasott számok átlagától való eltérése az átlag felénél nagyobb!
(1.9.)

4. Írjon

ratikus mátrixot 5. Írjon

eljárást, amely paraméterként megkapott, tetszoleges méretu, egészeket tartalmazó kvadtükröz a mellékátlójára! (1.32.) eljárást, amely egy paraméterként kapott tetszoleges méretu, egészeket tartalmazó egydikezdo- és végindexét két output
(1.13.)

menziós tömbben meghatározza a legnagyobb összegu résztömb paraméterében!

2.29.
1. Írjon

2001. december 17., nappali tagozat

minden elemét az

sztringeket tartalmazó egydimenziós tömb elején és a végén egyenletesen elosztott szóközökkel kiegészíti olyan hosszúságúra, mint a leghosszabb elem hossza! Az eredeti tömb nem módosulhat! (1.21.)
amely egy paraméterként kapott,

eljárást,

2. Írjon

függvényt,

amely egy

lományt dolgoz fel úgy, hogy megszámolja a benne használt 3. Írjon

szintaktikusan helyes C függvényt tartalmazó szöveges különbözo tömböket!

ál-

programot, amely billentyuzetrol beolvas egy szabályos, teljesen zárójelezett C kifejezést, amely operandusként csak konstansokat és változókat tartalmaz, és a képernyore írja azt a részkifejezést, amelyet eloször kell kiértékelni! (1.52.) eljárást,
amely paraméterként megkap egy mátrix minden oszlopa és a bitvektor között a továbbiakban nincs szükség.

4. Írjon

bitmátrixot és egy bitvektort, majd a bitkizáró vagy muveletet végez! Az eredeti bitmátrixra
(1.33.)

5. Írjon

logikai függvényt, amely egy paraméterként megkapott, egészeket tartalmazó, szigorú értelemben vett bináris fáról eldönti, hogy tökéletesen kiegyensúlyozott-e! (1.47.)
2001. december 18., levelezo tagozat

2.30.

1. Írjon egy

eljárást,

amely egy paraméterként megkapott,

mazó kvadratikus mátrix

tetszoleges méretu, egészeket tartalfoátlójában elhelyezi soronként a foátló fölötti elemek összegét!
(1.45.)

2. Írjon egy

függvényt, amelynek elso paramétere egy sztring, második paramétere egy pozitív egész szám, és a függvény adja vissza azt a sztringet, amely az eredetibol úgy keletkezik, hogy azt az elején és a végén kiegészítjük szóközökkel (egyenletesen elosztva azokat) úgy, hogy az új
sztring hossza a második paraméter értéke legyen! (1.29.)

2.31.

2002. január 2., levelezo tagozat

99

3. Írjon

programot,

amely egy szöveges állományban elhelyezett,

szintaktikailag helyes

Pascal (1.67.)

(C) forrásprogram szövegét úgy másolja át egy másik szöveges állományba, hogy közben kihagyja belole a

megjegyzéseket!

4. Írjon egy

mazó, egydimenziós tömböt a sztringek

eljárást, amely a paraméterként megkapott, tetszoleges méretu, sztringeket tartalhosszának csökkeno sorrendjébe teszi! Azonos hosszak
(1.15.) amely a billentyuzetrol pozitív egész számokat olvas mindaddig, míg 0-t nem

esetén a sztringek sorrendje az eredeti sorrend legyen! 5. Írjon

programot,

adunk.

A program válassza ki a számok közül a

nek azonos értékuek is, de legfeljebb 3-3), írja azok értékét a

hányadikként olvastuk be oket!
2.31.
1. Írjon

legkisebbeket és a legnagyobbakat (lehetképernyore, és adja meg, hogy
(1.4.)

2002. január 2., levelezo tagozat

mátrixról eldönti, hogy 2. Írjon

logikai függvényt, amely egy paraméterként szimmetrikus-e!

megadott, sztringeket tartalmazó négyzetes (1.31.)

méterként kapott 3. Írjon

eljárást, amely egy paraméterként megkapott bitmátrix minden sora és egy szintén parabitvektor között elvégzi a vagy muveletet!

ben meghatározza és 4. Írjon

eljárást, amely egy paraméterként megkapott, angol szavakat tartalmazó egydimenziós tömbképernyore írja a szavak gyakoriságát! (1.17.)

programot, amely billentyuzetrol egyenként, elsore nem meghatározható darabszámú pozitív egész értéket olvas be mindaddig, amíg 0 értéket nem kap! A program minden érték beolvasása után határozza meg az addig beolvasott értékek átlagát! Ha az új érték az eddigi átlag kétszeresénél nagyobb, akkor írja képernyore az eddig beolvasott értékek darabszámát és az új értéket, majd a hátralévo értékeket másolja át egy szöveges állományba, különben viszont a beolvasás végén írja képernyore a darabszámot és az átlagot! eljárást, amely egy paraméterként megadott, sztringeket tartalmazó egydimenziós tömböt elemeinek hossza szerint csökkeno sorrendbe rendez! (1.14.)
2002. január 2., nappali tagozat

5. Írjon

2.32.

1. Adva van egy olyan

szöveges állomány, amely sorai egyetlen szóközzel elválasztott angol programot, amely meghatározza és képernyore írja a szövegben eloforduló szavak gyakoriságát! (1.62.)
szavakat tartalmaznak. Írjon

2. Írjon csak

programot,

amely

billentyuzetrol

mely csak a

betu szerepel! eljárást,

+, -, , /

operátorokat és olyan

Tudjuk,

teljesen zárójelezett kifejezést, változó operandusokat tartalmaz, amelyek nevében hogy a kifejezésben zárójelhiba van. A program írja képernyore a
beolvas egy olyan (1.55.)

kifejezést, és jelölje meg a hiba helyét! 3. Írjon amely egy paraméterként megkapott,

egy szintén paraméterként megadott

értéket!

egészeket

tartalmazó

keresofából

kitöröl (1.50.)

Az eljárás írjon megfelelo hibaüzenetet a képernyore,

ha a törlés valamilyen okból nem hajtható végre! 4. Írjon

mátrixról eldönti, hogy 5. Írjon

logikai függvényt, amely egy paraméterként megkapott, sztringeket tartalmazó négyzetes szimmetrikus-e! (1.31.)

tartalmazó

függvényt, amely egy paraméterként megkapott, szintaktikusan helyes C függvényt szöveges állományt dolgoz fel úgy, hogy meghatározza a függvény által tartalmazott blokkok legnagyobb skatulyázási mélységét!

100

2.

Feladatsorok

2.33.
1. Írjon

2002. április 20., levelezo tagozat

programot, amely billentyuzetrol pozitív valós számokat olvas be mindaddig, amíg nullát 100 szám lehet). A program írja egy most létrehozott szöveges állományba azokat a beolvasott számokat, amelyeknek a számok átlagától való eltérése nagyobb, mint az átlag fele! (1.10.)
nem adunk (tudjuk, hogy maximum

2. Írjon

logikai függvényt, lindróma-e!

amely egy paraméterként megkapott

sztringrol

eldönti, hogy az

pa-

(1.22.)

3. Írjon

függvényt, amely egy paraméterként megkapott sztringben az egymás mellett álló szóközök közül csak egyet hagy meg, és visszatér az új sztringgel! (1.28.)
oszlopait úgy rendezi át, hogy az elso sor elemei nagyság szerint Feltehetjük, hogy az elso sor elemei különbözoek.

4. Írjon

eljárást, amely egy paraméterként megkapott, egészeket tartalmazó kétdimenziós tömb csökkeno sorrendben legyenek!
(1.38.)

5. Írjon

eljárást, amely egy paraméterként megkapott, sztringeket tartalmazó egydimenziós tömb azonos hosszúságúra (a maximális hosszúságú elem hosszúságára) hozza úgy, hogy a sztringek elejére megfelelo számú szóközt szúr be! (1.19.)
minden elemét

2.34.
1. Írjon

2002. május 13., nappali tagozat

függvényt,

amely egy egydimenziós, sztringeket tartalmazó tömböt kap

és annak minden elemét

paraméterként, csonkítja a legrövidebb elem hosszára, és visszaadja az új tömböt!
(1.20.)

2. Adva van egy

táblázat, amelynek kulcsa egész, érték része sztring típusú és maximum 500 elem fér függvényt, amely paraméterként megkapja a táblázatot, az aktuális elemszámot és egy egészet. A függvény bináris kereséssel keresse meg az adott egész által meghatározott kulcsú elemet és adja vissza annak érték részét! Ha nincs ilyen elem, a függvény az üres sztringgel térjen vissza! (1.8.)
el benne. Írjon azon

3. Írjon

eljárást, amely egy paraméterként megadott kétdimenziós, egészeket tartalmazó tömb oszlopát határozza meg, amelyben benne van az egész tömb legnagyobb eleme (csak egy
(1.44.)

ilyen van)! 4. Adva van egy

szövegállomány, amely egy olyan C foprogramot tartalmaz, amelyben van felsorolásos típus deklarálva (több is lehet). Írjon programot, amely a foprogram végrehajtható utasításaiban minden felsorolásos típusú literált felülír annak értékével, és az új foprogramot elhelyezi egy másik szöveges állományban!
írja

5. Írjon

programot, amely billentyuzetrol megkap egy szabályos prex alakú kifejezést. A program képernyore az elsonek kiértékelento részkifejezést inx alakban! A kifejezés csak a +, -, ,
(1.53.)

/ kétoperandusú operátorokat és operandusként olyan változókat tartalmaz, amelyek neve egyetlen
karakterbol áll.

2.35.

2002. május 23., nappali tagozat

1. Adva van egy

szöveges állomány, amely egymástól egy szóközzel elválasztott különbözo angol programot, amely képernyore írja azokat a szavakat (ezekbol akármenynyi lehet), amelyekben a legtöbb magánhangzó van. (1.59.)
szavakat tartalmaz. Írjon olyan

2. Írjon logikai

függvényt, amely egy paraméterként kapott sztringrol részsztring, amely pontosan 4 azonos karakterbol áll!

eldönti, hogy van-e benne (1.27.)

3. Írjon

eljárást, amely egy paraméterként megkapott, egészeket tartalmazó, tetszoleges méretu kétdimenziós tömb minden olyan elemének a 0 értéket adja, amelynek a tömb elemeinek átlagától való eltérése az átlag felénél nagyobb! Az eredeti tömböt változatlanul kell hagyni.
(1.46.)

2.36.

2002. augusztus 21., esti tagozat

101

4. Adva van egy

tetszoleges egészeket tartalmazó bináris fa. Írjon függvényt, amely paramétergyökérmutatóját, a fában elhelyezett értékekbol felépít egy keresofát, és visszaadja annak gyökérmutatóját! Az új fa elemeinek szerkezete: kulcs (a különbözo egész értékek), gyakoriság (az eredeti fában az adott kulcs hányszor fordult elo). (1.49.)
ként megkapja a bináris fa az összes

5. Adva van egy állományba!

szöveges állomány, amely egy C foprogramot tartalmaz. Írjon programot, amely azonosítót nagybetusre írja át, és az új foprogramot elhelyezi egy másik szöveges
(1.68.)

2.36.
1. Írjon

2002. augusztus 21., esti tagozat

ha a szóban 2. Írjon

logikai függvényt, amely egy paraméterként megkapott angol szó esetén igazzal tér vissza, nincs egymás mellett két mássalhangzó! (1.25.)

programot, amely egy létezo szöveges állomány minden sorát 80 karakter hosszúságúra egészíti ki szóközökkel, ha rövidebbek a sorok 80 karakternél, és csonkítja a végén a sorokat, ha azok hosszabbak 80 karakternél! Az új sorokat egy új szöveges állományba kell írni. (1.64.)
ben meghatározza azon oszlopok

3. Írjon

eljárást, amely egy paraméterként megkapott, egészeket tartalmazó kétdimenziós tömbindexét (akárhány ilyen lehet), amelyekben a negatív elemek száma legalább kétszerese a nulla értéku elemek számának! A tömb mérete tetszoleges.(1.43.)
olyan sztringet kap, amely egy szabályos, meghatározza a kifejezés fájának

4. Írjon

függvényt, amely paraméterként egy zárójelezett inx kifejezést tartalmaz, és
+, -, , /

teljesen magasságát! A
(1.51.)

kifejezésben csak a fordulnak elo. 5. Adva van egy

bináris operátorok és maximum 3 jegyu egész szám operandusok

szöveges állomány, amely soraiban egymástól egyetlen szóközzel elválasztott magyar szavak állnak. Írjon eljárást, amely meghatározza az állományban eloforduló szavak gyakoriságát! Feltételezhetjük, hogy maximum 200 különbözo szó fordul elo. (1.61.)
2002. november 29., levelezo tagozat

2.37.

1. Írjon egy száma, és 2. Írjon

logikai függvényt,

amely egy paraméterként megkapott

tér vissza, ha a sztringben a betuk (angol ábécé!) száma

hamissal tér vissza egyébként!

nagyobb,

sztring

esetén

igaz

értékkel (1.23.)

mint a nem-betu karakterek

eljárást, amely paraméterként megkap egy tetszoleges méretu, egészeket tartalmazó egydimenziós tömböt. Az eljárás határozza meg a tömbben lévo pozitív, negatív és nulla elemek darabszámát! Az eljárás nem írhat a képernyore! (1.6.)

3. Írjon

programot, amely billentyuzetrol egyenként beolvas egész értékeket addig, amíg a -1 értéket képernyore a beolvasott számok azon szekvenciáját, amely a leghoszszabb szigorúan monoton csökkeno sorozatot alkotja! (1.12.)
nem kapja. A program írja

4. Adva van egy

szöveges állomány, amely egy szintaktikailag helyes, valós visszatérési értékkel függvényt tartalmaz. Írjon programot, amely eldönti, hogy a függvény rekurzív-e! Az eredmény jelenjen meg a képernyon! (1.69.)
rendelkezo C (Pascal)

5. Írjon

tetszoleges méretu, valós értékeket tartalmazó kétdimenziós tömböt oszlop indexét, amelyben van olyan elem, amelynek az értéke megegyezik az oszlop elemeinek átlagával! Ha több ilyen oszlop is van, akkor a legnagyobb indexértéket adja vissza! (1.34.)
amely kap paraméterként. A függvény határozza meg azon

függvényt,

2.38.
1. Írjon

2003. január 6., esti tagozat

eljárást,

amely egy paraméterként megkapott, tetszoleges méretu, valósakat tartalmazó

kétdimenziós tömb legyenek!

sorait

úgy rendezi át, hogy az

utolsó oszlop

értékei

csökkeno

sorrendben (1.39.)

102

2.

Feladatsorok

2. Írjon

logikai függvényt,

ha a sztringben van olyan 3. Adott egy csak a

4 elemu részsztring, amely legalább háromszor ismétlodik.

amely egy paraméterként megkapott sztringnél igaz értéket ad vissza, (1.26.)

+, -, /, * bináris operátorokat tartalmazó szabályos kifejezés fájának postorder bejárásával kapott sorozat. Az operátorokat és az operandusokat egy szóköz választja el egymástól. A sorozatot billentyuzetrol kapjuk. Írjon programot, amely képernyore írja a kifejezés prex alakját! (1.54.)

4. Írjon

eljárást, amely egy paraméterként megkapott, tetszoleges méretu, egészeket tartalmazó kétoszlopátlagai közül meghatározza a legnagyobbat (több ilyen is lehet)! Az eljárás nem írhat képernyore és állományba! (1.40.)
dimenziós tömb rendelkezo C

5. Adva van egy szöveges állomány, amely egy szintaktikailag helyes,

rekurzív-e!
2.39.
1. Írjon

függvényt

tartalmaz.

Az eredmény a

képernyon jelenjen meg!

Írjon

programot,

egész

visszatérési értékkel (1.69.)

amely meghatározza, hogy a függvény

2003. január 6., levelezo tagozat

eljárást,

amely egy paraméterként megkapott, tetszoleges méretu, valósakat tartalmazó

kétdimenziós tömb legyenek! 2. Írjon

sorait

úgy rendezi át, hogy az

utolsó oszlop

értékei

csökkeno

sorrendben (1.39.)

ha a sztring 3. Írjon

logikai függvényt, amely egy paraméterként megkapott tükörszimmetrikus (pl. görög, kosarasok)!

sztringnél igaz értéket ad vissza, (1.22.)

programot, amely billentyuzetrol látható karaktereket olvas mindaddig, amíg a @ karakA program határozza meg és írja képernyore a beolvasott különbözo karaktereket és azok gyakoriságát! (1.1.)
tert meg nem kapja.

4. Írjon

eljárást, amely egy paraméterként megkapott, tetszoleges méretu, egészeket tartalmazó kétoszlopátlagai közül meghatározza a legnagyobbat (több ilyen is lehet)! Az eljárás nem írhat képernyore és állományba! (1.40.)
dimenziós tömb

5. Adva van egy szöveges állomány, amely egy szintaktikailag helyes, delkezo C (Pascal)

egész visszatérési értékkel renfüggvényt tartalmaz. Írjon programot, amely meghatározza, hogy a függvény rekurzív-e! Az eredmény a képernyon jelenjen meg! (1.69.)
2003. május 17., levelezo tagozat
Írjon

2.40.

1. Adva van egy

szöveges állomány, benne egy szintaktikailag szabályos C (Pascal) függvény. függvényt, amely megadja a függvény végrehajtható utasításainak darabszámát.

2. Írjon

eljárást, amely paraméterként megkap egy karaktereket tartalmazó, tetszoleges méretu egydimenziós tömböt, és a tömb nem betu karaktereit kicseréli szóközre. (1.5.)

3. Írjon

függvényt, amely paraméterként megkap egy tetszoleges méretu, egészeket tartalmazó kvadratikus mátrixot, és visszaadja a foátló maximális és minimális elemét. A képernyore nem írunk! (1.41.) eljárást, amely paraméterként megkap egy azonos hosszúságú sztringeket tartalmazó, tetszoleges méretu egydimenziós tömböt, továbbá egy karaktert és egy pozitív egész számot, és a képernyore írja azokat a tömbelemeket, amelyekben a karakter pontosan az adott számszor fordul elo. A szélsoséges eseteket vizsgálni kell! (1.16.) programot, amely a billentyuzetrol angol szavakat olvas mindaddig, amíg üres sztringet nem kap. A program írja egy szöveges állományba azokat a szavakat, amelyekben egymás mellett van legalább három mássalhangzó. (1.58.)

4. Írjon

5. Írjon

2.41.

2003. május 23., nappali tagozat

103

2.41.

2003. május 23., nappali tagozat

1. Adva van egy

eljárást,

amely egy

szöveges állomány és benne egy szintaktikailag szabályos C függvény. Írjon új szöveges állományba átmásolja a formázott forrásszöveget. A formázás:

minden utasítás külön sorban legyen; a blokk kezdo és záró kapcsos zárójele külön sorban legyen; a beágyazott programegységek a tartalmazó programegység utasításaitól 3 karakternyi hellyel beljebb kezdodjenek; a szöveg balra zárt legyen. 2. Írjon

amely csak a

billentyuzetrol megkap egy olyan teljesen zárójelezett kifejezést, egy- és kétoperandusú operátorokat, operandusként pedig olyan C-beli változókat tartalmaz, melyek neve maximum két karakterbol áll. Ellenorizze le, hogy a kifejezés szabályos-e. A képernyore írjon értelemszeru hibaüzeneteket. (1.56.)
amely

programot,
-

és a

+

3. Írjon

függvényt, amely paraméterként megkap egy olyan tetszoleges méretu egydimenziós angol szavakat tartalmaz. A függvény visszatérési értéke adja meg a szavak gyakoriságát. (1.18.)
tömböt, amely

4. Írjon

eljárást, amely paraméterként megkap egy tetszoleges méretu, valósakat tartalmazó kétdimenziós tömböt, és eloállít egy olyan egydimenziós tömböt, amely a sorok átlagát tartalmazza. Az eljárás a képernyore nem írhat! (1.37.) programot, amely nullától különbözo egész értékeket olvas be a billentyuzetrol a 0 végképernyore azt a három értéket, amelynek átlaga maximális. (1.3.)
jelig. A program határozza meg és írja

5. Írjon

2.42.

2003. május 28., nappali tagozat

1. Adva van egy

eljárást,

amely egy

szöveges állomány és benne egy szintaktikailag szabályos C függvény. Írjon új szöveges állományba átmásolja a formázott forrásszöveget. A formázás:

minden utasítás külön sorban legyen; a blokk kezdo és záró kapcsos zárójele külön sorban legyen; a beágyazott programegységek a tartalmazó programegység utasításaitól 3 karakternyi hellyel beljebb kezdodjenek; a szöveg balra zárt legyen. 2. Írjon

függvényt,
-

amely és a

amely csak a

literálokat tartalmaz.

+

paraméterként megkap egy olyan teljesen zárójelezett kifejezést, egy- és kétoperandusú operátorokat, operandusként pedig C-beli A kifejezés szintaktikailag helyes. A függvény építse fel a kifejezés fáját.

3. Írjon

függvényt, amely paraméterként megkap egy olyan tetszoleges méretu egydimenziós angol szavakat tartalmaz. A függvény visszatérési értéke adja meg azon szavakat, melyekben legalább 3 mássalhangzó szerepel egymás mellett.
tömböt, amely

4. Írjon

eljárást, amely paraméterként megkap egy tetszoleges méretu, valósakat tartalmazó kétdimenziós tömböt és egy pozitív valós értéket, majd meghatározza azon sorok indexét (ezekbol akármennyi lehet), amelyekben a foátlóbeli elemek sorátlagtól való eltérése a második paraméter értékétol kisebb. Az eljárás a képernyore nem írhat! programot, amely nullától különbözo egész értékeket olvas be a billentyuzetrol a 0 végképernyore azt a leghosszabb számsorozatot (amennyiben több ilyen is van, akkor mindet), amelyben a számok elojele azonos.
jelig. A program határozza meg és írja

5. Írjon

2.43.

2003. augusztus 25., esti tagozat

1. Adva van egy szöveges állomány, amely egy tékkel rendelkezo

szintaktikailag helyes, karakteres visszatérési érszintaktikailag helyes foprogramot tartalmaz. Írjon programot, amely megállapítja, hogy a foprogram szabályosan hívta-e meg a függvényt! C függvényt
és egy

2. Írjon

eljárást, amely paraméterként megkap egy sztringeket tartalmazó, tetszoleges méretu egydimenziós tömböt, és ebbol a hívás helyén felhasználható új egydimenziós tömböt állít elo, amely azokat a sztringeket tartalmazza, amelyekben a betuk (angol ábécét tételezve fel) száma megegyezik a nem betu karakterek darabszámával.

104

2.

Feladatsorok

3. Írjon

függvényt, amely egy paraméterként megkapott, tetszoleges méretu, valósakat tartalkétdimenziós tömb minimális és maximális átlagú oszlopainak (ezekbol csak egy-egy lehet) indexét határozza meg visszatérési értékként.
mazó A program határozza meg és írja

4. Írjon

programot, amely nullától különbözo egész értékeket olvas be a billentyuzetrol a 0 végjelig. képernyore a beolvasott különbözo egész értékeket és azok gyakoriságát.

5. Írjon

függvényt, amely meghatározza a paramétereként megkapott, tetszoleges méretu (de legegészeket tartalmazó egydimenziós tömb harmadik legkisebb elemének az indexét (amennyiben több ilyen elem is van, akkor a legnagyobb indexet kell visszaadni).
alább négyelemu),

2.44.
1. Írjon

2003. december 5., levelezo tagozat

programot, amely egy létezo szöveges állomány maximum 100 karakrterbol álló sorainak 100 hosszúságúra egészíti ki, a sorok elején és végén egyenletesen elosztott módon szóközöket szúrva be ( középre igazítás). Az új sorokat egy most létrehozott szöveges
mindegyikét állományba kell elhelyezni.

2. Írjon

logikai függvényt, amely akkor tér vissza igaz értékkel, ha a paraméterként kapott sztring szabályos C azonosító.

3. Írjon

eljárást, amely paraméterként megkap egy tetszoleges méretu, valósakat tartalmazó kétdimenziós tömböt, és meghatározza azt a vektort, amely az oszlopok átlagát tartalmazza. Az eljárásban nem lehet semmilyen I/O muvelet! függvényt, amely paraméterként megkap egy tetszoleges méretu négyzetes bitmátrixot bitvektort, és visszatér azzal a bitvektorral, amely a mátrix foátlója és a vektor elemei között képzett kizáró vagy eredményeként keletkezik.
és egy megfelelo méretu

4. Írjon

5. Írjon

programot, amely billentyuzetrol egész értékeket olvas be a 0 végjelig. A program írja képernyore azokat az értékeket, amelyek elojele eltér a megelozo érték elojelétol. Például 1 2
3 4 0 esetén nincs ilyen érték, 1

-1

2

-2 -5

0 esetén kiírandó

-1

2

-2.

2.45.
1. Írjon

2004. január 9., levelezo tagozat

programot, amely egy létezo szöveges állomány sorainak mindegyikét 100 hosszúságúra szóközöket szúrva be, ha rövidebb, illetve elhagyva a fölösleges karaktereket, ha hosszabb. Az új sorokat egy most létrehozott szöveges állományba kell elhelyezni.
egészíti ki a sorok végén (1.65.)

2. Írjon

logikai függvényt, amely akkor tér vissza igaz értékkel, ha a paraméterként kapott sztring szabványos C egész literál. (1.30.)

3. Írjon

függvényt, amely paraméterként megkap egy tetszoleges méretu, valósakat tartalmazó kétdimenziós tömböt, és visszatérési értékként meghatározza a sorok átlagának minimumát és az oszlopok átlagának maximumát. (1.42.) eljárást, amely paraméterként megkap egy tetszoleges méretu, sztringeket tartalmazó vektort, és eloállít egy olyan vektort, amelymek elemei rendre a paraméterként kapott vektor elemeinek annyiadik karakterét tartalmazzák, amennyi az adott elem indexe, illetve a @ karaktert, ha nem létezik ilyen elem. Egy sztring karaktereit 0-tól sorszámozzuk. Az eljárásban nem lehet semmilyen I/O muvelet! (1.7.)

4. Írjon

5. Írjon

programot, amely billentyuzetrol egész értékeket olvas be a 0 végjelig. A program írja képernyore azokat az értékeket, amelyek megegyeznek az elozo két érték összegével. (1.2.)



Hasonló témájú dokumentumok

Általános gépatn példatár

- 2007-11-29 18:29:07

Kernighan - Ritchie - A C programozási nyelv

- 2009-02-22 12:38:16

gyakorló feladatok (számrendszerek, C)

- 2009-01-06 14:59:43

Bevezetés a programozásba I. - Dr. Vida Károly

- 2008-09-21 07:40:43

Diszkrét matematika II. példatár

- 2007-11-28 17:27:31

C programozási feladatgyűjtemény - Poppe András – Kocsis Tamás

- 2009-01-06 15:09:07

mintaprogramok C-hez

- 2009-01-06 14:56:36

A mások által feltöltött dokumentumokat értékelheted. Ha úgy ítéled meg, hogy a vizsgára való felkészülés szempontjából hasznos volt egy dokumentum, akkor adj rá sokcsillagos értékelést.
Ha hibákat tartalmaz, vagy egyéb probléma van vele, akkor keveset.
A dokumentumok sorrendje az értékelések alapján adódik. Ami fentebb van a listában, azt hasznosabbnak ítélték társaid. Az új dokumentumok pedig (értékelések hiányában) szintén a lista tetején kezdenek.

Hozzászólások

Ha észrevételed van egy dokumentummal kapcsolatban (például hibát találtál benne), akkor a Hozzászólások részben jelezheted. Az olyan jellegű kérdéseket mint pl.: A 2. feladat 4. sorából milyen átalakítással jutottunk az 5. sorban szereplő képlethez? - szintén ide érdemes írni

Egy tipp az oldalhoz! - Üzenj az összes olyan hallgatónak aki felvett egy bizonyos tantárgyat! Hasznos lehet ha egy tárggyal kapcsolatban olyan kérdéseid merülnek fel mint pl

• Hol lesz a vizsgamegtekintés?
• Meddig kell tudni az anyagot?
• Mely részeket adták le előadáson a könyből?
• stb...

Az üzeneted így ahhoz a célcsoporthoz jut el, akik együtt hallgatják veled a tárgyat. Ehhez kattints az Üzenetekre, ezután válaszd ki a tantárgyat a saját tárgyaid közül, majd kattints az Üzenet írására.

2008_12_17 alkszámtech általános médiaismeretek andorka anglia anyagismeret 2 atombomba biokémia biomérnöki corbu diplomadolgozat ergonómia fizikai+kémia freud funkcionalizmus gazdföci gépgyártás germánok gyep igaz józsef ii. jegyzetek jogszabályok kérdés válasz kereskedelem kiselőadás koncentráció korreláció kosztolányi középkori európa közgazdaságtan fő áramlata közigazgatás különleges épszerk lemezszegélyek lineáris litoszféra matrix megoldások nemzeti kisebbség parazitológia posztmodern regterv reklámelmélet és gyakorlat sejttan standardizálás számítógép architektúrák szervetlen szivattyú természetvédelem természetvédelmi mérnök