INFORMATIKA ÉRETTSÉGI EMELT SZINT PROGRAMOZÁSI FELADATOK MEGOLDÁSA C++

Ódor Péter INFORMATIKA ÉRETTSÉGI EMELT SZINT PROGRAMOZÁSI FELADATOK MEGOLDÁSA

C++ © Ódor Péter, 2015

Programozási feladatok megoldása

TARTALOMJEGYZÉK TÁJÉKOZTATÓ .......................................................................................................................................... 5 ADATSZERKEZETEK .................................................................................................................................. 6 TÖMB (VEKTOR, SOROZAT) ................................................................................................................. 6 MÁTRIX ................................................................................................................................................ 6 STRUKTÚRA ......................................................................................................................................... 8 SZÖVEGES FÁJLOK KEZELÉSE ................................................................................................................. 10 EGYÉB FÁJLKEZELÉSI MEGOLDÁS................................................................................................................ 12 NÉHÁNY KIEMELT ALGORITMUS ........................................................................................................... 13 NÉHÁNY MŰVELET STRINGEKKEL .......................................................................................................... 15 NÉHÁNY HASZNOS ALGORITMUS.......................................................................................................... 16 2005. május emelt LOTTÓ .................................................................................................................... 19 FELADAT SZÖVEGE......................................................................................................................... 20 FONTOSABB VÁLTOZÓK ................................................................................................................ 21 PROGRAMKÓD .............................................................................................................................. 22 2005. október emelt VIGENÉRE............................................................................................................ 26 FELADAT SZÖVEGE......................................................................................................................... 27 FONTOSABB VÁLTOZÓK ................................................................................................................ 28 PROGRAMKÓD .............................................................................................................................. 29 2006. február emelt TELEFONSZÁMLA................................................................................................. 32 FELADAT SZÖVEGE......................................................................................................................... 33 FONTOSABB VÁLTOZÓK ................................................................................................................ 34 PROGRAMKÓD .............................................................................................................................. 35 2006. május emelt FEHÉRJE .................................................................................................................. 39 FELADAT SZÖVEGE......................................................................................................................... 40 FONTOSABB VÁLTOZÓK ................................................................................................................ 42 PROGRAMKÓD .............................................................................................................................. 43 2006. október emelt ZENEI ADÓK ........................................................................................................ 48 FELADAT SZÖVEGE......................................................................................................................... 49 FONTOSABB VÁLTOZÓK ................................................................................................................ 50 PROGRAMKÓD .............................................................................................................................. 51 2007. május emelt SMS SZAVAK .......................................................................................................... 55 FELADAT SZÖVEGE......................................................................................................................... 56 FONTOSABB VÁLTOZÓK ................................................................................................................ 57 PROGRAMKÓD .............................................................................................................................. 58

2

Programozási feladatok megoldása 2007. október emelt FOCI..................................................................................................................... 63 FELADAT SZÖVEGE......................................................................................................................... 64 FONTOSABB VÁLTOZÓK ................................................................................................................ 65 PROGRAMKÓD .............................................................................................................................. 66 2008. május emelt SMS ........................................................................................................................ 70 FELADAT SZÖVEGE......................................................................................................................... 71 FONTOSABB VÁLTOZÓK ................................................................................................................ 72 PROGRAMKÓD .............................................................................................................................. 73 2008. október emelt ROBOT ................................................................................................................ 79 FELADAT SZÖVEGE......................................................................................................................... 80 FONTOSABB VÁLTOZÓK ................................................................................................................ 81 PROGRAMKÓD .............................................................................................................................. 82 2009. május emelt LIFT ......................................................................................................................... 87 FELADAT SZÖVEGE......................................................................................................................... 88 FONTOSABB VÁLTOZÓK ................................................................................................................ 90 PROGRAMKÓD .............................................................................................................................. 91 2009. október emelt ÚTÉPÍTÉS ............................................................................................................. 95 FELADAT SZÖVEGE......................................................................................................................... 96 FONTOSABB VÁLTOZÓK ................................................................................................................ 97 PROGRAMKÓD .............................................................................................................................. 98 2010. május emelt HELYJEGY ............................................................................................................. 103 FELADAT SZÖVEGE....................................................................................................................... 104 FONTOSABB VÁLTOZÓK .............................................................................................................. 105 PROGRAMKÓD ............................................................................................................................ 106 2010. október emelt ANAGRAMMA .................................................................................................. 112 FELADAT SZÖVEGE....................................................................................................................... 113 FONTOSABB VÁLTOZÓK .............................................................................................................. 114 PROGRAMKÓD ............................................................................................................................ 115 2011. május emelt SZÓJÁTÉK ............................................................................................................. 119 FELADAT SZÖVEGE....................................................................................................................... 120 FONTOSABB VÁLTOZÓK .............................................................................................................. 122 PROGRAMKÓD ............................................................................................................................ 123 2011. október emelt PITYPANG ......................................................................................................... 127 FELADAT SZÖVEGE....................................................................................................................... 128 FONTOSABB VÁLTOZÓK .............................................................................................................. 130 PROGRAMKÓD ............................................................................................................................ 131

3

Programozási feladatok megoldása 2012. május emelt FUTÁR .................................................................................................................. 137 FELADAT SZÖVEGE....................................................................................................................... 138 FONTOSABB VÁLTOZÓK .............................................................................................................. 139 PROGRAMKÓD ............................................................................................................................ 140 2012. október emelt SZÍN-KÉP ........................................................................................................... 146 FELADAT SZÖVEGE....................................................................................................................... 147 FONTOSABB VÁLTOZÓK .............................................................................................................. 148 PROGRAMKÓD ............................................................................................................................ 149 2013. május emelt VÁLASZTÁSOK ...................................................................................................... 155 FELADAT SZÖVEGE....................................................................................................................... 156 FONTOSABB VÁLTOZÓK .............................................................................................................. 157 PROGRAMKÓD ............................................................................................................................ 158 2013. október emelt KÖZÚTI ELLENŐRZÉS ........................................................................................ 162 FELADAT SZÖVEGE....................................................................................................................... 163 FONTOSABB VÁLTOZÓK .............................................................................................................. 164 PROGRAMKÓD ............................................................................................................................ 165 2014. május emelt IPv6 ...................................................................................................................... 169 FELADAT SZÖVEGE....................................................................................................................... 170 FONTOSABB VÁLTOZÓK .............................................................................................................. 171 PROGRAMKÓD ............................................................................................................................ 172 2014. október emelt NÉZŐTÉR ........................................................................................................... 177 FELADAT SZÖVEGE....................................................................................................................... 178 FONTOSABB VÁLTOZÓK .............................................................................................................. 179 PROGRAMKÓD ............................................................................................................................ 180

4


TÁJÉKOZTATÓ Az emelt szintű érettségi feladatok megoldása során elsődleges szempont az átláthatóság volt, és nem a hatékonyság. Ennek köszönhetően a programok nem mindig elegánsak vagy általánosak. Ahol lehetett, ott azért próbáltam általános függvényeket készíteni, főleg olyan helyzetekben, amikor egy feladatrész egy korábbi feladatrészt használt fel. A problémák megoldása során alapvető adatszerkezeti ismeretekre van szükség (tömb/vektor, mátrix, struktúra), ismerni kell a szöveges fájlok kezeléséhez szükséges alaputasításokat, eszközöket. Az adatszerkezeteken túl ismerni kell - az ugyancsak alapvető - programozási tételeket is (lineáris keresés, kiválasztás, összegzés, kiválogatás, megszámolás, rendezés, stb.)

5


ADATSZERKEZETEK TÖMB (VEKTOR, SOROZAT) A tömb azonos típusú adatok halmazát jelenti. A tömböt ugyanúgy, mint a „közönséges” változókat névvel azonosítjuk a programban, és a tömbben található egyes adatokat indexük, azaz sorszámuk segítségével lehet elérni, kezelni. (A C-ben az indexelés mindig 0-tól indul.) Példa int T[100]; (T 100 egész számot tartalmazó tömb, melynek ötödik elemét indexeléssel érhetjük el: T[4].) int T[5]={0,0,0,0,0}; (Minden elem kezdőértéke 0.) A tömbök feldolgozása általában ciklussal oldható meg (pl. for ciklus), ha minden elemével el kell végezni valamilyen műveletet, például értéket kell adni a tömbelemeknek: for(int i=0;i<100;i++) T[i]=0; (A fenti programrész T minden elemének a 0 kezdőértéket adja. Érdemes megfigyelni a ciklusváltozó és a tömbindexelés kapcsolatát. A legtöbb esetben az „i” ciklusváltozó indexként is felhasználható.) int i=0; while(i<20) { T[i]+=10; i++; } (A fenti programrész T első 20 elemének értékét 10-zel növeli)

MÁTRIX A mátrix is azonos típusú adatok egysége, de 2 vagy több dimenziós is lehet. Általában kétdimenziós mátrixokat használunk. Példa int M[100][3]; (M 100 sorból és 3 oszlopból álló adatszerkezet, minden eleme egész szám, melyben például az ötödik sor második elemét a következőképpen érhetjük el: T[4][1].) int T[3][3]={ {0,0,0}, {0,0,0}, {0,0,0} }; (Minden elem kezdőértéke 0.)

6

Programozási feladatok megoldása A mátrixok feldolgozása általában két ciklussal oldható meg (pl. for ciklusok), döntésünktől függően vagy „sorfolytonosan” vagy „oszlopfolytonosan”, azaz vagy egy soron végighaladva kezdünk új sort, vagy egy oszlopon végighaladva kezdünk új oszlopot. Ha például minden elemével el kell végezni valamilyen műveletet (értéket kell adni a mátrixelemeknek), az alábbiak szerint járhatunk el: for(int i=0;i<100;i++) { for(int j=0;j<3;j++) { T[i][j]=0;

//SORFOLYTONOS feldolgozás

} } (A fenti programrész T minden elemének a 0 kezdőértéket adja.) for(int j=0;j<3;j++) { for(int i=0;i<100;i++) { T[i][j]=0;

//OSZLOPFOLYTONOS feldolgozás

} } (A fenti programrész T minden elemének a 0 kezdőértéket adja.) További példák: int het[7]={1,2,3,4,5,6,7}; (Konstans tömb, pl. het[3]=4) string napok[7]={„hétfő”, „kedd”, „szerda”, „csütörtök”, „péntek”, „szombat”, „vasárnap”); cout << napok[het[5]] << endl; (Gyakori megoldás az, ha egy adott tömb-, vagy mátrixelem indexét (sorszámát) egy másik tömb vagy mátrix szolgáltatja. A példa erőltetett, csak illusztrálja ezt a lehetőséget, viszont az érettségi feladatokban gyakran alkalmazható eljárás. A példa a képernyőre a vasárnap szót írja ki, köszönhetően annak, hogy az indexek mindig 0-tól kezdődnek.)

7


STRUKTÚRA Ezt az összetett adatszerkezetet akkor használjuk, ha különböző típusú adatokat szeretnénk egy egységben kezelni. Példa struct str_nev { int a, b; char c; float f; string st; } Az str_nev a programban olyan, mint például az int, float, char, stb. Azaz egy új adattípust jelent. A fenti példa öt adatmezőből álló struktúrára mutat mintát. Látható, hogy az egyes mezők különböző típusúak. A programban a struktúra egyes mezőire a következőképpen tudunk hivatkozni: 1. Először is egy változót kell megadni ezzel az új, struktúra típussal: str_nev adat; 2. Az egyes mezők használata: adat.a=4; adat.b=adat.a*2 adat.c=’C’; adat.st=”Szöveges adat”; A struktúra és a tömb, vagy mátrix segítségével még összetettebb adatszerkezeteket hozhatunk létre. Nézzünk erre is példákat: Példa struct str_nev { int a, b; char c; float f; string st; } adat[100]; A fenti példában rögtön a struktúra definiálásakor egy tömböt is létrehozunk 100 elemmel, ahol az elemek a, b, c, f, st mezők együttesét jelenti, azaz „adatötösök” lesznek a tömbelemek.

8

Programozási feladatok megoldása Az egyes tömbelemek tehát a következőképpen érhetők el: adat[5].a=7; adat[7].st=”Szöveges információ”; Látható, hogy a tömbelemeket indexeléssel érjük el, és a tömbelemen belül az egyes mezőket ponttal elválasztva kezelhetjük, mint egy normál struktúra típusnál. Ha ugyanilyen struktúra típusú mátrixot is szeretnénk létrehozni, azt a következőképpen tehetjük meg: str_nev matrix[10][20]; A mátrix elemeinek használatára egy példa: matrix[4][8].f=3.14;

9


SZÖVEGES FÁJLOK KEZELÉSE Az érettségi feladatokban - eddig legalábbis - csak szövegfájlokat kellett kezelni. A fájlok tartalma lehet szöveg és szám is. Tartalmuk elrendezése szerint viszont nagy a változatosság: 1. 2. 3. 4.

minden adat külön sorban van, egy sorban több, de azonos típusú adat van szóközökkel elválasztva egy sorban több és különböző típusú adat van szóközökkel elválasztva egy sorban szóközökkel tagolt szöveg van

Nézzük meg, hogy az egyes tartalmi elrendezésekre milyen megoldást érdemes kidolgozni. (Természetesen más megoldások is lehetnek):

1.

minden adat külön sorban van

Ez a legegyszerűbb eset. Automatikusan beolvashatók a sorok, mivel a fájlkezelés során a „fájlmutató” automatikusan új sorra lép. Példa proba.txt fájl tartalma: 1 2 3 4

#include #include //fájlkezelés fv. tára #define max 10 //ha pl. 10 elem lehet maximum

int main() { int adat[max]; int i=0; ifstream fbe; //input fájlkezelés fbe.open(„proba.txt”); while(!fbe.eof()) { fbe >> adat[i]; i++; } fbe.close(); cout << „Beolvasott elemek száma:” << i; return 0; } A fenti példában nem ismert a fájlban található elemek száma, így a beolvasást addig kell folytatni, amíg a fájl végére nem érünk (fbe.eof() – eof: end of file). Az i ciklusváltozó a ciklus lefutása után a beolvasott elemek számát tartalmazza. Ha ismert a fájlban lévő elemek száma, akkor egy egyszerű „for” ciklussal is beolvashatjuk az elemeket.

10


2.

minden sorban több adat van

Ez sem okozhat problémát: az adatok beolvasása során automatikusan, szóközönként továbblép a „fájlmutató”, a sorok végén pedig automatikusan új sorra lép. Példa proba.txt fájl tartalma: 12345 6 7 8 9 10 11 12 13 14 15

#include #include //fájlkezelés fv. tára #define max 15 //ha pl. 15 elem lehet maximum

int main() { int adat[max]; int i=0; ifstream fbe; //input fájlkezelés fbe.open(„proba.txt”); while(!fbe.eof()) { fbe >> adat[i]; i++; } fbe.close(); cout << „Beolvasott elemek száma:” << i; return 0; } (Látható, hogy semmi különbség nincs az előző példához képest.)

11


3.

minden sorban több, különböző típusú adat van Példa proba.txt fájl tartalma: 123 ablak k 12.34 210 ajtó z 1023.3

#include #include //fájlkezelés fv. tára #define max 15 //ha pl. 15 elem lehet maximum struct adat { int szam; string szoveg; char k; float valos; } adatok[max]; int main() { int i=0; ifstream fbe; //input fájlkezelés fbe.open(„proba.txt”); while(!fbe.eof()) { fbe >> adatok[i].szam; fbe >> adatok[i].szoveg; fbe >> adatok[i].char; fbe >> adatok[i].valos; i++; } fbe.close(); cout << „Beolvasott elemek száma:” << i; return 0; }

Ha különböző típusú adatokat kell egy egységben kezelnünk, akkor célszerű lehet a struktúra (struct) használata. Ez megfelel egy adatbázistábla megadásának: mezőnevek és adattípusok. Rögtön a struktúra definiálásánál változót (a példában egy tömböt) rendelhetünk ehhez az új adatszerkezethez. Ekkor a változónk globális lesz, bármely függvényünkben felhasználhatjuk.

EGYÉB FÁJLKEZELÉSI MEGOLDÁS Mit tegyünk, ha az a feladat, hogy egy már létező fájlhoz kell új adatokat, sorokat hozzáfűzni? Ebben az esetben a fájlt append, azaz hozzáfűzés módban kell megnyitni. Nézzünk erre egy példát! Példa: ofstream ki; ki.open("eredmeny.txt", fstream::app); Az így megnyitott fájl tartalma, ha már létezett, nem törlődik, hanem az új tartalmak hozzáfűzésre kerülnek.

12


NÉHÁNY KIEMELT ALGORITMUS EGYSZERŰ CSERÉS RENDEZÉS! Példa: Adott egy N elemű x nevű tömb, melynek elemeit növekvő sorrendbe kell rendezni. Az algoritmus C nyelven: for(int i=0; i x[j]) swap(x[i], x[j]);

//külső ciklus N-1-ig megy //belső ciklus mindig i+1-től N-ig //Ha sorrend nem jó, akkor csere

} } MEGSZÁMOLÁS! Példa: Adott egy N elemű x nevű tömb és egy T tulajdonság. Számoljuk meg, hány elem rendelkezik ezzel a tulajdonsággal! Az algoritmus C nyelven: int db=0; for(int i=0; i
//minden elemet meg kell vizsgálni

cout << db; MAXIMUMKERESÉS! Példa: Adott egy N elemű x nevű tömb, melynek elemei összehasonlíthatók. Keressük meg a legnagyobb elemet! Az algoritmus C nyelven: int max=0; for(int i=1; ix[max]) max=i; }

//feltételezzük, hogy a 0 indexű elem a legnagyobb //a ciklus az 1 indexűtől indul //ha az i. elem nagyobb, akkor a max „címkét” ő kapja meg

cout << „Legnagyobb elem:” << x[max]; LINEÁRIS KERESÉS! Példa: Adott egy N elemű x nevű tömb és egy T tulajdonság. Keressünk T tulajdonságú elemet! Ez az algoritmus, nevéből is adódóan, az elsőt fogja megadni, ha van. Az algoritmus C nyelven: int i=0; //a ciklus addig megy, amíg van még elem és az éppen vizsgált nem T tulajdonságú while(i
//ha a ciklus végére i
13

Programozási feladatok megoldása EGYSZERŰ CSERÉS RENDEZÉS TÖBB RENDEZÉSI SZEMPONTTAL! Példa: Adott egy N elemű x nevű struktúra, például nev, magassag, testsuly mezőkkel. Feladat: rendezzük névsorba, azon belül pedig magasság szerint az adatokat! Az algoritmus C nyelven: struct adat { string nev; int magassag, testsuly; } x[N]; //Tegyük fel, hogy az x tömbben vannak adatok //Rendezés: for(int i=0; ix[j].nev||x[i].nev==x[j].nev&&x[i].magassag>x[j].magassag) { swap(x[i], x[j]); //Ha sorrend nem jó, akkor csere } } }

14


NÉHÁNY MŰVELET STRINGEKKEL Az alábbi programrészlet néhány alapvető „stringműveletet” illusztrál. #include #include <string> #include using namespace std; int main() { setlocale(LC_ALL, "hun"); string s="Próba szöveg - második rész"; string s2="csere"; char szov[10]; cout << "Eredeti szöveg: " << s << endl; cout << "s.size(): " << s.size() << endl; //szöveg hossza cout << "s.length(): " << s.length() << endl; //szöveg hossza cout << "Szövegben csere lesz: " << endl; cout << s.replace(15,7,s2) << endl; //15. karaktertől 7 karakter cseréje s2-re cout << "Új hosszúság: " << s.length() << endl; for(int i=0; i<s.length(); i++) s[i]=toupper(s[i]); //párja tolower() cout << "Most már nagybetűsen:" << endl; cout << s << endl; //Ékezetes betűk eltávolítása for(int i=0;i<s.length();i++) { if(s[i]=='Ö'||s[i]=='Ó'||s[i]=='Ő') s[i]='O'; if(s[i]=='Ü'||s[i]=='Ű'||s[i]=='Ú') s[i]='U'; if(s[i]=='Á') s[i]='A'; if(s[i]=='É') s[i]='E'; if(s[i]=='Í') s[i]='I'; } cout << "Ékezetmentesen:" << endl; cout << s << endl; int found; found=s.find('-'); string s_bal=s.substr(0,found); //részszöveg 0, found-ig string s_jobb=s.substr(found+2,s.length()); cout << "bal: " << s_bal << endl; cout << "jobb: " << s_jobb << endl; return 0; }

15


NÉHÁNY HASZNOS ALGORITMUS LEGNAGYOBB KÖZÖS OSZTÓ, LEGKISEBB KÖZÖS TÖBBSZÖRÖS Két szám legnagyobb közös osztóját az EUKLIDESZI ALGORITMUS segítségével határozhatjuk meg. A legkisebb közös többszörös ebből már közvetlenül számolható: LKKT=a*b/LNKO(a,b). Az algoritmus a következő C nyelven: #include using namespace std; int lnko(int a, int b) { //EUKLIDÉSZI ALGORITMUS int x=0; while(b>0) { x=a%b; a=b; b=x; } return a; } int lkkt(int a, int b) { return (a*b)/lnko(a,b); } int main() { setlocale(LC_ALL, "hun"); int A, B; cout << "A="; cin >> A; cout << "B="; cin >> B; cout << A << " és " << B << " legnagyobb közös osztója: " << lnko(A,B) << endl; cout << A << " és " << B << " legkisebb közös többszöröse: " << lkkt(A,B) << endl; return 0; }

16

Programozási feladatok megoldása PRÍMSZÁMOK LISTÁZÁSA Az algoritmus 2-től „akármeddig” kilistázza a prímszámokat. A lényeg: egy adott szám osztói a szám fele+1-nél kisebbek, ha vannak. Például 24 osztói: 2, 3, 4, 6, 8, 12 < 24/2+1. Ha a 17-et nézzük, ugye ez egy prímszám, akkor 17/2+1-ig, azaz 9-ig nem találunk egy osztót sem. A C nyelv szigorúan típusos nyelv, így az osztást (/) egész számok között úgy végzi el, hogy az eredmény is egész lesz. Pl.: 17/2=8 (A valós eredmény 8,5 lenne.) Az algoritmus C nyelven: #include using namespace std; int main() { int szamlalo; for(int i = 2; i < 1000; i++) { if(szamlalo == 0) cout << i-1 << " "; szamlalo = 0; for(int j = 2; j < i/2 + 1; j++) { if(i%j == 0) szamlalo++; } }

//prímszám kiírása //egy adott szám osztóit számlálja meg //ha a szám feléig nem talál osztót, //akkor a szám prímszám, //ha mégis talál, a szamlaloban számolja //mennyi van

}

17

INFORMATIKA EMELT SZINT

PROGRAMOZÁSI FELADATOK MEGOLDÁSA

2005. MÁJUS EMELT LOTTÓ

Programozási feladatok megoldása FELADAT SZÖVEGE Magyarországon 1957 óta lehet ötös lottót játszani. A játék lényege a következő: a lottószelvényeken 90 szám közül 5 számot kell a fogadónak megjelölnie. Ha ezek közül 2 vagy annál több megegyezik a kisorsolt számokkal, akkor nyer. Az évek során egyre többen hódoltak ennek a szerencsejátéknak és a nyeremények is egyre nőttek. Adottak a lottosz.dat szöveges állományban a 2003. év 51 hetének ötös lottó számai. Az első sorában az első héten húzott számok vannak, szóközzel elválasztva, a második sorban a második hét lottószámai vannak stb. Például: 37 42 44 61 62 18 42 54 83 89 ... 9 20 21 59 68 A lottószámok minden sorban emelkedő számsorrendben szerepelnek. Az állományból kimaradtak az 52. hét lottószámai. Ezek a következők voltak: 89 24 34 11 64. Készítsen programot a következő feladatok megoldására! 1. Kérje be a felhasználótól az 52. hét megadott lottószámait! 2. A program rendezze a bekért lottószámokat emelkedő sorrendbe! A rendezett számokat írja ki a képernyőre! 3. Kérjen be a felhasználótól egy egész számot 1-51 között! A bekért adatot nem kell ellenőrizni! 4. Írja ki a képernyőre a bekért számnak megfelelő sorszámú hét lottószámait, a lottosz.dat állományban lévő adatok alapján! 5. A lottosz.dat állományból beolvasott adatok alapján döntse el, hogy volt-e olyan szám, amit egyszer sem húztak ki az 51 hét alatt! A döntés eredményét (Van/Nincs) írja ki a képernyőre! 6. A lottosz.dat állományban lévő adatok alapján állapítsa meg, hogy hányszor volt páratlan szám a kihúzott lottószámok között! Az eredményt a képernyőre írja ki! 7. Fűzze hozzá a lottosz.dat állományból beolvasott lottószámok után a felhasználótól bekért, és rendezett 52. hét lottószámait, majd írja ki az összes lottószámot a lotto52.ki szöveges fájlba! A fájlban egy sorba egy hét lottószámai kerüljenek, szóközzel elválasztva egymástól! 8. Határozza meg a lotto52.ki állomány adatai alapján, hogy az egyes számokat hányszor húzták ki 2003-ban. Az eredményt írja ki a képernyőre a következő formában: az első sor első eleme az a szám legyen ahányszor az egyest kihúzták! Az első sor második eleme az az érték legyen, ahányszor a kettes számot kihúzták stb.! (Annyit biztosan tudunk az értékekről, hogy mindegyikük egyjegyű.)

Példa egy lehetséges eredmény elrendezésére (6 sorban, soronként 15 érték). 4 1 3 4 5 4

2 3 3 2 2 3

2 5 5 1 0 2

4 0 4 2 2 2

2 5 3 3 2 3

2 5 1 2 4 1

6 2 4 2 4 1

1 6 2 2 3 4

1 6 2 4 1 1

2 5 4 4 3 3

1 1 2 5 6 3

5 0 4 1 1 2

2 6 1 3 5 1

1 4 2 5 6 5

1 3 3 5 2 3

9. Adja meg, hogy az 1-90 közötti prímszámokból melyiket nem húzták ki egyszer sem az elmúlt évben. A feladat megoldása során az itt megadott prímszámokat felhasználhatja vagy előállíthatja! (2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89.)

20

Programozási feladatok megoldása FONTOSABB VÁLTOZÓK ADAT NEVE

TÍPUSA

FELÉPÍTÉSE

SZEREPE

FELHASZNÁLÁS

lsz[52][5]

int

52x5-ös mátrix

A lottosz.dat fájlban található adatok és a felhasználótól bekért 5 szám tárolása. Szerkezete az 52 hétnek felel meg, és a hetente kihúzott 5 számnak.

globális

t[90]

int

90 elemű tömb

A sorsolásokon a számok 1 és 90 közöttiek lehetnek. Ha kihúzott szám pl. 6, akkor a t tömb ennek megfelelő elemét kezeljük!

globális

Sorsolt szám: 6 t[6-1] elem beállításra kerül. Lsd a megfelelő programrészt! primek[90]

int

90 elemű tömb

9. feladatban arra használjuk, hogy a prímszámú indexeken 0ról 1-re állítjuk, a feladatmegoldáshoz így felhasználhatjuk!

lokális

21

Programozási feladatok megoldása PROGRAMKÓD #include #include using namespace std; int lsz[52][5]; //0..51 0..4 ezek az indexek int t[90]; //maguk a kihúzott számok fogják indexelni ezt a tömböt!!! void F1() { cout << "Kérem a hiányzó 52. hét számait:" << endl; //A hiányzó számokat beillesztjük a mátrixba, így a 7. feladat könnyű lesz!! for(int i=0;i<5;i++) { cout << i+1 <<".szám:"; cin >> lsz[51][i]; } } void F2() { //Egyszerű cserés rendezés for(int i=0;i<4;i++) { for(int j=i+1;j<5;j++) { if(lsz[51][i]>lsz[51][j]) swap(lsz[51][i],lsz[51][j]); } } }

22

Programozási feladatok megoldása void F3_4() { //3. és 4. feladat egyben ifstream f; f.open("lottosz.dat"); for(int i=0;i<51;i++) //sorok { for(int j=0;j<5;j++) //oszlopok, azaz az 5 szám az adott sorban { f >> lsz[i][j]; cout << lsz[i][j] << " "; } cout << endl; } f.close(); cout << "Kérek egy hetet (1-51):"; int het; cin >> het; for(int i=0;i<5;i++) { cout << lsz[het-1][i] << " "; } cout << endl; } void F5() { for(int i=0;i<90;i++) t[i]=0; //ez a cikluspár a 8. feladatot is megoldja!!! for(int i=0;i<51;i++) //51 a vége, mert ezt kéri a feladat { for(int j=0;j<5;j++) { t[lsz[i][j]-1]++; //lsz[i][j] a kihúzott szám most indexként működik (-1 az kell, tudjuk) } } bool nincs=true;

//azt állítjuk, hogy nincs olyan, amit nem húztak ki

for(int i=0;i<90;i++) { if(t[i]==0) nincs=false; } if(nincs) cout << "Minden számot kihúztak legalább egyszer!"; else cout << "Van olyan szám, amit egyszer sem húztak ki!"; cout << endl; } 23

Programozási feladatok megoldása void F6() { //Ha 2-vel osztva a maradék 1, akkor páratlan a szám, ha 0, akkor páros int ptlan=0; for(int i=0;i<51;i++) //51 a vége, mert ezt kéri a feladat { for(int j=0;j<5;j++) { if(lsz[i][j]%2==1) ptlan++; } } cout << "Páratlan számok száma: " << ptlan << endl; } void F7() { ofstream ki; ki.open("lotto52.ki"); for(int i=0;i<52;i++) //51 a vége, mert ezt kéri a feladat { for(int j=0;j<5;j++) { ki << lsz[i][j] << " "; } ki << endl; } ki.close(); } void F8() { for(int i=0;i<90;i++) { if(i%15==0) cout << endl; cout << t[i] << " "; } }

24

Programozási feladatok megoldása void F9() { int primek[90]; //t tömbbel "párhuzamos" tömb, csak a prímszámokat megjelöljük benne for(int i=0;i<90;i++) primek[i]=0; //primek tömb prímszám indexű(-1) elemeinek beállítása 1-re int szamlalo, prim; for(int i = 2; i < 90; i++) { if(szamlalo == 0) { prim=i-1; primek[prim-1]=1; } szamlalo = 0; for(int j = 2; j < i/2 + 1; j++) { if(i%j == 0) szamlalo++; }

//egy adott szám osztóit számlálja meg //ha a szám feléig nem talál osztót, //akkor a szám prímszám, //ha mégis talál, a szamlaloban számolja //mennyi van

} cout << endl << "Ezeket a prímszámokat nem húzták ki egyszer sem:" << endl; //Melyiket nem húzták ki? for(int i=0;i<90;i++) { if(t[i]==0&&primek[i]==1) //0-t számoltunk korábban és prím is, akkor oké { cout << i+1 << " "; } } } int main() { setlocale(LC_ALL, "hun"); cout << "Lottósorsolás" << endl; F1(); F2(); F3_4(); F5(); F6(); F7(); F8(); F9(); return 0; }

25

2005. OKTÓBER EMELT VIGENÉRE


FELADAT SZÖVEGE Már a XVI. században komoly titkosítási módszereket találtak ki az üzenetek elrejtésére. A század egyik legjobb kriptográfusának Blaise de Vigenère-nek a módszerét olvashatja a következőkben. A kódoláshoz egy táblázatot és egy ún. kulcsszót használt. A táblázatot a jobb oldali ábra tartalmazza. A tábla adatait a vtabla.dat fájlban találja a következő formában.

Készítsen programot kodol néven a következő feladatok végrehajtására! 1. Kérjen be a felhasználótól egy maximum 255 karakternyi, nem üres szöveget! A továbbiakban ez a nyílt szöveg. 2. Alakítsa át a nyílt szöveget, hogy a későbbi kódolás feltételeinek megfeleljen! A kódolás feltételei: • • •

A magyar ékezetes karakterek helyett ékezetmenteseket kell használni. (Például á helyett a; ő helyett o stb.) A nyílt szövegben az átalakítás után csak az angol ábécé betűi szerepelhetnek. A nyílt szöveg az átalakítás után legyen csupa nagybetűs.

3. Írja ki a képernyőre az átalakított nyílt szöveget! 4. Kérjen be a felhasználótól egy maximum 5 karakteres, nem üres kulcsszót! A kulcsszó a kódolás feltételeinek megfelelő legyen! (Sem átalakítás, sem ellenőrzés nem kell!) Alakítsa át a kulcsszót csupa nagybetűssé! 5. A kódolás első lépéseként fűzze össze a kulcsszót egymás után annyiszor, hogy az így kapott karaktersorozat (továbbiakban kulcsszöveg) hossza legyen egyenlő a kódolandó szöveg hosszával! Írja ki a képernyőre az így kapott kulcsszöveget! 6. A kódolás második lépéseként a következőket hajtsa végre! Vegye az átalakított nyílt szöveg első karakterét, és keresse meg a vtabla.dat fájlból beolvasott táblázat első oszlopában! Ezután vegye a kulcsszöveg első karakterét, és keresse meg a táblázat első sorában! Az így kiválasztott sor és oszlop metszéspontjában lévő karakter lesz a kódolt szöveg első karaktere. Ezt ismételje a kódolandó szöveg többi karakterével is! 7. Írja ki a képernyőre és a kodolt.dat fájlba a kapott kódolt szöveget!

27


TÍPUSA

FELÉPÍTÉSE

SZEREPE

FELHASZNÁLÁS

VT[26][26]

char

26x26-os karaktermátrix

A fájlban található Vigenére táblázat tárolása.

globális

nyers kodolt

string string

globális globális

k kulcs

string string

Eredeti nyers szöveg A nyers szöveg ékezetes betűk és egyéb írásjelek nélkül, csupa nagybetűvel Billentyűzetről beolvasott kulcs A k kulcsból kodolt szöveg hoszszan felépített kulcs.

globális globális

Pl.: nyers=”Ez a szövegem, amit kódolok! kodolt=”EZASZOVEGEMAMITKODOLOK” k=”auto” kulcs=”AUTOAUTOAUTOAUTOAUTOAU”

eredmeny

string

Ebben alakul ki a végleges kódolt szöveg

globális

28

Programozási feladatok megoldása PROGRAMKÓD #include #include #include <string> #include <windows.h> using namespace std; char VT[26][26]; string nyers, kodolt, k, kulcs, eredmeny; void kiir(string s) { cout << s <<". feladat" << endl; } void F123() { //Első három feladat mehet egybe... cout << "Kérek egy szöveget: " << endl; getline(cin,nyers); kodolt=""; for(int i=0;i='a' && nyers[i]<='z') || (nyers[i]>='A' && nyers[i]<='Z')) { kodolt+=toupper(nyers[i]); } } cout << "Kódolt szöveg:" << endl; cout << kodolt << endl; }

29

Programozási feladatok megoldása void F4() { cout << "Kérem a kulcsot (max. 5 karakter): "; cin>> k; for(int i=0;i>VT[i][j]; } } V.close(); ofstream ki; ki.open("kodolt.dat"); eredmeny=""; //Ebbe "gyűjtjük" a karaktereket a VT mátrixból for(int i=0;i
30

Programozási feladatok megoldása int main() { setlocale(LC_ALL, "hun"); kiir("1-3"); F123(); kiir("4"); F4(); kiir("5"); F5(); kiir("6-7"); F67(); return 0; }

31

2006. FEBRUÁR EMELT TELEFONSZÁMLA


FELADAT SZÖVEGE Egy új szolgáltatás keretében ki lehet kérni a napi telefonbeszélgetéseink listáját. A listát egy fájlban küldik meg, amelyben a következő adatok szerepelnek: hívás kezdete, hívás vége, hívott telefonszám. A hívás kezdete és vége óra, perc, másodperc formában szerepel. Például 6 15 0 6 19 0 395682211 9 58 15 10 3 53 114571155

Óra Telefonszám Óra Telefonszám

perc

mperc

Óra

perc

mperc

perc

mperc

Óra

perc

mperc

A hívások listája időben rendezett módon tartalmazza az adatokat, és szigorúan csak egy napi adatot, azaz nincsenek olyan beszélgetések, amelyeket előző nap kezdtek vagy a következő napon fejeztek be. Továbbá az elmúlt időszak statisztikái alapján tudjuk, hogy a napi hívások száma nem haladja meg a kétszázat. A telefonálás díjait a következő táblázat foglalja össze. Hívásirány Vezetékes Mobil társaság

Csúcsidőben 700 - 1800 (Ft/perc) 30 69,175

Csúcsidőn kívül 000 – 700 és 1800 – 2400 (Ft/perc) 15 46,675

További fontos információk: • A csúcsidő reggel 7:00:00-kor, a csúcsidőn kívüli időszak pedig 18:00:00-kor kezdődik. A díjazás számításakor az számít, hogy mikor kezdte az illető a beszélgetést. (Például: ha 17:55-kor kezdett egy beszélgetést, de azt 18:10-kor fejezte be, akkor is csúcsidőbeli díjakkal kell számlázni.) • Minden megkezdett perc egy egész percnek számít. • Minden telefonszám elején egy kétjegyű körzetszám, illetve mobil hívószám található. A mobil hívószámok: 39, 41, 71 kezdődnek, minden egyéb szám vezetékes hívószámnak felel meg. A következő feladatokat oldja meg egy program segítségével! A programot mentse szamla néven! 1. Kérjen be a felhasználótól egy telefonszámot! Állapítsa meg a program segítségével, hogy a telefonszám mobil-e vagy sem! A megállapítást írja ki a képernyőre! 2. Kérjen be továbbá egy hívás kezdeti és hívás vége időpontot óra perc másodperc formában! A két időpont alapján határozza meg, hogy a számlázás szempontjából hány perces a beszélgetés! A kiszámított időtartamot írja ki a képernyőre! 3. Állapítsa meg a hivasok.txt fájlban lévő hívások időpontja alapján, hogy hány számlázott percet telefonált a felhasználó hívásonként! A kiszámított számlázott perceket írja ki a percek.txt fájlba a következő formában! perc telefonszám 4. Állapítsa meg a hivasok.txt fájl adatai alapján, hogy hány hívás volt csúcsidőben és csúcsidőn kívül! Az eredményt jelenítse meg a képernyőn! 5. A hivasok.txt fájlban lévő időpontok alapján határozza meg, hogy hány percet beszélt a felhasználó mobil számmal és hány percet vezetékessel! Az eredményt jelenítse meg a képernyőn! 6. Összesítse a hivasok.txt fájl adatai alapján, mennyit kell fizetnie a felhasználónak a csúcsdíjas hívásokért! Az eredményt a képernyőn jelenítse meg!

33


TÍPUSA

FELÉPÍTÉSE

SZEREPE

FELHASZNÁLÁS

adat[200]

hivasok típusú 200 elemű tömb, minden eleme egy adathetest tartalmaz

struktúra 7 adatmezővel: 1-6. mező int ko – hívás kezdő óra kp – hívás kezdő perc km – hívás kezdő másodperc vo – hívás vége óra vp – hívás vége perc vm – hívás vége másodperc tsz – telefonszám (string)

A fájlban található adatok tárolása.

globális

N

int

hívások száma

globális

34

Programozási feladatok megoldása PROGRAMKÓD #include #include #include <windows.h> #include <string> using namespace std; struct hivasok { int ko, kp, km, vo, vp, vm; string tsz; } adat[200]; int N; //Hívások száma void kiir(int ssz) { cout << "---------------------" << endl; cout << ssz << ". feladat" << endl; cout << "---------------------" << endl; } //Mivel a fő adataink globálisak itt nem is kellene paraméterátadás, de lássunk ilyet is!! :) bool mobil(string t) { bool az=false; if(t.substr(0,2)=="39"||t.substr(0,2)=="41"||t.substr(0,2)=="71") { az=true; } return az; } //Mivel a fő adataink globálisak itt nem is kellene paraméterátadás, de lássunk ilyet is!! :) int perc(int o1,int p1,int m1,int o2,int p2,int m2) { int ido1=o1*3600+p1*60+m1; int ido2=o2*3600+p2*60+m2; int percek=(ido2-ido1)/60; //Minden megkezdett perc számít, így a maradékot is vizsgálni kell! if((ido2-ido1)%60!=0) percek++; return percek; }

35

Programozási feladatok megoldása //Mivel a fő adataink globálisak itt nem is kellene paraméterátadás, de lássunk ilyet is!! :) bool csucsido(int ora) { bool csucs=false; if(ora>=7&&ora<18) csucs=true; return csucs; } /* A mobil, perc, csucsido függvények nagyban megkönnyítik a feladat megoldását. Érdemes ilyen "általános célú" függvényeket készíteni, ha több feladatrész is fel tudja használni! */ void F1() { string tel; cout << "Kérek egy telefonszámot: "; cin >> tel; if(mobil(tel)) cout << "MOBILSZÁM!"; else cout << "NEM MOBILSZÁM!"; cout << endl; } void F2() { int k_o, k_p, k_m, v_o, v_p, v_m; cout << "Kérem a hívás adatait: "; cout << "Kezdés óra: "; cin >> k_o; cout << "Kezdés perc: "; cin >> k_p; cout << "Kezdés másodperc: "; cin >> k_m; cout << "Vége óra: "; cin >> v_o; cout << "Vége perc: "; cin >> v_p; cout << "Vége másodperc: "; cin >> v_m; cout << perc(k_o,k_p,k_m,v_o,v_p,v_m) << " perces volt!" << endl; }

36

Programozási feladatok megoldása void F3() { cout << "Adatok beolvasása és feldolgozása..." << endl; ifstream be; be.open("HIVASOK.txt"); ofstream ki; ki.open("percek.txt"); int i=0; while(!be.eof()) { be >> adat[i].ko; be >> adat[i].kp; be >> adat[i].km; be >> adat[i].vo; be >> adat[i].vp; be >> adat[i].vm; be >> adat[i].tsz; ki << perc(adat[i].ko,adat[i].kp,adat[i].km,adat[i].vo,adat[i].vp,adat[i].vm) << " " << adat[i].tsz << endl; i++; } N=i; cout << "Hívások száma: " << N << endl; ki.close(); be.close(); } void F4() { int db=0; for(int i=0;i
37

Programozási feladatok megoldása void F6() { //Ez a feladat lehetne a 4-es és az 5-ös kombinációja, //ha általánosítjuk ezeket is, de most külön megoldjuk a 6. feladatot float fizet=0; int percek; for(int i=0;i
38

2006. MÁJUS EMELT FEHÉRJE


FELADAT SZÖVEGE A fehérjék óriás molekulák, amelyeknek egy része az élő szervezetekben végbemenő folyamatokat katalizálják. Egy-egy fehérje aminosavak százaiból épül fel, melyek láncszerűen kapcsolódnak egymáshoz. A természetben a fehérjék fajtája több millió. Minden fehérje húszféle aminosav különböző menynyiségű és sorrendű összekapcsolódásával épül fel. Az alábbi táblázat tartalmazza az aminosavak legfontosabb adatait, a megnevezéseket és az őket alkotó atomok számát (az aminosavak mindegyike tartalmaz szenet, hidrogént, oxigént és nitrogént, néhányban kén is van): Neve Glicin Alanin Arginin Fenilalanin Cisztein Triptofán Valin Leucin Izoleucin Metionin Prolin Szerin Treonin Aszparagin Glutamin Tirozin Hisztidin Lizin Aszparaginsav Glutaminsav

Rövidítés Gly Ala Arg Phe Cys Trp Val Leu Ile Met Pro Ser Thr Asn Gln Tyr His Lys Asp Glu

Betűjele G A R F C W V L I M P S T N Q Y H K D E

C 2 3 6 9 3 11 5 6 6 5 5 3 4 4 5 9 6 6 4 5

H 5 7 14 11 7 12 11 13 13 11 9 7 9 8 10 11 9 14 7 9

O 2 2 2 2 2 2 2 2 2 2 2 3 3 3 3 3 2 2 4 4

N 1 1 4 1 1 2 1 1 1 1 1 1 1 2 2 1 3 2 1 1

S 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0

Készítsen programot feherje néven, ami megoldja a következő feladatokat! Ügyeljen arra, hogy a program forráskódját a megadott helyre mentse! 1. Töltse be az aminosav.txt fájlból az aminosavak adatait! A fájlban minden adat külön sorban található, a fájl az aminosavak nevét nem tartalmazza. Ha az adatbetöltés nem sikerül, vegye fel a fenti táblázat alapján állandóként az első öt adatsort, és azzal dolgozzon! Az első néhány adat: Gly G 2 5 2 1 0 Ala A 3 7 2 1 0 …

40

Programozási feladatok megoldása 2. Határozza meg az aminosavak relatív molekulatömegét, ha a szén atomtömege 12, a hidrogéné 1, az oxigéné 16, a nitrogéné 14 és a kén atomtömege 32! Például a Glicin esetén a relatív molekulatömeg 2·12 + 5·1 + 2·16 + 1·14 + 0·32 = 75. A következő feladatok eredményeit írja képernyőre, illetve az eredmeny.txt fájlba! A kiírást a feladat sorszámának feltüntetésével kezdje (például: 4. feladat)! 3. Rendezze növekvő sorrendbe az aminosavakat a relatív molekulatömeg szerint! Írja ki a képernyőre és az eredmeny.txt fájlba az aminosavak hárombetűs azonosítóját és a molekulatömeget! Az azonosítót és hozzátartozó molekulatömeget egy sorba, szóközzel elválasztva írja ki! 4. A bsa.txt a BSA nevű fehérje aminosav sorrendjét tartalmazza – egybetűs jelöléssel. (A fehérjelánc legfeljebb 1000 aminosavat tartalmaz.) Határozza meg a fehérje összegképletét (azaz a C, H, O, N és S számát)! A meghatározásánál vegye figyelembe, hogy az aminosavak összekapcsolódása során minden kapcsolat létrejöttekor egy vízmolekula (H2O) lép ki! Az összegképletet a képernyőre és az eredmeny.txt fájlba az alábbi formában írja ki: Például: C 16321 H 34324 O 4234 N 8210 S 2231 (Amennyiben a bsa.txt beolvasása sikertelen, helyette tárolja a G, A, R, F, C betűjeleket tízszer egymás után és a feladatokat erre a „láncra” oldja meg!) 5. A fehérjék szekvencia szerkezetét hasításos eljárással határozzák meg. Egyes enzimek bizonyos aminosavak után kettéhasítják a fehérjemolekulát. Például a Kimotripszin enzim a Tirozin (Y), Fenilalanin (W) és a Triptofán (F) után hasít. Határozza meg, és írja ki képernyőre a Kimotripszin enzimmel széthasított BSA lánc leghosszabb darabjának hosszát és az eredeti láncban elfoglalt helyét (első és utolsó aminosavának sorszámát)! A kiíráskor nevezze meg a kiírt adatot, például: „kezdet helye:”! 6. Egy másik enzim (a Factor XI) az Arginin (R) után hasít, de csak akkor, ha Alinin (A) vagy Valin (V) követi. Határozza meg, hogy a hasítás során keletkező első fehérjelánc részletben hány Cisztein (C) található! A választ teljes mondatba illesztve írja ki a képernyőre!

41


TÍPUSA

FELÉPÍTÉSE

SZEREPE

FELHASZNÁLÁS

aminosav[20]

adatok típusú 20 elemű tömb, minden eleme egy adat- nyolcast tartalmaz

struktúra 8 adatmezővel: ko – hívás kezdő óra r –rövid név (string) b – betűjel (char) c – szén h – hidrogén o – oxigén n – nitrogén s – kén rm – realatív molekulatömeg (ezek a mezők int típusúak)


globális

BSA[1000]

bsa_lh

char típusú maximum 1000 elemből álló tömb int

A 3. feladatban történő rendezés miatt vesszük bele a struktúrába az rm mezőt.

BSA.txt fájl tartalmának tárolása, a 4. feladattól kerül felhasználásra. BSA lánc hossza, 4. feladat.

globális

globális

42

Programozási feladatok megoldása PROGRAMKÓD #include #include #include #include <windows.h> #include <string> #define C 12 #define H 1 #define O 16 #define N 14 #define S 32 using namespace std; struct adatok { string r; char b; int c, h, o, n, s; int rm; } aminosav[20]; char BSA[1000]; int bsa_lh; void kiir(int ssz) { cout << "---------------------" << endl; cout << ssz << ". feladat" << endl; cout << "---------------------" << endl; } int szamol(int index) { int rel_mol; rel_mol=aminosav[index].c*C+aminosav[index].h*H+aminosav[index].o*O+aminosav[index].n* N+aminosav[index].s*S; aminosav[index].rm=rel_mol; return rel_mol; }

43

Programozási feladatok megoldása void F1() { cout << "Adatok beolvasása..." << endl; ifstream be; be.open("aminosav.txt"); for(int i=0;i<20;i++) { be >> aminosav[i].r; be >> aminosav[i].b; be >> aminosav[i].c; be >> aminosav[i].h; be >> aminosav[i].o; be >> aminosav[i].n; be >> aminosav[i].s; cout << aminosav[i].r << " " << aminosav[i].b << " " << aminosav[i].c << " "; cout << aminosav[i].h << " " << aminosav[i].o << " " << aminosav[i].n << " "; cout << aminosav[i].s << endl; } be.close(); } void F2() { cout << "Relatív molekulatömegek meghatározása:" << endl; for(int i=0;i<20;i++) { cout << aminosav[i].r << ": " << setw(3) << szamol(i) << endl; } } void F3() { ofstream ki; ki.open("eredmeny.txt"); cout << "Relatív molekulatömegek növekvő sorrendben:" << endl; for(int i=0;i<19;i++) { for(int j=i+1;j<20;j++) { if(aminosav[i].rm>aminosav[j].rm) swap(aminosav[i], aminosav[j]); } } for(int i=0;i<20;i++) { cout << aminosav[i].r << " " << aminosav[i].rm << endl; ki << aminosav[i].r << " " << aminosav[i].rm << endl; } ki.close(); }

44

Programozási feladatok megoldása void F4() { ofstream ki; ki.open("eredmeny.txt", fstream::app); ifstream be; be.open("bsa.txt"); int i=0, index; int c_db=0, h_db=0, o_db=0, n_db=0, s_db=0; while(!be.eof()) { be >> BSA[i]; index=0; //keressük meg a lánc adott betűjét az aminosavak között!! while(BSA[i]!=aminosav[index].b) index++; //BIZTOSAN MEGFOGJUK TALÁLNI! c_db+=aminosav[index].c; h_db+=aminosav[index].h; o_db+=aminosav[index].o; n_db+=aminosav[index].n; s_db+=aminosav[index].s; i++; } bsa_lh=i-1; cout << "BSA lánc hossza: " << bsa_lh << endl; o_db=o_db-bsa_lh; //H2O kivonása h_db=h_db-2*bsa_lh; cout << "C " << c_db << " H " << h_db << " O " << o_db << " N " << n_db << " S " << s_db << endl; ki << "C " << c_db << " H " << h_db << " O " << o_db << " N " << n_db << " S " << s_db << endl; be.close(); ki.close(); }

45

Programozási feladatok megoldása void F5() { ofstream ki; ki.open("eredmeny.txt", fstream::app); int darabhossz=0, kezdete, vege, maxhossz=0; for(int i=0;i
46

Programozási feladatok megoldása int main() { setlocale(LC_ALL, "hun"); kiir(1); F1(); kiir(2); F2(); kiir(3); F3(); kiir(4); F4(); kiir(5); F5(); kiir(6); F6(); return 0; }

47

2006. OKTÓBER EMELT ZENEI ADÓK


FELADAT SZÖVEGE A rádióhallgatás ma már egyre inkább zene vagy hírek hallgatására korlátozódik. Ez a feladat három, folyamatosan zenét sugárzó adóról szól, azok egyetlen napi műsorát feldolgozva. A reklám elkerülése érdekében az adókat nevük helyett egyetlen számmal azonosítottuk. A musor.txt állomány első sorában az olvasható, hogy hány zeneszám (z<=1000) szólt aznap a rádiókban, majd ezt z darab sor követi. Minden sor négy, egymástól egyetlen szóközzel elválasztott adatot tartalmaz: a rádió sorszámát, amit a szám hossza követ két egész szám (perc és másodperc) formában, majd a játszott szám azonosítója szerepel, ami a szám előadójából és címéből áll. A rádió sorszáma az 1, 2, 3 számok egyike. Az adás minden adón 0 óra 0 perckor kezdődik. Egyik szám sem hosszabb 30 percnél, tehát a perc értéke legfeljebb 30, a másodperc pedig legfeljebb 59 lehet. A szám azonosítója legfeljebb 50 karakter hosszú, benne legfeljebb egy kettőspont szerepel, ami az előadó és a cím között található. A számok az elhangzás sorrendjében szerepelnek az állományban, tehát a később kezdődő szám későbbi sorban található. Az állományban minden zeneszám legfeljebb egyszer szerepel. Például: 677 1 5 3 Deep Purple:Bad Attitude 2 3 36 Eric Clapton:Terraplane Blues 3 2 46 Eric Clapton:Crazy Country Hop 3 3 25 Omega:Ablakok … Készítsen programot zene néven, amely az alábbi kérdésekre válaszol! Ügyeljen arra, hogy a program forráskódját a megadott helyre mentse! A képernyőre írást igénylő részfeladatok eredményének megjelenítése előtt írja a képerny őre a feladat sorszámát (például: 3. feladat:). Ha a billentyűzetről olvas be adatot, jelenítse meg a képernyőn, hogy milyen értéket vár. Az adatszerkezet készítése során vegye figyelembe az Ön által használt programozási környezetben az adatok tárfoglalási igényét! 1. Olvassa be a musor.txt állományban talált adatokat, s annak felhasználásával oldja meg a következő feladatokat! Ha az állományt nem tudja beolvasni, akkor a forrás első 10 sorának adatait jegyezze be a programba, s úgy oldja meg a következő feladatokat! 2. Írja a képernyőre, hogy melyik csatornán hány számot lehetett meghallgatni! 3. Adja meg, mennyi idő telt el az első Eric Clapton szám kezdete és az utolsó Eric Clapton szám vége között az 1. adón! Az eredményt óra:perc:másodperc formában írja a képernyőre! 4. Amikor az „Omega:Legenda” című száma elkezdődött, Eszter rögtön csatornát váltott. Írja a képernyőre, hogy a szám melyik adón volt hallható, és azt, hogy a másik két adón milyen számok szóltak ekkor. Mivel a számok a kezdés időpontja szerint növekvő sorrendben vannak, így a másik két adón már elkezdődött a számok lejátszása. Feltételezheti, hogy a másik két adón volt még adás.

49

Programozási feladatok megoldása 5. Az egyik rádióműsorban sms-ben, telefonon, de akár képeslapon is kérhető szám. Ám a sokszor csak odafirkált kéréseket olykor nehéz kibetűzni. Előfordul, hogy csak ennyi olvasható: „gaoaf”, tehát ezek a betűk biztosan szerepelnek, mégpedig pontosan ebben a sorrendben. Annyi biztos, hogy először a szerző neve szerepel, majd utána a szám címe. Olvassa be a billentyűzetről a felismert karaktereket, majd írja a keres.txt állományba azokat a számokat, amelyek ennek a feltételnek megfelelnek. Az állomány első sorába a beolvasott karaktersorozat, majd utána soronként egy zeneszám azonosítója kerüljön! A feladat megoldása során ne különböztesse meg a kis- és a nagybetűket! 6. Az 1. adón változik a műsor szerkezete: minden számot egy rövid, egyperces bevezető előz majd meg, és műsorkezdéstől minden egész órakor 3 perces híreket mondanak. Természetesen minden szám egy részletben hangzik el továbbra is, közvetlenül a bevezető perc után. Így ha egy szám nem fejeződne be a hírekig, el sem kezdik, az üres időt a műsorvezető tölti ki. Írja a képernyőre óra:perc:másodperc formában, hogy mikor lenne vége az adásnak az új műsorszerkezetben! FONTOSABB VÁLTOZÓK ADAT NEVE

TÍPUSA

FELÉPÍTÉSE

SZEREPE

FELHASZNÁLÁS

adat[1000]

zene típusú 1000 elemű tömb, minden eleme egy adat-ötöst tartalmaz

struktúra 5 adatmezővel: r –rádió sorszáma (int) p – perc (int) mp – másodperc (int) eloado – (előadó neve (string) cim – dal címe (string)


globális

N

int

Az előadó és dalcím szöveget szétbontjuk az első (F1) feladatban musor.txt első sorában található szám, a zeneszámok száma

globális

50

Programozási feladatok megoldása PROGRAMKÓD #include #include #include <windows.h> #include <string> using namespace std; struct zene { int r, p, mp; //r - rádió sorszáma, p - perc <=30, mp - másodperc<=59 string eloado, cim; } adat[1000]; int N; //zeneszámok száma void kiir(int ssz) { cout << "-----------------------------" << endl; cout << ssz << ". feladat" << endl; cout << "-----------------------------" << endl; } void szamoldki(int x) { int ora, perc, mp, m; ora=x/3600; m=x%3600; perc=m/60; mp=m%60; //6. feladat miatt kell ez az if-es játék if(ora==0) cout << perc << ":" << mp << endl; else cout << ora << ":" << perc << ":" << mp << endl; } void F1() { ifstream be; be.open("musor.txt"); be >> N; for(int i=0;i> adat[i].r; be >> adat[i].p; be >> adat[i].mp; getline(be, adat[i].eloado,':'); getline(be, adat[i].cim); //LEVESSZÜK AZ ELŐADÓ NEVE ELŐTTI FELESLEGES SZÓKÖZT!! adat[i].eloado.erase(0,1); //0. karaktertől 1 karakter törlése } be.close(); }

51

Programozási feladatok megoldása void F2() { int db1=0, db2=0, db3=0; for(int i=0;i=0&&!(adat[i].r==1&&adat[i].eloado=="Eric Clapton")) { i--; } if(i>=0) utolso=i; else utolso=-1; /* Ez könnyen lehet, hogy felesleges, mert feltételezhetjük, hogy van legalább 2 Eric Clapton szám az 1-es rádión!! */ int masodperc=0; if(elso!=-1&&utolso!=-1) { for(int i=elso;i
52

Programozási feladatok megoldása void F4() { // Megkeressük az Omega-számot és az előtte lévő másik adók számai kellenek string aktualis_e[3]={"", "", ""}; string aktualis_c[3]={"", "", ""}; int i=0; int omega; while(i> reszlet; ki << reszlet << endl; int egyezes; //ebben nezzük hány betű egyezik a reszletből az aktuális műsorszám betűivel for(int i=0;i
53

Programozási feladatok megoldása void F6() { int ujido=180; //Feltéve, hogy 3 perces hírműsorral indulnak int dalhossz, ora=0; for(int i=0;i3600) //Túllépné az egész órát { //Ha túllépnénk az egész órát, akkor //180 mp hírek és utána játszák le a dalt ujido=180+dalhossz; //És így egy újabb óra eltelt ora++; } else { //a fenti miatt az ujidoben csak az egész óra utáni másodpercek lesznek ujido+=dalhossz; } } } cout << ora << ":"; szamoldki(ujido); } int main() { setlocale(LC_ALL, "hun"); kiir(1); F1(); kiir(2); F2(); kiir(3); F3(); kiir(4); F4(); kiir(5); F5(); kiir(6); F6(); return 0; }

54

2007. MÁJUS EMELT SMS SZAVAK


FELADAT SZÖVEGE Napjainkban a kommunikáció egy elterjedt formája az SMS-küldés. Az SMS-küldésre alkalmas telefonok prediktív szövegbevitellel segítik az üzenetek megírását. Ennek használatakor a szavakat úgy tudjuk beírni, hogy a telefon számbillentyűjén található betűknek megfelelő számokat kell beírnunk. A számok és betűk megfeleltetését az alábbi táblázat mutatja:

Ha meg szeretnénk jeleníteni az „ablak” szót, akkor a 22525 kódot kell beírnunk. A telefon a tárolt szótára alapján a kódhoz kikeresi a megfelelő szót. Ha több szóhoz is azonos kód tartozik, akkor a kódhoz tartozó összes szót felkínálja választásra. Egy ilyen szógyűjteményt talál a szavak.txt fájlban. A fájlról a következőket tudjuk: • Legfeljebb 600 szó található benne. • Minden szó külön sorban található. • A szavak hossza maximum 15 karakter. • A szavak mindegyike csak az angol ábécé kisbetűit tartalmazza. • Minden szó legfeljebb egyszer szerepel. Írjon sms néven programot, ami a szógyűjtemény felhasználásával megoldja az alábbi feladatokat! 1. Kérjen be a felhasználótól egy betűt, és adja meg, hogy milyen kód (szám) tartozik hozzá! Az eredményt írassa a képernyőre! 2. Kérjen be a felhasználótól egy szót, és határozza meg, hogy milyen számsorral lehet ezt a telefonba bevinni! Az eredményt írassa a képernyőre! 3. Olvassa be a szavak.txt fájlból a szavakat, és a továbbiakban azokkal dolgozzon! Ha nem tudja az állományból beolvasni az adatokat, akkor az állományban található „b” kezdőbetűs szavakat gépelje be a programba, és azokkal oldja meg a feladatokat! 4. Határozza meg és írassa a képernyőre, hogy melyik a leghosszabb tárolt szó! Amennyiben több azonos hosszúságú van, elegendő csak az egyiket megjeleníteni. Adja meg ennek a szónak a hosszát is! 5. Határozza meg és írassa a képernyőre, hogy hány rövid szó található a fájlban! Rövid szónak tekintjük a legfeljebb 5 karakterből álló szavakat. 6. Írassa a kodok.txt állományba a szavak.txt fájlban található szavaknak megfelelő számkódokat! Minden szónak feleljen meg egy számkód, és minden számkód külön sorba kerüljön! 7. Kérjen be a felhasználótól egy számsort, és határozza meg, hogy melyik szó tartozhat hozzá! Amennyiben több szó is megfelelő, akkor mindegyiket írassa ki! (Teszteléshez használhatja például a 225 számsort, mivel ehhez egynél több szó tartozik a szógyűjteményben.) 8. Határozza meg, hogy a szógyűjteményben mely kódokhoz tartozik több szó is! Írassa ki a képernyőre ezeket a szavakat a kódjukkal együtt egymás mellé az alábbi mintának megfelelően (a szavak sorrendje ettől eltérhet): baj : 225; bal : 225; arc : 272; apa : 272; eb : 32; fa : 32; dal : 325; fal : 3 25; eltesz : 358379; elvesz : 358379; fojt : 3658; folt : 3658; ...

56

Programozási feladatok megoldása 9. Határozza meg, hogy melyik kódnak megfelelő szóból van a legtöbb! Írassa ki a képernyőre a kódot, és a kódhoz tartozó összes tárolt szót! Ha több kódhoz is azonos számú szó tartozik, akkor elegendő ezen kódok közül csak az egyikkel foglalkozni. FONTOSABB VÁLTOZÓK ADAT NEVE

TÍPUSA

FELÉPÍTÉSE

SZEREPE

FELHASZNÁLÁS

szavak[600]

string string

N

int

A fájlban található szavak tárolása minden szóhoz egy kódszó tartozik, szintén stringként kezelhetjük, mivel számolni nem kell vele A fájlban található szavak száma

globális

kodok[600]

600 elemű tömb 600 elemű tömb

melyik

int

A 8. és 9. feladatban használjuk. A legtöbb szóval rendelkező kód indexe a kodok tömbben

globális

globális

globális

57

Programozási feladatok megoldása PROGRAMKÓD #include #include #include <windows.h> #include <string> using namespace std; string szavak[600]; string kodok[600]; int N; //beolvasott szavak száma int melyik; //8. és 9. feladathoz, a leggyakoribb kód indexe void kiir(int ssz) { cout << "___________________________________________________" << endl; cout << ssz << ". feladat" << endl; cout << "---------------------------------------------------" << endl; } char kodolas(char betu) { char kod; betu=tolower(betu);

//karakter kisbetűsre állítása, párja: toupper

if(betu=='a'||betu=='b'||betu=='c') kod='2'; if(betu=='d'||betu=='e'||betu=='f') kod='3'; if(betu=='g'||betu=='h'||betu=='i') kod='4'; if(betu=='j'||betu=='k'||betu=='l') kod='5'; if(betu=='m'||betu=='n'||betu=='o') kod='6'; if(betu=='p'||betu=='q'||betu=='r'||betu=='s') kod='7'; if(betu=='t'||betu=='u'||betu=='v') kod='8'; if(betu=='w'||betu=='x'||betu=='y'||betu=='z') kod='9'; return kod; } string szokodolas(string szo) { string s=""; for(int i=0;i<szo.length();i++) { s=s+kodolas(szo[i]); } return s; }

58

Programozási feladatok megoldása void F1() { char betu; cout << "Kérek egy betűt: "; cin >> betu; cout << "A(z) '" << betu << "' betű kódja: " << kodolas(betu) << endl; } void F2() { string szo; cout << "Kérek egy szót: "; cin >> szo; cout << "Kódolása: "; for(int i=0;i<szo.length();i++) { cout << kodolas(szo[i]); } cout << endl; } void F3() { ifstream be; be.open("szavak.txt"); int i=0; while(!be.eof()) { be >> szavak[i]; i++; } N=i; be.close(); cout << "Beolvasott szavak száma: " << N << endl; } void F4() { int melyik=0; // melyik - a leghosszabb szó indexe lesz for(int i=1;iszavak[melyik].length()) melyik=i; } cout << "A leghosszabb szó: '" << szavak[melyik] << "', hossza: " << szavak[melyik].length() << endl; }

59

Programozási feladatok megoldása void F5() { int h=5; int rovid_db=0; for(int i=0;i> kodszo; bool volt=false; for(int i=0;i
60

Programozási feladatok megoldása void F8() { //Rendezéssel oldjuk meg, és 9. feladatot is előkészítjük int max=0; for(int i=0;ikodok[j]) { swap(kodok[i],kodok[j]); swap(szavak[i],szavak[j]); } } } bool van_meg;

//Ha lesz egy szónak minimum egy párja, akkor ez igaz lesz

for(int i=0;imax) { melyik=i; max=darab; } } cout << endl; } void F9() { cout << "Leggyakoribb kód: " << kodok[melyik] << endl; cout << "A kódhoz tartozó szavak:" << endl; for(int i=0;i
Programozási feladatok megoldása int main() { setlocale(LC_ALL, "hun"); kiir(1); F1(); kiir(2); F2(); kiir(3); F3(); kiir(4); F4(); kiir(5); F5(); kiir(6); F6(); kiir(7); F7(); kiir(8); F8(); kiir(9); F9(); return 0; }

62

2007. OKTÓBER EMELT FOCI


FELADAT SZÖVEGE Perec város sportéletében fontos szerepet játszanak a fiatalok nagypályás labdarúgó mérkőzései. Tavasszal minden csapat minden csapattal pontosan egy mérkőzést játszott. A folyamatosan vezetett eredménylista azonban eltűnt, így csak a mérkőzések jegyzőkönyvei álltak rendelkezésre. A jegyzőkönyveket ismételten feldolgozták, ehhez első lépésként a meccs.txt állományba bejegyeztek néhány adatot. Önnek ezzel az állománnyal kell dolgoznia. A meccs.txt állomány első sorában az állományban tárolt mérkőzések száma található. Alatta minden sorban egy-egy mérkőzés adatai olvashatók. Egy mérkőzést 7 adat ír le. Az első megadja, hogy a mérkőzést melyik fordulóban játszották le. A második a hazai, a harmadik a vendégcsapat góljainak száma a mérkőzés végén, a negyedik és ötödik a félidőben elért gólokat jelöli. A hatodik szöveg a hazai csapat neve, a hetedik a vendégcsapat neve. Az egyes adatokat egyetlen szóköz választja el egymástól. A sor végén nincs szóköz. A csapatok és a fordulók száma nem haladja meg a 20, a mérkőzések száma pedig a 400 értéket. Egy csapat sem rúgott meccsenként 9 gólnál többet. A csapatok neve legfeljebb 20 karakter hosszú, a névben nincs szóköz. Például: 112 14 1 2 0 2 Agarak Ovatosak 5 4 0 1 0 Erosek Agarak 4 0 2 0 2 Ijedtek Hevesek 8 1 1 0 0 Ijedtek Nyulak 8 3 2 3 1 Lelkesek Bogarak 13 0 1 0 1 Fineszesek Csikosak 2 1 0 0 0 Pechesek Csikosak 1 4 0 2 0 Csikosak Kedvesek 9 2 0 0 0 Nyulak Lelkesek 6 0 2 0 0 Ovatosak Nyulak Az 2. sor mutatja, hogy a 14. fordulóban az otthon játszó Agarakat az Óvatosak 2-1-re megverték úgy, hogy a félidőben már vezettek 2-0-ra. Készítsen programot, amely az alábbi kérdésekre válaszol! A program forráskódját mentse foci néven! (A program megírásakor a felhasználó által megadott adatok helyességét, érvényességét nem kell ellenőriznie.) A képernyőre írást igénylő részfeladatok eredményének megjelenítése előtt írja a képernyőre a feladat sorszámát (például: 3. feladat:). Ha a felhasználótól kér be adatot, jelenítse meg a képernyőn, hogy milyen értéket vár! 1. Olvassa be a meccs.txt állományban talált adatokat, s annak felhasználásával oldja meg a következő feladatokat! Ha az állományt nem tudja beolvasni, az első 10 mérkőzés adatait jegyezze be a programba és dolgozzon azzal! 2. Kérje be a felhasználótól egy forduló számát, majd írja a képernyőre a bekért forduló mérkőzéseinek adatait a következő formában: Edes-Savanyu: 2-0 (1-0)! Soronként egy mérkőzést tüntessen fel! A különböző sorokban a csapatnevek ugyanazon a pozíción kezdődjenek! Például: Edes-Savanyu: 2-0 (1-0) Ijedtek-Hevesek: 0-2 (0-2) ...

64

Programozási feladatok megoldása 3. Határozza meg, hogy a bajnokság során mely csapatoknak sikerült megfordítaniuk az állást a második félidőben! Ez azt jelenti, hogy a csapat az első félidőben vesztésre állt ugyan, de sikerült a mérkőzést megnyernie. A képernyőn soronként tüntesse fel a forduló sorszámát és a győztes csapat nevét! 4. Kérje be a felhasználótól egy csapat nevét, és tárolja el! A következő két feladat megoldásához ezt a csapatnevet használja! Ha nem tudta beolvasni, használja a Lelkesek csapatnevet! 5. Határozza meg, majd írja ki, hogy az adott csapat összesen hány gólt lőtt és hány gólt kapott! Például: lőtt: 23 kapott: 12 6. Határozza meg, hogy az adott csapat otthon melyik fordulóban kapott ki először és melyik csapattól! Ha egyszer sem kapott ki (ilyen csapat például a Bogarak), akkor „A csapat otthon veretlen maradt.” szöveget írja a képernyőre! 7. Készítsen statisztikát, amely megadja, hogy az egyes végeredmények hány alkalommal fordultak elő! Tekintse egyezőnek a fordított eredményeket (például 4-2 és 2-4)! A nagyobb számot mindig előre írja! Az elkészült listát a stat.txt állományban helyezze el! Például: 2-1: 18 darab 4-0: 2 darab 2-0: 19 darab ... FONTOSABB VÁLTOZÓK ADAT NEVE

TÍPUSA

FELÉPÍTÉSE

SZEREPE

FELHASZNÁLÁS

t[400]

merkozes típusú 400 elemű tömb, minden eleme egy adathetest tartalmaz

struktúra 7 adatmezővel: f – forduló sorszáma hg – hazai lőtt gólok száma vg – vendég gólok száma fhg – félidei hazai gólok fvg – félidei vendég gólok h – hazai csapat v - vendégcsapat


globális

N csn

int string

e[10][10]

int

10x10-es mátrix

mérkőzések száma globális csapatnév a 4. és 5. felglobális adathoz a különböző lehetséges globális eredmények számolásához kell. Az indexei az egyes eredményeket „képviselik”. Pl.: e[2][1] 21-es eredmények gyűjtője

65

Programozási feladatok megoldása PROGRAMKÓD #include #include #include <string> #include <windows.h> using namespace std; //a meccs.txt 1-1 sora struct merkozes { int f, hg, vg, fhg, fvg; string h, v; } t[400]; int N; //mérközések száma string csn; void kiir(int s) { cout << "......................." << endl; cout << s << ". feladat" << endl; cout << "......................." << endl; } void F1() { ifstream meccs; meccs.open("meccs.txt"); meccs >> N; for(int i=0;i> t[i].f; meccs >> t[i].hg; meccs >> t[i].vg; meccs >> t[i].fhg; meccs >> t[i].fvg; meccs >> t[i].h; meccs >> t[i].v; cout << t[i].f << " " << t[i].hg << " " << t[i].vg << " " << t[i].fhg << " " << t[i].fvg << " " << t[i].h << " " << t[i].v << endl; } meccs.close(); }

66

Programozási feladatok megoldása void F2() { int fs; cout << "Forduló sorszáma: "; cin >> fs; for(int i=0;it[i].vg) { cout << t[i].f << " " << t[i].h << endl; } if(t[i].fhg>t[i].fvg&&t[i].hg> csn; } void F5() { int lg=0; //összes lőtt gól int kg=0; //összes kapott gólja for(int i=0;i

void F6() { for(int i=0;it[j].f) swap(t[i],t[j]); } } /* for(int i=0;i
}

68

Programozási feladatok megoldása void F7() { int e[10][10]; for(int i=0;i<10;i++) for(int j=0;j<10;j++) e[i][j]=0;

int s,o; for(int i=0;it[i].vg) { s=t[i].hg; o=t[i].vg; } else { s=t[i].vg;o=t[i].hg; } e[s][o]++; } //Kiírjuk az eredményt for(int i=0;i<10;i++) for(int j=0;j<10;j++) { if(e[i][j]>0) { cout << i << "-" << j << ": " << e[i][j] << " db" << endl; } } } int main() { setlocale(LC_ALL, "hun"); kiir(1); F1(); kiir(2); F2(); kiir(3); F3(); kiir(4); F4(); kiir(5); F5(); kiir(6); F6(); kiir(7); F7(); return 0; } 69

2008. MÁJUS EMELT SMS


FELADAT SZÖVEGE Esemes Ernő szenvedélyes SMS-küldő, ezért a MaMobil nevű cég tesztelésre kérte fel. Ehhez egy új, kézreálló telefont adnak, amelynek tesztüzemben egyetlen hátránya, hogy legfeljebb az először érkező 10 darab, egyenként legfeljebb 100 karakteres üzenetet tud eltárolni. Ha ettől több üzenet van, akkor azokat korlátlan számban a szolgáltató őrzi meg a hangpostához hasonlóan, tehát azokhoz csak bizonyos díj fejében juthat hozzá. Az üzenetek nem tartalmazhatnak ékezetes karaktereket. Az sms.txt állomány első sorában az a k szám olvasható, amely megadja, hogy hány üzenet érkezett a készülékre a mai napon. Az érkező üzenetek száma legalább egy, de nem haladja meg a 100 darabot. Minden üzenethez 2 sor tartozik. Az első sor szerkezete a következő: először az érkezés órája (szám), érkezés perce (szám), telefonszám (pontosan 9 jegyű szám), a másodikban pedig az üzenet (legfeljebb 100 karakternyi szöveg) található. Az állományban az üzenetek számát követően k×2 sor szerepel. Az üzenetek érkezési idő szerint növekvően rendezettek. Például: 30 9 11 123456789 Szia, mikor jossz? 9 13 434324223 Nem kerek ebedet! 9 14 434324223 Hova menjek erted? 9 20 123456789 Hozd el a mintas pulcsimat! 9 21 434324223 Nyertünk a palyazaton! … Készítsen programot sms néven, amely az alábbi kérdésekre válaszol! Ügyeljen arra, hogy a program forráskódját a megadott helyre mentse! A képernyőre írást igénylő részfeladatok eredményének megjelenítése előtt írja a képernyőre a feladat sorszámát! (Például 3. feladat: ) 1. Olvassa be az sms.txt állományban talált adatokat, s annak felhasználásával oldja meg a következő feladatokat! Ha az állományt nem tudja beolvasni, akkor a benne található adatok közül az első tíz üzenet adatait jegyezze be a programba, s úgy oldja meg a feladatokat! 2. A fájlban tárolt utolsó üzenet érkezésekor melyik üzenet a legfrissebb a telefon memóriájában? Írja az üzenet szövegét a képernyőre! 3. Adja meg a leghosszabb és a legrövidebb üzenetek adatait! Ha több azonos hosszúságú üzenet van, akkor elegendő csak egyet-egyet megadnia! A képernyőn óra, perc, telefonszám, üzenet formában jelenítse meg az adatokat! 4. Készítsen karakterhossz szerinti statisztikát: 1-20, 21-40, 41-60, 61-80, 81-100! Az intervallumok mellé a hozzájuk tartozó üzenetek darabszámát írja, mint eredményt a képernyőre! 5. Ha Ernő minden óra 0. percében elolvasná a memóriában lévő üzeneteket (az éppen ekkor érkező üzeneteket nem látja), majd ki is törölné, akkor hány olyan üzenet lenne, amelynek elolvasásához fel kellene hívnia a szolgáltatót? Írja ezt a számot a képernyőre! (Az üzeneteket először 1, utoljára 24 órakor olvassa el.) 6. Ernő barátnője gyakran küld sms-t az 123456789-es számról. Mennyi volt a leghosszabb idő, amennyi eltelt két üzenete között? Ha legfeljebb 1 üzenet érkezett tőle, akkor írja ki, hogy „nincs elegendő üzenet”, egyébként pedig adja meg a leghosszabb időtartamot óra perc alakban!

71

Programozási feladatok megoldása 7. Egy üzenet véletlenül késett. Olvassa be a billentyűzetről ennek az sms-nek az adatait, majd tárolja el a memóriában a többihez hasonlóan! 8. Az smski.txt állományban készítsen egy listát az üzenetekről telefonszám szerinti csoportosításban, telefonszám szerint növekvő sorrendben! Egy csoporthoz tartozó első sorban a feladó telefonszáma szerepeljen! Az alatta lévő sorokban a feladás ideje, majd a tőle újabb szóközzel elválasztva az üzenet szövege szerepeljen! FONTOSABB VÁLTOZÓK ADAT NEVE

TÍPUSA

FELÉPÍTÉSE

SZEREPE

FELHASZNÁLÁS

sms[100]

uzenet típusú 100 elemű tömb, minden eleme egy adatnégyest tartalmaz

struktúra 4 adatmezővel: o – üzenet érkezési óra p – üzenet érkezési perc tsz – telefonszám uzenet – uzenet szövege


globális

max

konstans

Értéke 10. A memóriában tárolható maximális üzenetszám

globális

k

int

Beérkezett üzenetek száma, a fájl első sora

globális

stat[5]

int típusú 5 elemű tömb

A 4. feladatban használjuk az egyes karakterhossz intervallumok összesítéséhez (5 intervallum van)

lokális

o[24]


Az 5. feladatban használjuk. Minden órára összesítjük, hogy mennyi üzenet van a szolgáltató központjában

lokális

72

Programozási feladatok megoldása PROGRAMKÓD #include #include #include <string> #include <windows.h> #define max 10 using namespace std; struct uzenet { int o, p; string tsz; string uzenet; } sms[100]; int k; //fájlban lévő üzenetek száma void kiir(int ssz) { cout << "___________________________________________________" << endl; cout << ssz << ". feladat" << endl; cout << "---------------------------------------------------" << endl; } int szamol(int x, int y) { //Percekre számoljuk át az időket int e=sms[x].o*60+sms[x].p; int v=sms[y].o*60+sms[y].p; return v-e; } void eredmeny(int x) { //Percekről óra és perc „visszaszámolása” int h, m; h=x/60; m=x%60; cout << h << " óra " << m << " perc"; }

73

Programozási feladatok megoldása void F1() { cout << "Adatok beolvasása..." << endl; ifstream be; be.open("sms.txt"); be >> k; cout << "Üzenetek száma: " << k << endl; cout << "Az üzenetek:" << endl; for(int i=0;i> sms[i].o; be >> sms[i].p; getline(be,sms[i].tsz); getline(be,sms[i].uzenet); cout << sms[i].o << " " << sms[i].p << " " << sms[i].tsz << endl; cout << sms[i].uzenet << endl; } be.close(); } void F2() { cout << "Legfrissebb üzenet a telefonban:" << endl; //Megnézzük, hogy 10-nél több vagy kevesebb üzenet érkezett-e? if(k<max) { cout << sms[k-1].uzenet; //-1 az indexek miatt } else { cout << sms[max-1].uzenet; //-1 az indexek miatt } cout << endl; } void F3() { int maxi=0, mini=0; for(int i=0;isms[maxi].uzenet.length()) maxi=i; if(sms[i].uzenet.length()<sms[mini].uzenet.length()) mini=i; } cout << "Leghosszabb üzenet adatai:" << endl; cout << sms[maxi].o << " " << sms[maxi].p << " " << sms[maxi].tsz << endl; cout << sms[maxi].uzenet << endl; cout << "Legrövidebb üzenet adatai:" << endl; cout << sms[mini].o << " " << sms[mini].p << " " << sms[mini].tsz << endl; cout << sms[mini].uzenet << endl; }

74

Programozási feladatok megoldása void F4() { //1-20 21-40 41-60 61-80 81-100 int stat[5]={0,0,0,0,0}; for(int i=0;i20&&sms[i].uzenet.length()<41) stat[1]++; if(sms[i].uzenet.length()>40&&sms[i].uzenet.length()<61) stat[2]++; if(sms[i].uzenet.length()>60&&sms[i].uzenet.length()<81) stat[3]++; if(sms[i].uzenet.length()>80) stat[4]++; } cout << "Statisztika:" << endl; //20-asával "mennek" az intervallumok, ezt kihasználhatjuk a kiírásban for(int i=0;i<5;i++) { cout << (i%20)*20+1 << " - " << (i%20)*20+20 << ": " << stat[i] << endl; } } void F5() { int o[24]; for(int i=0;i<24;i++) o[i]=0; //Számoljuk meg, hogy az egyes órákban hány üzenet van! for(int i=0;imax) szolg+=(o[i]-max); cout << i+1 << " órában " << szolg << " üzenet van a szolgáltatónál" << endl; } cout << endl; cout << "A nap végén " << szolg << " üzenet van a szolgáltatónál" << endl; }

75

Programozási feladatok megoldása void F6() { string b_tsz=" 123456789"; /* szóköz az elején, mert a getline a szóközt is beovasta a telefonszám előtt */ //keressük meg az első üzenetet ezzel a telefonszámmal int i=0, maxi=0, ido, elozo, kovetkezo; bool volt=false; while(imaxi) maxi=ido; elozo=kovetkezo; } } if(maxi>0) volt=true; } if(volt) { cout << "Két üzenet közt eltelt leghosszabb idő: "; eredmeny(maxi); } else cout << "Nincs elegendő üzenet!"; cout << endl; }

76

Programozási feladatok megoldása void F7() { //Ezt a feladatot nem is értem!!!??? int index=k;

//indexek -1-es elcsűszása miatt pont k lesz az új üzenet indexe

cout << "Kérem, adja meg az üzenet adatait:" << endl; cout << "Óra: "; cin >> sms[k].o; cout << "Perc: "; cin >> sms[k].p; cout << "Telefonszám: "; cin >> sms[k].tsz; sms[k].tsz=" "+sms[k].tsz; string puffer; //kell egy üres getline, hogy az előző adatbevitel után //üres legyen a billentyűzetpuffer getline(cin, puffer); cout << "Üzenet: "; getline(cin, sms[k].uzenet); k++; //Mert azért 1-gyel több üzenetünk lett!!! } void F8() { cout << "Adatok kiírása..." << endl; //rendezzük az adatokat telefonszám szerint for(int i=0;isms[j].tsz) swap(sms[i],sms[j]); } } ofstream ki; ki.open("smski.txt"); string elozo=""; for(int i=0;i
77

Programozási feladatok megoldása int main() { setlocale(LC_ALL, "hun"); kiir(1); F1(); kiir(2); F2(); kiir(3); F3(); kiir(4); F4(); kiir(5); F5(); kiir(6); F6(); kiir(7); F7(); kiir(8); F8(); return 0; }

78

2008. OKTÓBER EMELT ROBOT


FELADAT SZÖVEGE Gáborék iskolai szakkörön robotot építenek. Már elkészítettek egy olyan változatot, amelyik sík terepen kellő pontossággal vezérelhető. A robot a memóriájába előre betáplált programok egyikét hajtja végre. A robot jelenleg csak az E, K, D, N utasításokat érti, amelyek a négy égtáj (sorrendben: észak, kelet, dél, nyugat) irányában tett 1 centiméteres elmozdulást eredményezik. A robotba táplált programokat a program.txt állományban rögzítettük. Az állomány első sorában a betáplált programok száma található, amely legfeljebb 100. Alatta soronként egy-egy program olvasható. Egy sor legfeljebb 200 karakter hosszúságú, benne az E, K, D, N karakterek mint utasítások találhatók. A sorok nem tartalmaznak szóközt. Például: program.txt 12 ENNNDKENDND ENNDDDDENDENDEEDDNNKED ... A 2. sorban az első betáplált program utasításai vannak. Készítsen programot, amely az alábbi kérdésekre válaszol! A program forráskódját robot néven mentse! Minden részfeladat megoldása előtt írja a képernyőre a feladat sorszámát! Ha a felhasználótól kér be adatot, jelenítse meg a képernyőn, hogy milyen értéket vár (például 2. feladat: Kérem az utasítássor sorszámát!)! 1. Olvassa be a program.txt állományban talált adatokat, s azok felhasználásával oldja meg a következő feladatokat! Ha az állományt nem tudja beolvasni, az állomány első 10 sorának adatait jegyezze be a programba és dolgozzon azzal! 2. Kérje be egy utasítássor számát, majd írja a képernyőre, hogy: a. Egyszerűsíthető-e az utasítássorozat! Az egyszerűsíthető, illetve nem egyszerűsíthető választ írja a képernyőre! (Egy utasítássort egyszerűsíthetőnek nevezünk, ha van benne két szomszédos, ellentétes irányt kifejező utasításpár, hiszen ezek a párok elhagyhatók. Ilyen ellentétes utasításpár az ED, DE, KN, NK.) b. Az utasítássor végrehajtását követően legkevesebb mennyi E vagy D és K vagy N utasítással lehetne a robotot a kiindulási pontba visszajuttatni! A választ a következő formában jelenítse meg: 3 lépést kell tenni az ED, 4 lépést a KN tengely mentén. c. Annak végrehajtása során hányadik lépést követően került (légvonalban) legtávolabb a robot a kiindulási ponttól és mekkora volt ez a távolság! A távolságot a lépés sorszámát követően 3 tizedes pontossággal írja a képernyőre! 3. A robot a mozgáshoz szükséges energiát egy beépített akkuból nyeri. A robot 1 centiméternyi távolság megtételéhez 1 egység, az irányváltásokhoz és az induláshoz 2 egység energiát használ. Ennek alapján az EKK utasítássor végrehajtásához 7 egység energia szükséges. A szakkörön használt teljesen feltöltött kis kapacitású akkuból 100, a nagykapacitásúból 1000 egységnyi energia nyerhető ki. Adja meg azon utasítássorokat, amelyek végrehajtásához a teljesen feltöltött kis kapacitású akku is elegendő! Írja a képernyőre egymástól szóközzel elválasztva az utasítássor sorszámát és a szükséges energia mennyiségét! Minden érintett utasítássor külön sorba kerüljön! 4. Gáborék továbbfejlesztették az utasításokat értelmező programot. Az új, jelenleg még tesztelés alatt álló változatban a több, változatlan irányban tett elmozdulást helyettesítjük az adott irányban tett

80

Programozási feladatok megoldása elmozdulások számával és az irány betűjével. Tehát például a DDDKDD utasítássor leírható rövidített 3DK2D formában is. Az önállóan álló utasításnál az 1-es számot nem szabad kiírni! Hozza létre az ujprog.txt állományt, amely a program.txt állományban foglalt utasítássorozatokat az új formára alakítja úgy, hogy az egymást követő azonos utasításokat minden esetben a rövidített alakra cseréli! Az ujprog.txt állományba soronként egy utasítássor kerüljön, a sorok ne tartalmazzanak szóközt! 5. Sajnos a tesztek rámutattak arra, hogy a program új verziója még nem tökéletes, ezért vissza kell térni az utasítássorok leírásának régebbi változatához. Mivel a szakkörösök nagyon bíztak az új változatban, ezért néhány utasítássort már csak ennek megfelelően készítettek el. Segítsen ezeket visszaírni az eredeti formára! Az ismétlődések száma legfeljebb 200 lehet! Kérjen be egy új formátumú utasítássort, majd írja a képernyőre régi formában!

FONTOSABB VÁLTOZÓK ADAT NEVE

TÍPUSA

FELÉPÍTÉSE

SZEREPE

FELHASZNÁLÁS

sor[100][200]

char

100x200-as karakter mátrix

A fájlban található adatok tárolása, az egyes utasítássorok tárolása.

globális

Az utasítások száma maximum 100 és minden utasítássor maximum 200 karakter Az egyes utasítások karaktereinek száma kerül a tömbbe. Az első 4. feladatban lesz szerepe az egyes utasítássorok feldolgozásakor

globális

int

utasítássorok száma

globális

string

F2a és F2bc feladatokban van szerepe, paraméterátadás helyett globális

globális

sordb[100]

int

N s

100 elemű tömb

81

Programozási feladatok megoldása PROGRAMKÓD #include #include <string> #include #include #include #include

//sqrt miatt (sqrt = négyzetgyök) lsd. F2bc függvénynél //setprecision miatt (tizedesjegyek szanályozása lsd. F2bc függvénynél

using namespace std; int N, s; char sor[100][200]; int sordb[100]; void k(int x) { cout << x << endl; } void F1() { int db; ifstream be; be.open("program.txt"); be >> N; /* Az alábbi kiírás csak önellenőrzés a feladat szempontjából nincs szerepe */ for(int i=0; i> sor[i]; db=0; for(int j=0; j<200; j++) if(sor[i][j]=='E'||sor[i][j]=='D'||sor[i][j]=='K'||sor[i][j]=='N') db++; sordb[i]=db; cout << sor[i] << " (" << sordb[i] << ")" << endl; } be.close(); } void F2a() { cout << "Utasítássor száma: "; cin >> s; if(strstr(sor[s-1],"ED")==NULL && strstr(sor[s-1],"DE")==NULL && strstr(sor[s-1],"KN")==NULL && strstr(sor[s-1],"NK")==NULL) cout << "Nem egyszerűsíthető" << endl; else cout << "Egyszerűsíthető" << endl; }

82

Programozási feladatok megoldása void F2bc() { int x=0, y=0, ls; float max=0, m; for(int i=0; i<sordb[s-1]; i++) { if(sor[s-1][i]=='E') x++; if(sor[s-1][i]=='D') x--; if(sor[s-1][i]=='K') y++; if(sor[s-1][i]=='N') y--; m=sqrt(x*x+y*y); if(m>max) { max=m; ls=i+1; } } cout << abs(x) <<" lépést kell tenni az ED, " << abs(y) << " lépést a KN tengely mentén." << endl; cout << "Legnagyobb távolság " << ls << " lépésben: " << setprecision(4) << max << endl; } void F3() { int e; //energia for(int i=0;i
83

Programozási feladatok megoldása void F4() { ofstream ki; ki.open("ujprog.txt"); int db; string s; for(int i=0;i
84

Programozási feladatok megoldása void F5() { string s; cout << "Kérek egy új utasítássort: "; cin >> s; for(int i=0; i<s.length(); i++) s[i]=toupper(s[i]); cout << s << endl; float szam, kezd, vege; cout << "A régi kód:" << endl; for(int i=0;i<s.length();i++) { if(s[i]!='E'&&s[i]!='D'&&s[i]!='N'&&s[i]!='K') { /* Ha az adott karakter nem égtáj, akkor elkezdjük nézni, hogy meddig tartanak a számjegyek */ kezd=i; // Itt kezdődnek vege=kezd+1; while(s[vege]<'D') { vege++; } i=vege; // Itt érnek véget (vege) // Az i=vege azért kell, hogy a "nagy ciklus" a számjegyek után folytatódjon! szam=0; // SZámjegykarakterek helyiérték szerinti számmá alakítása // (A pow(10,x) 10 az x-edikent jelenti (cmath kell hozzá, lsd. fent includeoknál!!) for(int j=kezd;j
85

Programozási feladatok megoldása int main() { setlocale(LC_ALL,""); k(1); F1(); k(2); F2a(); F2bc(); k(3); F3(); k(4); F4(); k(5); F5(); return 0; }

86

2009. MÁJUS EMELT LIFT


FELADAT SZÖVEGE A Madárház Kft. toronyházak építésével foglalkozik. Jelenleg a Csúcs Rt. 100 szintes szerkezetkész épületén kezdték meg a belső szerelési műveleteket. Az egyes szerelőcsapatok naponta többször változtatják helyüket. Ha az új munkaterület egy másik emeleten van, akkor – a biztonsági előírások miatt – lifttel kell menniük. A házban egyetlen lift működik, amelynek igénybevételét az egyes csapatok a célszint megadásával jelezhetik. A lift az igényeket a jelzés sorrendjében szolgálja ki, és egyszerre csak egy csapatot szállít. A csapatok mozgását a 9 és 14 óra közötti intervallumban követjük nyomon. Ez az intervallum a munkaidőnek csak egy része, tehát a csapatok már dolgoznak valamelyik szinten, de 9 órakor teljesítetlen kérés nincs és a lift szabad. A lifthasználati igényeket az igeny.txt állomány tartalmazza. Első sorában a szintek száma (legfeljebb 100), a második sorban a csapatok száma (legfeljebb 50), a harmadik sorban pedig az igények száma (legfeljebb 100) olvasható. A negyedik sortól kezdve soronként egy-egy igény szerepel a jelzés sorrendjében. Egy igény hat számból áll: az első három szám az időt adja meg (óra, perc, másodpercszám sorrendben), a negyedik a csapat sorszáma, az ötödik az induló-, a hatodik a célszint sorszáma. Az egyes számokat pontosan egy szóköz választja el egymástól. Például: igeny.txt 100 10 55 9 7 11 7 6 22 9 10 30 8 18 2 9 11 0 5 12 20 … A 4. sor megmutatja, hogy 9 óra 7 perc 11 másodperckor a 7. csapat igényelt liftet, hogy a 6. szintről a 22. szintre eljusson. Készítsen programot, amely az alábbi kérdésekre válaszol! A program forráskódját lift néven mentse! Ügyeljen arra, hogy programjának minden helyes tartalmú bemeneti állomány esetén működnie kell! Minden részfeladat megoldása előtt írja a képernyőre a feladat sorszámát! Ha a felhasználótól kér be adatot, jelenítse meg a képernyőn, hogy milyen értéket vár (például a 2. feladat esetén: „2. feladat Kérem a lift indulási helyét!”)! A képernyőn megjelenített üzenetek esetén az ékezetmentes kiírás is elfogadott. 1. Olvassa be az igeny.txt állományban talált adatokat, s azok felhasználásával oldja meg a következő feladatokat! Ha az állományt nem tudja beolvasni, az első 8 igényhez tartozó adatokat jegyezze be a programba és dolgozzon azzal! 2. Tudjuk, hogy a megfigyelés kezdetén a lift éppen áll. Kérje be a felhasználótól, hogy melyik szinten áll a lift, és a további részfeladatok megoldásánál ezt vegye figyelembe! Ha a beolvasást nem tudja elvégezni, használja az igeny.txt fájlban az első igény induló szintjét! 3. Határozza meg, hogy melyik szinten áll majd a lift az utolsó kérés teljesítését követően! Írja képernyőre a választ a következőhöz hasonló formában: „A lift a 33. szinten áll az utolsó igény teljesítése után.” ! 4. Írja a képernyőre, hogy a megfigyelés kezdete és az utolsó igény teljesítése között melyik volt a legalacsonyabb és melyik a legmagasabb sorszámú szint, amelyet a lift érintett! 5. Határozza meg, hogy hányszor kellett a liftnek felfelé indulnia utassal és hányszor utas nélkül! Az eredményt jelenítse meg a képernyőn!

88

Programozási feladatok megoldása 6. Határozza meg, hogy mely szerelőcsapatok nem vették igénybe a liftet a vizsgált intervallumban! A szerelőcsapatok sorszámát egymástól egy-egy szóközzel elválasztva írja a képernyőre! 7. Előfordul, hogy egyik vagy másik szerelőcsapat áthágja a szabályokat, és egyik szintről gyalog megy a másikra. (Ezt onnan tudhatjuk, hogy más emeleten igényli a liftet, mint ahova korábban érkezett.) Generáljon véletlenszerűen egy létező csapatsorszámot! (Ha nem jár sikerrel, dolgozzon a 3. csapattal!) Határozza meg, hogy a vizsgált időszak igényei alapján lehet-e egyértelműen bizonyítani, hogy ez a csapat vétett a szabályok ellen! Ha igen, akkor adja meg, hogy melyik két szint közötti utat tették meg gyalog, ellenkező esetben írja ki a Nem bizonyítható szabálytalanság szöveget! 8. A munkák elvégzésének adminisztrálásához minden csapatnak egy blokkoló kártyát kell használnia. A kártyára a liftben elhelyezett blokkolóóra rögzíti az emeletet, az időpontot. Ennek a készüléknek a segítségével kell megadni a munka kódszámát és az adott munkafolyamat sikerességét. A munka kódja 1 és 99 közötti egész szám lehet. A sikerességet a „befejezett” és a „befejezetlen” szavakkal lehet jelezni. Egy műszaki hiba folytán az előző feladatban vizsgált csapat kártyájára az általunk nyomon követett időszakban nem került bejegyzés. Ezért a csapatfőnöknek a műszak végén pótolnia kell a hiányzó adatokat. Az igeny.txt állomány adatait felhasználva írja a képernyőre időrendben, hogy a vizsgált időszakban milyen kérdéseket tett fel az óra, és kérje be az adott válaszokat a felhasználótól! A pótlólag feljegyzett adatokat írja a blokkol.txt állományba! A blokkol.txt állomány tartalmát az alábbi sorok mintájára alakítsa ki: Befejezés ideje: 9:23:11 Sikeresség: befejezett ----Indulási emelet: 9 Célemelet: 11 Feladatkód: 23 Befejezés ideje: 10:43:22 Sikeresség: befejezetlen ----Indulási emelet: 11 Célemelet: 6 Feladatkód: 6 …

89


TÍPUSA

FELÉPÍTÉSE

SZEREPE

FELHASZNÁLÁS

igeny[100]

igenyles típusú 100 elemű tömb, minden eleme egy adathatost tartalmaz

struktúra 6 adatmezővel: o – óra p – perc m – másodperc ssz –csapat sorszáma ind –induló szint cel – célszint


globális

sz cs isz fsz

int int int int

max. 100 max. 50

globális globális globális globális

igenybevett[cs]

int

0 vagy 1 értékű tömb, cscsapatok száma

szintek száma csapatok száma igénylések száma hol áll a lift A 2. és 5. feladatrészben van szerepe A 6. feladathoz

felh. adja meg

lokális

90

Programozási feladatok megoldása PROGRAMKÓD #include #include #include using namespace std; using namespace std; int sz; int cs; int isz, fsz; struct igenyles { int o, p, m, ssz, ind, cel; } igeny[100]; void kiir(int sorszam) { cout << sorszam << ". feladat" << endl; } void F1() { ifstream be; be.open("igeny.txt"); be >> sz; be >> cs; be >> isz; for(int i=0;i> igeny[i].o; be >> igeny[i].p; be >> igeny[i].m; be >> igeny[i].ssz; be >> igeny[i].ind; be >> igeny[i].cel; } be.close(); } void F2() { cout << "Hol áll a lift: "; cin >> fsz; }

91

Programozási feladatok megoldása void F3() { cout << "A lift a(z) " << igeny[isz-1].cel << ". szinten áll az utolsó igény teljesítése után." << endl; } void F4() { int max=0, min=sz+1; for(int i=0;imax) max=igeny[i].ind; if(igeny[i].cel>max) max=igeny[i].cel; if(igeny[i].ind<min) min=igeny[i].ind; if(igeny[i].cel<min) min=igeny[i].cel; } cout << "Legalacsonyabb szint: " << min << endl; cout << "Legmagasabb szint: " << max << endl; } void F5() { int ures=0, teli=0; if(igeny[0].ind>fsz) ures++; if(igeny[0].ind
Programozási feladatok megoldása void F7() { int csapat; srand(time(NULL)); csapat=rand()%cs+1; //a generált véletlenszám 1 és cs közé fog esni cout << "A vizsgálandó csapat: " << csapat << endl; //megkeressük az adott csapat első igénylését - LINEÁRIS KERESÉS int i=0; while(i
93

Programozási feladatok megoldása int main() { setlocale(LC_ALL, "hun"); cout << "LIFT" << endl; kiir(1); F1(); kiir(2); F2(); kiir(3); F3(); kiir(4); F4(); kiir(5); F5(); kiir(6); F6(); kiir(7); F7(); return 0; }

94

2009. OKTÓBER EMELT ÚTÉPÍTÉS


FELADAT SZÖVEGE Az Alsó és Felső várost összekötő út 1 000 m hosszú részének a felújításán dolgoznak. Ennek a szakasznak a forgalmát figyeljük egy nap néhány óráján keresztül. Az említett szakaszon előzési tilalom van érvényben. A forgalmat a forgalom.txt állomány tartalmazza. Első sorában a megfigyelési időszakban áthaladó járművek száma (legfeljebb 2000) látható, a továbbiakban pedig soronként egy áthaladó jármű adatai olvashatók időrendben. Egy sorban az első három szám azt az időpontot jelöli (óra, perc, másodperc), amikor a jármű belép a vizsgált útszakaszra. A következő szám jelöli, hogy a jármű az érintett távolságot hány másodperc alatt tenné meg (legfeljebb 300) – a belépéskor mért sebességgel –, ha haladását semmi nem akadályozná. Ezt egy betű követi, amely jelzi, hogy a jármű melyik város irányából érkezett. Ennek megfelelően a betű A vagy F lehet. Az egyes adatokat pontosan egy szóköz választja el egymástól. Ha az útszakaszon egyik jármű utoléri a másikat, akkor az előzési tilalom miatt úgy tekintjük, hogy változatlan sorrendben, ugyanabban az időpillanatban hagyják el a szakasz, mint ahogy a lassabb jármű tenné. Például: forgalom.txt 1105 7 21 7 21 7 22 7 22 7 23

1 60 F 58 69 F 4 117 F 39 155 A 11 99 A

… A 3. sor megmutatja, hogy a 7 óra 21 perc 58 másodperckor a Felső város felől érkező jármű 69 másodperc alatt tenné meg ezt az 1 km hosszú távolságot. Ez a jármű – ha más járművek nem akadályozzák – 7 óra 23 perc 7 másodperckor lép ki az útszakaszról, tehát akkor már nem tartózkodik ott. Készítsen programot, amely az alábbi kérdésekre válaszol! A program forráskódját ut néven mentse! Ügyeljen arra, hogy programjának más bemeneti állomány esetén is működnie kell! Minden részfeladat megoldása előtt írja a képernyőre annak sorszámát! Ha a felhasználótól kér be adatot, jelenítse meg a képernyőn, hogy milyen értéket vár (például a 2. feladat esetén: „2. feladat Adja meg a jármű sorszámát!”)! 1. Olvassa be a forgalom.txt állományban talált adatokat, s azok felhasználásával oldja meg a következő feladatokat! Ha az állományt nem tudja beolvasni, akkor az első 10 sorának adatait jegyezze be a programba és dolgozzon azzal! 2. Írja ki a képernyőre, hogy az n-edikként belépő jármű melyik város felé haladt! Ehhez kérje be a felhasználótól az n értékét! 3. Írja a képernyőre, hogy a Felső város irányába tartó utolsó két jármű hány másodperc különbséggel érte el az útszakasz kezdetét! 4. Határozza meg óránként és irányonként, hogy hány jármű érte el a szakaszt! Soronként egy-egy óra adatait írja a képernyőre! Az első érték az órát, a második érték az Alsó, a harmadik a Felső város felől érkező járművek számát jelentse! A kiírásban csak azokat az órákat jelenítse meg, amelyekben volt forgalom valamely irányban!

96

Programozási feladatok megoldása 5. A belépéskor mért értékek alapján határozza meg a 10 leggyorsabb járművet! Írassa ki a képernyőre ezek belépési idejét, a várost (Alsó, illetve Felső), amely felől érkezett, és m/s egységben kifejezett sebességét egy tizedes pontossággal, sebességük szerinti csökkenő sorrendben! Ha több azonos sebességű járművet talál, bármelyiket megjelenítheti. Soronként egy jármű adatait jelenítse meg, és az egyes adatokat szóközzel tagolja! (A feladat megoldásakor figyeljen arra, hogy a következő feladatban az adatok eredeti sorrendjét még fel kell használni!) 6. Írassa ki az also.txt állományba azokat az időpontokat, amikor az Alsó város felé tartók elhagyták a kérdéses útszakaszt! Ha egy jármű utolér egy másikat, akkor a kilépésük időpontja a lassabb kilépési ideje legyen! A fájl minden sorába egy-egy időpont kerüljön óra perc másodperc formában! A számokat pontosan egy szóköz válassza el egymástól! FONTOSABB VÁLTOZÓK ADAT NEVE

TÍPUSA

FELÉPÍTÉSE

SZEREPE

FELHASZNÁLÁS

adatok[2000]

jarmu típusú 2000 elemű tömb, minden eleme egy adatötöst tartalmaz

struktúra 5 adatmezővel: 4 int és 1 char típusú mező o – óra p – perc mp – másodperc ido – ennyi ideig tart megtenni az 1000 méteres utat honnan –’A’ vagy ’F’, attól függ honnan jön a jármű

A fájlban található adatok tárolása

globális

N

int

Az útszakaszon áthaladó globális járművek száma

97

Programozási feladatok megoldása PROGRAMKÓD #include // printf miatt az 5. feladatban #include #include #include <string> #include <windows.h> #include //precision miatt using namespace std; struct jarmu { int o, p, mp, ido; char honnan; } adatok[2000];

// A vagy F

int N; //Járművek száma void kiir(int szam) { cout << "--------------------" << endl; cout << szam << ". feladat" << endl; cout << "--------------------" << endl; } void F1() { cout << "Adatok beolvasása..." << endl; ifstream be; be.open("forgalom.txt"); be >> N; for(int i=0;i> adatok[i].o; be >> adatok[i].p; be >> adatok[i].mp; be >> adatok[i].ido; be >> adatok[i].honnan; } be.close(); }

98

Programozási feladatok megoldása void F2() { int n; cout << "Melyik autóra kiváncsi? (1-" << N << ")" << endl; cout << "Kérek egy számot: "; cin >> n; if(adatok[n-1].honnan=='A') cout << "Felső város felé haladt a jármű"; else cout << "Alsó város felé haladt a jármű"; cout << endl; } void F3() { int i, j, mpi, mpj, kulonbseg; i=N-1; while(i>=0&&adatok[i].honnan!='A') { i--; } if(i>=0) { j=i-1; while(j>=0&&adatok[j].honnan!='A') { j--; } if(j>=0) { mpi=adatok[i].o*3600+adatok[i].p*60+adatok[i].mp; mpj=adatok[j].o*3600+adatok[j].p*60+adatok[j].mp; kulonbseg=mpi-mpj; cout << i+1 << ": " << adatok[i].o << " " << adatok[i].p << " " << adatok[i].mp << " " << adatok[i].ido << " " << adatok[i].honnan << endl; cout << j+1 << ": " << adatok[i].o << " " << adatok[j].p << " " << adatok[j].mp << " " << adatok[j].ido << " " << adatok[j].honnan << endl; cout << "Különbség: " << kulonbseg << endl; } else { cout << "Nem találtam két ilyen járművet!" << endl; } } }

99

Programozási feladatok megoldása void F4() { int ora1, ora2; int orak[2][24]; //A és F valamint 24 óra szerinti mátrix for(int i=0;i<2;i++) { for(int j=0;j<24;j++) { orak[i][j]=0; } } for(int i=0;i
100

Programozási feladatok megoldása void F5() { jarmu rend[N]; for(int i=0;irend[j].ido) swap(rend[i], rend[j]); } } float x, ido2; for(int i=0;i<10;i++) { cout.width(2); cout << rend[i].o << ":"; cout.width(2); cout << rend[i].p << ":"; cout.width(2); cout << rend[i].mp << " "; if(rend[i].honnan=='A') cout << "Alsó "; else cout << "Felső "; ido2=rend[i].ido; //rá kell venni a programot, hogy valós számokkal dolgozzon!! x=1000/ido2; //hogy legyen törtrész is, amit kerekíthetünk printf("%3.1f m/s\n",x);//1 tizedes jegyre. Most a printf-et is használhatjuk! } }

101

Programozási feladatok megoldása void F6() { cout << "Adatok fájlba írása..." << endl; ofstream ki; ki.open("also.txt"); int mp_aktualis, mp_elozo, elso=0; //Keressük meg az első Alsó városba tartót! //Feltételezhetjük, hogy biztosan van ilyen jármű while(adatok[elso].honnan!='F') elso++; ki << adatok[elso].o << " " << adatok[elso].p << " " << adatok[elso].mp << endl; int elozo=elso; for(int i=elozo+1;i
102

2010. MÁJUS EMELT HELYJEGY


FELADAT SZÖVEGE Egy autóbuszokat üzemeltető társaság távolsági járataira az utasok jobb kiszolgálása érdekében csak akkor ad el jegyet, ha ülőhelyet is tud biztosítani. Minden jegyre rányomtatja, hogy az adott vonalon mettől meddig érvényes és melyik ülést lehet elfoglalni birtokában. Az eladott.txt állomány pontosan egy út jegyvásárlásait tartalmazza. Az első sorban az eladott jegyek száma (legfeljebb 500), a vonal hossza (legfeljebb 200 km) és minden megkezdett 10 km után fizetendő összeg (legfeljebb 100 Ft) található. Az állomány további sorai — a vásárlás sorrendjében — egy-egy jegy három adatát írják le: az utas melyik ülést foglalhatja el, hol száll fel és hol száll le. (A fel- és a leszállás helyét a járat kezdőállomásától mért távolsággal adják meg.) Az üléseket 1-től 48-ig folyamatosan számozták. A soron belüli határoló jel minden esetben egy-egy szóköz. Az állomány csak egész számokat tartalmaz. Az utast a későbbiekben egyetlen sorszámmal azonosítjuk, azzal az értékkel, amely megadja, hogy hanyadik jegyvásárló volt. A jegy árának meghatározásakor az értéket öttel osztható számra kell kerekítenie. (1, 2, 6 és 7 esetén lefelé, 3, 4, 8 és 9 esetén pedig felfelé kell kerekítenie.) Például: eladott.txt 132 200 71 20 0 110 12 13 65 … Az adott járat 200 km hosszú úton közlekedik. Eddig 132 jegyet adtak el, és megkezdett 10 km-ként 71 Ft-ba kerül a jegy. Az állomány harmadik sora tartalmazza a második jegyvásárló adatait, aki a 13. és a 65. km között utazik a 12. helyen ülve. A megtett távolság 52 km, tehát 6 darab 10 km hosszú szakaszért kell fizetnie, ennek értéke 6*71, azaz 426 Ft. Mivel kerekíteni kell, ezért a fizetendő összeg 425 Ft. Készítsen programot, amely az alábbi kérdésekre válaszol! A program forráskódját helyjegy néven mentse! Minden – képernyőre írást igénylő – részfeladat megoldása előtt írja a képernyőre a feladat sorszámát! Ha a felhasználótól kér be adatot, jelenítse meg a képernyőn, hogy milyen értéket vár (például a 7. feladat esetén: „7. feladat Adja meg, hogy az út mely kilométerén kéri az utaslistát!”)! Az ékezetmentes kiírás is elfogadott. 1. Olvassa be az eladott.txt állományban talált adatokat, s azok felhasználásával oldja meg a következő feladatokat! Ha az állományt nem tudja beolvasni, az állomány első 10 sorának adatait jegyezze be a programba és dolgozzon azzal! 2. Adja meg a legutolsó jegyvásárló ülésének sorszámát és az általa beutazott távolságot! A kívánt adatokat a képernyőn jelenítse meg! 3. Listázza ki, kik utazták végig a teljes utat! Az utasok sorszámát egy-egy szóközzel elválasztva írja a képernyőre! 4. Határozza meg, hogy a jegyekből mennyi bevétele származott a társaságnak! Az eredményt írja a képernyőre! 5. Írja a képernyőre, hogy a busz végállomást megelőző utolsó megállásánál hányan szálltak fel és le! 6. Adja meg, hogy hány helyen állt meg a busz a kiinduló állomás és a célállomás között! Az eredményt írja a képernyőre!

104

Programozási feladatok megoldása 7. Készítsen „utaslistát” az út egy pontjáról! A listában ülésenként tüntesse fel, hogy azt az adott pillanatban melyik utas foglalja el! A pontot, azaz a kiindulási állomástól mért távolságot, a felhasználótól kérje be! Ha a beolvasott helyen éppen megálló lett volna, akkor a felszálló utasokat vegye figyelembe, a leszállókat pedig hagyja figyelmen kívül! Az eredményt az ülések sorszámának sorrendjében írja a kihol.txt állományba! Az üres helyek esetén az „üres” szót jelenítse meg! Minden ülés külön sorba kerüljön! Például: kihol.txt 1. ülés: 2. ülés: 3. ülés: 4. ülés: 5. ülés: …

üres üres üres 29. utas 95. utas


TÍPUSA

FELÉPÍTÉSE

SZEREPE

FELHASZNÁLÁS

utasok[500]

utas típusú 500 elemű tömb, minden eleme egy adatötöst tartalmaz

struktúra 5 adatmezővel: sorszam – az utas sorszáma ules – ülés száma fel – felszállás km helye le – leszállás km helye fizet –fizetendo összeg

A fájlban található adatok tárolása, valamint a sorszám és fizetendő kezelésére szolgál

globális

utvonal[201]


globális

e_szam

int

vonalhossz

int

ar_10

int

A 6. feladatban használjuk fel, gyakorlatilag 0200 km-ig minden egyes kilométerhez rendelünk egy értéket, vagy 0-t vagy az ott lévő utasok számát eladott jegyek száma (a fájl első sora) a járat hossza km-ben (a fájl második sora) 10km-es szakasz viteldíja (a fájl harmadik sora)

globális globális globális

105

Programozási feladatok megoldása PROGRAMKÓD #include #include #include using namespace std; struct utas { int sorszam, ules, fel, le, fizet; } utasok[500]; int e_szam; //eladott jegyek száma int vonalhossz; int ar_10; int utvonal[201]; //0 és 200 km majd nem játszik void kiir(int s) { cout << endl; cout << s << ". feldat" << endl; cout << "..............." << endl; } int kerekit(int ezt) { // 1,2,6,7 le 3,4,8,9 fel int kerek; int maradek=ezt%5; if(maradek<3) kerek=ezt-maradek; else kerek=ezt-maradek+5; return kerek; }

106

Programozási feladatok megoldása void F1() { int fizetendo; //beolvasáskor kiszámolhatjuk a fizetendo díjat minden utasra int megtett_ut; ifstream be; be.open("eladott.txt"); be >> e_szam; be >> vonalhossz; be >> ar_10; cout << "Eladott jegyek száma: " << e_szam << endl; cout << "Vonal hossza: " << vonalhossz << endl; cout << "10 km ára: " << ar_10 << endl << endl; for(int i=0;i<e_szam;i++) { utasok[i].sorszam=i+1; be >> utasok[i].ules; be >> utasok[i].fel; be >> utasok[i].le; megtett_ut=utasok[i].le-utasok[i].fel; if(megtett_ut%10!=0) fizetendo=(megtett_ut/10+1)*ar_10; else fizetendo=(megtett_ut/10)*ar_10; utasok[i].fizet=kerekit(fizetendo); //Adatok kiírása (nem kell), csak rossz szokás... .) cout << utasok[i].sorszam << " "; cout << utasok[i].ules << " "; cout << utasok[i].fel << " "; cout << utasok[i].le << " "; cout << utasok[i].fizet << endl; } be.close(); }

107

Programozási feladatok megoldása void F2() { int i=e_szam-1; cout << "Utolsó (" << utasok[i].sorszam << ".) utas adatai: " << endl; cout << "Ülésszám: " << utasok[i].ules; cout << " Beutazott távolság: " << utasok[i].le-utasok[i].fel << endl; } void F3() { for(int i=0;i<e_szam;i++) { if(utasok[i].fel==0&&utasok[i].le==vonalhossz) { cout << utasok[i].sorszam << " "; } } cout << endl; } void F4() { //egyszerű összegzés a feladat int bevetel=0; for(int i=0;i<e_szam;i++) { bevetel=bevetel+utasok[i].fizet; } cout << "A társaság bevétele: " << bevetel << endl; }

108

Programozási feladatok megoldása void F5() { //Több megoldás is lehetséges!!! int max_fel=0; //Második legnagyobb szám keresése felszálláskor for(int i=1;i<e_szam;i++) { if(utasok[i].fel>max_fel&&utasok[i].fel!=vonalhossz) max_fel=utasok[i].fel; } cout << "Utolsó előtti megálló felszállók esetén: " << max_fel << endl; int max_le=0; //Második legnagyobb szám keresése felszálláskor for(int i=1;i<e_szam;i++) { if(utasok[i].le>max_le&&utasok[i].le!=vonalhossz) max_le=utasok[i].le; } cout << "Utolsó előtti megálló leszállók esetén: " << max_le << endl; //Végső maximum, azaz utolsó előtti megálló //Valószínű, hogy a max_fel és max_le azonos, de hát ki tudja? int max; if(max_fel>=max_le) max=max_fel; else max=max_le; int fel_db=0, le_db=0; for(int i=0;i<e_szam;i++) { if(utasok[i].fel==max) fel_db++; if(utasok[i].le==max) le_db++; } cout << "Utolsó előtti megállónál felszállók száma: " << fel_db << endl; cout << "Utolsó előtti megállónál leszállók száma : " << le_db << endl; cout << endl; cout << "Fel- és leszállók összesen: " << fel_db+le_db << endl; }

109

Programozási feladatok megoldása void F6() { //Itt is több megoldás lehetséges! for(int i=0;i<201;i++) utvonal[i]=0; //Az utasok fel- és leszállása alapján növeljük az adott kilométernek megfelelő tömbelemet, //így jelezzük, hogy ott megálló volt for(int i=0;i<e_szam;i++) { utvonal[utasok[i].fel]++; utvonal[utasok[i].le]++; } int megallo_db=0; //0 és 200 km most nem játszik for(int i=1;i<200;i++) { if(utvonal[i]!=0) megallo_db++; } cout << "Az induló és a végállomás közötti megállók száma: " << megallo_db << endl; } void F7() { ofstream ki; ki.open("kihol.txt"); int tav; cout << "Távolság: "; cin >> tav; int ules[48]; //48 ülés van, kezdetben mind üres for(int i=0;i<48;i++) ules[i]=0; for(int i=0;i<e_szam;i++) { //ha tav=felszallasi hely, azt is kezeljuk if(tav>=utasok[i].fel&&tav
110

Programozási feladatok megoldása int main() { setlocale(LC_ALL, "hun"); cout << "Helyjegy" << endl; kiir(1); F1(); kiir(2); F2(); kiir(3); F3(); kiir(4); F4(); kiir(5); F5(); kiir(6); F6(); kiir(6); F7(); return 0; }

111

2010. OKTÓBER EMELT ANAGRAMMA


FELADAT SZÖVEGE Az anagramma a szójátékok egy fajtája, melyben értelmes szavak vagy mondatok betűinek sorrendjét úgy változtatjuk meg, hogy az eredmény szintén értelmes szó vagy mondat lesz. Sok anagramma esetén az eredeti szó és a végeredmény között humoros vagy egyéb kapcsolat van, ez növeli az anagramma érdekességét, értékét. Például a satu szó anagrammái: utas, tusa, suta. A szotar.txt ASCII kódolású állomány legfeljebb 300 különböző szót tartalmaz. A szavak legalább 2, legfeljebb 30 karakter hosszúságúak, és csak az angol ábécé kisbetűit tartalmazzák. Az állományban az egyes szavak külön sorokban szerepelnek, és minden szó csak egyszer fordulhat elő. Például: szotar.txt eszesen kereszt keretes keretez nyertesek hadartam maradhat … Készítsen programot, amely az alábbi kérdésekre válaszol! A program forráskódját anagram néven mentse! Ügyeljen arra, hogy programjának minden helyes tartalmú bemeneti állomány esetén működnie kell! Minden részfeladat megoldása előtt írja a képernyőre a feladat sorszámát! Ha a felhasználótól kér be adatot, jelenítse meg a képernyőn, hogy milyen értéket vár (például az 1. feladat esetén: „Adja meg a szöveget:”)! A képernyőn megjelenített üzenetek esetén az ékezetmentes kiírás is elfogadott. 1. Kérjen be a felhasználótól egy szöveget, majd határozza meg, hogy hány különböző karakter található a szövegben! A darabszámot és a karaktereket írja ki a képernyőre! 2. Olvassa be a szotar.txt állományból a szavakat, és a következő feladatok megoldása során ezekkel dolgozzon! Amennyiben nem tudja beolvasni az állományból a szavakat, akkor az első 10 szóval dolgozzon! 3. Az állományból beolvasott szavakat alakítsa át úgy, hogy minden szó karaktereit egyenként tegye ábécérendbe! Az így létrehozott szavakat írja ki az abc.txt állományba az eredeti állománnyal egyező sorrendben! Például: Eredeti tervez

Ábécé sorrendben lévő eertvz

nyugalom

aglmnouy

4. Kérjen be a felhasználótól két szót, és döntse el, hogy a két szó anagramma-e! Ha azok voltak, írja ki a képernyőre az „Anagramma” szót, ha nem, akkor pedig a „Nem anagramma” szöveget! 5. Kérjen be a felhasználótól egy szót! A szotar.txt állomány szavaiból keresse meg a szó anagrammáit (a szót önmagát is annak tekintve)! Ha van találat, azokat egymás alá írja ki a képernyőre, ha nem volt találat, akkor írja ki a „Nincs a szótárban anagramma” szöveget! 6. Határozza meg, hogy a szotar.txt állományban melyik a leghosszabb szó! Ha több, ugyanannyi karakterből álló leghosszabb szó volt, akkor az ugyanazokat a karaktereket tartalmazó szavakat (amelyek

113

Programozási feladatok megoldása egymás anagrammái) közvetlenül egymás alá írja ki! A feltételnek megfelelő összes szó pontosan egyszer szerepeljen a kiírásban! 7. Rendezze a szotar.txt állományban lévő szavakat a karakterek száma szerint növekvő sorrendbe! Az egyforma hosszúságú és ugyanazokat a karaktereket tartalmazó szavak (amelyek egymás anagrammái) szóközzel elválasztva ugyanabba a sorba kerüljenek! Az egyforma hosszúságú, de nem ugyanazokat a karaktereket tartalmazó szavak külön sorba kerüljenek! A különböző hosszúságú szavakat egy üres sorral különítse el egymástól! Az így rendezett szavakat írja ki a rendezve.txt állományba! Például: Eredeti halat

Rendezett ajak ajka kaja

rakat

papi pipa

ajak

satu suta tusa utas

papi rakta ajka

halat rakat rakta takar tarka

takar kaja satu vallat

vallat paplan

tarka pipa paplan


TÍPUSA

sz[300]

string típusú 300 elemű tömb string típusú 300 elemű tömb

r[300]

N

int

FELÉPÍTÉSE

SZEREPE

FELHASZNÁLÁS

A szotar.txt tárban található maximum 300 db szó tárolása Az sz tömb rendezett példánya, azaz ebben a tömbben az sz-beli szavak betűi rendezve szerepelnek A szotar.txt-ben szereplő szavak száma

globális

globális

globális

114

Programozási feladatok megoldása PROGRAMKÓD #include #include #include <string> #include <windows.h> using namespace std; string sz[300]; string r[300]; int N; string szorendezo(string a) { for(int i=0;ia[j]) swap(a[i],a[j]); } return a; } void F1() { string be; cout << "Szöveg:"; cin >> be; if(be.length()>0) { //rendezés be=szorendezo(be); cout << "Rendezve: " << be << endl; //számolás int db=1; for(int i=1;i
115

Programozási feladatok megoldása void F2() { ifstream be; be.open("szotar.txt"); int i=0; while(!be.eof()) { be >> sz[i]; i++; } //szavak száma N=i; be.close(); } void F3() { ofstream ki; ki.open("abc.txt"); for(int i=0;i> a; cout << "2. szó: "; cin >> b; if(szorendezo(a)==szorendezo(b)) { cout << "Anagramma" << endl; } else { cout << "Nem anagramma" << endl; } }

116

Programozási feladatok megoldása void F5() { string t; cout << "Kérek egy szót: "; cin >> t; t=szorendezo(t); int db=0; cout << "Találatok:" << endl; for(int i=0;i
117

Programozási feladatok megoldása void F7(){ //Hosszúság szerint növekvően, azon belül ABC rendbe rendezzük az r tömböt, //és vele párhuzamosan az sz tömböt is átrendezzük. Hasonlóan a 6. feladathoz. for(int i=0;ir[j].length()||(r[i].length()==r[j].length()&&r[i]>=r[j])) { swap(r[i],r[j]); swap(sz[i],sz[j]); } } ofstream ki; ki.open("rendezve.txt"); for(int i=0;i
118

2011. MÁJUS EMELT SZÓJÁTÉK


FELADAT SZÖVEGE Sok szórakoztató szójátékkal lehet elütni az időt. Ezek közül némelyekhez segítségül hívhatjuk a technikát is. Az alábbiakban szójátékokhoz kapcsolódó problémákat kell megoldania. A feladatok megoldásához rendelkezésére áll a szoveg.txt fájl, amelybe Gárdonyi Géza Egri csillagok című regényéből gyűjtöttünk ki szavakat. Az állományban csak olyan szavak szerepelnek, melyek az angol ábécé betűivel leírhatók, és minden szó csak egyszer szerepel. A könnyebb feldolgozhatóság érdekében valamennyi szó csupa kisbetűvel szerepel, szavanként külön sorban. Tudjuk, hogy ebben az állományban a szavak 20 karakternél nem hosszabbak. Készítsen programot, amely az alábbi feladatokat megoldja! A program forráskódját szavak néven mentse! Minden – képernyőre írást igénylő – részfeladat megoldása előtt írja a képernyőre a feladat sorszámát! Ha a felhasználótól kér be adatot, jelenítse meg a képernyőn, hogy milyen értéket vár (például a 1. feladat esetén: „1. feladat Adjon meg egy szót: ”)! Az ékezetmentes kiírás is elfogadott. 1. Kérjen be a felhasználótól egy szót, és döntse el, hogy tartalmaz-e magánhangzót! Amennyiben tartalmaz, írja ki, hogy „Van benne magánhangzó.”! Ha nincs, akkor írja ki, hogy „Nincs benne magánhangzó.”! A begépelendő szóról feltételezheti, hogy csak az angol ábécé kisbetűit tartalmazza. (Az angol ábécé magánhangzói: a, e, i, o, u.) 2. Írja ki a képernyőre, hogy melyik a leghosszabb szó a szoveg.txt állományban, és az hány karakterből áll! Ha több azonos leghosszabb hosszúságú szó is van a szógyűjteményben, akkor azok közül elegendő egyetlen szót kiírnia. A feladatot úgy oldja meg, hogy tetszőleges hosszúságú szövegállomány esetén működjön, azaz a teljes szöveget ne tárolja a memóriában! 3. A magyar nyelv szavaiban általában kevesebb a magánhangzó, mint a mássalhangzó. Határozza meg, hogy az állomány mely szavaiban van több magánhangzó, mint egyéb karakter! Ezeket a szavakat írja ki a képernyőre egy-egy szóközzel elválasztva! A szavak felsorolása után a mintának megfelelően az alábbi adatokat adja meg: • hány szót talált; • hány szó van összesen az állományban; • a talált szavak hány százalékát teszik ki az összes szónak! A százalékot két tizedessel szerepeltesse! Például: 130/3000 : 4,33% A következőkben a szólétra játékkal kapcsolatos feladatokat kell megoldania. A szólétra építés egy olyan játék, amikor adott egy szó közepe, például isz, amit a létra fokának nevezünk. Ennek a szócsonknak az elejére és a végére kell egy-egy betűt illesztenünk úgy, hogy értelmes szót hozzunk létre, például hiszi vagy liszt. Ezt az értelmes szót a játékban létraszónak nevezzük. Az adott szórészlethez minél több létraszót tudunk kitalálni, annál magasabb lesz a szólétra. A cél az, hogy egy megadott szócsonkhoz a lehető legmagasabb szólétrát építsük.

120

Programozási feladatok megoldása Például: Szórészlet: isz A hozzá tartozó létraszavak: hiszi liszt viszi tiszt … 4. Hozzon létre egy tömb vagy lista adatszerkezetet, és ebbe gyűjtse ki a fájlban található ötkarakteres szavakat! A szoveg.txt állomány legfeljebb 1000 darab ötkarakteres szót tartalmaz. Kérjen be a felhasználótól egy 3 karakteres szórészletet! Írja ki a képernyőre a szólétra építés szabályai szerint hozzá tartozó ötkarakteres szavakat a tárolt adathalmazból! A kiírásnál a szavakat egy-egy szóköz válassza el! (Teszteléshez használhatja például az „isz” vagy „obo” szórészleteket, mert ezekhez a megadott szövegállományban több létraszó is tartozik.) 5. Az eltárolt ötkarakteres szavakból csoportosítsa azokat a szavakat, melyek ugyanannak a hárombetűs szórészletnek a létraszavai! Hozzon létre egy letra.txt állományt, amelybe ezeket a szavakat írja az alábbiak szerint: • minden szó külön sorba kerüljön; • csak olyan szó szerepeljen az állományban, aminek van legalább egy párja, amivel egy létrát alkotnak (azaz első és utolsó karakter nélkül megegyeznek); • az egy létrához tartozó szavak közvetlenül egymás után helyezkedjenek el; • két létra szavai között egy üres elválasztó sor legyen! Például: letra.txt megye vegye hegyi tegye lehet teher mehet tejes fejet fejen neked nekem reked ...

121


TÍPUSA

FELÉPÍTÉSE

SZEREPE

FELHASZNÁLÁS

szavak[1000]

string

1000 elemű stringeket tartalmazó tömb

Az ötbetűs szavakat tárolja. A 4. és 5. feladatban használjuk.

globális

SZ

int

globális

ot

int

A szoveg.txt fájlból beolvasott szavak száma Az ötbetűs szavak száma. A 4. és 5. feladatban használjuk.

globális

Ebben a feladatban a stringekkel kapcsolatos eszközökre lesz szükség, így javaslom az ide vonatkozó fejezet tanulmányozását – NÉHÁNY MŰVELET STRINGEKKEL!

122

Programozási feladatok megoldása PROGRAMKÓD #include #include #include <string> #include <windows.h> #include

//precision miatt

using namespace std; #define N 1000 string szavak[N]; int SZ, ot; //ot - az ötbetűs szavak száma void kiir(int szam) { cout << "--------------------" << endl; cout << szam << ". feladat" << endl; cout << "--------------------" << endl; } int maganhangzo(string szo) { int db=0; char mh[5]={'a', 'e', 'i', 'o', 'u'}; for(int i=0;i<szo.length();i++) { for(int j=0;j<5;j++) { if(szo[i]==mh[j]) { db++; } } } return db; } void F1() { string be; cout << "Kérek egy szót: "; cin >> be; int mennyi=maganhangzo(be); if(mennyi >0) cout << "Van benne magánhangzó." << " db: " << mennyi; else cout << "Nincs benne magánhangzó."; cout << endl; }

123

Programozási feladatok megoldása void F2() { ifstream be; be.open("szoveg.txt"); string s; string max=""; int i=0; while(!be.eof()) { be >> s; if(s.length()>max.length()) max=s; i++; } SZ=i-1; //beolvasott szavak száma! 3. feladathoz jó lesz! cout << "A leghosszab szó: " << max << endl; be.close(); } void F3() { ifstream be; be.open("szoveg.txt"); string s; string max=""; int db=0; while(!be.eof()) { be >> s; if(maganhangzo(s)>s.length()/2) { cout << s << " "; db++; } } cout << endl; be.close(); cout << "Talált szavak száma: " << db << " db." << endl; cout << "Összes szavak száma: " << SZ << " db." << endl; cout << "Százalékban: " << db << "/" << SZ << " : "; cout.precision(4); cout << (float) db/SZ*100 << "%" << endl; }

124

Programozási feladatok megoldása void F4() { ifstream be; be.open("szoveg.txt"); string s; ot=0;

//Feltetelzhetjuk, hogy lesznek 5 betűs szavak

for(int i=0;i<SZ;i++) { be >> s; if(s.length()==5) { szavak[ot]=s; ot++; } } be.close(); string harom; cout << "Kérek egy 3 karakteres szórészletet: "; cin >> harom; for(int i=0;i
//1,3 mert 0 1 ... a karakterek indexelése

}

125

Programozási feladatok megoldása void F5() { //Rendezéssel is megoldható, de lehet más megoldás is //Próbáljuk meg a középső három karakter szerint rendezni a szavakat for(int i=0;iszavak[j].substr(1,3)) { swap(szavak[i],szavak[j]); } } } ofstream ki; ki.open("letra.txt"); //Most nézzük a rendezett tömb szavainak a közepét bool enter=false; for(int i=1;i
126

2011. OKTÓBER EMELT PITYPANG


FELADAT SZÖVEGE A kerekdombi Pitypang wellness hotel nem régen nyitotta meg kapuit. A szállodában összesen 27 szoba van. A szobák egységesen kétágyasak, de minden szobában egy pótágy elhelyezésére is van lehetőség. Árképzés szempontjából három különböző időszakot határolt el a szálloda vezetősége: tavaszi, nyári és őszi szakaszt. Ennek megfelelően az árakat az alábbi táblázat tartalmazza. Tavasz

Nyár

Ősz

01. 01. – 04. 30.

05. 01. – 08. 31.

09. 01. – 12. 31.

9 000 Ft

10 000 Ft

8 000 Ft

A feltüntetett értékek egy szoba árát mutatják egy éjszakára. Ha csak egy fő száll meg, akkor is ki kell fizetni a teljes szobaárat. Egy adott foglalás besorolása az érkezés napjától függ. A pótágy díja 2 000 Ft éjszakánként. Amennyiben a vendég igényel reggelit, azért a fenti áron felül személyenként és naponként 1 100 Ft-ot kell fizetni. Ha például a két felnőttből és egy gyermekből álló Tóth család április 30. és május 4. között 4 éjszakát tölt a hotelben és kér reggelit, akkor ők az alábbi összegeket fizetik: • 4 × 9 000 Ft-ot a szobáért, • 4 × 2 000 Ft-ot a pótágyért, • 4 × 3 × 1 100 Ft-ot a reggeliért. A végső számla így 36 000 Ft + 8 000 Ft + 13 200 Ft = 57 200 Ft lesz. A szálloda eddigi foglalásait a pitypang.txt fájl tartalmazza. Az első sor a fájlban tárolt foglalások számát mutatja. A további sorokban szóközzel elválasztva soronként az alábbi adatok találhatók: • a foglalás sorszáma, • a szoba száma (1–27), • az érkezés napjának sorszáma, • a távozás napjának sorszáma, • a vendégek száma, • kérnek-e reggelit (1=igen vagy 0=nem), • a foglalást végző vendég nevéből képzett azonosítója (maximum 25 karakter). A napok sorszámozása január 1-jétől (1-es sorszám) kezdődik. Április 30-hoz például a 31 + 28 + 31 + 30 = 120-as sorszám tartozik. A Tóth család foglalása ebben a szerkezetben a következőképpen néz ki: 123 21 120 124 3 1 Toth_Balint A fájl egy éven belül tartalmaz foglalásokat. Az adatok az érkezés napja szerint növekvő sorrendben vannak rendezve a fájlban. Tájékoztatásul a honapok.txt fájl a hónapok neveit, a rá következő sorban az adott hónap napjainak számát, majd az ezt követő sorban pedig a hónap első napjának sorszámát tartalmazza. Az állományt forrásfájlként is felhasználhatja. A fenti táblázatnak megfelelő nyári időszak a 121. napon, míg az őszi a 244. napon kezdődik. Készítsen programot szalloda néven, amely az alábbi kérdésekre válaszol! A képernyőre írást igénylő részfeladatok eredményének megjelenítése előtt írja a képernyőre a feladat sorszámát (például 3. feladat:)! Ahol a felhasználótól kér be adatot, ott írja a képernyőre, hogy milyen adatot vár! 128

Programozási feladatok megoldása 1. Olvassa be az pitypang.txt állományban található maximum 1000 foglalás adatát, s annak felhasználásával oldja meg a következő feladatokat! Ha az állományt nem tudja beolvasni, akkor a benne található adatok közül az 1-5, 326-330 és 695-699 foglalási sorszámú sorok adatait jegyezze be a programba, s úgy oldja meg a feladatokat! 2. Jelenítse meg a képernyőn a leghosszabb szállodai tartózkodást! Csak az időtartamot vegye figyelembe, azaz nem számít, hogy hány vendég lakott az adott szobában! Az esetlegesen azonos hosszúságú tartózkodások közül bármelyiket kiválaszthatja. Az eredményt ebben a formában írja a képernyőre: Név (érkezési_nap_sorszáma) – eltöltött_éjszakák_száma például: Nagy_Bertalan (105) – 16 3. Számítsa ki, hogy az egyes foglalások után mennyit kell fizetnie az egyes vendégeknek! A foglalás sorszámát és a kiszámított értékeket kettősponttal elválasztva írja ki a bevetel.txt fájlba! Ez – a példában szereplő Tóth család esetén – a következő lenne: 123:57200 (Amennyiben nem tudja a fájlba íratni a kiszámított értékeket, úgy az első tíz foglaláshoz tartozó értéket a képernyőre írassa ki!) Írja a képernyőre a szálloda teljes évi bevételét! 4. Készítsen statisztikát az egyes hónapokban eltöltött vendégéjszakákról! Egy vendégéjszakának egy fő egy eltöltött éjszakája számít. A példában szereplő Tóth család áprilisban 3, májusban pedig 9 vendégéjszakát töltött a szállodában. Írassa ki a havi vendégéjszakák számát a képernyőre az alábbi formában: hónap_sorszáma: x vendégéj például: 8: 1059 vendégéj 5. Kérje be a felhasználótól egy új foglalás kezdő dátumához tartozó nap sorszámát és az eltöltendő éjszakák számát! Határozza meg, hogy hány szoba szabad a megadott időszak teljes időtartamában! A választ írassa ki a képernyőre!

129


TÍPUSA

FELÉPÍTÉSE

SZEREPE

FELHASZNÁLÁS

fogl[1000]

foglalas típusú 1000 elemű tömb, minden eleme egy adathetest tartalmaz

struktúra 7 adatmezővel: s – foglalás sorszáma sz – szoba száma e – érkezés napja t – távozás napja v –vendégek száma r – reggeli (1/0) az – vendég azonosítója (string)


globális

ho[12]

honap típusú 12 elemű tömb, minden eleme egy adathármast tartalmaz

struktúra 3 adatmezővel: hn – hónap neve nap – hónap napjainak száma ksz – hónap kezdő napjának sorszáma


globális

N

int

szabad[27][365]

bool

mátrix

foglalások száma (a fájl globális első sora) Utolsó feladatban kell. lokális Logikai mátrix, melyben false egy elem, ha foglalt a szoba az adott napon, és true, ha szabad. 27 szoba, minden szoba 365 napját kezeljük vele

130

Programozási feladatok megoldása PROGRAMKÓD #include #include #include #include <stdio.h> #include <windows.h> #include //math.h #include #include <string> using namespace std; struct honap { string hn; //hónap neve int nap; //hónap napjainak száma int ksz; //hónap kezdősorszáma } ho[12]; //12 hónap tömbje, minden eleme 3 mezőből áll struct foglalas { int s, sz, e, t, v, r; string az; } fogl[1000]; int N; void F1() { ifstream be; be.open("pitypang.txt"); be >> N; for(int i=0;i> fogl[i].s; be >> fogl[i].sz; be >> fogl[i].e; be >> fogl[i].t; be >> fogl[i].v; be >> fogl[i].r; be >> fogl[i].az; } be.close(); }

131

Programozási feladatok megoldása void F1_2() { ifstream be; be.open("honapok.txt"); for(int i=0;i<12;i++) { be >> ho[i].hn; be >> ho[i].nap; be >> ho[i].ksz; cout << ho[i].hn << " " << ho[i].nap << ho[i].ksz << endl; } be.close(); } void F2() { int max=0; int maxth=fogl[max].t-fogl[max].e; for(int i=1;imaxth) { max=i; maxth=fogl[i].t-fogl[i].e; } } cout << fogl[max].az << " (" << fogl[max].e << ") - " << maxth << endl; }

132

Programozási feladatok megoldása void F3() { int bev=0; int fiz; ofstream ki; ki.open("bevetel.txt"); for(int i=0;i=121&&fogl[i].e<244) fiz=10000; if(fogl[i].e>=244) fiz=8000; //pótágy 2000/éj if(fogl[i].v>2) fiz=fiz+(fogl[i].t-fogl[i].e)*2000; //reggeli 1100/fő/nap if(fogl[i].r==1) fiz=fiz+fogl[i].v*(fogl[i].t-fogl[i].e)*1100; ki << fogl[i].s << ":" << fiz << endl; bev=bev+fiz; fiz=0; } ki.close(); cout << "Összbevétel: " << bev << endl; } int hol_van(int x) { int honap=0; for(int i=0;i<12;i++) { if(i<11) { if(x>=ho[i].ksz&&x=ho[i].ksz) honap=i; } } return honap; }

133

Programozási feladatok megoldása void F4() { int vej[12]; for(int i=0;i<12;i++) vej[i]=0; int erk_honap; int tav_honap; for(int i=0;i
134

Programozási feladatok megoldása void F5() { char szabad[27][365]; for(int i=0;i<27;i++) { for(int j=0;j<365;j++) { szabad[i][j]=true; } } int x,y,z; //x - szoba (sor), y - érkezés napja (oszlopok) z - távozás napja for(int i=0;i> enap; cout << "Eltöltendő éjszakák száma:"; cin >> ejsz; //ejsz hosszú TRUE értékű sorozat keresése a SZABAD mátrixban bool van=false; int j,db; //szobánként haladunk for(int i=0;i<27;i++) { j=enap-1; db=0; //számoljuk az egymást követő szabad napokat egy-egy szobánál ejsz hosszú "szakaszon" while(j<enap+ejsz-1) { if(szabad[i][j]) db++; j++; } if(db==ejsz) { van=true; cout << i+1 << ". szoba" << endl; break; //Nem elegáns, de ha volt ilyen szabad sorozat, akkor fejezzük be! } } if(!van) cout << "Nincs szabad szoba ebben az időszakban!" << endl; } 135

Programozási feladatok megoldása int main() { setlocale(LC_ALL, "hun"); cout << "1. feladat" << endl; F1(); F1_2(); cout << "2. feladat" << endl; F2(); cout << "3. feladat" << endl; F3(); cout << "4. feladat" << endl; F4(); cout << "5. feladat" << endl; F5(); return 0; }

136

2012. MÁJUS EMELT FUTÁR


FELADAT SZÖVEGE A nagyvárosokon belül, ha csomagot gyorsan kell eljuttatni egyik helyről a másikra, akkor sokszor a legjobb választás egy kerékpáros futárszolgálat igénybevétele. A futárszolgálat a futárjainak a megtett utak alapján ad fizetést. Az egyik futár egy héten át feljegyezte fuvarjai legfontosabb adatait, és azokat eltárolta egy állományban. Az állományban az adatok rögzítése nem mindig követi az időrendi sorrendet. Azokra a napokra, amikor nem dolgozott, nincsenek adatok bejegyezve az állományba. A fájlban legalább 10 sor van, és minden sor egy-egy út adatait tartalmazza egymástól szóközzel elválasztva. Az első adat a nap sorszáma, ami 1 és 7 közötti érték lehet. A második szám a napon belüli fuvarszám, ami 1 és 40 közötti érték lehet. Ez minden nap 1-től kezdődik, és az aznapi utolsó fuvarig egyesével növekszik. A harmadik szám az adott fuvar során megtett utat jelenti kilométerben, egészre kerekítve. Ez az érték nem lehet 30-nál nagyobb. Például:

1 1 3 1 3 …

1 2 2 4 1

5 9 12 3 7

A 3. sor például azt mutatja, hogy a hét harmadik napján a második fuvar 12 kilométeres távolságot jelentett. Készítsen programot, amely a tavok.txt állomány adatait felhasználva az alábbi kérdésekre válaszol! A program forráskódját mentse futar néven! (A program megírásakor a felhasználó által megadott adatok helyességét, érvényességét nem kell ellenőriznie, feltételezheti, hogy a rendelkezésre álló adatok a leírtaknak megfelelnek.) A képernyőre írást igénylő részfeladatok eredményének megjelenítése előtt írja a képernyőre a feladat sorszámát (például: 3. feladat:)! Ha a felhasználótól kér be adatot, jelenítse meg a képernyőn, hogy milyen értéket vár! Az ékezetmentes kiírás is elfogadott. 1. Olvassa be a tavok.txt állományban talált adatokat, s annak felhasználásával oldja meg a következő feladatokat! 2. Írja ki a képernyőre, hogy mekkora volt a hét legelső útja kilométerben! Figyeljen arra, hogy olyan állomány esetén is helyes értéket adjon, amiben például a hét első napján a futár nem dolgozott! 3. Írja ki a képernyőre, hogy mekkora volt a hét utolsó útja kilométerben! 4. Tudjuk, hogy a futár minden héten tart legalább egy szabadnapot. Írja ki a képernyőre, hogy a hét hányadik napjain nem dolgozott a futár! 5. Írja ki a képernyőre, hogy a hét melyik napján volt a legtöbb fuvar! Amennyiben több nap is azonos, maximális számú fuvar volt, elegendő ezek egyikét kiírnia. 6. Számítsa ki és írja a képernyőre a mintának megfelelően, hogy az egyes napokon hány kilométert kellett tekerni! 1. nap: 124 km 2. nap: 0 km 3. nap: 75 km …

138

Programozási feladatok megoldása 7. A futár az egyes utakra az út hosszától függően kap fizetést az alábbi táblázatnak megfelelően: 1 – 2 km 3 – 5 km 6 – 10 km 11 – 20 km 21 – 30 km

500 Ft 700 Ft 900 Ft 1 400 Ft 2 000 Ft

Kérjen be a felhasználótól egy tetszőleges távolságot, és határozza meg, hogy mekkora díjazás jár érte! Ezt írja a képernyőre! 8. Határozza meg az összes rögzített út ellenértékét! Ezeket az értékeket írja ki a dijazas.txt állományba nap szerint, azon belül pedig az út sorszáma szerinti növekvő sorrendben az alábbi formátumban: 1. nap 1. út: 700 Ft 1. nap 2. út: 900 Ft 1. nap 3. út: 2000 Ft … 9. Határozza meg, és írja ki a képernyőre, hogy a futár mekkora összeget kap a heti munkájáért! FONTOSABB VÁLTOZÓK ADAT NEVE

TÍPUSA

FELÉPÍTÉSE

SZEREPE

FELHASZNÁLÁS

adatok[7][40]

futar típusú 7x40 elemű tömb, minden eleme egy adatkettőst tartalmaz

struktúra 2 adatmezővel: km – adott nap, adott fuvar megtett km-re ft – adott nap, adott fuvar megtett kilométere után fizetendő összeg

A fájlban található adatok tárolása, egyben a feladatot leegyszerűsítő adatszerkezet, mivel pontosan napok szerint indexelt és fuvar szerint indexelt a mátrix

globális

napi_km[7]

int

7 elemű tömb

elso_nap

int

kezdőértékkel rendelkező változó kezdőértéke: 7+1

utolso_nap

int

kezdőértékkel rendelkező változó kezdőértéke: 0

az ft mezőt csak a 8. feladattól használjuk, akkor kap értéket egy adott naphoz a 7 közül a napi összes km-t tartalmazza adatbeolvasás során ebbe helyezzük az első nap sorszámát. Azért 8 a kezdőértéke, hogy tudjunk nála kisebbet keresni. 2. feladat adatbeolvasás során ebbe helyezzük az utolsó nap sorszámát. Azért 0 a kezdőértéke, hogy tudjunk nála nagyobbat keresni. 3. feladat

globális

globális

globális

139

Programozási feladatok megoldása PROGRAMKÓD #include #include #include <windows.h> using namespace std; struct futar{ int km; int ft; } adatok[7][40]; int elso_nap=7+1, utolso_nap=0, napi_km[7]; void kiir(int szam) { cout << endl; cout << szam << ". FELADAT" << endl; cout << "................" << endl; } void F1() { /*mátrix nullázása, hogy ha egy nap nem volt fuvar, vagy nem volt 40 fuvar, csak kevesebb, akkor ott nulla legyen. Ezt később ki tudjuk használni.*/ for(int i=0;i<7;i++) { for(int j=0;j<40;j++) { adatok[i][j].km=0; } } ifstream be; be.open("tavok.txt"); int nap, fuvar; int i=0; while(!be.eof()) { be >> nap; if(nap<elso_nap) elso_nap=nap; //minimumkeresés if(nap>utolso_nap) utolso_nap=nap; //maximumkeresés be >> fuvar; be >> adatok[nap-1][fuvar-1].km; //Ez itt a lényeg, azINDEXELÉS!!!!! cout << nap << " " << fuvar << " " << adatok[nap-1][fuvar-1].km << endl; i++; } cout << "Első nap: " << elso_nap << " utolsó nap: " << utolso_nap << endl; be.close(); }

140

Programozási feladatok megoldása void F2() { cout << elso_nap << ".nap első fuvar: " << adatok[elso_nap-1][0].km << " km volt" << endl; } void F3() { //lineáris keresés a végétől az eleje felé int j=39; while(j>-1&&adatok[utolso_nap-1][j].km==0) { j--; } if(j>-1) { cout << "A(z) " << utolso_nap << ". nap (utolsó nap) utolsó fuvar: " << adatok[utolso_nap-1][j].km << " km" << endl; } } void F4() { int i=0; int db=0; for(int i=0;i<7;i++) { if(adatok[i][0].km==0) { cout << i+1 << ". napon nem dolgozott" << endl; db++; } } if(db==0) cout << "Minden nap dolgozott!" << endl; }

141

Programozási feladatok megoldása void F5() { int max_fuvar=0, mikor; for(int i=0;i<7;i++) { int j=0; while(j<40&&adatok[i][j].km!=0) { j++; } if(j<40) { if(j>max_fuvar) { max_fuvar=j; mikor=i+1; } } } cout << "A(z) " << mikor << ". napon ment a legtöbbet!" << endl; } void F6_seged() //napi összegzés { //ha kevés elem van, így is adhatunk nekik kezdőértéket napi_km[7]=(0,0,0,0,0,0,0); for(int i=0;i<7;i++) { for(int j=0;j<40;j++) { napi_km[i]=napi_km[i]+adatok[i][j].km; } } } void F6() { //F6_seged alapjan itt már csak ki kell írni az adatokat! for(int i=0;i<7;i++) { cout << i+1 << ". nap: " << napi_km[i] << " km" << endl; } }

142

Programozási feladatok megoldása int F7_kalkulator(int tav) { // 1 – 2 km 500 Ft // 3 – 5 km 700 Ft // 6 – 10 km 900 Ft // 11 – 20 km 1400 Ft // 21 – 30 km 2000 Ft int fizet=0; if(tav<3) fizet=500; else if(tav<6) fizet=700; else if(tav<11) fizet=900; else if(tav<21) fizet=1400; else if(tav<31) fizet=2000; else fizet=0; // :) Ez a feladatból következik, nem... :) return fizet; } void F7() { int tavolsag; cout << "Adjon meg egy távolságot: "; cin >> tavolsag; cout << "Erre jár " << F7_kalkulator(tavolsag) << " Ft." << endl; }

143

Programozási feladatok megoldása void F8() { ofstream ki; ki.open("dijazas.txt"); //Itt is nagyon jól kihasználhatjuk a mátrixunk előnyeit, //mely mátrix - ugye - napok és utak szerint indexelt!! for(int i=0;i<7;i++) //napok szerint megy a ciklus { for(int j=0;j<40;j++) //azon belül pedig utanként { if(adatok[i][j].km!=0) //csak akkor írjuk ki a mátrix alapján a Ft-ot, ha ott tényleg volt út!! { //csak egyszerűen a kalkulátorra bízzuk a számolást és rögtön kiírjuk az eredményt! //képernyőre... //a 9. feladathoz kell, hogy ez a ft mező is feltöltésre kerüljön. //akár itt is összegezhetnénk a keresetet, de meghagyjuk a 9. pontnak! adatok[i][j].ft=F7_kalkulator(adatok[i][j].km); cout << i+1 << ". nap " << j+1 << ". út: " << adatok[i][j].ft << " Ft" << endl; //...és fájlba ki << i+1 << ". nap " << j+1 << ". út: " << adatok[i][j].ft << " Ft" << endl; } } } ki.close(); } void F9() { int kereset=0; //Egyszerű összegzés mátrix elemekre for(int i=0;i<7;i++) //napok szerint megy a ciklus { for(int j=0;j<40;j++) //azon belül pedig utanként { if(adatok[i][j].km!=0) //csak akkor számolunk a mátrix alapján a Ft-ot, ha ott tényleg volt út!! { kereset=kereset+adatok[i][j].ft; } } } cout << "Heti munka díjazása: " << kereset << " Ft" << endl; }

144

Programozási feladatok megoldása int main() { setlocale(LC_ALL, "hun"); kiir(1); F1(); kiir(2); F2(); kiir(3); F3(); kiir(4); F4(); kiir(5); F5(); kiir(6); F6(); kiir(7); F7(); kiir(8); F8(); kiir(9); F9(); return 0; }

145

2012. OKTÓBER EMELT SZÍN-KÉP

Programozási feladatok megoldása FELADAT SZÖVEGE Egy digitális kép tárolásánál minden egyes képpont színét tároljuk. A képpontok színét az RGB kód adja. Az RGB kód a vörös (R), zöld (G) és a kék (B) színösszetevő értékét határozza meg. Ezen színösszetevők értéke 0 és 255 közötti egész szám lehet. A kep.txt fájlban egy 50×50 képpontos kép képpontjainak RGB kódjai vannak a következő formában. Az állomány a képet sorfolytonosan, a képpontok RGB kódját szóközzel elválasztva tartalmazza, minden képpontot egy újabb sorban: 200 200 200 200 200

96 96 96 96 96

64 64 64 64 64

Készítsen programot szinkep néven a következő feladatok megoldására! A program futása során a képernyőre való kiíráskor, illetve az adatok billentyűzetről való beolvasásakor utaljon a feladat sorszámára és a kiírandó, illetve bekérendő adatra! 1. Olvassa be a fájlból egy megfelelő adatszerkezetbe az egyes képpontok RGB kódját! 2. Kérjen be a felhasználótól egy RGB kódot! Állapítsa meg a program segítségével, hogy a bekért szín megtalálható-e a képen! A megállapítás eredményét írja ki a képernyőre! 3. Határozza meg, hogy a kép 35. sor 8. képpontjának színe hányszor szerepel a 35. sorban, illetve a 8. oszlopban. Az értékeket írja ki a képernyőre az alábbi formában: Például: Sorban: 5 Oszlopban: 10 4. Állapítsa meg, hogy a vörös, kék és zöld színek közül melyik szín fordul elő legtöbbször a képen! Az (egyik) legtöbbször előforduló szín nevét írja ki a képernyőre! A színek kódjai: Vörös 255, 0, 0 Zöld 0, 255, 0 Kék 0, 0, 255 5. Készítsen 3 képpont széles, fekete színű keretet a képnek! A keretet úgy hozza létre, hogy a kép mérete ne változzon! A fekete szín kódja RGB (0, 0, 0). 6. A kép képpontjainak színét írja ki a keretes.txt nevű szövegfájlba a bemeneti fájl formátumával egyezően! A képet sorfolytonosan tárolja, minden képpontot új sorba, a képpontok RGB kódját szóközzel elválasztva írja ki! Például: ... 0 0 0 0 0 0 200 96 64 ...

147

Programozási feladatok megoldása 7. Az 50×50-es képen a kerettől függetlenül egy sárga RGB (255, 255, 0) színű téglalap van. Határozza meg a program segítségével a bal felső és a jobb alsó sárga képpontnak a helyét (sor, oszlop), majd határozza meg, hogy a sárga téglalap hány képpontból áll! A képpontok helyét és a sárga alakzat méretét a következő formában írassa ki a képernyőre: Kezd: sor, oszlop Vége: sor, oszlop Képpontok száma: darab Például: Kezd: 18, 12 Vége: 25, 19 Képpontok száma: 64 FONTOSABB VÁLTOZÓK ADAT NEVE

TÍPUSA

FELÉPÍTÉSE

SZEREPE

FELHASZNÁLÁS

kep[50][50]

RGB típus 50x50-es mátrix, minden eleme egy adathármast tartalmaz

struktúra 3 adatmezővel: R – vörös színkód G – zöld színkód B – kék színkód


globális

148

Programozási feladatok megoldása PROGRAMKÓD #include #include using namespace std; struct RGB { int R; int G; int B; } kep[50][50]; void kiir(int ssz) { cout << ssz << ".feladat" << endl; } void F1() { ifstream be; be.open("kep.txt"); for(int i=0;i<50;i++) { for(int j=0;j<50;j++) { be >> kep[i][j].R; be >> kep[i][j].G; be >> kep[i][j].B; } } be.close(); }

149

Programozási feladatok megoldása void F2() { int r,g,b; cout << "Kérek egy RGB kódot:"; cout << "r="; cin>>r; cout << "g="; cin>>g; cout << "b="; cin>>b; int i=0; int j=0; while(i<50&&!(kep[i][j].R==r&&kep[i][j].G==g&&kep[i][j].B==b)) //Lineáris keresés mátrixra alkalmazása { j=0; while(j<50&&!(kep[i][j].R==r&&kep[i][j].G==g&&kep[i][j].B==b)) { j++; } i++; } if(i<50) cout << "Van ilyen kód!"; else cout << "Nincs ilyen kód!"; cout << endl; } void F3() { int r=kep[34][7].R; int g=kep[34][7].G; int b=kep[34][7].B; int sdb=0,odb=0; for(int i=0;i<50;i++) { if(kep[34][i].R==r&&kep[34][i].G==g&&kep[34][i].B==b) sdb++; } for(int i=0;i<50;i++) { if(kep[i][7].R==r&&kep[i][7].G==g&&kep[i][7].B==b) odb++; } cout << "Sorban: " << sdb << " Oszlopban: " << odb << endl; }

150

Programozási feladatok megoldása void F4() { //3 elemű tömb, az egyes színek (V, Z, K) előfordulásának számolására int szin[3]={0, 0, 0}; //Kevés elem esetén így is adhatunk kezdőértéket a tömbelemeknek for(int i=0;i<50;i++) { for(int j=0;j<50;j++) { if(kep[i][j].R==255&&kep[i][j].G==0&&kep[i][j].B==0) szin[0]++; if(kep[i][j].R==0&&kep[i][j].G==255&&kep[i][j].B==0) szin[1]++; if(kep[i][j].R==0&&kep[i][j].G==0&&kep[i][j].B==255) szin[2]++; } } int max=0, sorszam; for(int i=0;i<3;i++) { if(szin[i]>max) { max=szin[i]; sorszam=i; } } switch(sorszam) { case 0: cout << "Leggyakoribb szín: VÖRÖS"; break; case 1: cout << "Leggyakoribb szín: ZÖLD"; break; case 2: cout << "Leggyakoribb szín: KÉK"; break; } cout << endl; } void F5() { for(int i=0;i<50;i++) { //ELSŐ és UTOLSÓ HÁROM SOR átszínezése kep[0][i].R=0; kep[0][i].G=0; kep[0][i].B=0; kep[1][i].R=0; kep[1][i].G=0; kep[1][i].B=0; kep[2][i].R=0; kep[2][i].G=0; kep[2][i].B=0; kep[47][i].R=0; kep[47][i].G=0; kep[47][i].B=0; kep[48][i].R=0; kep[48][i].G=0; kep[48][i].B=0; kep[49][i].R=0; kep[49][i].G=0; kep[49][i].B=0; //ELSŐ és UTOLSÓ HÁROM OSZLOP átszínezése kep[i][0].R=0; kep[i][0].G=0; kep[i][0].B=0; kep[i][1].R=0; kep[i][1].G=0; kep[i][1].B=0; kep[i][2].R=0; kep[i][2].G=0; kep[i][2].B=0; kep[i][47].R=0; kep[i][47].G=0; kep[i][47].B=0; kep[i][48].R=0; kep[i][48].G=0; kep[i][48].B=0; kep[i][49].R=0; kep[i][49].G=0; kep[i][49].B=0; } } 151

Programozási feladatok megoldása void F6() { ofstream ki; ki.open("keretes.txt"); for(int i=0;i<50;i++) { for(int j=0;j<50;j++) { ki << kep[i][j].R << " "; ki << kep[i][j].G << " "; ki << kep[i][j].B << endl; } } ki.close(); }

152

Programozási feladatok megoldása void F7() { int i, j, ki, kj, vi, vj; // ki - sárga terület balfelső sarok i. sora, kj - sárga terület balfelső sarok j. oszlopa (kezdő koordináták) // vi - sárga terület jobbalsó sarok i. sora, kj - sárga terület jobbalsó sarok j. oszlopa (vég koordináták) //BAL FELSŐ SAROKBÓL KEZDEM A KERESÉST i=3; while(i<50) { j=3; while(j<50&&!(kep[i][j].R==255&&kep[i][j].G==255&&kep[i][j].B==0)) { j++; } if(j<50) { cout << "Kezd: " << i << ", " << j << endl; ki=i; kj=j; i=50; } i++; } //JOBB ALSÓ SAROKBÓL KEZDEM A KERESÉST i=46; while(i>0) { j=46; while(j>0&&!(kep[i][j].R==255&&kep[i][j].G==255&&kep[i][j].B==0)) { j--; } if(j>0) { cout << "Vége: " << i << ", " << j << endl; vi=i; vj=j; i=0; } i--; } cout << "Képpontok száma: " << (vi-ki+1)*(vj-kj+1) << endl; }

153

Programozási feladatok megoldása int main() { setlocale(LC_ALL,"hun"); kiir(1); F1(); kiir(2); F2(); kiir(3); F3(); kiir(4); F4(); kiir(5); F5(); kiir(6); F6(); kiir(7); F7(); return 0; }

154

2013. MÁJUS EMELT VÁLASZTÁSOK

Programozási feladatok megoldása FELADAT SZÖVEGE Eszemiszom városában időközi helyhatósági választásokat írtak ki. A városban összesen 12 345 szavazásra jogosult állampolgár van, akiket nyolc választókerületbe soroltak. Minden választókerületben több jelölt is indul, de egy jelölt csak egy választókerületben indulhat. Egy választókerület szavazói az adott választókerületben induló jelöltek közül egy jelöltre adhatnak le szavazatot, de nem kötelező részt venniük a szavazáson. Minden választókerületben az a jelölt nyer, aki a legtöbb szavazatot kapja. (Feltételezheti, hogy egyetlen választókerületben sem alakult ki holtverseny.) A jelöltek vagy egy párt támogatásával, vagy független jelöltként indulhatnak. Az idei évben a Gyümölcsevők Pártja (GYEP), a Húsevők Pártja (HEP), a Tejivók Szövetsége (TISZ) vagy a Zöldségevők Pártja (ZEP) támogatja a jelölteket. A szavazás eredményét a szavazatok.txt szóközökkel tagolt fájl tartalmazza, amelynek minden sorában egy-egy képviselőjelölt adatai láthatók. Például: 8 149 Zeller Zelma ZEP 6 63 Zsoldos Zsolt -

Az első két adat a választókerület sorszáma és a képviselőjelöltre leadott szavazatok száma. Ezt a jelölt vezeték- és utóneve, majd a jelöltet támogató párt hivatalos rövidítése követi. Független jelöltek esetében a párt rövidítése helyett egy kötőjel szerepel. Minden képviselőjelöltnek pontosan egy utóneve van. Készítsen programot valasztas néven, amely az alábbi kérdésekre válaszol! Minden részfeladat feldolgozása során írja ki a képernyőre a részfeladat sorszámát, (például: 2. feladat)! Ahol a felhasználótól kér be adatot, ott írja ki a képernyőre azt is, hogy milyen adatot vár! Az ékezetmentes kiírás is elfogadott. 1. Olvassa be a szavazatok.txt fájl adatait, majd ezek felhasználásával oldja meg a következő feladatokat! Az adatfájlban legfeljebb 100 képviselőjelölt adatai szerepelnek. 2. Hány képviselőjelölt indult a helyhatósági választáson? A kérdésre egész mondatban válaszoljon az alábbi mintához hasonlóan: A helyhatósági választáson 92 képviselőjelölt indult. 3. Kérje be egy képviselőjelölt vezetéknevét és utónevét, majd írja ki a képernyőre, hogy az illető hány szavazatot kapott! Ha a beolvasott név nem szerepel a nyilvántartásban, úgy jelenjen meg a képernyőn az „Ilyen nevű képviselőjelölt nem szerepel a nyilvántartásban!” figyelmeztetés! A feladat megoldása során feltételezheti, hogy nem indult két azonos nevű képviselőjelölt a választáson. 4. Határozza meg, hányan adták le szavazatukat, és mennyi volt a részvételi arány! (A részvételi arány azt adja meg, hogy a jogosultak hány százaléka vett részt a szavazáson.) A részvételi arányt két tizedesjegy pontossággal, százalékos formában írja ki a képernyőre! Például: A választáson 5001 állampolgár, a jogosultak 40,51%-a vett részt.

156

Programozási feladatok megoldása 5. Határozza meg és írassa ki a képernyőre az egyes pártokra leadott szavazatok arányát az összes leadott szavazathoz képest két tizedesjegy pontossággal! A független jelölteket együtt, „Független jelöltek” néven szerepeltesse! Például: Zöldségevők Pártja= 12,34% Független jelöltek= 23,40% 6. Melyik jelölt kapta a legtöbb szavazatot? Jelenítse meg a képernyőn a képviselő vezetékés utónevét, valamint az őt támogató párt rövidítését, vagy azt, hogy független! Ha több ilyen képviselő is van, akkor mindegyik adatai jelenjenek meg! 7. Határozza meg, hogy az egyes választókerületekben kik lettek a képviselők! Írja ki a választókerület sorszámát, a győztes vezeték- és utónevét, valamint az őt támogató párt rövidítését, vagy azt, hogy független egy-egy szóközzel elválasztva a kepviselok.txt nevű szöveges fájlba! Az adatok a választókerületek száma szerinti sorrendben jelenjenek meg! Minden sorba egy képviselő adatai kerüljenek!


TÍPUSA

FELÉPÍTÉSE

SZEREPE

FELHASZNÁLÁS

adatok[100]

adat típus 100 elemű tömb, minden eleme egy adatötöst tartalmaz

struktúra 5 adatmezővel: vk - választókerület sz – kapott szavazatok száma vnev - vezetéknév knev - keresztnév part – támogató párt/független


globális

V

konstans értéke 12345 int

Választásra jogosultak száma Forrás fájlban található sorok száma, azaz a képviselőjelöltek száma

globális

N

globális

157

Programozási feladatok megoldása PROGRAMKÓD Speciális elemek a programkódban Ebben a feladatban szükségünk lesz az IOMANIP nevű függvénytárra, melyben az I/O műveletek manipulálására alkalmas függvények találhatók. (Lsd. F4() és F5() feladatrészekben a cout.precision(4), illetve a setprecision(4) függvényeket!)

#include #include #include #define V 12345 using namespace std; struct adat { int vk; int sz; string vnev; string knev; string part; } adatok[100]; int N; float szumma; void kiir(int ssz) { cout << ssz << ". feladat" << endl; } void F1() { ifstream be; be.open("szavazatok.txt"); int i=0; while(!be.eof()) { be >> adatok[i].vk; be >> adatok[i].sz; be >> adatok[i].vnev; be >> adatok[i].knev; be >> adatok[i].part; cout << adatok[i].vk << " " << adatok[i].sz << " " << adatok[i].vnev << " " << adatok[i].knev << " " << adatok[i].part << endl; i++; } N=i; be.close(); }

158

Programozási feladatok megoldása void F2() { cout << "A helyhatósági választáson " << N << " képviselőjelölt indult." << endl; } void F3() { string vn, kn; cout << "Kerem a vezeteknevet: "; cin >> vn; cout << "Kerem a keresztnevet: "; cin >> kn; int i=0; while(i=N) { cout << "Ilyen nevu kepviselojelolt nem szerepel a nyilvántartásban!" << endl; } else { cout <<"Kapott szavazatok száma: " << adatok[i].sz << endl; } } float osszesen() { float szumma=0; for(int i=0;i
159

Programozási feladatok megoldása int F5() { float gy=0, h=0, t=0, z=0, f=0, szumma=osszesen(); for(int i=0;imax) max=adatok[i].sz; } for(int i=0;i
160

Programozási feladatok megoldása void F7() { int ker[8][2]; for(int i=0;i<8;i++) ker[i][0]=0; for(int i=0;iker[adatok[i].vk-1][0]) { ker[adatok[i].vk-1][0]=adatok[i].sz; ker[adatok[i].vk-1][1]=i; } } ofstream ki; ki.open("kepviselok.txt"); for(int i=0;i<8;i++) { cout << adatok[ker[i][1]].vnev << " " << adatok[ker[i][1]].knev << " "; if(adatok[ker[i][1]].part!="-") cout << adatok[ker[i][1]].part; else cout << "független"; cout << endl; //fájlba írási rész ki << adatok[ker[i][1]].vnev << " " << adatok[ker[i][1]].knev << " "; if(adatok[ker[i][1]].part!="-") ki << adatok[ker[i][1]].part; else ki << "független"; ki << endl; } ki.close(); } int main() { setlocale(LC_ALL,"hun"); kiir(1); F1(); kiir(2); F2(); kiir(3); F3(); kiir(4); F4(); kiir(5); F5(); kiir(6); F6(); kiir(7); F7(); return 0; }

161

2013. OKTÓBER EMELT KÖZÚTI ELLENŐRZÉS

Programozási feladatok megoldása FELADAT SZÖVEGE Bizonyára mindenki látott már rendőrjárőrt, aki szolgálata során egy út menti ellenőrző pontról a forgalmat figyelte. A járőr feladata lehet a szabálytalankodók kiszűrése mellett az elhaladó járművek szúrópróbaszerű vagy módszeres ellenőrzése. Bizonyos esetekben egy műszaki ellenőrző állomás is kitelepül, amely alkalmas a kiválasztott járművek műszaki állapotának felmérésére. Egy olyan nap adatait kell feldolgoznia, amelyen a rendőri mellett műszaki ellenőrzés is zajlott egy egyirányú út mentén. Az úton haladó legalább 50, de legfeljebb 1000 jármű adatait a jarmu.txt állományban tárolta el a rendőrautó forgalomrögzítő kamerájához csatlakoztatott gép. Az állomány sorai azonos szerkezetűek, az időt és a rendszámot tartalmazzák az elhaladás sorrendjében. A rendszám mindig 7 karakter hosszú, az angol ábécé nagybetűit, kötőjelet és számjegyeket tartalmaz ebben a sorrendben. A példában szereplőtől eltérő felépítésű rendszámok is lehetségesek. Például: 11 11 11 11

12 12 12 13

05 09 41 12

TI-2342 BU-5523 AAAA-99 DM-5632

… A 2. sor mutatja, hogy a BU-5523 jármű 11 óra 12 perc 9 másodperckor haladt át az ellenőrző ponton. Készítsen programot, amely az alábbi kérdésekre válaszol! A program forráskódját mentse jaror néven! (A program megírásakor a felhasználó által megadott adatok helyességét, érvényességét nem kell ellenőriznie.) A képernyőre írást igénylő részfeladatok eredményének megjelenítése előtt írja a képernyőre a feladat sorszámát (például: 3. feladat:)! Ha a felhasználótól kér be adatot, jelenítse meg a képernyőn, hogy milyen értéket vár! Az ékezetmentes kiírás is elfogadott. 1. Olvassa be a jarmu.txt állományban talált adatokat, s annak felhasználásával oldja meg a következő feladatokat! 2. Határozza meg, hogy aznap legalább hány óra hosszat dolgoztak az ellenőrzést végzők, ha munkaidejük egész órakor kezdődik, és pontosan egész órakor végződik! (Minden óra 0 perc 0 másodperckor kezdődik, és 59 perc 59 másodperccel végződik.) Az eredményt jelenítse meg a képernyőn! 3. Műszaki ellenőrzésre minden órában egy járművet választanak ki. Azt, amelyik abban az órában először halad arra. Az ellenőrzés óráját és az ellenőrzött jármű rendszámát jelenítse meg a képernyőn a következő formában: 9 óra: AB-1234! Minden óra adata külön sorba kerüljön! Csak azon órák adatai jelenjenek meg, amikor volt ellenőrizhető jármű! 4. A rendszám első karaktere külön jelentéssel bír. Az egyes betűk közül a „B” autóbuszt, a „K” kamiont, az „M” motort jelöl, a többi rendszámhoz személygépkocsi tartozik. Jelenítse meg a képernyőn, hogy az egyes kategóriákból hány jármű haladt el az ellenőrző pont előtt! 5. Mettől meddig tartott a leghosszabb forgalommentes időszak? A választ jelenítse meg a képernyőn a következő formában: 9:9:13 - 9:15:3! 6. A rendőrök egy baleset közelében látott járművet keresnek rendszám alapján. A szemtanúk csak a rendszám bizonyos karaktereire emlékeztek, így a rendszám ismeretlen karaktereit a * karakterrel helyettesítve keresik a nyilvántartásban. Kérjen be a felhasználótól egy ilyen rendszámot, majd jelenítse meg a képernyőn az arra illeszthető rendszámokat!

163

Programozási feladatok megoldása 7. Egy közúti ellenőrzés pontosan 5 percig tart. Amíg az ellenőrzés folyik, a járművek szabadon elhaladhatnak, a következő megállítására csak az ellenőrzés befejezése után kerül sor. Ha a rendőrök a legelső járművet ellenőrizték, akkor mely járműveket tudták ellenőrizni a szolgálat végéig? Írja az ellenőrzött járművek áthaladási idejét és rendszámát a vizsgalt.txt állományba az áthaladás sorrendjében, a bemenettel egyező formában! Ügyeljen arra, hogy az időadatokhoz tartozó számok a bevezető nullákat tartalmazzák!


TÍPUSA

FELÉPÍTÉSE

SZEREPE

FELHASZNÁLÁS

a [1000]

adat típus 100 elemű tömb, minden eleme egy adatötöst tartalmaz

struktúra 5 adatmezővel: vk - választókerület sz – kapott szavazatok száma vnev - vezetéknév knev - keresztnév part – támogató párt/független


globális

V

konstans értéke 12345 int

Választásra jogosultak száma Forrás fájlban található sorok száma, azaz a képviselőjelöltek száma

globális

N

globális

164

Programozási feladatok megoldása PROGRAMKÓD #include #include #include <string> #include <windows.h> using namespace std; int N; struct adatok{ int h; // óra int p; //perc int m; //másodperc string r; //rendszám } a[1000]; void kiir(int x) { cout << x << ". feladat" << endl; } void F1() { ifstream be; be.open("jarmu.txt"); int i=0; while(!be.eof()) { be >> a[i].h; be >> a[i].p; be >> a[i].m; be >> a[i].r; i++; } N=i; be.close(); } void F2() { int x = a[N-1].h+1; //utolsó elem órája + 1, mert egész óráig dolgoztak int y = a[0].h; //első elem órája, mert egész órakor kezdték cout << x-y << " orat dolgoztak legalabb." << endl; //8kor kezdték és 14ig tartott, ha feltételezzük, hogy nem dolgoztak munkdaidőn kívűl }

165

Programozási feladatok megoldása void F3() { for(int i=0; imax) { index=i; max=(a[i+1].h*3600+a[i+1].p*60+a[i+1].m)(a[i].h*3600+a[i].p*60+a[i].m); } } cout << a[index].h << ":" << a[index].p << ":" << a[index].m << " - " << a[index+1].h << ":" << a[index+1].p << ":" << a[index+1].m << endl; }

166

Programozási feladatok megoldása void F6() { string x; cout << "Kerem a keresett rendszamot, ismeretlen betuit '*' jellel helyetesitve: "; getline(cin,x); int azonos; int db=0; for(int i=0; i
167

Programozási feladatok megoldása void F7() { ofstream ki; ki.open("vizsgalt.txt"); int j; if(a[0].h<10) ki << "0" << a[0].h << " "; else ki << a[0].h << " "; if(a[0].p<10) ki << "0" << a[0].p << " "; else ki << a[0].p << " "; if(a[0].m<10) ki << "0" << a[0].m << " "; else ki << a[0].m << " "; ki << a[0].r << endl; for(int i=0; i= 300 ) //azért >=300, mert abban a pillanatban, amint lejár a 300 másodperc(=5 perc), rögtön képesek egy új járművet ellenőrizni

{ if(a[i+j].h<10) ki << "0" << a[i+j].h << " "; else ki << a[i+j].h << " "; if(a[i+j].p<10) ki << "0" << a[i+j].p << " "; else ki << a[i+j].p << " "; if(a[i+j].m<10) ki << "0" << a[i+j].m << " "; else ki << a[i+j].m << " "; ki << a[i].r << endl; i+=j; break; } j++; } } ki.close(); } int main() { setlocale(LC_ALL,"hun"); F1(); kiir(2); F2(); kiir(3); F3(); kiir(4); F4(); kiir(5); F5(); kiir(6); F6(); F7(); return 0; } 168

2014. MÁJUS EMELT IP V 6


FELADAT SZÖVEGE A számítógépes hálózatok üzemeltetésében az IPv4-es címeket lassan leváltja az IPv6-os címzési rendszer, amely az eddigi 32 bit hosszúságú címek helyett 128 bit hosszúságú címeket használ. Az IPv6-os címeket hexadecimális alakban ábrázoljuk, nyolc darab négyes csoportba osztva. Az egyes számjegyek a tízes számrendszerben is használt számjegyek, valamint az a, b, c, d, e, f betűk lehetnek. Az egyes csoportokat kettősponttal választjuk el. Ezek alapján formailag megfelelő IPv6-os cím a következő: 2001:0db8:03cd:0000:0000:ef45:0006:0123 Egy nagyvállalatnál készítettek egy programot, ami a cég szerverén tárolt összes dokumentumból kigyűjtötte az IPv6-címeket. Az így keletkezett gyűjteményt az ip.txt fájl tárolja. Minden IP-címet csak az első előfordulásakor rögzítettek. Az állomány legalább 20, de legfeljebb 500 adatsort, soronként egy IP-címet tartalmaz a következő példának megfelelően: 2001:0db8:03cd:0000:0000:ef45:0006:0123 2001:0e10:0000:aabc:0000:01ac:0000:0001 fdf8:f53b:82e4:0000:0000:0000:0000:0053 fc00:0000:0000:ad65:0124:33ab:0100:6543 … A vállalatnál háromféle IP-cím fordul elő. A feladat megoldásában csak ezekkel a címekkel kell foglalkozni:  A 2001:0db8 kezdetű címek a dokumentációs címek, eszközöknek nincsenek kiosztva.  A 2001:0e kezdetű címek az informatikai eszközöknek kiosztott globális egyedi címek.  Az fc, valamint az fd kezdetű címek az eszközöknek kiosztott helyi egyedi címek. Több szabály vonatkozik a címek rövidebb leírásának lehetőségére:  Az egyes csoportokban a bevezető nullák elhagyhatók. Például így leírva a fenti cím: 2001:db8:3cd:0:0:ef45:6:123  Kettő vagy több csak nullákból álló csoportot le lehet egyszerűsíteni két kettőspont közötti üres csoportra. Ezzel a szabállyal tovább egyszerűsítve az előző címet: 2001:db8:3cd::ef45:6:123  Ha egy címben több helyen is vannak csak nullákból álló csoportok, akkor is csak egyszer lehet ez utóbbi módszerrel rövidítést végrehajtani. Ilyen esetben mindig a több nullás csoportot kell rövidíteni. Ha azonos számú nullás csoport található a címen belül több helyen is, akkor balról az elsőt kell rövidíteni. Például: 2001:0000:0000:00f5:0000:0000:0000:0123 Rövidítve: 2001:0:0:f5::123 Készítsen programot, amely az ip.txt állomány adatait felhasználva az alábbi kérdésekre válaszol! A program forráskódját mentse cimek néven! (A program megírásakor a megadott adatok helyességét, érvényességét nem kell ellenőriznie, feltételezheti, hogy a rendelkezésre álló adatok a leírtaknak megfelelnek.) A képernyőre írást igénylő részfeladatok eredményének megjelenítése előtt írja a képernyőre a feladat sorszámát (például: 3. feladat:)! Ha a felhasználótól kér be adatot, jelenítse meg a képernyőn, hogy milyen értéket vár! Az ékezetmentes kiírás is elfogadott. A képernyőre írást igénylő feladatok eredményét a feladatok utáni mintának megfelelően jelenítse meg! 1. Olvassa be az ip.txt állományban talált adatokat, s annak felhasználásával oldja meg a következő feladatokat! 2. Határozza meg és írja a képernyőre, hogy hány adatsor van az állományban!

170

Programozási feladatok megoldása 3. Írja a képernyőre az állományban található legalacsonyabb IP-címet! A megoldásában felhasználhatja, hogy a betűk ASCII-kódjai a számok ASCII-kódjai után találhatók a kódtáblában. 4. Határozza meg, hogy az állományban hány darab IP-cím van az egyes fajtákból! Az eredményt jelenítse meg a képernyőn a mintának megfelelően! 5. Gyűjtse ki a sok.txt állományba azokat az IP-címeket, melyek legalább 18 nullát tartalmaznak! A fájlban minden sor elején szerepeljen az eredeti állományból a cím sorszáma! Ezt kövesse egy szóközzel elválasztva a cím az ip.txt állományban szereplő alakjával! 6. Kérjen be a felhasználótól egy sorszámot! Az állományban a megadott sorszámon található IPcímet rövidítse a csoportokon belüli bevezető nullák elhagyásával! Az állományban található alakot és a rövidített változatot írja a képernyőre egymás alá! 7. Az előző feladatban használt IP-címet rövidítse tovább az egymást követő nullás csoportok rövidítésére vonatkozó szabályoknak megfelelően! Az eredményt jelenítse meg a képernyőn! Amennyiben nem rövidíthető, írja ki: „Nem rövidíthető tovább.”! Minta a szöveges kimenetek kialakításához: 2. feladat: Az állományban 372 darab adatsor van. 3. feladat: A legalacsonyabb tárolt IP-cím: 2001:0db8:0000:00b9:0800:0f00:e02a:71ac 4. feladat: Dokumentációs cím: 106 darab Globális egyedi cím: 120 darab Helyi egyedi cím: 146 darab 6. feladat: Kérek egy sorszámot: 10 fcef:b0e7:7d20:0000:0000:0000:3b95:0565 fcef:b0e7:7d20:0:0:0:3b95:565 7. feladat: fcef:b0e7:7d20::3b95:565 FONTOSABB VÁLTOZÓK ADAT NEVE

TÍPUSA

FELÉPÍTÉSE

SZEREPE

FELHASZNÁLÁS

ip[500]

string típusú 500 elemű tömb

alaphelyzetben minden string 255 karakter hoszszú lehet maximum

A fájlban található ipcímek tárolása.

globális

N

int

globális

ipx

string

resz[8]

string típusú 8 elemű tömb

Forrás fájlban található sorok száma, azaz az ip-címek száma A 6. és 7. feladatban kell a címek rövidítéséhez minden ip-cím 8 részből áll, ezeknek a részeknek a kezeléséhez kell

globális

globális

171

Programozási feladatok megoldása PROGRAMKÓD #include #include #include <string> #include using namespace std; string ip[500]; int N; string ipx; string resz[8]; void kiir(int sorszam) { cout << sorszam << ". feladat" << endl; } void F1() { ifstream be; be.open("ip.txt"); int i=0; while(!be.eof()) { be >> ip[i]; cout << ip[i] << endl; i++; } N=i-1; be.close(); } void F2() { cout << "Az állományban " << N << " darab adatsor van" << endl; }

172

Programozási feladatok megoldása void F3() { ofstream ki2; ki2.open("rendezett.txt"); string ip2[500]; for(int i=0;iip2[j]) { swap(ip2[i],ip2[j]); } } } for(int i=0;i
173

Programozási feladatok megoldása void F5() { ofstream ki; ki.open("sok.txt"); int nulla; int hatar=18; string ssz; for(int i=0;i=hatar) { ki << i+1 << " " << ip[i] << endl; cout << i+1 << " " << ip[i] << endl; } } ki.close(); } void F6() { int ssz; cout << "Kérek egy sorszámot: "; cin >> ssz; int i=ssz-1; int index=0; cout << ip[i] << endl; for(int j=0;j<8;j++) { resz[j]=ip[i].substr(j*5,4); } cout << endl; for(int i=0;i<8;i++) { while(resz[i][0]=='0') { resz[i]=resz[i].substr(1,4); } if(resz[i].length()==0) resz[i]="0"; if(i<7) { ipx+=resz[i]+":"; } else { ipx+=resz[i]; } } cout << "A rövidített IP-cím:" << endl; cout << ipx << endl; }

174

Programozási feladatok megoldása void F7() { int max=0; int db=0, hely; for(int i=0;i<8;i++) { if(resz[i]=="0") { int j=i+1; while(resz[j]=="0") { j++; } db=j-i; if(db>max) { max=db; db=0; hely=i; } i=j; } } cout << "Lehetséges rövidítés helye: " << hely << ", száma: " << max << endl; for(int i=hely;i
175

Programozási feladatok megoldása int main() { setlocale(LC_ALL, "hun"); kiir(1); F1(); kiir(2); F2(); kiir(3); F3(); kiir(4); F4(); kiir(5); F5(); kiir(6); F6(); kiir(7); F7(); return 0; }

176

2014. OKTÓBER EMELT NÉZŐTÉR


FELADAT SZÖVEGE A Fregoli Színházban a jegyeladásokat elektronikusan rögzítik. A színházban 15 sor, és soronként 20 szék van. A sorokat 1-től 15-ig számozzák, a sorokon belül pedig a székeket 1-től 20-ig. Egy előadásra a pillanatnyilag eladott jegyek eloszlását a foglaltsag.txt szöveges állomány tartalmazza, melyben „x” jelzi a foglalt és „o” a szabad helyeket. Például: ooxxxoxoxoxoxxxooxxx xxxxxxxxxxxxxxxxxxxx oxxxxxoooxxxxxxxxxxo … Az első sor 1-2. széke például még szabad, míg a 2. sorba az összes jegyet eladták. A jegyek ára nem egyforma, összege a helytől függően ötféle lehet. Azt, hogy az adott szék az öt közül melyik árkategóriába tartozik, a kategoria.txt fájl tartalmazza az alábbi formában: Például: 33222111111111122233 43322221111112222334 44433322222222333444 … A példa szerint az 1. sor 2. széke a 3. kategóriába, a 2. sor 1. széke a 4. kategóriába esik. Készítsen programot nezoter néven a következő feladatok megoldására! A program futása során a képernyőre való kiíráskor, illetve az adatok billentyűzetről való beolvasásakor utaljon a feladat sorszámára (például: 3. feladat), és a kiírandó, illetve bekérendő tartalomra! Az ékezetmentes kiírás is elfogadott. 1. Olvassa be és tárolja el a foglaltsag.txt és a kategoria.txt fájl adatait! 2. Kérje be a felhasználótól egy sor, és azon belül egy szék számát, majd írassa ki a képernyőre, hogy az adott hely még szabad-e vagy már foglalt! 3. Határozza meg, hogy hány jegyet adtak el eddig, és ez a nézőtér befogadóképességének hány százaléka! A százalékértéket kerekítse egészre, és az eredményt a következő formában írassa ki a képernyőre: Például: Az előadásra eddig 156 jegyet adtak el, ez a nézőtér 42%-a. 4. Határozza meg, hogy melyik árkategóriában adták el a legtöbb jegyet! Az eredményt írassa ki a képernyőre az alábbi formában: Például: A legtöbb jegyet a(z) 3. árkategóriában értékesítették.

5. A jegyek árát kategóriánként a következő táblázat tartalmazza: árkategória ár (Ft)

1 5000

2 4000

3 3000

4 2000

5 1500

Mennyi lenne a színház bevétele a pillanatnyilag eladott jegyek alapján? Írassa ki az eredményt a képernyőre!

178

Programozási feladatok megoldása 6. Mivel az emberek általában nem egyedül mennek színházba, ha egy üres hely mellett nincs egy másik üres hely is, akkor azt nehezebben lehet értékesíteni. Határozza meg, és írassa ki a képernyőre, hogy hány ilyen „egyedülálló” üres hely van a nézőtéren! 7. A színház elektronikus eladási rendszere az érdeklődőknek az üres helyek esetén a hely árkategóriáját jeleníti meg, míg a foglalt helyeket csak egy „x” karakterrel jelzi. Készítse el ennek megfelelően a fenti adatokat tartalmazó szabad.txt fájlt! Például: 33xxx1x1x1x1xxx22xxx xxxxxxxxxxxxxxxxxxxx 4xxxxx222xxxxxxxxxx4 … FONTOSABB VÁLTOZÓK ADAT NEVE

TÍPUSA

N M

konstans konstans

FELÉPÍTÉSE

SZEREPE

FELHASZNÁLÁS

sorok száma globális oszlopok (székek) száma egy sor- globális ban sor[N] string foglaltsag.txt file egy-egy sorát globális tartalmazza, azaz N db stringet (lsd. foglaltsag.txt képet lent) kat[N] string kategoria.txt file egy-egy sorát globális tartalmazza, azaz N db stringet (lsd. kategoria.txt képet lent) m[5] int 5 elemű A 4. és 5. feladatban kap szereglobális tömb pet, amikor az egyes kategóriákat darabra megszámoljuk, illetve forintra váltjuk Mivel a sor[] és a kat[] tömbök stringeket tartalmaznak, lehetőség van arra, hogy karakterenként is kezeljük ezeket, de ekkor a sort és a katot is mátrixként kell kezelni. Itt lesz szerepe az M konstansnak. Lásd: már a 2. feladattól kezdve mátrixként kezeljük a sort. (N sor, és minden sorban M szék, azaz karakter.)

179

Programozási feladatok megoldása PROGRAMKÓD #include #include #include #include <stdio.h> #include <windows.h> #include #include <string> #include #include <stdlib.h> #define N 15 //sor #define M 20 //oszlop using namespace std; string sor[N]; string kat[N]; int m[5]; //money kategóriánként void F1() { ifstream fsor; fsor.open("foglaltsag.txt"); ifstream ksor; ksor.open("kategoria.txt"); for(int i=0;i> sor[i]; ksor >> kat[i]; } ksor.close(); fsor.close(); for(int i=0;i> s; cout << "Szék száma: "; cin >> o; if(sor[s-1][o-1]=='x') cout << "Foglalt"; else cout << "Szabad"; cout << endl; }

180

Programozási feladatok megoldása void F3() { float e=0; //Az e float típusú legyen, hogy a törtrésze se vesszen el! for(int s=0;s
if(sor[s][o]=='x') m[kategoria]++; } } for(int i=0;i<5;i++) { cout << i+1 << ": " << m[i] << endl; } kategoria=1; int max=m[0]; //maximum eladás db, az index pedig //a kategóriát mondja meg!!! for(int i=1;i<5;i++) { if(m[i]>max) { max=m[i];kategoria=i+1; } } cout << "A legtöbb jegyet a(z) " << kategoria << ". árkategóriában értékesítették." << endl; }

181

Programozási feladatok megoldása void F5() { int bev=0; for(int i=0;i<5;i++) { if(i==0) bev=bev+m[0]*5000; //1 kategória darabszáma*5000 if(i==1) bev=bev+m[1]*4000; //2 kategória darabszáma*4000 if(i==2) bev=bev+m[2]*3000; //3 kategória darabszáma*3000 if(i==3) bev=bev+m[3]*2000; //4 kategória darabszáma*2000 if(i==4) bev=bev+m[4]*1500; //5 kategória darabszáma*1500 } cout << "A színház bevétele: " << bev << " Ft" << endl; } void F6() { int u_db=0; for(int s=0;s0&&o<M&&sor[s][o]=='o'&&sor[s][o-1]=='x'&&sor[s][o+1]=='x') u_db++; //jobbszél üres, de előtte foglalt if(o==M-1&&sor[s][o]=='o'&&sor[s][o-1]=='x') u_db++; } } cout << "Egyedülálló helyek száma: " << u_db << endl; } void F7() { ofstream ki; ki.open("szabad.txt"); for(int s=0;s
182

Programozási feladatok megoldása int main() { setlocale(LC_ALL, "hun"); cout << "1. feladat" << endl; F1(); cout << "2. feladat" << endl; F2(); cout << "3. feladat" << endl; F3(); cout << "4. feladat" << endl; F4(); cout << "5. feladat" << endl; F5(); cout << "6. feladat" << endl; F6(); cout << "7. feladat" << endl; F7(); return 0; }

183

INFORMATIKA ÉRETTSÉGI EMELT SZINT PROGRAMOZÁSI FELADATOK MEGOLDÁSA C++

Recommend Documents