Szerkesztő:LinguisticMystic/ru/программирование/средняя школа
2003 Triatlon
[szerkesztés]Egy triatlon versenyen a versenyzőknek a verseny folyamán egymás után kell először úszniuk, kerékpározniuk majd futniuk. Az győz, aki a legrövidebb idő alatt fejezi be a versenyt.
Az egyes versenyzők adatai és időeredményei a triatlon.be fájlban találhatók.
Az első sorban 0<N<100, versenyzők száma, a következő sorokban a versenyzők adatai a következők szerint szerepelnek:
Név Úszás idő Kerékpár idő Futás idő
Például:
Gipsz Jakab 1345 2312 7988
Az elért időeredményeket másodpercekben tároljuk.
- Olvassa be a triatlon.be fájlból az adatokat!
- Írja ki az összesített időeredmények alapján az első három versenyző nevét a képernyőre!
- Írja ki a képernyőre az első helyezett nevét és azt, hogy mekkora volt az átlagsebessége (km/h-ban) az úszásban, kerékpározásban és futásban, ha a távok a következők voltak:
- Úszás: 1,5 km, Kerékpározás:40 km, Futás: 10 km!
- Konvertálja át a versenyzők végső időeredményeit óó:pp:ss formátumra (Óra:Perc:Másodperc). Mindegyik értéket két számjeggyel jelölje!
- A versenyzők nevét és az átkonvertált, összesített időeredményét írja ki a triatlon.ki fájlba!
- A fájlban a név mellett szerepeljen az időeredmény, például: Gipsz Jakab 03:14:05!
- Mivel a közönség kíváncsi arra is, hogy az egyes számokat (azaz az úszást, kerékpározást, futást) kik nyerték, ezért a reszer.ki fájlba 3 versenyző nevét és átkonvertált, időeredményét kell kiírni. Az első név az úszás győztesének a neve és az úszásban elért ideje, a második sorban a kerékpározásban győztes neve és a kerekpározásban elért időeredménye, a harmadik sorban pedig a futásban legjobb időt elért versenyző neve és időeredménye szerepeljen! Ha többen ugyanazt az eredményt érték el valamelyik versenyszámban, akkor elég az egyikük nevét kiírni.
#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <iomanip>
using namespace std;
struct Versenyzo {
string nev;
int uszas, kerekpar, futas, osszido;
};
string konvertalo(int t) {
int ora = t / 3600;
int perc = (t % 3600) / 60;
int mp = t % 60;
char buffer[9];
snprintf(buffer, sizeof(buffer), "%02d:%02d:%02d", ora, perc, mp);
return string(buffer);
}
int main() {
ifstream be("triatlon.be");
if (!be) {
cerr << "Hiba a fajl megnyitasakor!" << endl;
return 1;
}
int n;
be >> n;
be.ignore();
vector<Versenyzo> eredmenyek;
for (int i = 0; i < n; i++) {
Versenyzo v;
getline(be, v.nev);
be >> v.uszas >> v.kerekpar >> v.futas;
be.ignore();
v.osszido = v.uszas + v.kerekpar + v.futas;
eredmenyek.push_back(v);
}
be.close();
// 2. feladat - Első három helyezett
sort(eredmenyek.begin(), eredmenyek.end(), [](const Versenyzo &a, const Versenyzo &b) {
return a.osszido < b.osszido;
});
cout << "Az első három helyezett:\n";
for (int i = 0; i < min(3, (int)eredmenyek.size()); i++) {
cout << i + 1 << ". " << eredmenyek[i].nev << endl;
}
// 3. feladat - Átlagsebesség számítása
if (!eredmenyek.empty()) {
double vu = 3.6 * 1500 / eredmenyek[0].uszas;
double vk = 3.6 * 40000 / eredmenyek[0].kerekpar;
double vf = 3.6 * 10000 / eredmenyek[0].futas;
cout << "\nAz első helyezett neve: " << eredmenyek[0].nev << endl;
cout << "Úszás: " << fixed << setprecision(2) << vu << " km/h, ";
cout << "Kerékpár: " << vk << " km/h, ";
cout << "Futás: " << vf << " km/h\n";
}
// 4. feladat - Idők konvertálása és fájlba írás
ofstream ki("triatlon.ki");
for (auto &v : eredmenyek) {
ki << v.nev << " " << konvertalo(v.osszido) << "\n";
}
ki.close();
cout << "\nA triatlon.ki fájl kiírása befejeződött.\n";
// 7. feladat - reszer.ki fájlba a versenyszámok nyertesei
ofstream reszer("reszer.ki");
for (int i = 0; i < 3; i++) {
auto minElem = min_element(eredmenyek.begin(), eredmenyek.end(), [i](const Versenyzo &a, const Versenyzo &b) {
return (i == 0 ? a.uszas < b.uszas : i == 1 ? a.kerekpar < b.kerekpar : a.futas < b.futas);
});
reszer << minElem->nev << " " << konvertalo(i == 0 ? minElem->uszas : i == 1 ? minElem->kerekpar : minElem->futas) << "\n";
}
reszer.close();
cout << "A reszer.ki fájl kiírása befejeződött.\n";
cout << "\nA befejezéshez nyomd meg az ENTER billentyűt!";
cin.get();
return 0;
}
2003 Kugli
[szerkesztés]A kugli játéknál 9 bábut állítanak fel egy négyzet alakú helyre, ezeket a bábukat egy golyóval lehet ledönteni. A játékosok egymás után dobnak. A játékszabály a következő: a játékosoknak legalább annyi bábut kell ledöntenie, mint amennyit az előtte dobó játékos ledöntött. Ha kevesebbet dönt le, akkor hibapontot kap. A játékos 2 hibapont után kiesik a játékból. A játékosok száma 5, és a játék 4 kör alatt ért véget. Az első játékos az első körben nem kaphat hibapontot, de a további körökben az előző kör utolsó dobáseredményéhez viszonyítják teljesítményét. A kugli játék körönkénti eredményeit az eredm1.txt, eredm2.txt, eredm3.txt, eredm4.txt fájlokban tároljuk. Minden fájlban a még versenyben lévő személyek nevét és a körben elért eredményét, a következőképpen:
Versenyző neve Ledöntött bábuk száma
Ha valaki kiesett a játékból, akkor a további körök eredményeit tároló fájlban a ledöntött bábuk száma sorban értékként 10 szerepel. Például:
Gipsz Jakab 5 Kelep Elek 10 Kiss Géza 6 Nagy Péter 4 Kovács Éva 8
- Olvassa be az eredm1.txt fájlból az adatokat!
- A szabályok alapján állapítsa meg, hogy az első körben mely játékosok kaptak hibapontot. Ezek nevét írja ki a képernyőre!
- Olvassa be az eredm2.txt, eredm3.txt és az eredm4.txt fájlokból az adatokat!
- Számítsa ki, hogy a versenyzők a játék során külön-külön mennyi bábut döntöttek le, az eredményt írja ki a képernyőre! A kiírásnál a név mellett szerepeljen az elért eredmény! Például:
Gipsz Jakab 24
Kelep Elek 12
- Írja ki a képernyőre a legtöbb pontot elért versenyző nevét és eredményét!
- Állapítsa meg – a fájlokban lévő adatok alapján – a kiesett versenyzők nevét és azt, hogy melyik körben estek ki! A neveket és a kör számát írja ki a képernyőre!
- Írja ki a képernyőre azoknak a versenyzőknek a nevét, akiknek sikerült 9 bábut eldönteniük a dobásukkal a játék során! A nevük mellett szerepeljen, hogy mely körökben érték el ezt az eredményt! (A név legfeljebb egyszer szerepeljen!)
#include <iostream>
#include <fstream>
#include <vector>
#include <map>
#include <algorithm>
using namespace std;
struct Player {
string name;
vector<int> scores;
int totalScore = 0;
int eliminationRound = 0;
vector<int> ninePinRounds;
};
vector<string> files = {"eredm1.txt", "eredm2.txt", "eredm3.txt", "eredm4.txt"};
map<string, Player> players;
void readFile(const string &filename, int roundNum) {
ifstream file(filename);
if (!file) {
cerr << "Error opening file: " << filename << endl;
return;
}
for (int i = 0; i < 5; i++) {
string name;
int score;
getline(file, name);
file >> score;
file.ignore();
if (players.find(name) == players.end()) {
players[name] = {name};
}
players[name].scores.push_back(score);
if (score != 10) {
players[name].totalScore += score;
} else if (players[name].eliminationRound == 0) {
players[name].eliminationRound = roundNum - 1;
}
if (score == 9) {
players[name].ninePinRounds.push_back(roundNum);
}
}
file.close();
}
int main() {
cout << "1. feladat\n";
readFile(files[0], 1);
cout << "Az eredm1.txt fájl adatainak beolvasása megtörtént.\n\n";
cout << "2. feladat\n";
cout << "Az 1. körben hibapontot kaptak:\n";
vector<Player> playerList;
for (auto &p : players) {
playerList.push_back(p.second);
}
for (int i = 1; i < playerList.size(); i++) {
if (playerList[i].scores[0] < playerList[i - 1].scores[0]) {
cout << " " << playerList[i].name << "\n";
}
}
cout << "\n";
cout << "3. feladat\n";
for (int i = 1; i < 4; i++) {
readFile(files[i], i + 1);
}
cout << "Az összes fájl adatainak beolvasása megtörtént.\n\n";
cout << "4. feladat\n";
cout << "A ledöntött bábuk száma:\n";
for (const auto &p : players) {
cout << " " << p.second.name << " " << p.second.totalScore << "\n";
}
cout << "\n";
cout << "5. feladat\n";
auto maxPlayer = max_element(players.begin(), players.end(), [](const auto &a, const auto &b) {
return a.second.totalScore < b.second.totalScore;
});
cout << "A legtöbb pontot elért versenyző: " << maxPlayer->second.name << " " << maxPlayer->second.totalScore << " pont\n\n";
cout << "6. feladat\n";
cout << "A kiesett versenyzők és a kiesés köre:\n";
for (const auto &p : players) {
if (p.second.eliminationRound > 0) {
cout << " " << p.second.name << " " << p.second.eliminationRound << "\n";
}
}
cout << "\n";
cout << "7. feladat\n";
cout << "A 9 pontos versenyzők és a 9 pontos körök:\n";
for (const auto &p : players) {
if (!p.second.ninePinRounds.empty()) {
cout << " " << p.second.name << " ";
for (int round : p.second.ninePinRounds) {
cout << round << " ";
}
cout << "\n";
}
}
cout << "\n";
cout << "A befejezéshez nyomd meg az ENTER billentyűt!";
cin.get();
return 0;
}
2004. május - Személyazonosító jel
[szerkesztés]Az ország állampolgárainak van egyedi azonosítójuk. Ez a személyazonosító jel. Az 1997. január 1-je után születetteknél ez a következőképpen néz ki.
A személyazonosító jel 11 jegyű. Az első jegy a személy nemét jelöli, az alábbi táblázat alapján.
| 1997. január 1. és 1999. december 31. között született | 1999. december 31. után született | ||
| Férfi | Nő | Férfi | Nő |
| 1 | 2 | 3 | 4 |
A 2–7 számjegyek a születési év utolsó két jegyét, a születési hónapot és napot tartalmazza. A 8–10. számjegyek az azonos napon születettek születési sorszáma. A 11. jegy az első tíz jegyből képzett ellenőrző szám.
Írjon olyan programot, amely végrehajtja az alábbi utasításokat!
a) Kérje be egy személyazonosító jel első 10 jegyét!
b) Írassa ki a képernyőre, a személyazonosító jel alapján, hogy az adott személy férfi vagy nő!
c) Írassa ki a képernyőre, az adott személy születési sorszámát!
d) Írassa ki a képernyőre, hogy hányadik születésnapja van ebben az évben a személynek!
e) Kérjen be egy másik személyazonosító jelet is! (Szintén csak az első 10 jegyét!)
f) Határozza meg, a két beadott személyazonosító jel alapján, hogy melyik személy idősebb! (Ha két ember ugyanakkor született, akkor a 8–10. jegy alapján döntse el, melyik az idősebb!) Az eredményt a képernyőn jelenítse meg!
g) Mennyi a különbség a születési éveik között? Figyeljen a 1999. dec. 31. után születettekre is! Az eredményt írassa ki a képernyőre!
h) A másodikként beadott személyazonosító jelből, számítsa ki a 11. jegyet és írassa ki a képernyőre a teljes személyazonosító jelet. A számítás a következő szabály alapján működik. A első tíz számjegy mindegyikét szorozzuk meg egy számmal. Mégpedig a 10. helyen állót eggyel, a 9. helyen állót kettővel és így tovább. Az így kapott szorzatokat adjuk össze. A kapott összeget osszuk el tizeneggyel. Az osztás maradéka lesz a 11. jegy.
Kivéve, ha a maradék 10. Mert ekkor azt a születési sorszámot nem adják ki.
Ebben az esetben írja ki, hogy hibás a születési sorszám!
i) Mindkét korábban beadott személyazonosító jel első 10 jegyét írja a szemszam.txt fájlba!
#include <iostream>
#include <fstream>
#include <string>
#include <ctime>
#include <cstdlib>
using namespace std;
int getBirthYear(const string& code) {
int year = stoi(code.substr(1, 2));
if (code[0] == '1' || code[0] == '2')
year += 1900;
else
year += 2000;
return year;
}
int calculate11thDigit(const string& szj) {
int s = 0;
for (int i = 0; i < 10; ++i) {
s += (szj[i] - '0') * (10 - i);
}
int ell = s % 11;
return (ell == 10) ? -1 : ell;
}
int main() {
string szj1, szj2;
cout << "\na) feladat\n";
cout << "Adja meg egy személyazonosító jel első tíz jegyét! ";
cin >> szj1;
cout << "\nb) feladat\n";
if (szj1[0] == '1' || szj1[0] == '3')
cout << "A megadott személy férfi.\n";
else if (szj1[0] == '2' || szj1[0] == '4')
cout << "A megadott személy nő.\n";
else
cout << "A megadott személyazonosító jel hibás.\n";
cout << "\nc) feladat\n";
cout << "A megadott személy születési sorszáma: " << szj1.substr(7) << "\n";
cout << "\nd) feladat\n";
time_t now = time(0);
tm *ltm = localtime(&now);
int currentYear = 1900 + ltm->tm_year;
cout << "A megadott személynek idén a(z) " << (currentYear - getBirthYear(szj1)) << ". születésnapja van.\n";
cout << "\ne) feladat\n";
cout << "Kérem egy másik személyazonosító jel első tíz jegyét! ";
cin >> szj2;
cout << "\nf) feladat\n";
string date1 = to_string(getBirthYear(szj1)) + szj1.substr(3);
string date2 = to_string(getBirthYear(szj2)) + szj2.substr(3);
cout << ((date1 < date2) ? "Az első személy az idősebb.\n" : "A második személy az idősebb.\n");
cout << "\ng) feladat\n";
cout << "A két megadott személy születési éveinek különbsége: " << abs(getBirthYear(szj2) - getBirthYear(szj1)) << "\n";
cout << "\nh) feladat\n";
int ell = calculate11thDigit(szj2);
if (ell == -1)
cout << "Hibás a születési sorszám.\n";
else
cout << "A teljes második kód: " << szj2 + to_string(ell) << "\n";
cout << "\ni) feladat\n";
ofstream outfile("szemszam.txt");
outfile << szj1 << "\n" << szj2 << "\n";
outfile.close();
cout << "A kiíratás és a szövegfájl lezárása sikeresen befejeződött.\n";
cout << "A befejezéshez nyomd meg az ENTER billentyűt!";
cin.ignore();
cin.get();
return 0;
}
2005. május - Lottó
[szerkesztés]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!
- Kérje be a felhasználótól az 52. hét megadott lottószámait!
- A program rendezze a bekért lottószámokat emelkedő sorrendbe! A rendezett számokat írja ki a képernyőre!
- 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!
- Í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!
- 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!
- 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!
- 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!
- 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ű.)
- 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.)
Példa egy lehetséges eredmény elrendezésére (6 sorban, soronként 15 érték).
| 4 | 2 | 2 | 4 | 2 | 2 | 6 | 1 | 1 | 2 | 1 | 5 | 2 | 1 | 1 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | 3 | 5 | 0 | 5 | 5 | 2 | 6 | 6 | 5 | 1 | 0 | 6 | 4 | 3 |
| 3 | 3 | 5 | 4 | 3 | 1 | 4 | 2 | 2 | 4 | 2 | 4 | 1 | 2 | 3 |
| 4 | 2 | 1 | 2 | 3 | 2 | 2 | 2 | 4 | 4 | 5 | 1 | 3 | 5 | 5 |
| 5 | 2 | 0 | 2 | 2 | 4 | 4 | 3 | 1 | 3 | 6 | 1 | 5 | 6 | 2 |
| 4 | 3 | 2 | 2 | 3 | 1 | 1 | 4 | 1 | 3 | 3 | 2 | 1 | 5 | 3 |
#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
ifstream be("lottosz.dat");
ofstream ki("lotto52.ki");
vector<vector<int>> szamok(51, vector<int>(5));
for(int i=0; i<51; i++)
for(int j=0; j<5; j++)
be >> szamok[i][j];
vector<int> het52(5);
cout << "Adja meg az 52. hét lottószámait:" << endl;
for(int &sz : het52)
cin >> sz;
sort(het52.begin(), het52.end());
cout << "52. hét rendezett számai: ";
for(int sz : het52) cout << sz << " ";
cout << endl;
int sorszam;
cout << "Adjon meg egy hét sorszámot (1-51): ";
cin >> sorszam;
cout << sorszam << ". hét számai: ";
for(int sz : szamok[sorszam-1]) cout << sz << " ";
cout << endl;
vector<int> gyakorisag(91,0);
for(auto &het : szamok)
for(int sz : het)
gyakorisag[sz]++;
bool volt_kihuzatlan = false;
for(int i=1; i<=90; i++)
if(gyakorisag[i]==0)
volt_kihuzatlan = true;
cout << (volt_kihuzatlan ? "Van" : "Nincs") << " olyan szám, amit nem húztak ki." << endl;
int paratlan = 0;
for(auto &het : szamok)
for(int sz : het)
if(sz%2!=0) paratlan++;
cout << "Páratlan számok darabszáma: " << paratlan << endl;
// lotto52.ki fájl készítése
for(auto &het : szamok){
for(int sz : het)
ki << sz << " ";
ki << endl;
}
for(int sz : het52)
ki << sz << " ";
ki << endl;
ki.close();
// 8. feladat: számok gyakorisága
gyakorisag.assign(91, 0);
ifstream lotto52("lotto52.ki");
int tmp;
while(lotto52 >> tmp)
gyakorisag[tmp]++;
for(int i=1; i<=90; i++){
cout << gyakorisag[i] << "\t";
if(i%15==0) cout << endl;
}
// 9. feladat: prímszámok
vector<int> primek = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89};
cout << "Egyszer sem kihúzott prímszámok: ";
for(int p : primek)
if(gyakorisag[p]==0)
cout << p << " ";
cout << endl;
return 0;
}
2005. október - Vigenère tábla
[szerkesztés]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.
ABCDEFGHIJKLMNOPQRSTUVWXYZ BCDEFGHIJKLMNOPQRSTUVWXYZA CDEFGHIJKLMNOPQRSTUVWXYZAB DEFGHIJKLMNOPQRSTUVWXYZABC EFGHIJKLMNOPQRSTUVWXYZABCD FGHIJKLMNOPQRSTUVWXYZABCDE
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!
Példa:
Nyílt szöveg: Ez a próba szöveg, amit kódolunk!
Szöveg átalakítása: EZAPROBASZOVEGAMITKODOLUNK
Kulcsszó: auto
Kulcsszó nagybetűssé alakítása: AUTO
Nyílt szöveg és kulcsszöveg együtt:
| E | Z | A | P | R | O | B | A | S | Z | O | V | E | G | A | M | I | T | K | O | D | O | L | U | N | K |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| A | U | T | O | A | U | T | O | A | U | T | O | A | U | T | O | A | U | T | O | A | U | T | O | A | U |
Kódolt szöveg:
| E | T | T | D | R | I | U | O | S | T | H | J | E | A | T | A | I | N | D | C | D | I | E | I | N | E |
|---|
#include <iostream>
#include <fstream>
#include <vector>
#include <cwctype> // For towupper() in wide characters
#include <string>
#include <unordered_map>
using namespace std;
const int ALPHA_SIZE = 26;
vector<vector<wchar_t>> VigenereTable(ALPHA_SIZE, vector<wchar_t>(ALPHA_SIZE));
// Function to load Vigenère table from a file
void LoadVigenereTable(const string &filename) {
wifstream file(filename);
file.imbue(locale("")); // Enable wide character support
if (!file) {
wcerr << L"Error: Could not open " << filename.c_str() << endl;
exit(1);
}
for (int i = 0; i < ALPHA_SIZE; ++i) {
for (int j = 0; j < ALPHA_SIZE; ++j) {
file >> VigenereTable[i][j];
}
}
file.close();
}
// Function to normalize text: remove accents and convert to uppercase
wstring NormalizeText(const wstring &text) {
wstring result;
unordered_map<wchar_t, wchar_t> accents = {
{L'Á', L'A'}, {L'É', L'E'}, {L'Í', L'I'}, {L'Ó', L'O'}, {L'Ö', L'O'}, {L'Ő', L'O'},
{L'Ú', L'U'}, {L'Ü', L'U'}, {L'Ű', L'U'}, {L'á', L'a'}, {L'é', L'e'}, {L'í', L'i'},
{L'ó', L'o'}, {L'ö', L'o'}, {L'ő', L'o'}, {L'ú', L'u'}, {L'ü', L'u'}, {L'ű', L'u'}
};
for (wchar_t c : text) {
if (accents.find(c) != accents.end()) {
c = accents[c]; // Replace accented character
}
if (iswalpha(c)) { // Ensure valid characters
result += towupper(c); // Use towupper for wide characters
}
}
return result;
}
// Function to extend the key to match the text length
wstring ExtendKey(const wstring &key, int length) {
if (key.empty()) {
wcerr << L"Error: Key cannot be empty!" << endl;
exit(1);
}
wstring extendedKey;
for (int i = 0; i < length; ++i) {
extendedKey += key[i % key.size()];
}
return extendedKey;
}
// Function to encrypt text using the Vigenère cipher
wstring Encrypt(const wstring &text, const wstring &key) {
wstring ciphertext;
wstring processedText = NormalizeText(text);
wstring extendedKey = ExtendKey(key, processedText.size());
for (size_t i = 0; i < processedText.size(); ++i) {
wchar_t row = processedText[i];
wchar_t col = extendedKey[i];
if (row < L'A' || row > L'Z' || col < L'A' || col > L'Z') { // Ensure valid table lookups
wcerr << L"Error: Invalid character found in text or key." << endl;
exit(1);
}
ciphertext += VigenereTable[row - L'A'][col - L'A'];
}
return ciphertext;
}
// Function to write encrypted text to file
void WriteToFile(const string &filename, const wstring &content) {
wofstream file(filename);
if (!file) {
wcerr << L"Error: Could not open " << filename.c_str() << L" for writing." << endl;
exit(1);
}
file << content;
file.close();
}
// Main function
int main() {
setlocale(LC_ALL, ""); // Enable Unicode support
LoadVigenereTable("Vtabla.dat");
wstring plaintext, key;
wcout << L"Enter text to encode: ";
getline(wcin, plaintext);
wcout << L"Enter a key (max 5 characters): ";
wcin >> key;
key = NormalizeText(key);
if (key.empty() || key.length() > 5) {
wcerr << L"Error: Key must be between 1 and 5 characters!" << endl;
exit(1);
}
wstring encryptedText = Encrypt(plaintext, key);
wcout << L"Encoded text: " << encryptedText << endl;
WriteToFile("kodolt.dat", encryptedText);
return 0;
}
2006. február - Telefonszámla
[szerkesztés]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 | Óra | perc | mperc | Óra | perc | mperc |
|---|---|---|---|---|---|---|
| 395682211 | Telefonszám | |||||
| 9 58 15 10 3 53 | Óra | perc | mperc | Óra | perc | mperc |
| 114571155 | Telefonszám |
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 | Csúcsidőben 700 - 1800 (Ft/perc) |
Csúcsidőn kívül 000 – 700 és 1800 – 2400 (Ft/perc) |
|---|---|---|
| Vezetékes | 30 | 15 |
| Mobil társaság | 69,175 | 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 _szaml_a 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!
#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <cmath>
struct CallRecord {
int start_hour, start_minute, start_second;
int end_hour, end_minute, end_second;
std::string phone_number;
};
bool isMobile(const std::string& phone_number) {
return phone_number.rfind("39", 0) == 0 || phone_number.rfind("41", 0) == 0 ||
phone_number.rfind("71", 0) == 0;
}
int calculateMinutes(int sh, int sm, int ss, int eh, int em, int es) {
int start_total_seconds = sh * 3600 + sm * 60 + ss;
int end_total_seconds = eh * 3600 + em * 60 + es;
int duration_seconds = end_total_seconds - start_total_seconds;
return std::ceil(duration_seconds / 60.0);
}
std::vector<CallRecord> readCallsFile(const std::string& filename) {
std::vector<CallRecord> records;
std::ifstream file(filename);
if (!file) {
std::cerr << "Error opening file: " << filename << std::endl;
return records;
}
CallRecord record;
while (file >> record.start_hour >> record.start_minute >> record.start_second
>> record.end_hour >> record.end_minute >> record.end_second
>> record.phone_number) {
records.push_back(record);
}
file.close();
return records;
}
void saveCallDurations(const std::vector<CallRecord>& records, const std::string& filename) {
std::ofstream outFile(filename);
if (!outFile) {
std::cerr << "Error opening file: " << filename << std::endl;
return;
}
for (const auto& record : records) {
int minutes = calculateMinutes(record.start_hour, record.start_minute, record.start_second,
record.end_hour, record.end_minute, record.end_second);
outFile << minutes << " " << record.phone_number << std::endl;
}
outFile.close();
}
void analyzeCallTimes(const std::vector<CallRecord>& records) {
int peak_calls = 0, off_peak_calls = 0;
int mobile_minutes = 0, landline_minutes = 0;
double peak_charge = 0;
const double peak_rate_mobile = 69.175, peak_rate_landline = 30;
const double off_peak_rate_mobile = 46.675, off_peak_rate_landline = 15;
for (const auto& record : records) {
int minutes = calculateMinutes(record.start_hour, record.start_minute, record.start_second,
record.end_hour, record.end_minute, record.end_second);
bool peak = (record.start_hour >= 7 && record.start_hour < 18);
if (peak) {
peak_calls++;
if (isMobile(record.phone_number)) {
peak_charge += minutes * peak_rate_mobile;
mobile_minutes += minutes;
} else {
peak_charge += minutes * peak_rate_landline;
landline_minutes += minutes;
}
} else {
off_peak_calls++;
if (isMobile(record.phone_number)) {
mobile_minutes += minutes;
} else {
landline_minutes += minutes;
}
}
}
std::cout << "Peak calls: " << peak_calls << "\nOff-peak calls: " << off_peak_calls << std::endl;
std::cout << "Mobile minutes: " << mobile_minutes << "\nLandline minutes: " << landline_minutes << std::endl;
std::cout << "Total peak-time charges: " << peak_charge << " Ft" << std::endl;
}
int main() {
std::string filename = "hivasok.txt";
std::vector<CallRecord> records = readCallsFile(filename);
if (!records.empty()) {
std::string input_number;
std::cout << "Enter a phone number: ";
std::cin >> input_number;
std::cout << "The number is " << (isMobile(input_number) ? "mobile" : "landline") << ".\n";
int sh, sm, ss, eh, em, es;
std::cout << "Enter call start time (hh mm ss): ";
std::cin >> sh >> sm >> ss;
std::cout << "Enter call end time (hh mm ss): ";
std::cin >> eh >> em >> es;
std::cout << "Call duration: " << calculateMinutes(sh, sm, ss, eh, em, es) << " minutes\n";
saveCallDurations(records, "percek.txt");
analyzeCallTimes(records);
} else {
std::cerr << "No data found in file." << std::endl;
}
return 0;
}
2006. május - Fehérje
[szerkesztés]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ő mennyisé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 | Rövidítés | Betűjele | C | H | O | N | S |
|---|---|---|---|---|---|---|---|
| Glicin | Gly | G | 2 | 5 | 2 | 1 | 0 |
| Alanin | Ala | A | 3 | 7 | 2 | 1 | 0 |
| Arginin | Arg | R | 6 | 14 | 2 | 4 | 0 |
| Fenilalanin | Phe | F | 9 | 11 | 2 | 1 | 0 |
| Cisztein | Cys | C | 3 | 7 | 2 | 1 | 1 |
| Triptofán | Trp | W | 11 | 12 | 2 | 2 | 0 |
| Valin | Val | V | 5 | 11 | 2 | 1 | 0 |
| Leucin | Leu | L | 6 | 13 | 2 | 1 | 0 |
| Izoleucin | Ile | I | 6 | 13 | 2 | 1 | 0 |
| Metionin | Met | M | 5 | 11 | 2 | 1 | 1 |
| Prolin | Pro | P | 5 | 9 | 2 | 1 | 0 |
| Szerin | Ser | S | 3 | 7 | 3 | 1 | 0 |
| Treonin | Thr | T | 4 | 9 | 3 | 1 | 0 |
| Aszparagin | Asn | N | 4 | 8 | 3 | 2 | 0 |
| Glutamin | Gln | Q | 5 | 10 | 3 | 2 | 0 |
| Tirozin | Tyr | Y | 9 | 11 | 3 | 1 | 0 |
| Hisztidin | His | H | 6 | 9 | 2 | 3 | 0 |
| Lizin | Lys | K | 6 | 14 | 2 | 2 | 0 |
| Aszparaginsav | Asp | D | 4 | 7 | 4 | 1 | 0 |
| Glutaminsav | Glu | E | 5 | 9 | 4 | 1 | 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!
- 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 …
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!
#include <iostream>
#include <fstream>
#include <vector>
#include <map>
#include <algorithm>
using namespace std;
const int atomC = 12, atomH = 1, atomO = 16, atomN = 14, atomS = 32;
struct Aminosav {
string rovid;
char jel;
int c, h, o, n, s, molTomeg;
};
vector<Aminosav> aminosavak;
map<char, Aminosav> amino_map;
void betoltes() {
ifstream be("aminosav.txt");
if (!be) {
cout << "A fájl nem található, alapértelmezett adatokkal dolgozom!\n";
aminosavak = { {"Gly",'G',2,5,2,1,0},{"Ala",'A',3,7,2,1,0},{"Arg",'R',6,14,2,4,0},{"Phe",'F',9,11,2,1,0},{"Cys",'C',3,7,2,1,1} };
} else {
for (int i = 0; i < 20; ++i) {
Aminosav a;
be >> a.rovid >> a.jel >> a.c >> a.h >> a.o >> a.n >> a.s;
aminosavak.push_back(a);
}
be.close();
}
for(auto &a : aminosavak) {
a.molTomeg = a.c*atomC + a.h*atomH + a.o*atomO + a.n*atomN + a.s*atomS;
amino_map[a.jel] = a;
}
}
void kiiras(const string& szoveg) {
ofstream ki("eredmeny.txt", ios::app);
cout << szoveg << endl;
ki << szoveg << endl;
}
int main() {
betoltes();
// 3. feladat
sort(aminosavak.begin(), aminosavak.end(), [](Aminosav a, Aminosav b){ return a.molTomeg < b.molTomeg; });
kiiras("3. feladat");
for(auto &a : aminosavak)
kiiras(a.rovid + " " + to_string(a.molTomeg));
// BSA lánc betöltése
string bsa;
ifstream bsa_file("bsa.txt");
if (!bsa_file) bsa = "GARFCGARFCGARFCGARFCGARFCGARFCGARFCGARFCGARFCGARFC";
else bsa_file >> bsa;
// 4. feladat
int C=0,H=0,O=0,N=0,S=0;
for(char ch : bsa){
Aminosav a = amino_map[ch];
C += a.c; H += a.h; O += a.o; N += a.n; S += a.s;
}
int v = bsa.size()-1;
H -= 2*v; O -= v;
kiiras("4. feladat");
kiiras("C " + to_string(C) + " H " + to_string(H) + " O " + to_string(O) + " N " + to_string(N) + " S " + to_string(S));
// 5. feladat
int maxHossz=0,kezdet=0,vege=0,tempkezdet=0;
for(int i=0; i<bsa.size(); i++){
if(bsa[i]=='Y' || bsa[i]=='W' || bsa[i]=='F'){
if(i-tempkezdet+1>maxHossz){
maxHossz=i-tempkezdet+1;
kezdet=tempkezdet;
vege=i;
}
tempkezdet=i+1;
}
}
kiiras("5. feladat");
cout << "kezdet helye: " << kezdet+1 << " vége helye: " << vege+1 << " hossza: " << maxHossz << endl;
// 6. feladat
int cisztein_db=0;
for(int i=0;i<bsa.size()-1;i++){
if(bsa[i]=='R' && (bsa[i+1]=='A' || bsa[i+1]=='V')){
for(int j=0;j<=i;j++) if(bsa[j]=='C') cisztein_db++;
break;
}
}
kiiras("6. feladat");
cout << "Az első fehérjelánc részletben " << cisztein_db << " Cisztein (C) található!\n";
return 0;
}
2006. október - Zenei adók
[szerkesztés]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 óra0 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!
- 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!
- Írja a képernyőre, hogy melyik csatornán hány számot lehetett meghallgatni!
- 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!
- 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.
- 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!
- 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!
#include <iostream>
#include <fstream>
#include <vector>
#include <sstream>
#include <algorithm>
#include <iomanip>
using namespace std;
struct Musor {
int radio;
int hossz;
int kezd;
string cim;
};
int IdoMasodpercben(int perc, int masodperc) {
return perc * 60 + masodperc;
}
string FormatIdo(int masodperc) {
int ora = masodperc / 3600;
int perc = (masodperc % 3600) / 60;
int sec = masodperc % 60;
stringstream ss;
ss << ora << ":" << setw(2) << setfill('0') << perc << ":" << setw(2) << setfill('0') << sec;
return ss.str();
}
int main() {
ifstream file("musor.txt");
if (!file) {
cout << "Nem sikerült megnyitni a fájlt!" << endl;
return 1;
}
int z;
file >> z;
vector<Musor> musorok;
int radio, perc, sec;
string cim;
int ido[4] = {0};
string sor;
getline(file, sor); // első sor lezárása
while (getline(file, sor)) {
stringstream ss(sor);
ss >> radio >> perc >> sec;
getline(ss, cim);
cim.erase(0, 1); // első szóköz eltávolítása
int hossz = IdoMasodpercben(perc, sec);
musorok.push_back({radio, hossz, ido[radio], cim});
ido[radio] += hossz;
}
cout << "2. feladat:" << endl;
int darab[4] = {0};
for (auto& m : musorok)
darab[m.radio]++;
for (int i = 1; i <= 3; ++i)
cout << i << ". csatorna: " << darab[i] << " db szám" << endl;
cout << "3. feladat:" << endl;
vector<Musor> clapton;
for (auto& m : musorok)
if (m.radio == 1 && m.cim.find("Eric Clapton") == 0)
clapton.push_back(m);
int vege = clapton.back().kezd + clapton.back().hossz;
cout << "Eric Clapton számok közötti idő: " << FormatIdo(vege - clapton.front().kezd) << endl;
cout << "4. feladat:" << endl;
Musor omega;
for (auto& m : musorok) {
if (m.cim == "Omega:Legenda") {
omega = m;
break;
}
}
cout << "Omega:Legenda a(z) " << omega.radio << ". adón szólt." << endl;
for (int i = 1; i <= 3; ++i) {
if (i != omega.radio) {
for (auto it = musorok.rbegin(); it != musorok.rend(); ++it) {
if (it->radio == i && it->kezd <= omega.kezd) {
cout << i << ". adón ekkor: " << it->cimAdat << endl;
break;
}
}
}
}
cout << "5. feladat: Adjon meg egy keresési karaktersorozatot: ";
string keresett;
cin >> keresett;
ofstream keres("keres.txt");
keres << keresett << endl;
for (auto& m : musorok) {
string cimkisbetus = m.CimAdat;
transform(cimkis.begin(), cimAdat.end(), cim.begin(), ::tolower);
string::size_type pos = 0;
for (char c : keresett) {
pos = cim.find(tolower(c), pos);
if (pos == string::npos)
break;
pos++;
}
if (pos != string::npos)
keres << m.CimAdat << endl;
}
cout << "6. feladat:" << endl;
int ido = 0;
int kovetkezoHir = 3600;
for (auto &m : musorok) {
if (m.radio == 1) {
if (ido % 3600 + 60 + m.hossz > 3600) {
ido += 3600 - ido % 3600;
ido += 180; // hírek
}
ido += 60 + m.hossz;
}
}
cout << "Új műsoridő vége: " << FormatIdo(ido) << endl;
return 0;
}
2007. május - SMS
[szerkesztés]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:
| 2 A B C | 3 D E F | |
| 4 G H I | 5 J K L | 6 M N O |
| 7 P Q R S | 8 T U V | 9 W X Y Z |
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 : 325; eltesz : 358379; elvesz : 358379; fojt : 3658; folt : 3658; …
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.
#include <iostream>
#include <fstream>
#include <unordered_map>
#include <vector>
#include <algorithm>
using namespace std;
string kodol(char betu) {
if (string("abc").find(betu) != string::npos) return "2";
if (string("def").find(betu) != string::npos) return "3";
if (string("ghi").find(betu) != string::npos) return "4";
if (string("jkl").find(betu) != string::npos) return "5";
if (string("mno").find(betu) != string::npos) return "6";
if (string("pqrs").find(betu) != string::npos) return "7";
if (string("tuv").find(betu) != string::npos) return "8";
if (string("wxyz").find(betu) != string::npos) return "9";
return "";
}
string szoKod(const string& szo) {
string kod;
for (char ch : szo) kod += kodol(ch);
return kod;
}
int main() {
ifstream fin("szavak.txt");
ofstream fout("kodok.txt");
vector<string> szavak;
string szo;
while (fin >> szo) szavak.push_back(szo);
// 4. feladat
auto leghosszabb = max_element(szavak.begin(), szavak.end(),
[](const string& a, const string& b){ return a.size() < b.size(); });
cout << "4. feladat - Leghosszabb szó: " << *leghosszabb << " (" << leghosszabb->size() << ")\n";
// 5. feladat
int rovidDb = count_if(szavak.begin(), szavak.end(), [](const string& sz){ return sz.size() <= 5; });
cout << "5. feladat - Rövid szavak száma: " << rovidDb << "\n";
// 6. feladat
unordered_map<string, vector<string>> kodSzavak;
for (const auto& sz : szavak) {
string kod = szoKod(sz);
fout << kod << '\n';
kodSzavak[kod].push_back(sz);
}
fout.close();
cout << "6. feladat - kodok.txt elkészült.\n";
// 9. feladat
auto leggazdagabb = max_element(kodSzavak.begin(), kodSzavak.end(),
[](const auto& a, const auto& b){ return a.second.size() < b.second.size(); });
cout << "9. feladat - Leggazdagabb kód: " << leggazdagabb->first << "\n";
cout << "Szavak: ";
for (const auto& sz : leggazdagabb->second) cout << sz << ' ';
cout << '\n';
return 0;
}
2007. október - Foci
[szerkesztés]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 dolgoz- nia.
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!
- 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 adata it jegyezze be a programba és dolgozzon azzal!
- 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)
...
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!
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!
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: 12Hatá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!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
...
#include <iostream>
#include <fstream>
#include <vector>
#include <sstream>
#include <map>
#include <algorithm>
using namespace std;
struct Meccs {
int fordulo;
int hGol, vGol;
int hFel, vFel;
string hCsapat, vCsapat;
};
string eredmenyKod(int a, int b) {
return to_string(max(a, b)) + "-" + to_string(min(a, b));
}
int main() {
ifstream be("meccs.txt");
if (!be) {
cerr << "A fájl nem található!" << endl;
return 1;
}
int n;
be >> n;
vector<Meccs> meccsek(n);
for (int i = 0; i < n; i++) {
be >> meccsek[i].fordulo >> meccsek[i].hGol >> meccsek[i].vGol
>> meccsek[i].hFel >> meccsek[i].vFel
>> meccsek[i].hCsapat >> meccsek[i].vCsapat;
}
be.close();
cout << "2. feladat:\nKérem egy forduló sorszámát: ";
int ford;
cin >> ford;
for (const auto& m : meccsek) {
if (m.fordulo == ford) {
printf("%-20s-%-20s: %d-%d (%d-%d)\n",
m.hCsapat.c_str(), m.vCsapat.c_str(),
m.hGol, m.vGol, m.hFel, m.vFel);
}
}
cout << "\n3. feladat:\nMásodik félidőben fordító csapatok:\n";
for (const auto& m : meccsek) {
if ((m.hGol - m.vGol) * (m.hFel - m.vFel) < 0) {
cout << m.fordulo << ". forduló: "
<< ((m.hGol > m.vGol) ? m.hCsapat : m.vCsapat) << endl;
}
}
cout << "\n4. feladat:\nKérem egy csapat nevét: ";
string csapat;
cin >> csapat;
int lott = 0, kapott = 0;
for (const auto& m : meccsek) {
if (m.hCsapat == csapat) {
lott += m.hGol;
kapott += m.vGol;
}
if (m.vCsapat == csapat) {
lott += m.vGol;
kapott += m.hGol;
}
}
cout << "\n5. feladat:\n";
cout << csapat << " lőtt: " << lott << " kapott: " << kapott << endl;
cout << "\n6. feladat:\n";
int elsoVeresegFordulo = 1000;
string ellenfel;
for (const auto& m : meccsek) {
if (m.hCsapat == csapat && m.hGol < m.vGol && m.fordulo < elsoVeresegFordulo) {
elsoVeresegFordulo = m.fordulo;
ellenfel = m.vCsapat;
}
}
if (elsoVeresegFordulo < 1000)
cout << "A(z) " << elsoVeresegFordulo << ". fordulóban a(z) " << ellenfel << " csapattól.\n";
else
cout << "A csapat otthon veretlen maradt.\n";
map<string, int> stat;
for (const auto& m : meccsek) {
stat[eredmenyKod(m.hGol, m.vGol)]++;
}
ofstream ki("stat.txt");
for (const auto& s : stat) {
ki << s.first << ": " << s.second << " darab\n";
}
ki.close();
cout << "\n7. feladat:\nA stat.txt állomány létrehozva.\n";
return 0;
}
2008. május - SMS
[szerkesztés]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:)
- 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!
- 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!
- 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!
- 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! - 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.)
- 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!
- 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!
- 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!
#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <map>
using namespace std;
struct SMS {
int hour, minute;
string phone, text;
};
vector<SMS> readSMSFile(const string &filename) {
ifstream file(filename);
vector<SMS> messages;
if (!file) {
cerr << "Error: Could not open file!" << endl;
return messages;
}
int k;
file >> k;
file.ignore();
for (int i = 0; i < k; i++) {
SMS msg;
file >> msg.hour >> msg.minute >> msg.phone;
file.ignore();
getline(file, msg.text);
messages.push_back(msg);
}
return messages;
}
string getLatestMessageInMemory(const vector<SMS> &messages, int maxMemory = 10) {
return messages[min((int)messages.size(), maxMemory) - 1].text;
}
pair<SMS, SMS> findLongestShortestMessages(const vector<SMS> &messages) {
auto longest = *max_element(messages.begin(), messages.end(), [](const SMS &a, const SMS &b) {
return a.text.length() < b.text.length();
});
auto shortest = *min_element(messages.begin(), messages.end(), [](const SMS &a, const SMS &b) {
return a.text.length() < b.text.length();
});
return {longest, shortest};
}
map<string, int> messageLengthStatistics(const vector<SMS> &messages) {
map<string, int> stats = {{"1-20", 0}, {"21-40", 0}, {"41-60", 0}, {"61-80", 0}, {"81-100", 0}};
for (const auto &msg : messages) {
int length = msg.text.length();
if (length <= 20) stats["1-20"]++;
else if (length <= 40) stats["21-40"]++;
else if (length <= 60) stats["41-60"]++;
else if (length <= 80) stats["61-80"]++;
else stats["81-100"]++;
}
return stats;
}
int countUnreadMessages(const vector<SMS> &messages, int maxMemory = 10) {
map<int, int> hourlyMessages;
int unread = 0;
for (const auto &msg : messages) hourlyMessages[msg.hour]++;
for (const auto &entry : hourlyMessages) {
if (entry.second > maxMemory) unread += entry.second - maxMemory;
}
return unread;
}
string longestTimeBetweenMessages(const vector<SMS> &messages, const string &targetPhone = "123456789") {
vector<SMS> filtered;
for (const auto &msg : messages) if (msg.phone == targetPhone) filtered.push_back(msg);
if (filtered.size() <= 1) return "Nincs elegendő üzenet";
int maxTime = 0;
for (size_t i = 1; i < filtered.size(); i++) {
int prevTime = filtered[i - 1].hour * 60 + filtered[i - 1].minute;
int currTime = filtered[i].hour * 60 + filtered[i].minute;
maxTime = max(maxTime, currTime - prevTime);
}
return to_string(maxTime / 60) + " óra " + to_string(maxTime % 60) + " perc";
}
void saveSMSGroupedByPhone(const vector<SMS> &messages, const string &filename = "smski.txt") {
ofstream file(filename);
map<string, vector<SMS>> grouped;
for (const auto &msg : messages) grouped[msg.phone].push_back(msg);
for (const auto &entry : grouped) {
file << entry.first << endl;
for (const auto &msg : entry.second) file << msg.hour << " " << msg.minute << " " << msg.text << endl;
}
}
int main() {
vector<SMS> messages = readSMSFile("sms.txt");
cout << "2. Legfrissebb üzenet a memóriában: " << getLatestMessageInMemory(messages) << endl;
auto [longest, shortest] = findLongestShortestMessages(messages);
cout << "3. Leghosszabb üzenet: " << longest.hour << " " << longest.minute << " " << longest.phone << " " << longest.text << endl;
cout << "Legrövidebb üzenet: " << shortest.hour << " " << shortest.minute << " " << shortest.phone << " " << shortest.text << endl;
cout << "4. Statisztika" << endl;
auto stats = messageLengthStatistics(messages);
for (const auto &[interval, count] : stats) cout << interval << ": " << count << endl;
cout << "5. Szolgáltatóhoz fordulást igénylő üzenetek: " << countUnreadMessages(messages) << endl;
cout << "6. Leghosszabb idő két üzenet között 123456789 szám esetén: " << longestTimeBetweenMessages(messages) << endl;
cout << "8. Üzenetek mentése telefonszám szerint csoportosítva" << endl;
saveSMSGroupedByPhone(messages);
return 0;
}
2008. október - Robot
[szerkesztés]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!)!
- 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!
- Kérje be egy utasítássor számát, majd írja a képernyőre, hogy:
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.)
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.
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!
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!
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 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!
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!
#include <iostream>
#include <string>
#include <cstring>
#include <fstream>
#include <cmath>
#include <iomanip>
using namespace std;
int N, s;
char sor[100][201]; // Extra space for null terminator
int sordb[100];
void k(int x) {
cout << "\n" << x << ". feladat" << endl;
}
void F1() {
ifstream be("program.txt");
if (!be) {
cerr << "Hiba: Nem sikerült megnyitni a program.txt fájlt!" << endl;
return;
}
be >> N;
be.ignore(); // Move to next line
for (int i = 0; i < N; i++) {
be.getline(sor[i], 201);
sordb[i] = strlen(sor[i]);
cout << sor[i] << " (" << sordb[i] << ")" << endl;
}
be.close();
}
void F2a() {
cout << "Utasítássor száma: ";
cin >> s;
s--;
if (s < 0 || s >= N) {
cout << "Hibás sorszám!" << endl;
return;
}
if (strstr(sor[s], "ED") || strstr(sor[s], "DE") || strstr(sor[s], "KN") || strstr(sor[s], "NK"))
cout << "Egyszerűsíthető" << endl;
else
cout << "Nem egyszerűsíthető" << endl;
}
void F2bc() {
int x = 0, y = 0, ls = 0;
float max_dist = 0.0, dist;
for (int i = 0; i < sordb[s]; i++) {
switch (sor[s][i]) {
case 'E': x++; break;
case 'D': x--; break;
case 'K': y++; break;
case 'N': y--; break;
}
dist = sqrt(x * x + y * y);
if (dist > max_dist) {
max_dist = dist;
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: " << fixed << setprecision(3) << max_dist << endl;
}
void F3() {
for (int i = 0; i < N; i++) {
int e = 2; // Start energy
for (int j = 0; j < sordb[i] - 1; j++) {
e++; // Move energy
if (sor[i][j] != sor[i][j + 1]) e += 2; // Turn energy
}
e++; // Last move
if (e <= 100) cout << i + 1 << " " << e << endl;
}
}
void F4() {
ofstream ki("ujprog.txt");
if (!ki) {
cerr << "Hiba: Nem sikerült létrehozni az ujprog.txt fájlt!" << endl;
return;
}
for (int i = 0; i < N; i++) {
string s;
int db;
for (int j = 0; j < sordb[i]; j++) {
db = 1;
while (j + 1 < sordb[i] && sor[i][j] == sor[i][j + 1]) {
db++;
j++;
}
if (db == 1) s += sor[i][j];
else s += to_string(db) + sor[i][j];
}
ki << s << endl;
}
ki.close();
}
void F5() {
string s, output;
cout << "Kérek egy új utasítássort: ";
cin >> s;
for (size_t i = 0; i < s.length(); i++) {
if (isdigit(s[i])) {
int num = 0;
while (i < s.length() && isdigit(s[i])) {
num = num * 10 + (s[i] - '0');
i++;
}
if (i < s.length()) output.append(num, s[i]);
} else {
output += s[i];
}
}
cout << "A régi kód: " << output << endl;
}
int main() {
setlocale(LC_ALL, "");
k(1);
F1();
k(2);
F2a();
F2bc();
k(3);
F3();
k(4);
F4();
k(5);
F5();
return 0;
}
2009. május - Automata
[szerkesztés]A Csokibolt Kft. a város több pontján üzemeltet csokoládé-automatát. Az automatákból sokféle csokoládét lehet vásárolni pénzérmék bedobásával. A vásárláshoz az 1, 2, 5, 10, 20, 50 és 100 fabatkás érmék használhatók. Egyszerre csak egyfajta csokoládé vásárolható. A vásárlás során először ki kell választani a csokoládét, majd be kell állítani a kívánt darabszámot, végül be kell dobni a pénzt. Ha a szükségesnél több pénzt dobnak be, a gép a csokoládé mellett kiadja a visszajárót is. Amennyiben az automatában már nincs a kívánt darabszámú csokoládé, vagy a bedobott összeg nem elegendő, a vásárlás meghiúsul.
Az egyik automatában árult csokoládék lényeges adatait a csoki.txt állomány tartalmazza. Első sorában az automata rekeszeinek száma (legfeljebb 100) található. A második sortól kezdve soronként három szám, egy-egy rekesz adatsora olvasható. Az első szám a rekesz sorszáma, a második a rekeszben található csokoládé darabszáma, a harmadik pedig az egységára. Egy-egy rekeszben legfeljebb 100 szelet fér el, egy szelet ára legfeljebb 300 fabatka. A rekeszek sorszámozása 1-től kezdődik és folyamatos.
A vásárlások adatai a vasarlas.txt állományban olvashatók. Az első sorban a vásárlások száma, legfeljebb 100 olvasható. A továbbiakban soronként 9 szám szerepel, ami egy vásárlás adatait jelenti az alábbiak szerint: az első szám a választott rekesz sorszáma, a második a kívánt darabszám, utána pedig az következik, hogy az egyes címletekből hány darabot dobtak a gépbe. Az első az 1 fabatkás, a többi növekvően szerepel mögötte, így az utolsó a 100 fabatkás. Az állományban egyetlen szám sem nagyobb 100-nál.
Például:
csoki.txt
23 1 23 76 2 8 111 3 0 0 …
Az 3. sor megmutatja, hogy a 2. rekeszben 8 csokoládé van, amelynek darabja 111 fabatka.
vasarlas.txt
19 2 3 1 1 0 1 1 0 3 2 6 0 0 0 0 0 0 7 1 2 2 0 0 0 0 0 2 …
A 3. sor megmutatja, hogy a második vásárló a 2. rekeszből 6 csokoládét választott, 7 darab 100 fabatkás érmét dobott az automatába és más címletű pénzt nem.
Készítsen programot, amely az alábbi kérdésekre válaszol! A program forráskódját automata 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 a 4. feladat esetén: „4. feladat Kérem a pénzösszeget!”)! Az ékezetmentes kiírás is elfogadott.
- Olvassa be a csoki.txt és a vasarlas.txt állományban talált adatokat, s azok felhasználásával oldja meg a következő feladatokat! Ha az állományokat nem tudja beolvasni, az állományok első 8 sorának adatait jegyezze be a programba és dolgozzon azzal!
- Milyen értékben van csokoládé az automatában? Írja képernyőre a választ a következőhöz hasonló formában: „Az automatában 24817 fabatka értékű csokoládé van.”!
- Írja a képernyőre, hogy mely rekeszekből próbáltak csokoládét vásárolni! Minden rekesz sorszámát csak egyszer jelenítse meg! A számokat egymástól szóközzel elválasztva tüntesse fel!
- Anna magának és barátainak összesen 7 egyforma csokoládét szeretne vásárolni. Kérje be a csokoládéra szánt pénzösszeget! Írja a képernyőre azon rekeszek sorszámát, amelyek közül választhat! A rekeszek sorszámát szóközökkel válassza el egymástól!
- Okos Péter szeret mindenütt pontosan annyi pénzt átadni, amennyi a fizetendő összeg. Ezen túl szeret úgy fizetni, hogy a lehető legkevesebb pénzérmét, bankjegyet kelljen átadnia. Kérje be egy rekesz sorszámát és a darabszámot, majd írja ki, hogy a felhasznált pénzérmékből címletenként hány darabot kell bedobnia Péternek! Csak a felhasznált címleteket adja meg! Egy sorba egy címlet kerüljön; először a címlet értéke, majd mögötte a darabszám jelenjen meg! Nem kell vizsgálnia, hogy van-e elég csokoládé a rekeszben! A megoldás során segítségként a következő algoritmust használhatja: Keresse meg a legnagyobb címletet, amely nem haladja meg a fizetendő összeget! Ebből a címletből kell egyet használnia! A fizetendőt csökkentse a címlet értékével, majd kezdje elölről az algoritmust, ha az nem nulla! Ez az algoritmus a feladatban szereplő címletek esetén működik, de létezhet olyan címletlista, amelynél nem alkalmazható.
- Írja a rekesz7.txt állományba, hogy hányas sorszámú vásárlások során hány darabot vettek a 7‑es rekeszből! Vegye figyelembe, hogy minden sikeres vásárlással csökken a rekeszben lévő csokoládék száma! Soronként egy vásárlási próbálkozást tüntessen fel! A sor elején a vásárlási próbálkozás sorszáma jelenjen meg, tőle tabulátorral (ASCII kódja a 9‑es) elválasztva pedig a vásárlás eredménye legyen olvasható! Az eredmény sikeres vásárlás esetén a darabszám. Ha nem volt megadott mennyiségnek megfelelő csokoládé, akkor a sorszám mögé a „kevés a csoki” üzenet kerüljön! Ha a vásárló által bedobott pénzösszeg kevés, akkor a „nem volt elég pénz” szöveget írja a fájlba! Amennyiben a vásárlás több okból is meghiúsulhat, elegendő csak az egyik okot megjeleníteni.
#include <iostream>
#include <fstream>
#include <vector>
#include <map>
#include <set>
#include <algorithm>
using namespace std;
struct Rekesz {
int sorszam;
int darabszam;
int ar;
};
struct Vasarlas {
int rekesz_sorszam;
int darabszam;
vector<int> cimletek;
};
vector<Rekesz> csokik;
vector<Vasarlas> vasarlasok;
vector<int> cimletek = {1, 2, 5, 10, 20, 50, 100};
void beolvasas() {
ifstream csokiFile("csoki.txt");
if (!csokiFile) {
cerr << "Hiba: Nem található csoki.txt!" << endl;
exit(1);
}
int rekdb;
csokiFile >> rekdb;
csokik.resize(rekdb);
for (int i = 0; i < rekdb; i++) {
csokiFile >> csokik[i].sorszam >> csokik[i].darabszam >> csokik[i].ar;
}
csokiFile.close();
ifstream vasarlasFile("vasarlas.txt");
if (!vasarlasFile) {
cerr << "Hiba: Nem található vasarlas.txt!" << endl;
exit(1);
}
int vasdb;
vasarlasFile >> vasdb;
vasarlasok.resize(vasdb);
for (int i = 0; i < vasdb; i++) {
vasarlasFile >> vasarlasok[i].rekesz_sorszam >> vasarlasok[i].darabszam;
vasarlasok[i].cimletek.resize(7);
for (int j = 0; j < 7; j++) {
vasarlasFile >> vasarlasok[i].cimletek[j];
}
}
vasarlasFile.close();
}
void feladat_2() {
int ertek = 0;
for (const auto &rekesz : csokik) {
ertek += rekesz.darabszam * rekesz.ar;
}
cout << "Az automatában " << ertek << " fabatka értékű csokoládé van." << endl;
}
void feladat_3() {
set<int> hasznalt_rekeszek;
for (const auto &vasarlas : vasarlasok) {
hasznalt_rekeszek.insert(vasarlas.rekesz_sorszam);
}
cout << "A következő rekeszekből próbáltak vásárolni: ";
for (int rekesz : hasznalt_rekeszek) {
cout << rekesz << " ";
}
cout << endl;
}
void feladat_4() {
int keret;
cout << "Kérem a 7 egyforma csokoládéra szánt összeget: ";
cin >> keret;
cout << "A következő rekeszekből lehet választani: ";
for (const auto &rekesz : csokik) {
if (rekesz.darabszam >= 7 && 7 * rekesz.ar <= keret) {
cout << rekesz.sorszam << " ";
}
}
cout << endl;
}
void feladat_5() {
int r, db;
cout << "Kérem a rekesz sorszámát: ";
cin >> r;
cout << "Kérem a csokoládék darabszámát: ";
cin >> db;
auto it = find_if(csokik.begin(), csokik.end(), [r](const Rekesz &rekesz) {
return rekesz.sorszam == r;
});
if (it == csokik.end()) {
cout << "Nincs ilyen rekesz!" << endl;
return;
}
int osszeg = it->ar * db;
cout << "A fizetendő összeg: " << osszeg << " fabatka." << endl;
cout << "Az optimális címletezés:" << endl;
map<int, int> cimletdb;
for (auto it = cimletek.rbegin(); it != cimletek.rend(); ++it) {
while (osszeg >= *it) {
cimletdb[*it]++;
osszeg -= *it;
}
}
for (auto &[cimlet, db] : cimletdb) {
cout << cimlet << ": " << db << endl;
}
}
int main() {
beolvasas();
cout << "\n1. feladat - Beolvasás kész" << endl;
feladat_2();
feladat_3();
feladat_4();
feladat_5();
return 0;
}
2009. május - Lift
[szerkesztés]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
\;img
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.
- 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!
- 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 igény.txt fájlban az első igény induló szintjét!
- 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.” !
- Í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!
- 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!
- 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!
- 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!
- 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:
\;img
#include <iostream>
#include <fstream>
#include <ctime>
using namespace std;
struct igenyles {
int o, p, m, ssz, ind, cel;
} igeny[100];
int sz, cs, isz, fsz;
void kiir(int sorszam) {
cout << sorszam << ". feladat" << endl;
}
void F1() {
ifstream be("igeny.txt");
if (!be) {
cerr << "Hiba: Nem sikerult megnyitni az igeny.txt fajlt!" << endl;
exit(1);
}
be >> sz >> cs >> isz;
for (int i = 0; i < isz; i++) {
be >> igeny[i].o >> igeny[i].p >> igeny[i].m >> igeny[i].ssz >> igeny[i].ind >> igeny[i].cel;
}
be.close();
}
void F2() {
cout << "Hol all a lift: ";
cin >> fsz;
}
void F8() {
ofstream ki("blokkol.txt");
if (!ki) {
cerr << "Hiba: Nem sikerult megnyitni a blokkol.txt fajlt!" << endl;
return;
}
cout << "8. feladat: Lift adminisztracios adatok rogzitese" << endl;
for (int i = 0; i < isz; i++) {
int kod;
string sikeresseg;
cout << "Befejezes ideje: " << igeny[i].o << ":" << igeny[i].p << ":" << igeny[i].m << endl;
cout << "Adja meg a munka kodjat (1-99): ";
cin >> kod;
while (kod < 1 || kod > 99) {
cout << "Ervenytelen kod! Adja meg ujra (1-99): ";
cin >> kod;
}
cout << "Adja meg a munka sikeresseget (befejezett/befejezetlen): ";
cin >> sikeresseg;
while (sikeresseg != "befejezett" && sikeresseg != "befejezetlen") {
cout << "Ervenytelen adat! Adja meg ujra (befejezett/befejezetlen): ";
cin >> sikeresseg;
}
ki << "Befejezes ideje: " << igeny[i].o << ":" << igeny[i].p << ":" << igeny[i].m << endl;
ki << "Sikeresseg: " << sikeresseg << endl;
ki << "----Indulasi emelet: " << igeny[i].ind << endl;
ki << "Celemelet: " << igeny[i].cel << endl;
ki << "Feladatkod: " << kod << endl;
}
ki.close();
cout << "Az adatok rogzitese befejezodott!" << endl;
}
int main() {
setlocale(LC_ALL, "hun");
cout << "LIFT" << endl;
kiir(1);
F1();
kiir(2);
F2();
kiir(8);
F8();
return 0;
}
2009. október - Útépítés
[szerkesztés]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
\;img
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!”)!
- 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!
- Í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!
- Í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!
- 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!
- 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!)
- Í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!
#include <iostream>
#include <fstream>
#include <algorithm>
#include <iomanip>
using namespace std;
struct jarmu {
int o, p, mp, ido;
char honnan;
} adatok[2000];
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("forgalom.txt");
if (!be) {
cerr << "Hiba: Nem sikerült megnyitni a fájlt!" << endl;
return;
}
be >> N;
for (int i = 0; i < N; i++) {
be >> adatok[i].o >> adatok[i].p >> adatok[i].mp >> adatok[i].ido >> adatok[i].honnan;
}
be.close();
}
void F2() {
int n;
cout << "Melyik autóra kíváncsi? (1-" << N << ")" << endl;
cout << "Kérek egy számot: ";
cin >> n;
if (n < 1 || n > N) {
cout << "Hibás érték!" << endl;
return;
}
cout << ((adatok[n - 1].honnan == 'A') ? "Felső város felé haladt a jármű" : "Alsó város felé haladt a jármű") << endl;
}
void F3() {
int i = N - 1, j;
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) {
int mpi = adatok[i].o * 3600 + adatok[i].p * 60 + adatok[i].mp;
int mpj = adatok[j].o * 3600 + adatok[j].p * 60 + adatok[j].mp;
cout << "Különbség: " << (mpi - mpj) << " másodperc" << endl;
} else {
cout << "Nem találtam két ilyen járművet!" << endl;
}
}
}
void F4() {
int orak[24][2] = {};
for (int i = 0; i < N; i++) {
orak[adatok[i].o][(adatok[i].honnan == 'A') ? 0 : 1]++;
}
cout << "Óra A F" << endl;
for (int i = 0; i < 24; i++) {
if (orak[i][0] > 0 || orak[i][1] > 0) {
cout << i << " " << orak[i][0] << " " << orak[i][1] << endl;
}
}
}
void F5() {
jarmu rend[2000];
copy(adatok, adatok + N, rend);
sort(rend, rend + N, [](jarmu a, jarmu b) { return a.ido < b.ido; });
cout << fixed << setprecision(1);
for (int i = 0; i < min(10, N); i++) {
cout << setw(2) << rend[i].o << ":" << setw(2) << rend[i].p << ":" << setw(2) << rend[i].mp << " ";
cout << ((rend[i].honnan == 'A') ? "Alsó " : "Felső ");
cout << (1000.0 / rend[i].ido) << " m/s" << endl;
}
}
void F6() {
cout << "Adatok fájlba írása..." << endl;
ofstream ki("also.txt");
if (!ki) {
cerr << "Hiba: Nem sikerült megnyitni a fájlt!" << endl;
return;
}
int mp_elozo = -1;
for (int i = 0; i < N; i++) {
if (adatok[i].honnan == 'F') {
int mp_aktualis = adatok[i].o * 3600 + adatok[i].p * 60 + adatok[i].mp + adatok[i].ido;
if (mp_elozo >= mp_aktualis) {
ki << adatok[i - 1].o << " " << adatok[i - 1].p << " " << adatok[i - 1].mp << endl;
} else {
ki << adatok[i].o << " " << adatok[i].p << " " << adatok[i].mp << endl;
}
mp_elozo = mp_aktualis;
}
}
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();
return 0;
}
2010. május - Telek
[szerkesztés]Patakfalván a faluszélen levő beépítetlen területet szeli ketté a Dirib patak. Az önkormányzat elhatározta, hogy építési telkek kialakításával létrehozza a Szép jövő lakótelepet. A beépítés után egy téglalap alakú területen két utca jön létre: Gazdagsor és Jólétsor. A két sor lakói „lábszomszédok”, de telkeiket elválasztja egymástól a Dirib patak. A két utca párhuzamos, az utcafrontokat 80 méter választja el egymástól. Mindkét soron azonos számú téglalap alakú telket jelöltek ki, soronként legfeljebb 30-at. Gazdagsoron csak páratlan, Jólétsoron csak páros házszámokat adnak ki (1-től, illetve 2-től indulva kihagyásmentesen számozva). Egy telek szélessége maximum 40 méter. Az utcák végén egy-egy híd köti össze a patak két partját. A telkek kijelölésénél figyelembe vették a patak medrének nyomvonalát.
\;img
A kijelölt telkekről kimutatás készült, amit a telkek.txt fájl tartalmaz. Ennek a fájlnak az első sora tartalmazza a kiosztandó telkek számát, majd az ezt követő sorokban az egyes telkek adatai találhatók. Az első adat a házszám, a második a telek szélessége, míg a harmadik az erre merőlegesen mért hosszúsága. Gazdagsor esetén az összes adat rendelkezésre áll, Jólétsor esetében viszont a hosszúság adatok helyén 0 áll. Az adatok között pontosan egy szóköz található.
Készítsen programot telek 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:)
- Olvassa be a telkek.txt állományban található 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 Gazdagsor 1., 3., 5., 7. és 9. számú, valamint Jólétsor 2., 4., 6., 8. és 10. számú telkének adatait jegyezze be a programba, s úgy oldja meg a feladatokat!
- Hány métert kell annak gyalogolnia, aki körbe akarja járni a két utcát? A kiszámított távolságot írassa ki a képernyőre!
- Az önkormányzat előírásai szerint a 20 m széles vagy annál keskenyebb telkek esetén teljes utcafront beépítést kell alkalmazni. Határozza meg és a képernyőre írassa ki, hogy ez hány telekre vonatkozik a Jólétsoron!
- Hány háznyira van egymástól a legnagyobb és a legkisebb területű telek Gazdagsoron? A két telek között elhelyezkedő telkek számát, valamint a legnagyobb és legkisebb telek házszámát, illetve területét írassa ki a képernyőre!
- Az önkormányzat telekadót fog kivetni. Az adót Fabatkában számolják. A 700 négyzetméteres és annál kisebb telkek esetén ez 51 Fabatka négyzetméterenként, az ennél nagyobb telkeknél az első 700 négyzetméterre vonatkozóan szintén 51 Fabatka, 700 négyzetméter felett egészen 1000 négyzetméterig 39 Fabatka a négyzetméterenkénti adó. Az 1000 négyzetméter feletti részért négyzetméter árat nem, csak 200 Fabatka egyösszegű általányt kell fizetni. A 15 m vagy annál keskenyebb, illetve a 25 m vagy annál rövidebb telkek tulajdonosai 20% adókedvezményben részesülnek. Az adó meghatározásánál 100 Fabatkás kerekítést kell használni (pl. 6238 esetén 6200, 6586 esetén 6600). Határozza meg, mekkora adóbevételre számíthat Gazdagsor után az önkormányzat!
- Melyik a 3 utolsó telek a Jólétsoron? A házszámokat és a telkeknek a Jólétsor elejétől mért távolságát írja ki a képernyőre a házszámok szerint csökkenő sorrendben!
- Határozza meg Jólétsor telkeinek hosszúságát! Vegye figyelembe, hogy a szemben fekvő telkek patak felőli határvonalait az utcafrontra merőleges irányban legalább 10 méternek kell elválasztania egymástól! Szemben fekvőnek számítanak a telkek akkor is, ha csak a telkek valamelyik széle van egymással szemben. (Például a 10-es számú telekkel csak a 9-es és 11-es számú telek van szemben.) A számításnál a feltételnek megfelelő legnagyobb telkeket kell kialakítani! Jólétsor adatait írja ki a joletsor.csv fájlba! Az egyes sorokban a házszám, a szélesség és a hosszúság szerepeljen! Az adatokat pontosan egy pontosvessző válassza el egymástól!
#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <cmath>
using namespace std;
struct Telek {
int hazszam;
int szelesseg;
int hossz;
};
vector<Telek> beolvasas(const string& fajlnev) {
ifstream fajl(fajlnev);
vector<Telek> telkek;
if (!fajl) {
cerr << "Hiba: A fájl nem található!" << endl;
return telkek;
}
int tdb;
fajl >> tdb;
for (int i = 0; i < tdb; i++) {
Telek telek;
fajl >> telek.hazszam >> telek.szelesseg >> telek.hossz;
telkek.push_back(telek);
}
fajl.close();
return telkek;
}
int korbejarasi_tav(const vector<Telek>& jsor) {
int jhossz = 0;
for (const auto& telek : jsor) {
jhossz += telek.szelesseg;
}
return 2 * (jhossz + 80);
}
int teljes_utcafront(const vector<Telek>& jsor) {
return count_if(jsor.begin(), jsor.end(), [](const Telek& telek) { return telek.szelesseg <= 20; });
}
pair<Telek, Telek> legnagyobb_legkisebb(const vector<Telek>& gsor) {
auto min_telek = *min_element(gsor.begin(), gsor.end(), [](const Telek& a, const Telek& b) {
return a.szelesseg * a.hossz < b.szelesseg * b.hossz;
});
auto max_telek = *max_element(gsor.begin(), gsor.end(), [](const Telek& a, const Telek& b) {
return a.szelesseg * a.hossz < b.szelesseg * b.hossz;
});
return {min_telek, max_telek};
}
int adoszamito(int szel, int hossz) {
int ter = szel * hossz;
int ado = 0;
if (ter <= 700) {
ado = ter * 51;
} else if (ter <= 1000) {
ado = 700 * 51 + (ter - 700) * 39;
} else {
ado = 700 * 51 + 300 * 39 + 200;
}
if (szel <= 15 || hossz <= 25) {
ado *= 0.8;
}
return round(ado / 100.0) * 100;
}
int teljes_ado(const vector<Telek>& gsor) {
int ossz_ado = 0;
for (const auto& telek : gsor) {
ossz_ado += adoszamito(telek.szelesseg, telek.hossz);
}
return ossz_ado;
}
void kiir_utolso_harom(const vector<Telek>& jsor) {
cout << "Jólétsor utolsó három telke és távolságuk Jólétsor elejétől:" << endl;
int tav = 0;
for (const auto& telek : jsor) {
tav += telek.szelesseg;
}
for (int i = jsor.size() - 1; i >= (int)jsor.size() - 3; --i) {
tav -= jsor[i].szelesseg;
cout << jsor[i].hazszam << " " << tav << " m" << endl;
}
}
void joletsor_hossz_meghatarozas(const vector<Telek>& gsor, const vector<Telek>& jsor, const string& fajlnev) {
ofstream fajl(fajlnev);
if (!fajl) {
cerr << "Hiba: Nem lehet megnyitni a fájlt!" << endl;
return;
}
for (const auto& telek : jsor) {
fajl << telek.hazszam << ";" << telek.szelesseg << ";" << (80 - 10) << endl;
}
fajl.close();
cout << "A kiíratás és a fájl lezárása sikeresen befejeződött." << endl;
}
int main() {
vector<Telek> telkek = beolvasas("telkek.txt");
vector<Telek> gsor, jsor;
for (const auto& telek : telkek) {
if (telek.hazszam % 2 == 1) {
gsor.push_back(telek);
} else {
jsor.push_back(telek);
}
}
cout << "\n2. feladat\n";
cout << "A két utca körbejárásához " << korbejarasi_tav(jsor) << " métert kell gyalogolni." << endl;
cout << "\n3. feladat\n";
cout << "A teljes utcafront beépítések száma Jólétsoron: " << teljes_utcafront(jsor) << endl;
cout << "\n4. feladat\n";
auto [min_telek, max_telek] = legnagyobb_legkisebb(gsor);
cout << "A legnagyobb területű telek házszáma " << max_telek.hazszam << ", területe " << (max_telek.szelesseg * max_telek.hossz) << " nm." << endl;
cout << "A legkisebb területű telek házszáma " << min_telek.hazszam << ", területe " << (min_telek.szelesseg * min_telek.hossz) << " nm." << endl;
cout << "\n5. feladat\n";
cout << "Gazdagsoron az önkormányzat " << teljes_ado(gsor) << " Fabatka telekadó bevételre számíthat." << endl;
cout << "\n6. feladat\n";
kiir_utolso_harom(jsor);
cout << "\n7. feladat\n";
joletsor_hossz_meghatarozas(gsor, jsor, "joletsor.csv");
cout << "\nA befejezéshez nyomd meg az ENTER billentyűt!";
cin.get();
return 0;
}
2010. május Helyjegy
[szerkesztés]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 hányadik 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
\;img
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.
- 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!
- 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!
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!
Határozza meg, hogy a jegyekből mennyi bevétele származott a társaságnak!
Az eredményt írja a képernyőre!
Í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!
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!
- 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
\;img
#include <iostream>
#include <fstream>
using namespace std;
struct utas {
int sorszam, ules, fel, le, fizet;
} utasok[500];
int e_szam, vonalhossz, ar_10;
int utvonal[201];
void kiir(int s) {
cout << endl << s << ". feladat" << endl;
cout << "---------------" << endl;
}
int kerekit(int ezt) {
int maradek = ezt % 5;
if (maradek == 1 || maradek == 2 || maradek == 6 || maradek == 7)
return ezt - maradek;
else
return ezt + (5 - maradek);
}
void F1() {
ifstream be("eladott.txt");
if (!be) {
cerr << "Hiba: Nem sikerult megnyitni az eladott.txt fajlt!" << endl;
return;
}
be >> e_szam >> vonalhossz >> ar_10;
for (int i = 0; i < e_szam; i++) {
utasok[i].sorszam = i + 1;
be >> utasok[i].ules >> utasok[i].fel >> utasok[i].le;
int megtett_ut = utasok[i].le - utasok[i].fel;
int fizetendo = ((megtett_ut + 9) / 10) * ar_10;
utasok[i].fizet = kerekit(fizetendo);
}
be.close();
}
void F2() {
int i = e_szam - 1;
cout << "Utolsó utas adatai: " << endl;
cout << "Ülésszám: " << utasok[i].ules << " 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() {
int bevetel = 0;
for (int i = 0; i < e_szam; i++) {
bevetel += utasok[i].fizet;
}
cout << "A társaság bevétele: " << bevetel << endl;
}
void F5() {
int max_megallo = -1;
for (int i = 0; i < e_szam; i++) {
if (utasok[i].fel < vonalhossz && utasok[i].fel > max_megallo)
max_megallo = utasok[i].fel;
if (utasok[i].le < vonalhossz && utasok[i].le > max_megallo)
max_megallo = utasok[i].le;
}
int fel_db = 0, le_db = 0;
for (int i = 0; i < e_szam; i++) {
if (utasok[i].fel == max_megallo) fel_db++;
if (utasok[i].le == max_megallo) 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;
}
void F6() {
fill(utvonal, utvonal + 201, 0);
for (int i = 0; i < e_szam; i++) {
utvonal[utasok[i].fel]++;
utvonal[utasok[i].le]++;
}
int megallo_db = 0;
for (int i = 1; i < vonalhossz; i++) {
if (utvonal[i] > 0) megallo_db++;
}
cout << "A megállók száma: " << megallo_db << endl;
}
void F7() {
ofstream ki("kihol.txt");
if (!ki) {
cerr << "Hiba: Nem sikerult megnyitni a kihol.txt fajlt!" << endl;
return;
}
int tav;
cout << "Adja meg a vizsgált távolságot: ";
cin >> tav;
int ules[48] = {0};
for (int i = 0; i < e_szam; i++) {
if (tav >= utasok[i].fel && tav < utasok[i].le) {
ules[utasok[i].ules - 1] = utasok[i].sorszam;
}
}
for (int i = 0; i < 48; i++) {
if (ules[i] == 0)
ki << i + 1 << ". ülés: üres" << endl;
else
ki << i + 1 << ". ülés: " << ules[i] << ". utas" << endl;
}
ki.close();
}
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(7); F7();
return 0;
}
2010. október - Anagramma
[szerkesztés]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
\;img
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!
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!
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
\;img
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!
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!
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 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!
- 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
\;img
#include <iostream>
#include <fstream>
#include <string>
#include <algorithm>
using namespace std;
string sz[300];
string r[300];
int N;
// Function to sort characters of a string
string szorendezo(string a) {
sort(a.begin(), a.end());
return a;
}
void F1() {
string be;
cout << "Adja meg a szoveget: ";
cin >> be;
if (!be.empty()) {
string sorted_be = szorendezo(be);
cout << "Rendezve: " << sorted_be << endl;
int db = unique(sorted_be.begin(), sorted_be.end()) - sorted_be.begin();
cout << "A kulonbozo karakterek szama: " << db << endl;
} else {
cout << "Ures szoveg: 0 db karakter" << endl;
}
}
void F2() {
ifstream be("szotar.txt");
if (!be) {
cerr << "Nem lehet megnyitni a szotar.txt fajlt!" << endl;
return;
}
N = 0;
while (N < 300 && be >> sz[N]) {
N++;
}
be.close();
}
void F3() {
ofstream ki("abc.txt");
for (int i = 0; i < N; i++) {
r[i] = szorendezo(sz[i]);
ki << r[i] << endl;
}
ki.close();
}
void F4() {
string a, b;
cout << "Kerek 2 szot!\n1. szo: ";
cin >> a;
cout << "2. szo: ";
cin >> b;
cout << (szorendezo(a) == szorendezo(b) ? "Anagramma" : "Nem anagramma") << endl;
}
void F5() {
string t;
cout << "Kerek egy szot: ";
cin >> t;
string sorted_t = szorendezo(t);
int db = 0;
cout << "Talalatok:" << endl;
for (int i = 0; i < N; i++) {
if (sorted_t == r[i]) {
cout << sz[i] << endl;
db++;
}
}
if (db == 0) cout << "Nincs a szotarban anagramma" << endl;
}
void F6() {
int max_len = 0;
for (int i = 0; i < N; i++) {
max_len = max(max_len, (int)sz[i].length());
}
for (int i = 0; i < N; i++) {
if (sz[i].length() == max_len) {
cout << sz[i] << endl;
}
}
}
void F7() {
sort(sz, sz + N, [](const string &a, const string &b) {
return a.length() < b.length() || (a.length() == b.length() && a < b);
});
ofstream ki("rendezve.txt");
int prev_len = 0;
for (int i = 0; i < N; i++) {
if (sz[i].length() != prev_len) {
if (i > 0) ki << "\n";
prev_len = sz[i].length();
}
ki << sz[i] << " ";
}
ki.close();
}
int main() {
F1();
F2();
F3();
F4();
F5();
F6();
F7();
return 0;
}
2011. május - Rejtvény
[szerkesztés]Egy weboldalon érdekes rejtvényt tesznek közzé hétről hétre. A rejtvényekben egy N×M-es területre világítótornyokat helyeznek le. Ezeket a tornyokat számmal jelölik. Minden alkalommal az a feladat, hogy a területre el kell helyezni X darab hajót úgy, hogy minden toronyból (vízszintesen és függőlegesen összesen) annyi hajó legyen látható, ahányas szám a tornyot jelképező mezőben van!
A hajókra vonatkozó szabályok a következők:
- Minden hajó egy négyzet nagyságú.
- A hajók nem érintkezhetnek egymással, még átlós irányban sem.
- A hajók nem érinthetik a világítótornyokat, még átlós irányban sem.
- A hajók egymást nem takarják ki. Azaz a világítótoronyból az egy vonalban lévő hajók is látszanak.
Például:
Egy 5×4-es terület és 3 hajó esetén
\;img
A weboldalon ugyanúgy, mint az előző hetekben, egy 10×10-es négyzetbe kell elhelyezni 12 darab hajót. A versenyzők által beküldött megfejtéseket alkalmazás segítségével összefűzik egy txt állományba. Ennek a fájlnak az első sora a megfejtések számát tartalmazza, ami maximálisan 20 darab lehet. Minden megfejtés előtt pedig a megfejtő neve található. Az egyes megfejtésekben a vizet 0-val, a világítótornyot egy 1 és 9 közötti számmal, a hajókat pedig 11-es számmal jelölik. A fájlban a számokat egy-egy szóközzel választják el.
Például:
A megoldas.txt állomány egy részlete. (A példát szabályos táblázatban jelenítjük meg a jobb átláthatóság érdekében.)
10 Absolon 0 0 0 0 11 0 11 0 0 0 11 0 2 0 0 0 0 0 0 11 0 0 0 0 0 1 0 11 0 0 0 0 0 11 0 0 0 0 0 0 0 3 0 0 0 0 0 0 11 0 0 0 0 0 2 0 11 0 0 0 0 11 0 0 0 0 0 0 3 0 0 0 0 0 0 0 3 0 0 0 0 11 0 3 0 0 0 0 11 0 0 0 0 0 0 0 11 0 0 0 …
A 2. sor 3. oszlopában tehát egy világítótorony van, amelynek sorában és oszlopában összesen 2 hajó lehet. A 2. sor 1. oszlopában és a 2. sor 10. oszlopában egy-egy hajó található.
Készítsen programot, amely a rejtvényre érkező megoldások helyességét ellenőrzi! A program forráskódját rejtveny néven mentse!
Minden feladat 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 torony adatait!”)! Az ékezetmentes kiírás is elfogadott.
A feladatok megoldása során feltételezzük, hogy a beolvasott adatok helyesek, ezért azokat sehol nem kell ellenőrizni!
- Kérje be a felhasználótól egy 10×10-es táblára vonatkozóan egy világítótorony pozícióját (a torony helyének sor és oszlop száma), és a toronyból látható hajók számát! A rejtvény megfejtését a nagy számmal rendelkező tornyoknál érdemes kezdeni. Ezért, ha a torony értéke nagyobb, mint három, akkor írja ki a képernyőre, hogy „Nehéz torony.”, más esetben ne írjon ki semmit!
- A megadott világítótorony helyzete alapján állapítsa meg, hogy a szabályok szerint a világítótorony körül mely helyekre biztosan nem kerülhet hajó! Az eredményt írassa ki a képernyőre úgy, hogy a tiltott helyek sor és oszlop azonosítói vesszővel elválasztva külön sorokba kerüljenek! Például ha a világítótorony a 2, 3 pozícióban van, akkor:
1,2 1,3 1,4 2,2 2,4 3,2 3,3 3,4
A feladvany.txt állomány tartalmazza az erre a hétre kiadott rejtvényt a már ismert formában. Olvassa be a rejtvényt az állományból és a megoldas.txt állományban beküldött megoldások közül szűrje ki azokat, amelyek nem az e heti feladványra érkeztek. Ezen megfejtő(k) nevét írja ki a képernyőre! Ha minden megfejtés az e heti feladványra érkezett, akkor írja ki a képernyőre, hogy „Mindegyik megoldás erre a heti feladványra érkezett.”!
Azok közül a megoldások közül, amelyek erre a heti feladványra érkeztek, állapítsa meg, hogy melyikekben van kevesebb vagy több hajó megadva, mint 12! Írja ki a képernyőre, hogy e szempontból hány darab hibás „megoldás” volt!
Hány olyan szabálytalan megoldás született az e heti feladatra, amelyben:
– a hajók száma megfelelő és
– egy vagy több hajó elhelyezése a szomszédsági kapcsolatokra vonatkozó szabályoknak nem megfelelő?
Az eredményt írja ki a képernyőre!
- Határozza meg, hogy hány megoldás volt helyes a beküldöttek közül! Az ellenőrzésnél vegye figyelembe az előző pontokban leírtakat, valamint azt, hogy a világítótornyok az értéküknek megfelelő számú hajót látnak-e! A helyes beküldők nevét írja ki a képernyőre!
#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <sstream>
#include <unordered_set>
using namespace std;
vector<vector<int>> beolvas_fajl(const string& fajlnev) {
ifstream file(fajlnev);
vector<vector<int>> adatok;
string sor;
while (getline(file, sor)) {
vector<int> sor_adatok;
stringstream ss(sor);
int szam;
while (ss >> szam) {
sor_adatok.push_back(szam);
}
adatok.push_back(sor_adatok);
}
return adatok;
}
pair<vector<string>, vector<vector<int>>> beolvas_megoldasok(const string& fajlnev) {
ifstream file(fajlnev);
int db;
file >> db;
file.ignore();
vector<string> bekuldok(db);
vector<vector<int>> megoldasok(db, vector<int>(100));
for (int i = 0; i < db; i++) {
getline(file, bekuldok[i]);
for (int j = 0; j < 100; j++) {
file >> megoldasok[i][j];
}
}
return {bekuldok, megoldasok};
}
bool tiltott(int objind, int moind) {
int objs = objind / 10, objo = objind % 10;
int mos = moind / 10, moo = moind % 10;
return (abs(mos - objs) == 1 && (moo == objo - 1 || moo == objo || moo == objo + 1)) ||
(mos == objs && (moo == objo - 1 || moo == objo + 1));
}
void ellenoriz_feladvanyhoz_tartozik(const vector<int>& feladvany, const vector<vector<int>>& megoldasok,
const vector<string>& bekuldok, vector<bool>& jomegoldasok) {
cout << "Nem erre a feladványra küldtek megoldást:" << endl;
int db = 0;
for (size_t i = 0; i < megoldasok.size(); i++) {
vector<int> alap(megoldasok[i].size());
transform(megoldasok[i].begin(), megoldasok[i].end(), alap.begin(), [](int x) { return x % 11; });
if (alap != feladvany) {
cout << bekuldok[i] << endl;
jomegoldasok[i] = false;
db++;
}
}
if (db == 0) cout << "Mindegyik megoldás erre a heti feladványra érkezett." << endl;
}
void ellenoriz_hajok_szama(const vector<vector<int>>& megoldasok, const vector<string>& bekuldok, vector<bool>& jomegoldasok) {
cout << "Nem jó a hajók száma:" << endl;
int db = 0;
for (size_t i = 0; i < megoldasok.size(); i++) {
if (jomegoldasok[i] && count(megoldasok[i].begin(), megoldasok[i].end(), 11) != 12) {
cout << bekuldok[i] << endl;
jomegoldasok[i] = false;
db++;
}
}
if (db == 0) cout << "Mindegyik fennmaradt beküldésben megfelelő számú hajó volt." << endl;
}
void ellenoriz_hajok_elhelyezese(const vector<vector<int>>& megoldasok, const vector<string>& bekuldok, vector<bool>& jomegoldasok) {
cout << "Nem szabályos a hajók elhelyezése:" << endl;
int db = 0;
for (size_t i = 0; i < megoldasok.size(); i++) {
if (!jomegoldasok[i]) continue;
unordered_set<int> objektumindexek;
for (size_t j = 0; j < megoldasok[i].size(); j++) {
if (megoldasok[i][j] > 0) objektumindexek.insert(j);
}
for (int obji : objektumindexek) {
for (int moi : objektumindexek) {
if (tiltott(obji, moi)) {
cout << bekuldok[i] << endl;
jomegoldasok[i] = false;
db++;
break;
}
}
if (!jomegoldasok[i]) break;
}
}
if (db == 0) cout << "Mindegyik fennmaradt beküldésben szabályos a hajók elrendezése." << endl;
}
void kiir_helyes_megoldasok(const vector<string>& bekuldok, const vector<bool>& jomegoldasok) {
cout << "\nEzen a héten " << count(jomegoldasok.begin(), jomegoldasok.end(), true) << " helyes megoldás érkezett a feladványra." << endl;
cout << "A helyes megoldást beküldők névsora:" << endl;
for (size_t i = 0; i < bekuldok.size(); i++) {
if (jomegoldasok[i]) cout << bekuldok[i] << endl;
}
}
int main() {
vector<int> feladvany;
for (const auto& sor : beolvas_fajl("feladvany.txt")) {
feladvany.insert(feladvany.end(), sor.begin(), sor.end());
}
auto [bekuldok, megoldasok] = beolvas_megoldasok("megoldas.txt");
vector<bool> jomegoldasok(bekuldok.size(), true);
ellenoriz_feladvanyhoz_tartozik(feladvany, megoldasok, bekuldok, jomegoldasok);
ellenoriz_hajok_szama(megoldasok, bekuldok, jomegoldasok);
ellenoriz_hajok_elhelyezese(megoldasok, bekuldok, jomegoldasok);
kiir_helyes_megoldasok(bekuldok, jomegoldasok);
cout << "\nA befejezéshez nyomd meg az ENTER billentyűt!";
cin.get();
return 0;
}
2011. május - Szójáték
[szerkesztés]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 ékezetmenteskiírás is elfogadott.
- 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.) - Í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! 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ő legmagasabbszólétrát építsük.
Például: Szórészlet: isz
A hozzá tartozó létraszavak:
hiszi liszt viszi tiszt …
- 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.) 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.txtmegye vegye hegyi tegye lehet teher mehet tejes fejet fejen neked nekem reked ...
#include <iostream>
#include <fstream>
#include <string>
#include <windows.h>
#include <iomanip>
#include <unordered_set>
using namespace std;
#define N 1000
string szavak[N];
int SZ = 0, ot = 0;
void kiir(int szam) {
cout << "--------------------" << endl;
cout << szam << ". feladat" << endl;
cout << "--------------------" << endl;
}
int maganhangzo(const string& szo) {
unordered_set<char> mh = {'a', 'e', 'i', 'o', 'u'};
int db = 0;
for (char c : szo) {
if (mh.count(c)) 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;
}
void F2() {
ifstream be("szoveg.txt");
string s, max = "";
while (be >> s) {
if (s.length() > max.length()) max = s;
SZ++;
}
cout << "A leghosszabb szó: " << max << endl;
be.close();
}
void F3() {
ifstream be("szoveg.txt");
string s;
int db = 0;
while (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 << " : " << fixed << setprecision(2) << (float)db / SZ * 100 << "%" << endl;
}
void F4() {
ifstream be("szoveg.txt");
string s;
while (be >> s) {
if (s.length() == 5 && ot < N) {
szavak[ot++] = s;
}
}
be.close();
string harom;
cout << "Kérek egy 3 karakteres szórészletet: ";
cin >> harom;
for (int i = 0; i < ot; i++) {
if (szavak[i].substr(1, 3) == harom) {
cout << szavak[i] << " ";
}
}
cout << endl;
}
void F5() {
sort(szavak, szavak + ot, [](const string& a, const string& b) {
return a.substr(1, 3) < b.substr(1, 3);
});
ofstream ki("letra.txt");
bool enter = false;
for (int i = 1; i < ot; i++) {
if (szavak[i].substr(1, 3) == szavak[i - 1].substr(1, 3)) {
if (!enter) {
cout << szavak[i - 1] << endl;
ki << szavak[i - 1] << endl;
}
cout << szavak[i] << endl;
ki << szavak[i] << endl;
enter = true;
} else if (enter) {
cout << endl;
ki << endl;
enter = false;
}
}
ki.close();
}
int main() {
setlocale(LC_ALL, "hun");
kiir(1);
F1();
kiir(2);
F2();
kiir(3);
F3();
kiir(4);
F4();
kiir(5);
F5();
return 0;
}
2011. október - Pitypang
[szerkesztés]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!
1. Olvassa be az pitypang.txt állományban található maximum 1 000 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!
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
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];
struct foglalas {
int s, sz, e, t, v, r;
string az;
} fogl[1000];
int N;
// Fallback data for missing files
vector<foglalas> fallback_data = {
{1, 5, 10, 15, 2, 1, "Test_User1"},
{2, 8, 20, 25, 3, 0, "Test_User2"},
{3, 12, 30, 35, 4, 1, "Test_User3"}
};
void F1() {
ifstream be("pitypang.txt");
if (!be) {
cout << "Hiba: Nem található pitypang.txt! Fallback adatok használata." << endl;
N = fallback_data.size();
for (int i = 0; i < N; i++) {
fogl[i] = fallback_data[i];
}
return;
}
be >> N;
for (int i = 0; i < N; i++) {
be >> fogl[i].s >> fogl[i].sz >> fogl[i].e >> fogl[i].t >> fogl[i].v >> fogl[i].r >> fogl[i].az;
}
be.close();
}
void F1_2() {
ifstream be("honapok.txt");
if (!be) {
cout << "Hiba: Nem található honapok.txt!" << endl;
return;
}
for (int i = 0; i < 12; i++) {
be >> ho[i].hn >> ho[i].nap >> ho[i].ksz;
}
be.close();
}
void F2() {
int maxIndex = 0;
int maxDays = fogl[maxIndex].t - fogl[maxIndex].e;
for (int i = 1; i < N; i++) {
int days = fogl[i].t - fogl[i].e;
if (days > maxDays) {
maxIndex = i;
maxDays = days;
}
}
cout << fogl[maxIndex].az << " (" << fogl[maxIndex].e << ") - " << maxDays << endl;
}
int getPricePerDay(int day) {
if (day < 121) return 9000; // Tavasz
if (day < 244) return 10000; // Nyár
return 8000; // Ősz
}
void F3() {
int totalRevenue = 0;
ofstream ki("bevetel.txt");
for (int i = 0; i < N; i++) {
int cost = 0;
for (int day = fogl[i].e; day < fogl[i].t; day++) {
cost += getPricePerDay(day);
}
// Pótágy díj
if (fogl[i].v > 2) cost += (fogl[i].t - fogl[i].e) * 2000;
// Reggeli díj
if (fogl[i].r == 1) cost += fogl[i].v * (fogl[i].t - fogl[i].e) * 1100;
ki << fogl[i].s << ":" << cost << endl;
totalRevenue += cost;
}
ki.close();
cout << "Összbevétel: " << totalRevenue << " Ft" << endl;
}
int hol_van(int x) {
for (int i = 0; i < 12; i++) {
if (x >= ho[i].ksz && (i == 11 || x < ho[i + 1].ksz)) {
return i;
}
}
return -1;
}
void F4() {
int vej[12] = {0};
for (int i = 0; i < N; i++) {
int erk_honap = hol_van(fogl[i].e);
int tav_honap = hol_van(fogl[i].t);
if (erk_honap == tav_honap) {
vej[erk_honap] += (fogl[i].t - fogl[i].e) * fogl[i].v;
} else {
vej[erk_honap] += (ho[tav_honap].ksz - fogl[i].e) * fogl[i].v;
vej[tav_honap] += (fogl[i].t - ho[tav_honap].ksz) * fogl[i].v;
}
}
for (int i = 0; i < 12; i++) {
cout << i + 1 << ": " << vej[i] << " vendégéj" << endl;
}
}
void F5() {
bool szabad[27][365] = {true};
for (int i = 0; i < N; i++) {
for (int j = fogl[i].e; j < fogl[i].t; j++) {
szabad[fogl[i].sz - 1][j - 1] = false;
}
}
int enap, ejsz;
cout << "Új foglalás" << endl;
cout << "Érkezési nap sorszáma: ";
cin >> enap;
cout << "Eltöltendő éjszakák száma: ";
cin >> ejsz;
int availableRooms = 0;
for (int i = 0; i < 27; i++) {
bool isFree = true;
for (int j = enap - 1; j < enap - 1 + ejsz; j++) {
if (!szabad[i][j]) {
isFree = false;
break;
}
}
if (isFree) {
availableRooms++;
}
}
if (availableRooms > 0) {
cout << "Szabad szobák száma: " << availableRooms << endl;
} else {
cout << "Nincs szabad szoba ebben az időszakban!" << endl;
}
}
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;
}
2012. május - Törtek
[szerkesztés]
A matematikában sokszor van szükségünk műveletvégzésre a közönséges törtekkel. A legtöbb számológép és számítógépes program csak a tizedestörteket ismeri.
Készítsen programot, amely az alábbi – közönséges törtekkel kapcsolatos – feladatokat megoldja! A program forráskódját tort néven mentse! A feladatban csak pozitív számokkal kell dolgoznia, és ennek a tulajdonságnak a feldolgozandó fájlban található számadatok is megfelelnek. A felhasználótól bekérendő és a feldolgozandó fájlban található számokról feltételezheti, hogy legfeljebb kétjegyűek.
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 az 1. feladat esetén: „1. feladat Adja meg a számlálót:”)! Az ékezetmentes kiírás is elfogadott.
Kérjen be a felhasználótól két számot, amely egy közönséges tört számlálója és nevezője! Döntse el, hogy az így bevitt tört felírható-e egész számként! Ha igen, írja ki értékét egész számként, ha nem, írja ki „Nem egész”!
A közönséges törteket úgy tudjuk a legegyszerűbb alakra hozni, ha a számlálóját és nevezőjét elosztjuk a két szám legnagyobb közös osztójával, és az így kapott érték lesz az új számláló, illetve nevező. Az egyszerűsítéshez készítsen egy rekurzív függvényt az alább leírt euklideszi algoritmusnak megfelelően!
Függvény lnko(a, b : egész számok) : egész szám ha a=b akkor lnko := a ha a<b akkor lnko := lnko(a, b-a) ha a>b akkor lnko := lnko(a-b, b) Függvény vége
Az első feladatban bekért törtet hozza a legegyszerűbb alakra a létrehozott függvény segítségével! Amennyiben nem sikerül az előírt függvényt elkészítenie, alkalmazhat más megoldást, hogy a további feladatokat meg tudja oldani. Az eredményt írja ki a következő formában:
24/32 = 3/4
Amennyiben a tört felírható egész számként, akkor ebben az alakban jelenjen meg:
24/6 = 4
Két törtet úgy tudunk összeszorozni, hogy a két tört számlálóját összeszorozva kapjuk az eredmény számlálóját, és a két tört nevezőjét összeszorozva kapjuk az eredmény nevezőjét. Kérjen be a felhasználótól egy újabb közönséges törtet a számlálójával és a nevezőjével! Szorozza meg ezzel a törttel az első feladatban bekért törtet! Az eredményt hozza a legegyszerűbb alakra, és ezt írja ki a következő formában:
24/32 * 12/15 = 288/480 = 3/5
Amennyiben az eredmény felírható egész számként, akkor ebben az alakban jelenjen meg:
24/32 * 8/3 = 192/96 = 2
Két közönséges tört összeadásához a következő lépésekre van szükség:
- Mindkét számot bővíteni kell, azaz mind a számlálóját, mind a nevezőjét ugyanazzal a számmal kell megszorozni. Ezt a bővítést úgy célszerű elvégezni, hogy a közös nevező a két eredeti nevező legkisebb közös többszöröse legyen. Ez lesz az összeg nevezője.
- A két bővített alakú tört számlálóját összeadjuk, ez lesz az eredmény számlálója.
Ehhez készítsen függvényt az alábbiakban leírtak szerint – a korábban elkészített lnko függvény felhasználásával – a legkisebb közös többszörös meghatározására!
Függvény lkkt(a, b : egész számok) : egész szám lkkt := a * b / lnko(a, b) Függvény vége
A függvény segítségével határozza meg a két bekért tört összegét, és ezt adja meg a következő formában! (Amennyiben nem sikerül az előírt függvényt elkészítenie, alkalmazhat más megoldást, hogy a további feladatokat meg tudja oldani.)
24/32 + 8/3 = 72/96 + 256/96 = 328/96 = 41/12
Amennyiben az eredmény felírható egész számként, akkor ebben az alakban jelenjen meg:
22/4 + 27/6 = 66/12 + 54/12 = 120/12 = 10
Az adat.txt állományban található műveleteket végezze el, és az eredményeket a korábbi, képernyőre kiírt formátumnak megfelelően írja az eredmeny.txt állományba! Az adat.txt fájlnak legfeljebb 100 sora lehet; soronként 4 számot és egy műveleti jelet tartalmaz, melyeket mindenhol egy szóköz választ el egymástól. Műveleti jelként csak összeadás és szorzás szerepel. Például:
adat.txt:
24 32 8 3 + 24 32 8 3 *
eredmeny.txt:
24/32 + 8/3 = 72/96 + 256/96 = 328/96 = 41/ 24/32 * 8/3 = 192/96 = 2
#include <iostream>
#include <fstream>
#include <string>
using namespace std;
int lnko(int a, int b) {
if (a == b) return a;
if (a < b) return lnko(a, b - a);
return lnko(a - b, b);
}
string formazo(int sz, int n) {
int gcd = lnko(sz, n);
if (sz % n == 0)
return to_string(sz / n);
return to_string(sz / gcd) + "/" + to_string(n / gcd);
}
int lkkt(int a, int b) {
return a * b / lnko(a, b);
}
int main() {
int sz, n, sz2, n2;
cout << "\n1. feladat\n";
cout << "Kérem a tört számlálóját: ";
cin >> sz;
cout << "Kérem a tört nevezőjét: ";
cin >> n;
if (sz % n == 0)
cout << "A megadott tört egész szám: " << sz << "/" << n << " = " << sz / n << endl;
else
cout << "Nem egész." << endl;
cout << "\n2. feladat\n";
cout << "Az lnko függvény definiálva." << endl;
cout << "\n3. feladat\n";
cout << sz << "/" << n << " = " << formazo(sz, n) << endl;
cout << "\n4. feladat\n";
cout << "Kérem a másik tört számlálóját: ";
cin >> sz2;
cout << "Kérem a másik tört nevezőjét: ";
cin >> n2;
cout << sz << "/" << n << " * " << sz2 << "/" << n2 << " = " << sz * sz2 << "/" << n * n2 << " = " << formazo(sz * sz2, n * n2) << endl;
cout << "\n5. feladat\n";
cout << "Az lkkt függvény definiálva." << endl;
cout << "\n6. feladat\n";
int lnkt = lkkt(n, n2);
int sz1_bovitett = sz * (lnkt / n);
int sz2_bovitett = sz2 * (lnkt / n2);
int osszeg_szamlalo = sz1_bovitett + sz2_bovitett;
cout << sz << "/" << n << " + " << sz2 << "/" << n2 << " = "
<< sz1_bovitett << "/" << lnkt << " + " << sz2_bovitett << "/" << lnkt << " = "
<< osszeg_szamlalo << "/" << lnkt << " = " << formazo(osszeg_szamlalo, lnkt) << endl;
cout << "\n7. feladat\n";
ifstream betxt("adat.txt");
ofstream kitxt("eredmeny.txt");
string muv;
while (betxt >> sz >> n >> sz2 >> n2 >> muv) {
if (muv == "*") {
kitxt << sz << "/" << n << " * " << sz2 << "/" << n2 << " = " << sz * sz2 << "/" << n * n2 << " = " << formazo(sz * sz2, n * n2) << endl;
} else {
lnkt = lkkt(n, n2);
sz1_bovitett = sz * (lnkt / n);
sz2_bovitett = sz2 * (lnkt / n2);
osszeg_szamlalo = sz1_bovitett + sz2_bovitett;
kitxt << sz << "/" << n << " + " << sz2 << "/" << n2 << " = "
<< sz1_bovitett << "/" << lnkt << " + " << sz2_bovitett << "/" << lnkt << " = "
<< osszeg_szamlalo << "/" << lnkt << " = " << formazo(osszeg_szamlalo, lnkt) << endl;
}
}
cout << "A feldolgozás befejeződött." << endl;
cout << "\nA befejezéshez nyomd meg az ENTER billentyűt!";
cin.ignore();
cin.get();
return 0;
}
2012. május - Futár
[szerkesztés]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 5
1 2 9
3 2 12
1 4 3
3 1 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.
- Olvassa be a tavok.txt állományban talált adatokat, s annak felhasználásával oldja meg a következő feladatokat!
- Í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!
- Írja ki a képernyőre, hogy mekkora volt a hét utolsó útja kilométerben!
- 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!
- Í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.
- 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
…
- 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 | 500 Ft |
|---|---|
| 3 – 5 km | 700 Ft |
| 6 – 10 km | 900 Ft |
| 11 – 20 km | 1 400 Ft |
| 21 – 30 km | 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!
- 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
…
- Határozza meg, és írja ki a képernyőre, hogy a futár mekkora összeget kap a heti munkájáért!
#include <iostream>
#include <fstream>
#include <windows.h>
#include <algorithm>
using namespace std;
struct futar {
int km;
int ft;
} adatok[7][40];
int elso_nap = 8, utolso_nap = 0, napi_km[7];
void kiir(int szam) {
cout << "\n" << szam << ". FELADAT" << endl;
cout << "................" << endl;
}
void F1() {
for (int i = 0; i < 7; i++) {
for (int j = 0; j < 40; j++) {
adatok[i][j].km = 0;
}
}
ifstream be("tavok.txt");
int nap, fuvar;
while (be >> nap >> fuvar >> adatok[nap - 1][fuvar - 1].km) {
if (nap < elso_nap) elso_nap = nap;
if (nap > utolso_nap) utolso_nap = nap;
}
cout << "Első nap: " << elso_nap << " utolsó nap: " << utolso_nap << endl;
be.close();
}
void F2() {
cout << elso_nap << ". nap első fuvar: " << adatok[elso_nap - 1][0].km << " km volt" << endl;
}
void F3() {
int last_km = 0;
for (int i = 6; i >= 0; i--) {
for (int j = 39; j >= 0; j--) {
if (adatok[i][j].km != 0) {
last_km = adatok[i][j].km;
cout << "A(z) " << i + 1 << ". nap utolsó fuvar: " << last_km << " km" << endl;
return;
}
}
}
}
void F4() {
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;
}
void F5() {
int max_fuvar = 0, mikor = 1;
for (int i = 0; i < 7; i++) {
int fuvar_count = 0;
for (int j = 0; j < 40; j++) {
if (adatok[i][j].km != 0) fuvar_count++;
}
if (fuvar_count >= max_fuvar) {
max_fuvar = fuvar_count;
mikor = i + 1;
}
}
cout << "A(z) " << mikor << ". napon ment a legtöbbet!" << endl;
}
void F6_seged() {
fill(begin(napi_km), end(napi_km), 0);
for (int i = 0; i < 7; i++) {
for (int j = 0; j < 40; j++) {
napi_km[i] += adatok[i][j].km;
}
}
}
void F6() {
F6_seged();
for (int i = 0; i < 7; i++) {
cout << i + 1 << ". nap: " << napi_km[i] << " km" << endl;
}
}
int F7_kalkulator(int tav) {
if (tav < 3) return 500;
else if (tav < 6) return 700;
else if (tav < 11) return 900;
else if (tav < 21) return 1400;
else if (tav < 31) return 2000;
return 0;
}
void F7() {
int tavolsag;
cout << "Adjon meg egy távolságot (1-30 km között): ";
cin >> tavolsag;
if (tavolsag < 1 || tavolsag > 30) {
cout << "Érvénytelen távolság!" << endl;
} else {
cout << "Erre jár " << F7_kalkulator(tavolsag) << " Ft." << endl;
}
}
void F8() {
ofstream ki("dijazas.txt");
for (int i = 0; i < 7; i++) {
for (int j = 0; j < 40; j++) {
if (adatok[i][j].km != 0) {
adatok[i][j].ft = F7_kalkulator(adatok[i][j].km);
cout << i + 1 << ". nap " << j + 1 << ". út: " << adatok[i][j].ft << " Ft" << endl;
ki << i + 1 << ". nap " << j + 1 << ". út: " << adatok[i][j].ft << " Ft" << endl;
}
}
}
ki.close();
}
void F9() {
int kereset = 0;
for (int i = 0; i < 7; i++) {
for (int j = 0; j < 40; j++) {
if (adatok[i][j].km != 0) {
kereset += adatok[i][j].ft;
}
}
}
cout << "Heti munka díjazása: " << kereset << " Ft" << 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();
kiir(8); F8();
kiir(9); F9();
return 0;
}
2012. október - Szín-kép
[szerkesztés]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:
\;img
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!
- Olvassa be a fájlból egy megfelelő adatszerkezetbe az egyes képpontok RGB kódját!
- 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!
- 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:
\;img
- Á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 |
- 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).
- 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:
\;img
- 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:
\;img
Például:
\;img
#include <iostream>
#include <fstream>
using namespace std;
struct RGB {
int R, G, B;
} kep[50][50];
void kiir(int ssz) {
cout << ssz << ". feladat" << endl;
}
void F1() {
ifstream be("kep.txt");
for (int i = 0; i < 50; i++) {
for (int j = 0; j < 50; j++) {
be >> kep[i][j].R >> kep[i][j].G >> kep[i][j].B;
}
}
be.close();
}
void F2() {
int r, g, b;
cout << "Kérek egy RGB kódot:\n";
cout << "r="; cin >> r;
cout << "g="; cin >> g;
cout << "b="; cin >> b;
bool megtalalt = false;
for (int i = 0; i < 50 && !megtalalt; i++) {
for (int j = 0; j < 50; j++) {
if (kep[i][j].R == r && kep[i][j].G == g && kep[i][j].B == b) {
megtalalt = true;
break;
}
}
}
cout << (megtalalt ? "Van ilyen kód!" : "Nincs ilyen kód!") << endl;
}
void F3() {
int r = kep[34][7].R, g = kep[34][7].G, 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++;
if (kep[i][7].R == r && kep[i][7].G == g && kep[i][7].B == b) odb++;
}
cout << "Sorban: " << sdb << " Oszlopban: " << odb << endl;
}
void F4() {
int szin[3] = {0, 0, 0};
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_idx = 0;
for (int i = 1; i < 3; i++) {
if (szin[i] > szin[max_idx]) max_idx = i;
}
cout << "Leggyakoribb szín: " << (max_idx == 0 ? "VÖRÖS" : max_idx == 1 ? "ZÖLD" : "KÉK") << endl;
}
void F5() {
for (int i = 0; i < 50; i++) {
for (int j = 0; j < 3; j++) {
kep[i][j] = {0, 0, 0};
kep[i][49 - j] = {0, 0, 0};
kep[j][i] = {0, 0, 0};
kep[49 - j][i] = {0, 0, 0};
}
}
}
void F6() {
ofstream ki("keretes.txt");
for (int i = 0; i < 50; i++) {
for (int j = 0; j < 50; j++) {
ki << kep[i][j].R << " " << kep[i][j].G << " " << kep[i][j].B << endl;
}
}
ki.close();
}
void F7() {
int ki = -1, kj = -1, vi = -1, vj = -1;
for (int i = 3; i < 50 && ki == -1; i++) {
for (int j = 3; j < 50; j++) {
if (kep[i][j].R == 255 && kep[i][j].G == 255 && kep[i][j].B == 0) {
ki = i; kj = j;
break;
}
}
}
for (int i = 46; i >= 0 && vi == -1; i--) {
for (int j = 46; j >= 0; j--) {
if (kep[i][j].R == 255 && kep[i][j].G == 255 && kep[i][j].B == 0) {
vi = i; vj = j;
break;
}
}
}
if (ki != -1 && kj != -1 && vi != -1 && vj != -1) {
cout << "Kezd: " << ki << ", " << kj << endl;
cout << "Vége: " << vi << ", " << vj << endl;
cout << "Képpontok száma: " << (vi - ki + 1) * (vj - kj + 1) << 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;
}
2013. május - Számok
[szerkesztés]
A Szereti Ön a számokat? internetes vetélkedőben a versenyzők olyan kérdéseket kapnak, amelyekre egy egész számmal kell válaszolniuk. A kérdések különböző témakörökből származnak (pl. magyar, matematika, történelem, kémia), és nehézségüktől függően 1-től 3-ig terjedő pontszámot érnek. Tudjuk, hogy a kérdésekre adható válaszok értéke 0 és 1 milliárd közé esik.
A feladatokat a verseny szervezői egy adatfájlban tárolják. A fájlban minden feladat két sorban helyezkedik el. Az első sor tartalmazza a kérdést, a második pedig – egy-egy szóközzel elválasztva – a helyes választ, a helyes válaszért adható pontszámot és a témakör megnevezését. A fájlban egyelőre ékezetes betűk nem szerepelnek, pl. a „gyümölcsízű” szó helyett a „gyumolcsizu” szót írták be.
Például:
Mikor volt a mohacsi vesz?
1526 1 tortenelem
A példában szereplő kérdés: Mikor volt a mohacsi vesz? A helyes válasz: 1526. A helyes válasz 1 pontot ér, és a kérdés a tortenelem témakörbe tartozik.
Az adatfájl még csak részben készült el. Az Ön feladata ennek a félkész adatfájlnak a tesztelése. A fájl legfeljebb 100 kérdést tartalmaz. Biztosan van benne matematika, történelem és földrajz feladat, de más témakörök is előfordulnak.
Készítsen programot, amely a felszam.txt állomány adatait felhasználva az alábbi kérdésekre válaszol! A program forráskódját mentse szamok néven! (A beolvasott fájl adatait és a felhasználó válaszainak az érvényességét nem kell ellenőriznie.)
A képernyőre írást igénylő feladatok eredményének megjelenítése előtt írja ki a képernyőre a feladat sorszámát (például: 3. feladat)! Ha a felhasználótól kér be adatot, akkor jelenítse meg a képernyőn azt is, hogy milyen adatot vár! Az ékezetmentes kiírás is elfogadott.
1. Olvassa be a felszam.txt állományban talált adatokat, és azok felhasználásával oldja meg a következő feladatokat!
2. Hány feladat van az adatfájlban? A választ írassa ki a képernyőre!
3. Határozza meg, hogy hány matematika feladat van az adatfájlban, és ezek közül hány feladat ér 1, 2, illetve 3 pontot! A választ egész mondatban írassa ki a képernyőre!
Például:
Az adatfajlban 20 matematika feladat van, 1 pontot er
10 feladat, 2 pontot er 6 feladat, 3 pontot er 4 feladat.
4. Mettől meddig terjed a fájlban található válaszok számértéke? A választ egész mondatban írja ki a képernyőre!
5. Milyen témakörök szerepelnek ténylegesen az adatfájlban? Írassa ki a témakörök nevét a képernyőre úgy, hogy minden előforduló témakör pontosan egyszer jelenjen meg!
6. Kérje be egy témakör nevét, és véletlenszerűen sorsoljon ki egy kérdést ebből a témakörből! Sorsoláskor ügyeljen arra, hogy az adott témakörbe eső valamennyi feladatnak legyen esélye! (Feltételezheti, hogy a felhasználó helyesen adta meg egy létező témakör nevét.) Írassa ki a kérdést, kérje be a felhasználó válaszát, majd adja meg a válaszért járó pontszámot! (Helytelen válaszért 0 pont jár.) Ha a válasz helytelen volt, a helyes választ is közölje! A párbeszéd az alábbi formában jelenjen meg:
Például:
Milyen temakorbol szeretne kerdest kapni? tortenelem
Mikor volt a mohacsi vesz? 1514
A valasz 0 pontot er.
A helyes valasz: 1526
7. Generáljon egy 10 kérdésből álló feladatsort véletlenszerűen úgy, hogy egyetlen feladat se szerepeljen benne kétszer! (Ügyeljen azonban arra, hogy minden beolvasott feladatnak legyen esélye a kiválasztásra!) A feladatsort írassa ki a tesztfel.txt állományba az alábbi formátumban! (Az első szám a helyes megoldásért járó pontszám, ezt követi a helyes válasz, majd a kérdés egy-egy szóközzel elválasztva.) Az állomány végére írassa ki a feladatsorra összesen adható pontszámot is!
Például:
…
1 1526 Mikor volt a mohacsi vesz?
…
A feladatsorra osszesen 20 pont adhato.
#include <iostream>
#include <fstream>
#include <vector>
#include <sstream>
#include <algorithm>
#include <unordered_set>
#include <random>
using namespace std;
struct Feladat {
string kerdes;
int valasz;
int pontszam;
string temakor;
};
vector<Feladat> beolvasFeladatok(const string &fajlnev) {
ifstream file(fajlnev);
vector<Feladat> feladatok;
string sor;
while (getline(file, sor)) {
Feladat feladat;
feladat.kerdes = sor;
getline(file, sor);
stringstream ss(sor);
ss >> feladat.valasz >> feladat.pontszam >> feladat.temakor;
feladatok.push_back(feladat);
}
file.close();
return feladatok;
}
void kiirFeladatSzam(const vector<Feladat> &feladatok) {
cout << "\n2. feladat\n";
cout << "Az adatfájlban " << feladatok.size() << " feladat van." << endl;
}
void statisztikaMatematika(const vector<Feladat> &feladatok) {
cout << "\n3. feladat\n";
int db = 0, pontok[3] = {0};
for (const auto &fel : feladatok) {
if (fel.temakor == "matematika") {
db++;
pontok[fel.pontszam - 1]++;
}
}
cout << "Az adatfájlban " << db << " matematika feladat van,\n"
<< "1 pontot ér " << pontok[0] << " feladat, 2 pontot ér " << pontok[1]
<< " feladat, 3 pontot ér " << pontok[2] << " feladat." << endl;
}
void minMaxValasz(const vector<Feladat> &feladatok) {
cout << "\n4. feladat\n";
auto minmax = minmax_element(feladatok.begin(), feladatok.end(),
[](const Feladat &a, const Feladat &b) {
return a.valasz < b.valasz;
});
cout << "A fájlban a válaszok legkisebb számértéke " << minmax.first->valasz
<< ", a legnagyobb pedig " << minmax.second->valasz << "." << endl;
}
void egyediTemakorok(const vector<Feladat> &feladatok) {
cout << "\n5. feladat\n";
unordered_set<string> temakorok;
for (const auto &fel : feladatok) {
temakorok.insert(fel.temakor);
}
cout << "Az adatfájlban szereplő témakörök: ";
for (const auto &t : temakorok) {
cout << t << ", ";
}
cout << endl;
}
void kerdezzTemakorbol(const vector<Feladat> &feladatok) {
cout << "\n6. feladat\n";
string temakor;
cout << "Kérem egy témakör nevét: ";
cin >> temakor;
vector<Feladat> szurt;
for (const auto &fel : feladatok) {
if (fel.temakor == temakor) {
szurt.push_back(fel);
}
}
if (szurt.empty()) {
cout << "Nincs ilyen témakör!" << endl;
return;
}
random_device rd;
mt19937 gen(rd());
uniform_int_distribution<> dist(0, szurt.size() - 1);
Feladat kivalasztott = szurt[dist(gen)];
int valasz;
cout << kivalasztott.kerdes << " ";
cin >> valasz;
if (valasz == kivalasztott.valasz) {
cout << "A válasz " << kivalasztott.pontszam << " pontot ér." << endl;
} else {
cout << "A válasz 0 pontot ér.\nA helyes válasz: " << kivalasztott.valasz << endl;
}
}
void generalFeladatsor(const vector<Feladat> &feladatok) {
cout << "\n7. feladat\n";
vector<int> indexek(feladatok.size());
iota(indexek.begin(), indexek.end(), 0);
shuffle(indexek.begin(), indexek.end(), random_device{});
ofstream file("tesztfel.txt");
int osszpont = 0;
for (int i = 0; i < min(10, (int)feladatok.size()); i++) {
file << feladatok[indexek[i]].pontszam << " " << feladatok[indexek[i]].valasz << " "
<< feladatok[indexek[i]].kerdes << "\n";
osszpont += feladatok[indexek[i]].pontszam;
}
file << "A feladatsorra összesen " << osszpont << " pont adható.\n";
file.close();
cout << "A kiíratás és a szövegfájl lezárása sikeresen befejeződött." << endl;
}
int main() {
vector<Feladat> feladatok = beolvasFeladatok("felszam.txt");
kiirFeladatSzam(feladatok);
statisztikaMatematika(feladatok);
minMaxValasz(feladatok);
egyediTemakorok(feladatok);
kerdezzTemakorbol(feladatok);
generalFeladatsor(feladatok);
cout << "\nA befejezéshez nyomd meg az ENTER billentyűt!";
cin.ignore();
cin.get();
return 0;
}
2013. május - Választások
[szerkesztés]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.
- 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.
- 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.
- 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.
- 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.
- 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%
- 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!
- 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!
#include <iostream>
#include <iomanip>
#include <fstream>
#include <vector>
#include <map>
#define V 12345
using namespace std;
struct Jelolt {
int vk;
int sz;
string vnev;
string knev;
string part;
};
vector<Jelolt> adatok;
int N = 0;
void kiir(int ssz) {
cout << ssz << ". feladat" << endl;
}
void F1() {
ifstream be("szavazatok.txt");
if (!be) {
cerr << "Hiba: Nem sikerult megnyitni a fajlt!" << endl;
return;
}
Jelolt temp;
while (be >> temp.vk >> temp.sz >> temp.vnev >> temp.knev >> temp.part) {
adatok.push_back(temp);
}
N = adatok.size();
be.close();
}
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;
for (const auto &jelolt : adatok) {
if (jelolt.vnev == vn && jelolt.knev == kn) {
cout << "Kapott szavazatok száma: " << jelolt.sz << endl;
return;
}
}
cout << "Ilyen nevu kepviselojelolt nem szerepel a nyilvantartasban!" << endl;
}
int osszesSzavazat() {
int szumma = 0;
for (const auto &jelolt : adatok) {
szumma += jelolt.sz;
}
return szumma;
}
void F4() {
int szumma = osszesSzavazat();
cout << "A választáson " << szumma << " állampolgár, a jogosultak "
<< fixed << setprecision(2) << (szumma * 100.0 / V) << "%-a vett részt." << endl;
}
void F5() {
map<string, int> szavazatok;
int szumma = osszesSzavazat();
for (const auto &jelolt : adatok) {
szavazatok[jelolt.part] += jelolt.sz;
}
for (const auto &partr : szavazatok) {
string nev = (partr.first == "-") ? "Független jelöltek" : partr.first;
cout << nev << " = " << fixed << setprecision(2) << (partr.second * 100.0 / szumma) << "%" << endl;
}
}
void F6() {
int maxSzavazat = 0;
vector<Jelolt> gyoztesek;
for (const auto &jelolt : adatok) {
if (jelolt.sz > maxSzavazat) {
maxSzavazat = jelolt.sz;
gyoztesek.clear();
gyoztesek.push_back(jelolt);
} else if (jelolt.sz == maxSzavazat) {
gyoztesek.push_back(jelolt);
}
}
for (const auto &g : gyoztesek) {
cout << g.vnev << " " << g.knev << " "
<< ((g.part == "-") ? "független" : g.part) << endl;
}
}
void F7() {
map<int, Jelolt> gyoztesek;
for (const auto &jelolt : adatok) {
if (gyoztesek.find(jelolt.vk) == gyoztesek.end() || gyoztesek[jelolt.vk].sz < jelolt.sz) {
gyoztesek[jelolt.vk] = jelolt;
}
}
ofstream ki("kepviselok.txt");
if (!ki) {
cerr << "Hiba: Nem sikerult megnyitni a kepviselok.txt fajlt!" << endl;
return;
}
for (const auto &g : gyoztesek) {
ki << g.second.vk << " " << g.second.vnev << " " << g.second.knev << " "
<< ((g.second.part == "-") ? "független" : g.second.part) << endl;
cout << g.second.vk << " " << g.second.vnev << " " << g.second.knev << " "
<< ((g.second.part == "-") ? "független" : g.second.part) << endl;
}
ki.close();
}
int main() {
kiir(1); F1();
kiir(2); F2();
kiir(3); F3();
kiir(4); F4();
kiir(5); F5();
kiir(6); F6();
kiir(7); F7();
return 0;
}
2013. október - Közúti ellenőrzés
[szerkesztés]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:
\;img
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.
- Olvassa be a jarmu.txt állományban talált adatokat, s annak felhasználásával oldja meg a következő feladatokat!
- 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!
- 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ű!
- 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!
- 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!
- 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!
- 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!
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <iomanip>
using namespace std;
struct Adatok {
int h, p, m;
string r;
};
vector<Adatok> a;
void kiir(int x) {
cout << x << ". feladat" << endl;
}
void F1() {
ifstream be("jarmu.txt");
Adatok temp;
while (be >> temp.h >> temp.p >> temp.m >> temp.r) {
a.push_back(temp);
}
be.close();
}
void F2() {
int munkaido = a.back().h - a.front().h + 1;
cout << munkaido << " orat dolgoztak legalabb." << endl;
}
void F3() {
vector<bool> ellenorzott(24, false);
for (const auto& jarmu : a) {
if (!ellenorzott[jarmu.h]) {
ellenorzott[jarmu.h] = true;
cout << jarmu.h << " ora: " << jarmu.r << "!" << endl;
}
}
}
void F4() {
int b = 0, k = 0, m = 0, sz = 0;
for (const auto& jarmu : a) {
switch (jarmu.r[0]) {
case 'B': b++; break;
case 'K': k++; break;
case 'M': m++; break;
default: sz++;
}
}
cout << b << " busz, " << k << " kamion, " << m << " motor es " << sz << " szemelygepkocsi haladt el az ellenorzo pont elott." << endl;
}
void F5() {
int max_ido = 0, index = 0;
for (size_t i = 0; i < a.size() - 1; ++i) {
int diff = (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);
if (diff > max_ido) {
max_ido = diff;
index = i;
}
}
cout << setfill('0') << setw(2) << a[index].h << ":" << setw(2) << a[index].p << ":" << setw(2) << a[index].m
<< " - " << setw(2) << a[index + 1].h << ":" << setw(2) << a[index + 1].p << ":" << setw(2) << a[index + 1].m << endl;
}
void F6() {
string x;
cout << "Kerem a keresett rendszamot, ismeretlen betuit '*' jellel helyettesitve: ";
cin >> x;
bool found = false;
for (const auto& jarmu : a) {
bool match = true;
for (size_t i = 0; i < x.size(); i++) {
if (x[i] != '*' && x[i] != jarmu.r[i]) {
match = false;
break;
}
}
if (match) {
cout << jarmu.r << endl;
found = true;
}
}
if (!found) {
cout << "Nincs talalat!" << endl;
}
}
void F7() {
ofstream ki("vizsgalt.txt");
size_t i = 0;
while (i < a.size()) {
ki << setfill('0') << setw(2) << a[i].h << " " << setw(2) << a[i].p << " " << setw(2) << a[i].m << " " << a[i].r << endl;
size_t j = i + 1;
while (j < a.size() && (a[j].h * 3600 + a[j].p * 60 + a[j].m) - (a[i].h * 3600 + a[i].p * 60 + a[i].m) < 300) {
j++;
}
i = j;
}
ki.close();
}
int main() {
F1();
kiir(2); F2();
kiir(3); F3();
kiir(4); F4();
kiir(5); F5();
kiir(6); F6();
kiir(7); F7();
return 0;
}
2014. május - Céllövészet
[szerkesztés]A Sor Lövészegylet rendszeresen rendez versenyt az alábbi, igen egyszerű szabályokkal:
- A lövések leadására korlátozott idő áll rendelkezésre, ezért a versenyzők eltérő számú lövést adhatnak le.
- A lövéseket sorszámozott korongokra kell leadni.
- Találatnak számít, ha a korongot bárhol érinti a lövedék.
- A lövésekhez pontértéket rendelnek: amíg nem hibázik valaki, minden találata 20 pontot ér; de rontás esetén minden hiba 1 ponttal csökkenti – egészen nulláig – a későbbi lövésekkel szerezhető pontszámot. A lövés pontértéke nem lehet negatív.
- Az végez előrébb a versenyben, aki több pontot szerez. A holtversenyt nem döntik el, mindegyik versenyző ugyanolyan helyezéssel végez, tehát mindenki helyezése megegyezik a nála több pontot szerzett versenyzők számánál eggyel nagyobb számmal.
A verseny.txt állományban versenyzőnként feljegyeztük a lövések eredményét. A fájl első sorában a versenyzők száma (2≤v≤100) szerepel. A következő v sorban legfeljebb l (4≤l≤40) karakter található, egy versenyző lövéseinek sorozata. Egy lövést egy karakter ír le, a – karakter a sikertelen, a + karakter a sikeres lövést rögzíti.
Például:
5
+–+
-+-+++-
-+–+–
++—
-++–
A példában a 4. sor azt mutatja, hogy a 3-as rajtszámú lövőnek a 2. és az 5. lövése talált, tehát a versenyző csak két korongot talált el. Mivel elsőre hibázott, az első találat 19 pontot ér, aztán a két újabb hiba miatt már csak 17 pontot jelentett a második találat. Tehát összesen 36 pontot szerzett. Az 5. sorban szereplő, 4-es rajtszámú versenyző ugyancsak 2 találattal 40 pontot szerzett.
Készítsen programot, amely a verseny.txt állomány adatait felhasználva az alábbi kérdésekre válaszol! A program forráskódját mentse loves 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:), az 5. feladat esetén pedig a részfeladat betűjelét is! 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.
- Olvassa be a verseny.txt állományban található adatokat, és annak felhasználásával oldja meg a következő feladatokat!
- Írja a képernyőre azon versenyzők rajtszámát, akiknek egymás után két (vagy több) lövése is talált! A versenyzők rajtszámát egy-egy szóközzel válassza el egymástól!
- Írja a képernyőre, hogy melyik versenyző adta le a legtöbb lövést! Ha többen is ugyanannyi lövést adtak le, elegendő egyikük rajtszámát kiírni.
- Készítsen függvényt loertek néven az alábbi algoritmus alapján! A függvény egy + és – jeleket tartalmazó, legfeljebb 40 hosszúságú karaktersorozathoz hozzárendeli a feladatban képviselt pontértékét. A függvény elkészítésekor az algoritmusban megadott változóneveket használja! Az elkészített függvényt a további feladatok megoldásánál használja fel! A függvény bemenő paramétere az egy játékos lövéseit leíró karaktersorozat, értéke pedig az ahhoz rendelt pontszám.
\;img
- Kérje be a felhasználótól egy versenyző sorszámát, majd írja ki, hogy:
hányadik lövései találtak (az értékeket egymástól szóközzel válassza el!)
hány korongot talált el összesen
milyen hosszú volt a leghosszabb hibátlan lövéssorozata
hány pontot ért el!
Az eredmény megjelenítése előtt írja képernyőre a részfeladat betűjelét is!
- Állítsa elő a sorrend.txt állományban a verseny végeredményét! A fájlban soronként tüntesse fel a versenyző helyezését, rajtszámát és pontszámát! A helyezés megadásakor a holtversenyt a bevezetőben megfogalmazott szabályok alapján az alábbi mintához hasonlóan kezelje! Az adatokat egy-egy tabulátorral (ASCII kódja a 9-es) válassza el egymástól! A lista legyen pontszám szerint csökkenő!
Például a feladat elején olvasható példa bemenet esetén a fájl tartalma:
\;img
Példa a szöveges kimenetek kialakításához:
\;img
#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;
// Function to calculate score based on the given shooting pattern
int loertek(const string& sor) {
int aktpont = 20, ertek = 0;
for (char c : sor) {
if (aktpont > 0 && c == '-') {
aktpont--;
} else {
ertek += aktpont;
}
}
return ertek;
}
int main() {
cout << "\n1. feladat\n";
ifstream file("verseny.txt");
if (!file) {
cerr << "Hiba: Nem sikerult megnyitni a verseny.txt fajlt!\n";
return 1;
}
int l;
file >> l;
file.ignore(); // Ignore newline
vector<string> loadatok(l);
for (int i = 0; i < l; ++i) {
getline(file, loadatok[i]);
}
file.close();
cout << "A beolvasas es a szovegfajl lezarasa sikeresen befejezodott.\n";
cout << "\n2. feladat\n";
cout << "Az egymast kovetoen tobbszor talalo versenyzok: ";
for (int i = 0; i < l; ++i) {
if (loadatok[i].find("++") != string::npos) {
cout << i + 1 << " ";
}
}
cout << "\n";
cout << "\n3. feladat\n";
int maxLoves = 0, maxIndex = 0;
for (int i = 0; i < l; ++i) {
if (loadatok[i].size() > maxLoves) {
maxLoves = loadatok[i].size();
maxIndex = i + 1;
}
}
cout << "A legtobb lovest leado versenyzo rajtszama: " << maxIndex << "\n";
cout << "\n4. feladat\n";
cout << "A fuggveny elkeszult.\n";
cout << "\n5. feladat\n";
int rsz;
cout << "Adjon meg egy rajtszamot! (1<= rajtszam <= " << l << "): ";
cin >> rsz;
string losor = loadatok[rsz - 1];
vector<int> talIndexek;
for (int i = 0; i < losor.size(); ++i) {
if (losor[i] == '+') {
talIndexek.push_back(i + 1);
}
}
cout << "5a. feladat: Celt ero lovesek: ";
for (int idx : talIndexek) cout << idx << " ";
cout << "\n";
cout << "5b. feladat: Az eltalalt korongok szama: " << talIndexek.size() << "\n";
size_t maxHitStreak = 0, currentStreak = 0;
for (char c : losor) {
if (c == '+') {
currentStreak++;
maxHitStreak = max(maxHitStreak, currentStreak);
} else {
currentStreak = 0;
}
}
cout << "5c. feladat: A leghosszabb hibatlan sorozat hossza: " << maxHitStreak << "\n";
cout << "5d. feladat: A versenyzo pontszama: " << loertek(losor) << "\n";
cout << "\n6. feladat\n";
vector<pair<int, int>> eredmenyek;
for (int i = 0; i < l; ++i) {
eredmenyek.push_back({i + 1, loertek(loadatok[i])});
}
sort(eredmenyek.begin(), eredmenyek.end(), [](const pair<int, int>& a, const pair<int, int>& b) {
return a.second > b.second;
});
ofstream outFile("sorrend.txt");
if (!outFile) {
cerr << "Hiba: Nem sikerult megnyitni a sorrend.txt fajlt!\n";
return 1;
}
int hely = 0, aktPont = eredmenyek[0].second + 1;
for (size_t i = 0; i < eredmenyek.size(); ++i) {
if (eredmenyek[i].second < aktPont) {
hely = i + 1;
aktPont = eredmenyek[i].second;
}
outFile << hely << "\t" << eredmenyek[i].first << "\t" << eredmenyek[i].second << "\n";
}
outFile.close();
cout << "A kiiratas es a szovegfajl lezarasa sikeresen befejezodott.\n";
cout << "\nA befejezeshez nyomd meg az ENTER billentyut!";
cin.ignore();
cin.get();
return 0;
}
2014. május - IPv6
[szerkesztés]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:
\;img
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ím_ek, eszközöknek nincsenek kiosztva.
- A 2001:0e kezdetű címek az informatikai eszközöknek kiosztott _globális egyedi cím_ek.
- Az fc, valamint az fd kezdetű címek az eszközöknek kiosztott _helyi egyedi cím_ek.
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!
- Olvassa be az ip.txt állományban talált adatokat, s annak felhasználásával oldja meg a következő feladatokat!
- Határozza meg és írja a képernyőre, hogy hány adatsor van az állományban!
- Í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.
- 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!
- 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 i_p.txt_ állományban szereplő alakjával!
- Kérjen be a felhasználótól egy sorszámot! Az állományban a megadott sorszámon található IP-cí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á!
- 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:
\;img
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <algorithm>
#include <unordered_map>
using namespace std;
vector<string> ip;
void kiir(int sorszam) {
cout << sorszam << ". feladat" << endl;
}
void F1() {
ifstream be("ip.txt");
string line;
while (getline(be, line)) {
ip.push_back(line);
}
be.close();
}
void F2() {
cout << "Az allomanyban " << ip.size() << " darab adatsor van" << endl;
}
void F3() {
vector<string> sorted_ip = ip;
sort(sorted_ip.begin(), sorted_ip.end());
cout << "A legalacsonyabb tarolt IP-cim:" << endl << sorted_ip.front() << endl;
}
void F4() {
unordered_map<string, int> count = { {"Dokumentacios", 0}, {"Globalis egyedi", 0}, {"Helyi egyedi", 0} };
for (const auto& address : ip) {
if (address.rfind("2001:0db8", 0) == 0) count["Dokumentacios"]++;
else if (address.rfind("2001:0e", 0) == 0) count["Globalis egyedi"]++;
else if (address.rfind("fc", 0) == 0 || address.rfind("fd", 0) == 0) count["Helyi egyedi"]++;
}
cout << "Dokumentacios cim: " << count["Dokumentacios"] << " darab" << endl;
cout << "Globalis egyedi cim: " << count["Globalis egyedi"] << " darab" << endl;
cout << "Helyi egyedi cim: " << count["Helyi egyedi"] << " darab" << endl;
}
void F5() {
ofstream ki("sok.txt");
for (size_t i = 0; i < ip.size(); i++) {
int zero_count = count(ip[i].begin(), ip[i].end(), '0');
if (zero_count >= 18) {
ki << (i + 1) << " " << ip[i] << endl;
}
}
ki.close();
}
string rovidit_csoporton_belul(string address) {
string result;
size_t pos = 0;
while ((pos = address.find(":0000")) != string::npos) {
address.replace(pos, 5, ":0");
}
return address;
}
void F6() {
int ssz;
cout << "Kerek egy sorszamot: ";
cin >> ssz;
if (ssz < 1 || ssz > ip.size()) {
cout << "Ervenytelen sorszam!" << endl;
return;
}
string original = ip[ssz - 1];
string short_form = rovidit_csoporton_belul(original);
cout << original << endl << short_form << endl;
}
string rovidit_nullak_csoportjait(string address) {
vector<string> parts;
size_t start = 0, end;
while ((end = address.find(':', start)) != string::npos) {
parts.push_back(address.substr(start, end - start));
start = end + 1;
}
parts.push_back(address.substr(start));
int max_zeros = 0, zero_start = -1, cur_zeros = 0, cur_start = -1;
for (size_t i = 0; i < parts.size(); i++) {
if (parts[i] == "0") {
if (cur_start == -1) cur_start = i;
cur_zeros++;
} else {
if (cur_zeros > max_zeros) {
max_zeros = cur_zeros;
zero_start = cur_start;
}
cur_zeros = 0;
cur_start = -1;
}
}
if (cur_zeros > max_zeros) {
max_zeros = cur_zeros;
zero_start = cur_start;
}
if (max_zeros > 1) {
string result;
for (size_t i = 0; i < parts.size(); i++) {
if (i == zero_start) {
result += "::";
i += max_zeros - 1;
} else {
if (!result.empty()) result += ":";
result += parts[i];
}
}
return result;
}
return "Nem roviditheto tovabb.";
}
void F7() {
string result = rovidit_nullak_csoportjait(ip.back());
cout << result << 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;
}
2014. október - Nézőtér
[szerkesztés]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:
\;img
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:
\;img
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.
- Olvassa be és tárolja el a foglaltsag.txt és a kategoria.txt fájl adatait!
- 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!
- 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.
- 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.
- Mennyi lenne a színház bevétele a pillanatnyilag eladott jegyek alapján? Írassa ki az eredményt a képernyőre!
- 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!
- 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!
A jegyek árát kategóriánként a következő táblázat tartalmazza:
| árkategória | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| ár (Ft) | 5000 | 4000 | 3000 | 2000 | 1500 |
Például:
\;img
#include <iostream>
#include <fstream>
#include <vector>
#include <cmath>
#define N 15 // Rows
#define M 20 // Columns
using namespace std;
vector<string> seating(N); // Stores seating arrangement
vector<string> category(N); // Stores category info
int category_sales[5] = {0}; // Stores ticket count per category
const int ticket_prices[5] = {5000, 4000, 3000, 2000, 1500};
void readFiles() {
ifstream seatFile("foglaltsag.txt");
ifstream categoryFile("kategoria.txt");
for (int i = 0; i < N; i++) {
seatFile >> seating[i];
categoryFile >> category[i];
}
seatFile.close();
categoryFile.close();
}
void checkSeatAvailability() {
int row, col;
cout << "Enter row number: ";
cin >> row;
cout << "Enter seat number: ";
cin >> col;
cout << ((seating[row - 1][col - 1] == 'x') ? "Occupied" : "Available") << endl;
}
void soldTicketsStats() {
int sold = 0;
for (const auto &row : seating)
sold += count(row.begin(), row.end(), 'x');
cout << "Sold tickets: " << sold << ", which is " << round(100.0 * sold / (N * M)) << "% of capacity." << endl;
}
void mostSoldCategory() {
fill(begin(category_sales), end(category_sales), 0);
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
if (seating[i][j] == 'x') {
int catIndex = category[i][j] - '1';
category_sales[catIndex]++;
}
}
}
int maxCategory = max_element(begin(category_sales), end(category_sales)) - begin(category_sales) + 1;
cout << "Most tickets sold in category: " << maxCategory << endl;
}
void calculateRevenue() {
int revenue = 0;
for (int i = 0; i < 5; i++) {
revenue += category_sales[i] * ticket_prices[i];
}
cout << "Total revenue: " << revenue << " Ft" << endl;
}
void countSingleSeats() {
int singleSeats = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
if (seating[i][j] == 'o') {
bool left = (j == 0 || seating[i][j - 1] == 'x');
bool right = (j == M - 1 || seating[i][j + 1] == 'x');
if (left && right) singleSeats++;
}
}
}
cout << "Number of single available seats: " << singleSeats << endl;
}
void generateFreeSeatsFile() {
ofstream outFile("szabad.txt");
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
outFile << ((seating[i][j] == 'o') ? category[i][j] : 'x');
}
outFile << endl;
}
outFile.close();
}
int main() {
setlocale(LC_ALL, "hun");
readFiles();
checkSeatAvailability();
soldTicketsStats();
mostSoldCategory();
calculateRevenue();
countSingleSeats();
generateFreeSeatsFile();
return 0;
}
2015. május - Latin táncok
[szerkesztés]
A Latin Tánciskola tanulói latin táncokat tanulnak, ezek a következők: cha-cha, salsa, rumba, samba, jive, tango, bachata.
A tanulók a tanév végén bemutatót tartottak. A bemutatón minden táncot csupán egyszer mutattak be, azonban az egyes táncok bemutatóján több pár is szerepelt. Az év végi bemutató táncrendjét a tancrend.txt fájl tartalmazza. A fájlban a táncok a bemutató tényleges sorrendjében szerepelnek. Tánconként minden párhoz három sor tartozik, ezek rendre a bemutatott táncot, majd a pár lány, végül a pár fiú tagjának utónevét tartalmazzák:
\;img
A fenti példa szerint a cha-chát két pár, Katalin és Bertalan, valamint Adrienn és Lajos mutatták be, a cha-cha után pedig a salsa következett. Egy személy a különböző táncokat eltérő partnerekkel is bemutathatja, de feltételezheti, hogy a táncosok között nincs két azonos nevű.
A fájl legfeljebb 140 tánc és táncospár nevét tartalmazza, továbbá tudjuk, hogy legfeljebb 20 fiú, és legfeljebb 20 lány vett részt a bemutatón. Készítsen programot, amely a tancrend.txt állomány adatait felhasználva az alábbi kérdésekre válaszol! A program forráskódját mentse tanciskola 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 tancrend.txt állományban talált adatokat, s annak felhasználásával oldja meg a következő feladatokat!
2. Írassa ki a képernyőre, hogy melyik volt az elsőként és melyik az utolsóként bemutatott tánc neve!
3. Hány pár mutatta be a sambát? A választ jelenítse meg a képernyőn!
4. Írassa ki a képernyőre, hogy Vilma mely táncokban szerepelt!
5. Kérje be egy tánc nevét, majd írassa ki a képernyőre, hogy az adott táncot Vilma kivel mutatta be! Például ha a bekért tánc a samba, és Vilma párja Bertalan volt, akkor „A samba bemutatóján Vilma párja Bertalan volt.” szöveg jelenjen meg! Ha Vilma az adott tánc bemutatóján nem szerepelt, akkor azt írja ki a képernyőre, hogy „Vilma nem táncolt samba-t.”.
6. Készítsen listát a bemutatón részt vett fiúkról és lányokról! A listát a szereplok.txt nevű szöveges állományba mentse el a következő formátumban: a neveket vesszők válasszák el egymástól, de az utolsó név után már ne szerepeljen írásjel. Például:
Lányok: Lujza, Katalin, Andrea, Emma
Fiúk: Ferenc, Ambrus, Andor, Kelemen, Bertalan
7. Írja ki a képernyőre, hogy melyik fiú szerepelt a legtöbbször a fiúk közül, és melyik lány a lányok közül! Ha több fiú, vagy több lány is megfelel a feltételeknek, akkor valamennyi fiú, illetve valamennyi lány nevét írja ki!
#include <iostream>
#include <fstream>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
using namespace std;
int main() {
cout << "\n1. feladat\n" << endl;
vector<string> tancok, lanyok, fiuk;
ifstream file("tancrend.txt");
string tanc, lany, fiu;
while (getline(file, tanc) && getline(file, lany) && getline(file, fiu)) {
tancok.push_back(tanc);
lanyok.push_back(lany);
fiuk.push_back(fiu);
}
file.close();
cout << "A beolvasás és a szövegfájl lezárása sikeresen befejeződött." << endl;
// 2. feladat
cout << "\n2. feladat\n" << endl;
cout << "Az elsőként bemutatott tánc neve: " << tancok.front() << endl;
cout << "Az utolsóként bemutatott tánc neve: " << tancok.back() << endl;
// 3. feladat
cout << "\n3. feladat\n" << endl;
int samba_count = count(tancok.begin(), tancok.end(), "samba");
cout << "A sambát " << samba_count << " pár mutatta be." << endl;
// 4. feladat
cout << "\n4. feladat\n" << endl;
set<string> vilma_tancok;
for (size_t i = 0; i < tancok.size(); i++) {
if (lanyok[i] == "Vilma") {
vilma_tancok.insert(tancok[i]);
}
}
cout << "Vilma a következő táncokban szerepelt: ";
for (const auto& t : vilma_tancok) cout << t << ", ";
cout << endl;
// 5. feladat
cout << "\n5. feladat\n" << endl;
string akttanc;
cout << "Kérek egy táncot a cha-cha, salsa, rumba, samba, jive, tango, bachata közül: ";
cin >> akttanc;
bool found = false;
for (size_t i = 0; i < tancok.size(); i++) {
if (tancok[i] == akttanc && lanyok[i] == "Vilma") {
cout << "A " << akttanc << " bemutatóján Vilma párja " << fiuk[i] << " volt." << endl;
found = true;
break;
}
}
if (!found) cout << "Vilma nem táncolt " << akttanc << "-t." << endl;
// 6. feladat
cout << "\n6. feladat\n" << endl;
set<string> unique_lanyok(lanyok.begin(), lanyok.end());
set<string> unique_fiuk(fiuk.begin(), fiuk.end());
ofstream outfile("szereplok.txt");
outfile << "Lányok: ";
for (auto it = unique_lanyok.begin(); it != unique_lanyok.end(); ++it) {
if (it != unique_lanyok.begin()) outfile << ", ";
outfile << *it;
}
outfile << "\nFiúk: ";
for (auto it = unique_fiuk.begin(); it != unique_fiuk.end(); ++it) {
if (it != unique_fiuk.begin()) outfile << ", ";
outfile << *it;
}
outfile << endl;
outfile.close();
cout << "A kiíratás és a szövegfájl lezárása sikeresen befejeződött." << endl;
// 7. feladat
cout << "\n7. feladat\n" << endl;
map<string, int> lany_count, fiu_count;
for (const auto& lany : lanyok) lany_count[lany]++;
for (const auto& fiu : fiuk) fiu_count[fiu]++;
int max_lany = max_element(lany_count.begin(), lany_count.end(),
[](const pair<string, int>& a, const pair<string, int>& b) { return a.second < b.second; })->second;
int max_fiu = max_element(fiu_count.begin(), fiu_count.end(),
[](const pair<string, int>& a, const pair<string, int>& b) { return a.second < b.second; })->second;
cout << "Lányok: ";
for (const auto& p : lany_count) {
if (p.second == max_lany) cout << p.first << " (" << p.second << " tánccal), ";
}
cout << endl;
cout << "Fiúk: ";
for (const auto& p : fiu_count) {
if (p.second == max_fiu) cout << p.first << " (" << p.second << " tánccal), ";
}
cout << endl;
cout << "\nA befejezéshez nyomd meg az ENTER billentyűt!";
cin.ignore();
cin.get();
return 0;
}
2015. május - Expedíció
[szerkesztés]
Expedíció
Valamikor a távközlés hőskorában egy ritka farkasfaj tudományos megfigyelésére expedíciót szerveztek a sarkkörön túlra. A magukkal vitt rádió csak napi egy adásra volt alkalmas, arra is csak 90 időegységig, időegységenként egy karaktert továbbítva. Az expedíció rádiósának üzeneteit több rádióamatőr is igyekezett lejegyezni. A feladatban a rádióamatőrök által lejegyzett üzeneteket kell feldolgoznia.
A veetel.txt fájl tartalmazza a rádióamatőrök által feljegyzett üzeneteket. Minden sorpár egy-egy feljegyzést tartalmaz.
- A sorpár első sorában két szám áll, az első a nap sorszáma, a második pedig – az előzőtől egy szóközzel elválasztva – a rádióamatőré.
- A sorpár második sorában a feljegyzéshez tartozó pontosan 90 karakter áll. A vett karakter az angol ábécé kisbetűje, számjegy, / jel vagy szóköz lehet. Ha az adott időegységben nem volt egyértelműen azonosítható a vett jel, akkor # karakter szerepel. Ha a tényleges üzenet befejeződött, az adó a fennmaradó időegységekben $ jelet küld.
- A napok sorszáma 1 és 11, a rádióamatőrök sorszáma 1 és 20 közötti egész szám lehet.
- Ha a megfigyelés során láttak farkasokat, akkor az üzenet két, / jellel elválasztott egész számmal, a látott kifejlett és kölyök egyedek számával kezdődik, amelyet szóköz követ. Más esetben nem szám az első karakter.
Például:
\;img
A fenti sorpár első sora mutatja, hogy az üzenet a 2. napon érkezett és a 15-ös rádióamatőr rögzítette. 1 felnőtt és 0 kölyök farkast figyeltek meg. Mivel a második sorban a 45. karakter $ jel, és előtte nem # jel szerepel, ezért az üzenet biztosan 44 karakter hosszú.
Készítsen programot, amely a veetel.txt állomány adatait felhasználva az alábbi kérdésekre válaszol! A program forráskódját mentse radio 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 és tárolja a veetel.txt fájl tartalmát!
2. Írja a képernyőre, hogy melyik rádióamatőr rögzítette az állományban szereplő első és melyik az utolsó üzenetet!
3. Adja meg az összes olyan feljegyzés napját és a rádióamatőr sorszámát, amelynek szövegében a „farkas” karaktersorozat szerepel!
4. Készítsen statisztikát, amely megadja, hogy melyik napon hány rádióamatőr készített feljegyzést. Azok a napok 0 értékkel szerepeljenek, amikor nem született feljegyzés! Az eredmény a képernyőn jelenjen meg a napok sorszáma szerint növekvően! A megjelenítést a feladat végén látható minta szerint alakítsa ki!
5. A rögzített üzenetek alapján kísérelje meg helyreállítani az expedíció által küldött üzenetet! Készítse el az adaas.txt fájlt, amely napok szerinti sorrendben tartalmazza a küldött üzeneteket! Ha egy időpontban senkinél nem volt vétel, akkor azon a ponton a # jel szerepeljen! (Feltételezheti, hogy az azonos üzenethez tartozó feljegyzések között nincs ellentmondás.)
Az alábbi minta az első napról tartalmaz három üzenetet:
\;img
A helyreállított üzenet:
\;img
6. Készítsen függvényt szame néven az alábbi algoritmus alapján! A függvény egy karaktersorozathoz hozzárendeli az igaz vagy a hamis értéket. A függvény elkészítésekor az algoritmusban megadott változóneveket használja! Az elkészített függvényt a következő feladat megoldásánál felhasználhatja.
\;img
7. Olvassa be egy nap és egy rádióamatőr sorszámát, majd írja a képernyőre a megfigyelt egyedek számát (a kifejlett és kölyök egyedek számának összegét)! Ha nem volt ilyen feljegyzés, a „Nincs ilyen feljegyzés” szöveget jelenítse meg! Ha nem volt megfigyelt egyed vagy számuk nem állapítható meg, a „Nincs információ” szöveget jelenítse meg! Amennyiben egy számot közvetlenül # jel követ, akkor a számot tekintse nem megállapíthatónak!
Minta a szöveges kimenetek kialakításához:
\;img
#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <array>
using namespace std;
struct Uzenet {
int nap, segito;
string szoveg;
};
void kiirFeladat(int feladat) {
cout << "\n" << feladat << ". feladat:" << endl;
}
bool szame(const string& szo) {
for (char c : szo) {
if (!isdigit(c)) return false;
}
return !szo.empty();
}
int main() {
// 1. feladat: Fájl beolvasása
kiirFeladat(1);
ifstream be("veetel.txt");
if (!be) {
cerr << "Hiba: Nem sikerült megnyitni a veetel.txt fájlt." << endl;
return 1;
}
vector<Uzenet> uzenetek;
Uzenet u;
while (be >> u.nap >> u.segito) {
be.ignore(); // Sortörés kihagyása
getline(be, u.szoveg);
uzenetek.push_back(u);
}
be.close();
// 2. feladat: Első és utolsó üzenet rögzítője
kiirFeladat(2);
cout << "Az elso uzenet rogzitoje: " << uzenetek.front().segito << endl;
cout << "Az utolso uzenet rogzitoje: " << uzenetek.back().segito << endl;
// 3. feladat: "farkas" szót tartalmazó feljegyzések
kiirFeladat(3);
for (const auto& u : uzenetek) {
if (u.szoveg.find("farkas") != string::npos) {
cout << u.nap << ". nap " << u.segito << ". radioamator" << endl;
}
}
// 4. feladat: Statisztika készítése
kiirFeladat(4);
array<int, 12> napok = {0};
for (const auto& u : uzenetek) {
napok[u.nap]++;
}
for (int n = 1; n <= 11; ++n) {
cout << n << ". nap: " << napok[n] << " radioamator" << endl;
}
// 5. feladat: Helyreállított üzenet elkészítése
kiirFeladat(5);
ofstream ki("adaas.txt");
array<string, 12> helyreallitottUzenet;
helyreallitottUzenet.fill(string(90, '#'));
for (const auto& u : uzenetek) {
for (size_t j = 0; j < u.szoveg.size(); ++j) {
if (u.szoveg[j] != '#') {
helyreallitottUzenet[u.nap][j] = u.szoveg[j];
}
}
}
for (int n = 1; n <= 11; ++n) {
ki << helyreallitottUzenet[n] << endl;
}
ki.close();
// 7. feladat: Megfigyelt egyedek számának lekérdezése
kiirFeladat(7);
int melynap, melyfigyelo;
cout << "Adja meg a nap sorszamat! ";
cin >> melynap;
cout << "Adja meg a radioamator sorszamat! ";
cin >> melyfigyelo;
string talalat;
for (const auto& u : uzenetek) {
if (u.nap == melynap && u.segito == melyfigyelo) {
talalat = u.szoveg;
break;
}
}
if (!talalat.empty()) {
stringstream ss(talalat);
string szo1, szo2;
getline(ss, szo1, '/');
getline(ss, szo2, ' ');
if (szame(szo1) && szame(szo2)) {
cout << "A megfigyelt egyedek szama: " << stoi(szo1) + stoi(szo2) << endl;
} else {
cout << "Nincs informacio." << endl;
}
} else {
cout << "Nincs ilyen feljegyzes." << endl;
}
return 0;
}
2015. október - Fej vagy írás
[szerkesztés]Ha egy szabályos pénzérmét feldobunk, ugyanannyi a valószínűsége annak, hogy leesés után az érme értéke lesz felül (írás, I), mint annak, hogy a címert tartalmazó másik oldala (fej, F). Ezért gyakran „pénzfeldobással” sorsolnak, például így döntik el, hogy melyik csapat kezdhet el egy futballmeccset.
Feladata a pénzfeldobás szimulálása, illetve pénzfeldobással kapott sorozatok elemzése lesz. A feladatok során az írást az I, a fejet az F nagybetű jelzi. Például egy 5 feldobásból álló sorozat esetén:
\;img
Készítsen programot fejvagyiras 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! Az ékezetmentes kiírás is elfogadott.
1. Szimuláljon egy pénzfeldobást, ahol azonos esélye van a fejnek és az írásnak is! Az eredményt írassa ki a képernyőre a mintának megfelelően!
2. Kérjen be a felhasználótól egy tippet, majd szimuláljon egy pénzfeldobást! Írassa ki a képernyőre a felhasználó tippjét és a dobás eredményét is, majd tájékoztassa a felhasználót az eredményről következő formában: „Ön eltalálta.” vagy „Ön nem találta el.”!
A kiserlet.txt állományban egy pénzfeldobás-sorozat eredményét találja. Mivel a sorozat hossza tetszőleges lehet, ezért az összes adat memóriában történő egyidejű eltárolása nélkül oldja meg a következő feladatokat! Feltételezheti, hogy egymilliónál több adata nem lesz.
3. Állapítsa meg, hány dobásból állt a kísérlet, és a választ a mintának megfelelően írassa ki a képernyőre!
4. Milyen relatív gyakorisággal dobtunk a kísérlet során fejet? (A fej relatív gyakorisága a fejet eredményező dobások és az összes dobás hányadosa.) A relatív gyakoriságot a mintának megfelelően két tizedesjegy pontossággal, százalék formátumban írassa ki a képernyőre!
5. Hányszor fordult elő ebben a kísérletben, hogy egymás után pontosan két fejet dobtunk? A választ a mintának megfelelően írassa ki a képernyőre! (Feltételezheti, hogy a kísérlet legalább 3 dobásból állt.)
Például az IFFFFIIFFIFFFIFF sorozatban kétszer fordult elő, hogy egymás után pontosan két fejet dobtunk.
6. Milyen hosszú volt a leghosszabb, csak fejekből álló részsorozat? Írassa ki a választ a képernyőre a mintának megfelelően, és adja meg egy ilyen részsorozat első tagjának helyét is! (A minta tagjainak számozását eggyel kezdjük.)
Sokan azt hiszik, hogy ha már elég sok fejet dobtunk, akkor a következő dobás nagyobb valószínűséggel lesz írás, mint fej. Ennek ellenőrzésére vonatkozik a következő feladat.
7. Állítson elő és tároljon a memóriában 1000 db négy dobásból álló sorozatot! Számolja meg, hogy hány esetben követett egy háromtagú „tisztafej” sorozatot fej, illetve hány esetben írás! Az eredményt írassa ki a dobasok.txt állományba úgy, hogy az első sorba kerüljön az eredmény, a második sorban pedig egy-egy szóközzel elválasztva, egyetlen sorban szerepeljenek a dobássorozatok!
Például:
\;img
Minta (a forrásállomány alapján készült, valós adatokat tartalmaz):
\;img
#include <iostream>
#include <fstream>
#include <vector>
#include <random>
#include <string>
using namespace std;
random_device rd;
mt19937 gen(rd());
uniform_int_distribution<int> coinFlip(0, 1);
char Dobas() {
return coinFlip(gen) == 0 ? 'F' : 'I';
}
void Feladat1() {
cout << "1. feladat" << endl;
cout << "A pénzfeldobás eredménye: " << Dobas() << endl;
}
void Feladat2() {
cout << "2. feladat" << endl;
cout << "Tippeljen! (F/I): ";
char tipp;
cin >> tipp;
tipp = toupper(tipp);
char dobott = Dobas();
cout << "A tipp: " << tipp << ", a dobás eredménye: " << dobott << endl;
cout << (tipp == dobott ? "Ön eltalálta." : "Ön nem találta el.") << endl;
}
void Feladat3_4_5_6() {
ifstream file("kiserlet.txt");
if (!file) {
cerr << "Hiba: 'kiserlet.txt' nem található!" << endl;
return;
}
int totalThrows = 0, headCount = 0, doubleHeadCount = 0;
int maxConsecutiveHeads = 0, maxStartIndex = 0, currentStart = 1, consecutiveHeads = 0;
string prev = "", prevPrev = "";
string line;
while (getline(file, line)) {
totalThrows++;
if (line == "F") {
headCount++;
consecutiveHeads++;
if (consecutiveHeads > maxConsecutiveHeads) {
maxConsecutiveHeads = consecutiveHeads;
maxStartIndex = currentStart;
}
if (prev == "F" && prevPrev == "I") {
doubleHeadCount++;
}
} else {
consecutiveHeads = 0;
currentStart = totalThrows + 1;
}
prevPrev = prev;
prev = line;
}
file.close();
cout << "A kísérlet " << totalThrows << " dobásból állt." << endl;
cout << "A kísérlet során a fej relatív gyakorisága: " << fixed << setprecision(2) << (100.0 * headCount / totalThrows) << "%" << endl;
cout << "A kísérlet során " << doubleHeadCount << " alkalommal dobtak pontosan két fejet egymás után." << endl;
cout << "A leghosszabb tisztafej sorozat " << maxConsecutiveHeads << " tagból áll, kezdete a(z) " << maxStartIndex << ". dobás." << endl;
}
void Feladat7() {
cout << "7. feladat" << endl;
const int sampleSize = 1000;
vector<string> sequences;
int ffffCount = 0, fffiCount = 0;
for (int i = 0; i < sampleSize; i++) {
string seq = string(1, Dobas()) + Dobas() + Dobas() + Dobas();
sequences.push_back(seq);
if (seq == "FFFF") ffffCount++;
else if (seq == "FFFI") fffiCount++;
}
ofstream outFile("dobasok.txt");
outFile << "FFFF: " << ffffCount << ", FFFI: " << fffiCount << endl;
for (const auto &seq : sequences) {
outFile << seq << " ";
}
outFile.close();
cout << "Eredmények elmentve a 'dobasok.txt' fájlba." << endl;
}
int main() {
try {
Feladat1();
Feladat2();
Feladat3_4_5_6();
Feladat7();
} catch (exception &e) {
cerr << "Hiba történt: " << e.what() << endl;
}
return 0;
}
2016. május - Zár
[szerkesztés]Egy ajtót elektronikus zárral láttak el. A zárat egy ismétlődő pontokat nem tartalmazó, megfelelő irányban rajzolt, törött vonalból álló mintával lehet nyitni. A minta megadását egy szabályos tízszög segíti, amelynek csúcsait 0-tól 9-ig sorszámozták, így a leghosszabb használható minta 10 számjegyet tartalmazhat. Az ajtót nyitó kódszám megadásánál csupán
az alakzat és annak iránya érdekes, ezért a 135 mintával nyitható zárat a 802 is nyitja (vagy akár a 024 kódszám is), de
a 208 nem. Tehát ebben a mintában a zár csak az óramutató járásával megegyező irányban nyílik. A nyitás az egyes számok egymást követő megérintésével történik.
\;img
Az ajto.txt fájl soronként egy-egy nyitási próbálkozás adatait tartalmazza. A fájlban legfeljebb 500 sor, soronként legalább 3, legfeljebb 10 karakter lehet.
Készítsen programot, amely az ajto.txt állomány adatait felhasználva az alábbi kérdésekre válaszol! A program forráskódját mentse zar 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.
- Olvassa be és tárolja el az ajto.txt fájl tartalmát!
- Kérjen be a felhasználótól egy számjegysorozatot, amely a zár kódszáma lesz! (Feltételezheti, hogy a felhasználó ismétlődés nélküli jelsorozatot ad meg.) A teszteléshez használhatja a 239451 sorozatot is.
- Jelenítse meg a képernyőn, hogy mely kísérleteknél használták a nyitáshoz pontosan az előző feladatban beolvasott kódszámot! A sorok számát egymástól pontosan egy szóközzel válassza el! (A sorok számozását 1-től kezdje!)
- Adja meg, hogy melyik az első olyan próbálkozás, amely ismétlődő karaktert tartalmaz! Ha nem volt ilyen, írja ki a „nem volt ismétlődő számjegy” üzenetet! (A sorok számozását 1-től kezdje!)
- Állítson elő egy, a második feladatban beolvasottal egyező hosszúságú, véletlenszerű, ismétlődés nélküli jelsorozatot, majd a mintának megfelelően jelenítse meg a hosszát és az előállított kódszámot!
- Készítsen függvényt nyit néven az alábbi algoritmus alapján, amely a neki átadott két kódszámról megállapítja, hogy ugyanazt a zárat nyitják-e! (A 239451 és a 017239 ugyanazt a zárat nyitja.) A függvény két, legfeljebb 10 számjegyből álló karaktersorozathoz egy logikai értéket rendel. A függvény elkészítésekor az algoritmusban megadott változóneveket használja! Az elkészített függvényt a következő feladat megoldásánál felhasználhatja.
\;img
A mondatszerű leírásban:
‑ az a mod b művelet eredménye az a szám b számmal történő osztásának maradéka;
‑ az ascii() függvény egy karakterhez annak karakterkódját rendeli.
Az ascii() függvény megvalósításához használhatja a következőket az egyes programozási nyelveken:
\;img
- Állítsa elő a siker.txt fáljt, amelynek soraiban a nyitási próbálkozás kódszáma után – attól egy szóközzel elválasztva – annak értékelése olvasható.
‑ „hibás hossz”, ha a felhasználótól a 2. feladatban bekért kódszám és a sorbeli kódszám hossza eltér;
‑ „hibás kódszám”, ha a felhasználótól a 2. feladatban bekért kódszám és a sorbeli kódszám hossza egyezik, de nem összetartozók;
‑ „sikeres”, ha a két kódszám egyenértékű.
Minta a szöveges kimenetek kialakításához:
\;img
Részlet a siker.txt fájlból:
\;img
// 2016. május idegennyelvű - Zár feladat megoldása
#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <algorithm>
#include <set>
#include <cstdlib>
#include <ctime>
using namespace std;
bool ismetlodo(const string &kod) {
set<char> egyedi(kod.begin(), kod.end());
return egyedi.size() != kod.size();
}
bool nyit(const string &jo, const string &proba) {
if (jo.size() != proba.size()) return false;
int elteres = jo[0] - proba[0];
for (size_t i = 1; i < jo.size(); i++) {
if ((elteres - (jo[i] - proba[i])) % 10 != 0)
return false;
}
return true;
}
int main() {
srand(time(nullptr));
// 1. Feladat
cout << "1. feladat\n";
ifstream file("ajto.txt");
vector<string> kodok;
string sor;
while (file >> sor) {
kodok.push_back(sor);
}
file.close();
cout << "Adatok beolvasva.\n";
// 2. Feladat
cout << "\n2. feladat\n";
string nyito;
cout << "Adja meg, mi nyitja a zárat! ";
cin >> nyito;
// 3. Feladat
cout << "\n3. feladat\n";
cout << "A nyitó kódszámok sorai:";
for (size_t i = 0; i < kodok.size(); i++) {
if (kodok[i] == nyito) {
cout << " " << i + 1;
}
}
cout << "\n";
// 4. Feladat
cout << "\n4. feladat\n";
bool volt_ismet = false;
for (size_t i = 0; i < kodok.size(); i++) {
if (ismetlodo(kodok[i])) {
cout << "Az első ismétlődést tartalmazó próbálkozás sorszáma: " << i + 1 << "\n";
volt_ismet = true;
break;
}
}
if (!volt_ismet)
cout << "Nem volt ismétlődő számjegy.\n";
// 5. Feladat
cout << "\n5. feladat\n";
string veletlen_kod;
vector<char> szamok = {'0','1','2','3','4','5','6','7','8','9'};
random_shuffle(szamok.begin(), szamok.end());
veletlen_kod = string(szamok.begin(), szamok.begin() + nyito.size());
cout << "Egy " << nyito.size() << " hosszú kódszám: " << veletlen_kod << "\n";
// 6-7. Feladat
ofstream out("siker.txt");
for (const auto &kod : kodok) {
out << kod << " ";
if (kod.size() != nyito.size()) {
out << "hibas hossz\n";
} else if (nyit(nyito, kod)) {
out << "sikeres\n";
} else {
out << "hibas kodszam\n";
}
}
out.close();
cout << "\n7. feladat\nAz ertekelesek siker.txt-be kiirva.";
return 0;
}
2016. május - Ötszáz
[szerkesztés]Egy apróságokat árusító boltban minden árucikk darabja 500 Ft. Ha egy vásárlás során valaki egy adott árucikkből több darabot is vesz, a második ára már csak 450 Ft, a harmadik pedig 400 Ft, de a negyedik és további darabok is ennyibe kerülnek, tehát az ár a harmadik ugyanazon cikk vásárlása után már nem csökken tovább.
A pénztárhoz menők kosarában legalább 1 és legfeljebb 20 darab árucikk lehet. A kosarak tartalmát a penztar.txt fájl írja le, amelyben soronként egy-egy árucikk neve vagy az F karakter szerepel. A fájlban legfeljebb 1000 sor lehet. Az F karakter azt jelzi, hogy az adott vásárlónak nincs már újabb árucikk a kosarában, fizetés következik. Az árucikkek neve ékezet nélküli, több szóból is állhat, hossza legfeljebb 30 karakter.
Példa a penztar.txt fájl első néhány sorára:
\;img
A példa alapján az első vásárló összesen 1 tollat vásárolt, ezért összesen 500 Ft-ot kell fizetnie. A második vásárlás során hatféle árucikket vásároltak – a HB ceruzából és a colostokból többet is –, összesen 3900 Ft értékben.
Készítsen programot, amely a penztar.txt állomány adatait felhasználva az alábbi kérdésekre válaszol! A program forráskódját mentse otszaz néven! (A program megírásakor a felhasználó által megadott adatok helyességét, érvényességét nem kell ellenőriznie, és 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.
- Olvassa be és tárolja el a penztar.txt fájl tartalmát!
- Határozza meg, hogy hányszor fizettek a pénztárnál!
- Írja a képernyőre, hogy az első vásárlónak hány darab árucikk volt a kosarában!
- Kérje be a felhasználótól egy vásárlás sorszámát, egy árucikk nevét és egy darabszámot! A következő három feladat megoldásánál ezeket használja fel!
Feltételezheti, hogy a program futtatásakor csak a bemeneti állományban rögzített adatoknak megfelelő vásárlási sorszámot és árucikknevet ad meg a felhasználó.
- Határozza meg, hogy a bekért árucikkből
melyik vásárláskor vettek először, és melyiknél utoljára!
összesen hány alkalommal vásároltak!
Határozza meg, hogy a bekért darabszámot vásárolva egy termékből mennyi a fizetendő összeg! A feladat megoldásához készítsen függvényt ertek néven, amely a darabszámhoz a fizetendő összeget rendeli!
Határozza meg, hogy a bekért sorszámú vásárláskor mely árucikkekből és milyen mennyiségben vásároltak! Az árucikkek nevét tetszőleges sorrendben megjelenítheti.
Készítse el az osszeg.txt fájlt, amelybe soronként az egy-egy vásárlás alkalmával fizetendő összeg kerüljön a kimeneti mintának megfelelően!
Minta a szöveges kimenetek kialakításához:
\;img
Részlet az osszeg.txt fájlból:
\;img
#include <iostream>
#include <fstream>
#include <vector>
#include <map>
#include <algorithm>
using namespace std;
struct Tcikk {
int vasarlo;
string nev;
};
int ertek(int db) {
if (db == 1) return 500;
if (db == 2) return 450 + 500;
if (db == 3) return 400 + 450 + 500;
return 1350 + (db - 3) * 400;
}
int main() {
vector<Tcikk> cikkek;
ifstream be("penztar.txt");
string sor;
int sorszam = 1;
while (getline(be, sor)) {
Tcikk cikk;
cikk.nev = sor;
cikk.vasarlo = sorszam;
if (sor == "F") {
sorszam++;
} else {
cikkek.push_back(cikk);
}
}
be.close();
cout << "2. feladat" << endl;
cout << "A fizetesek szama: " << sorszam - 1 << endl;
cout << "3. feladat" << endl;
int elsodb = count_if(cikkek.begin(), cikkek.end(), [](const Tcikk &c) { return c.vasarlo == 1; });
cout << "Az elso vasarlo " << elsodb << " darab arucikket vasarolt." << endl;
cout << "4. feladat" << endl;
int keresett_vasarlo, darabszam;
string arucikk;
cout << "Adja meg egy vasarlas sorszamat! ";
cin >> keresett_vasarlo;
cin.ignore();
cout << "Adja meg egy arucikk nevet! ";
getline(cin, arucikk);
cout << "Adja meg a vasarolt darabszamot! ";
cin >> darabszam;
cout << "5. feladat" << endl;
int elso = sorszam, utolso = 0, hanyan = 0;
for (const auto &c : cikkek) {
if (c.nev == arucikk) {
hanyan++;
elso = min(elso, c.vasarlo);
utolso = max(utolso, c.vasarlo);
}
}
cout << "Az elso vasarlas sorszama: " << elso << endl;
cout << "Az utolso vasarlas sorszama: " << utolso << endl;
cout << hanyan << " vasarlas soran vettek belole." << endl;
cout << "6. feladat" << endl;
cout << darabszam << " darab vetelekor fizetendo: " << ertek(darabszam) << " Ft" << endl;
cout << "7. feladat" << endl;
map<string, int> vasarlasok;
for (const auto &c : cikkek) {
if (c.vasarlo == keresett_vasarlo) {
vasarlasok[c.nev]++;
}
}
for (const auto &[nev, db] : vasarlasok) {
cout << db << " " << nev << endl;
}
cout << "8. feladat" << endl;
ofstream ki("osszeg.txt");
int akt_vasarlo = 1, osszeg = 0;
map<string, int> kosar;
for (const auto &c : cikkek) {
if (c.vasarlo != akt_vasarlo) {
ki << akt_vasarlo << ": " << osszeg << " Ft" << endl;
akt_vasarlo = c.vasarlo;
osszeg = 0;
kosar.clear();
}
kosar[c.nev]++;
osszeg += ertek(kosar[c.nev]);
}
ki << akt_vasarlo << ": " << osszeg << " Ft" << endl;
ki.close();
return 0;
}
2016. október - Telefonos ügyfélszolgálat
[szerkesztés]Egy kis cég ügyfélszolgálata 8 és 12 óra között várja az érdeklődőket. Egyszerre egy hívást tudnak fogadni. A hívások végén azonnal bekapcsolják a következő hívást.
A hívások irányítását egy automata végzi. Nyitáskor és később is – amint a munkatárs szabaddá válik – a legrégebben várakozót kapcsolja be. A munkaidőben érkező hívások esetén – ha a hívónak várnia kell – közli vele a várakozók számát. Munkaidőn kívül érkező hívás esetén az automata a legközelebbi időpontot jelzi az ügyfélnek, aki akár vonalban is maradhat addig. A munkatársnak az összes, a munkaidő vége előtt beérkezett hívást fogadnia kell – tehát a 12:00:00-kor érkezőt már nem –, még akkor is, ha a bekapcsolásukra már a munkaidő befejezése után kerül sor.
A hívások adatait (a kapcsolat létrehozásának és a vonal bontásának időpontját) a hivas.txt fájl tárolja a híváskezdés időpontjának sorrendjében. Minden sor két időpontot tartalmaz óra, perc, másodperc formában. A hat számot pontosan egy szóköz választja el egymástól. A sorok száma legfeljebb 1000. Az adatok egy napra vonatkoznak, munkaidőn kívüli értékeket is tartalmazhatnak, minden hívás ezen a napon kezdődött, és be is fejeződött a nap végéig. Feltételezheti, hogy van – legalább két – munkaidőbe eső hívás is. A hívót – a könnyebb kezelhetőség érdekében – a feladatban az időadat sorszámával azonosítjuk.
Például:
\;img
A példában egy fájl első 5 sora látható. Ebben az esetben a 2. sor azt mutatja, hogy a hívás a munkaidő kezdete előtt érkezett, de a hívó kivárta, hogy az ügyfélszolgálatos fogadja a hívást. Beszélgetésük 8:0:0-kor kezdődött és 8:1:39-ig tartott, tehát pontosan 99 másodpercig. A 4. hívó megvárta, míg a 2. hívó befejezi, ő 8:1:39-től 8:4:17-ig beszélt az ügyfélszolgálatossal. Az 5. hívóval az automata azt közölte, hogy vele együtt 2 várakozó hívás van. Ő nem várta meg, hogy rá kerüljön a sor.
Látható, hogy egy hívó akkor tudott az ügyfélszolgálatossal beszélni, ha a hívását 12 óra előtt kezdte, valamint 8 óra után, és az összes korábbi hívás végénél később fejezte be.
Készítsen programot, amely a hivas.txt állomány adatait felhasználva az alábbi kérdésekre válaszol! A program forráskódját mentse telefon 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. Készítse el az mpbe függvényt, amely az óra, perc, másodperc alakban megadott időpont másodpercben kifejezett értékét adja! A függvényt a megoldásba be kell építenie!
\;img
2. Olvassa be a hivas.txt állományban talált adatokat, s annak felhasználásával oldja meg a következő feladatokat!
3. Készítsen statisztikát, amely megadja, hogy óránként hány hívás futott be! A képernyőn soronként egy óra-darabszám párost jelenítsen meg! Csak azok az órák jelenjenek meg, amelyben volt hívás!
4. Írja a képernyőre a leghosszabb hívásnak a sorszámát és másodpercben kifejezett hosszát – attól függetlenül, hogy a hívó tudott-e beszélni az ügyfélszolgálatossal vagy sem! Azonos híváshossz esetén elegendő egyet megjelenítenie.
5. Olvasson be egy munkaidőn belüli időpontot, majd jelenítse meg a képernyőn, hogy hányadik hívóval beszélt akkor az alkalmazott, és éppen hányan vártak arra, hogy sorra kerüljenek! Ha nem volt hívó, akkor a „Nem volt beszélő.” üzenetet jelenítse meg!
6. Írja a képernyőre, annak a hívónak az azonosítóját, akivel a munkatárs utoljára beszélt! Írja ki a várakozás másodpercekben mért hosszát is! (Ha nem kellett várnia, a várakozási idő 0.)
7. Készítse el a sikeres.txt állományt, amely az ügyfélszolgálathoz bekapcsolt hívások listáját tartalmazza! A fájl egyes soraiban a hívó sorszáma, a beszélgetés kezdete (amikor az ügyfélszolgálatos fogadta a hívást) és vége szerepeljen az alábbi mintának megfelelő formában! Például a feladat elején olvasható példa bemenet esetén a fájl tartalma:
\;img
Példa a szöveges kimenetek kialakításához:
\;img
#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <algorithm>
using namespace std;
struct Hivas {
int kezd, befejez;
};
int mpbe(int o, int p, int mp) {
return (o * 60 + p) * 60 + mp;
}
string idopont(int mp) {
int ora = mp / 3600;
int perc = (mp % 3600) / 60;
int masodperc = mp % 60;
return to_string(ora) + " " + to_string(perc) + " " + to_string(masodperc);
}
vector<Hivas> beolvasas(const string& filename) {
ifstream be(filename);
vector<Hivas> hivasok;
int ko, kp, kmp, vo, vp, vmp;
while (be >> ko >> kp >> kmp >> vo >> vp >> vmp) {
hivasok.push_back({mpbe(ko, kp, kmp), mpbe(vo, vp, vmp)});
}
return hivasok;
}
void statisztika(const vector<Hivas>& hivasok) {
cout << "3. feladat" << endl;
int ora[24] = {};
for (const auto& h : hivasok) {
ora[h.kezd / 3600]++;
}
for (int i = 0; i < 24; i++) {
if (ora[i] > 0) {
cout << i << " ora " << ora[i] << " hivas" << endl;
}
}
}
void leghosszabb_hivas(const vector<Hivas>& hivasok) {
cout << "4. feladat" << endl;
auto max_hivas = max_element(hivasok.begin(), hivasok.end(), [](const Hivas& a, const Hivas& b) {
return (a.befejez - a.kezd) < (b.befejez - b.kezd);
});
cout << "A leghosszabb hivas a " << (distance(hivasok.begin(), max_hivas) + 1)
<< ". sorban szerepel, hossza: " << (max_hivas->befejez - max_hivas->kezd) << " masodperc." << endl;
}
void keres_idopont_szerint(const vector<Hivas>& hivasok) {
cout << "5. feladat" << endl;
int o, p, mp;
cout << "Adjon meg egy idopontot! (ora perc masodperc) ";
cin >> o >> p >> mp;
int keresett = mpbe(o, p, mp);
int varakozo = 0, beszelo = -1;
for (int i = hivasok.size() - 1; i >= 0; i--) {
if (hivasok[i].kezd <= keresett && keresett < hivasok[i].befejez) {
varakozo++;
beszelo = i;
}
}
if (beszelo > -1) {
cout << "A varakozok szama: " << varakozo - 1 << ", a beszelo a " << beszelo + 1 << ". hivo." << endl;
} else {
cout << "Nincs beszelo." << endl;
}
}
void utolso_hivo(const vector<Hivas>& hivasok) {
cout << "6. feladat" << endl;
int mbefejez = mpbe(12, 0, 0);
int vegso = 0, vegsoelott = 0;
for (int i = 0; i < hivasok.size(); i++) {
if (hivasok[i].kezd < mbefejez && hivasok[i].befejez > hivasok[vegso].befejez) {
vegsoelott = vegso;
vegso = i;
}
}
cout << "Az utolso hivo a(z) " << vegso + 1 << ". sorban szerepel, "
<< max(0, hivasok[vegsoelott].befejez - hivasok[vegso].kezd) << " masodpercet vart." << endl;
}
void sikeres_hivasok(const vector<Hivas>& hivasok) {
ofstream ki("sikeres.txt");
int mkezd = mpbe(8, 0, 0), mbefejez = mpbe(12, 0, 0);
int beszel = 0;
while (hivasok[beszel].befejez <= mkezd) beszel++;
ki << beszel + 1 << " " << idopont(max(mkezd, hivasok[beszel].kezd)) << " " << idopont(hivasok[beszel].befejez) << endl;
for (const auto& h : hivasok) {
if (h.befejez > hivasok[beszel].befejez && h.kezd <= mbefejez) {
ki << (&h - &hivasok[0]) + 1 << " " << idopont(max(h.kezd, hivasok[beszel].befejez)) << " " << idopont(h.befejez) << endl;
beszel = &h - &hivasok[0];
}
}
ki.close();
}
int main() {
vector<Hivas> hivasok = beolvasas("hivas.txt");
statisztika(hivasok);
leghosszabb_hivas(hivasok);
keres_idopont_szerint(hivasok);
utolso_hivo(hivasok);
sikeres_hivasok(hivasok);
return 0;
}
2017. május - Fürdő
[szerkesztés]
A fürdőkben egyre gyakoribb a különböző beléptető és fürdőn belüli mozgást rögzítő rendszerek alkalmazása. Egy fürdő a szolgáltatások fejlesztése miatt szeretné a vendégek fürdőzési szokásait felmérni. Ezért egy napi forgalomból véletlenszerűen választották ki a vendégek adatait.
A fürdő négy elkülönített részleggel rendelkezik. A vendégek a fürdő részlegeit az öltözőből kilépve az átjárón keresztül érhetik el, és a fürdőből távozni is az öltözőn keresztül tudnak. Minden vendég a belépéskor egy karszalagot kap. A karszalagon lévő érzékelő minden részlegbe való belépést és kilépést rögzít. Minden vendég az öltözőt egyszer hagyja el – ekkor lép a fürdő belső területére –, és egyszer megy be az öltözőbe – ekkor hagyja el a fürdőt. A nap folyamán már nem jön vissza ismét a fürdőbe. A fürdő 6 órától 20 óráig tart nyitva.
A szóközökkel tagolt furdoadat.txt fájl maximálisan 800 adatsort tartalmazhat. A fájlban 100 fürdővendég adatai vannak. A lista vendégenként csoportosított, azon belül idő szerint rendezett. A vendégek sorrendjét az öltözőből való kilépés ideje szabja meg.
- A sor első értéke egy háromjegyű szám, ami a vendég azonosítója.
- A sor második értéke a fürdőrészleg azonosítója.
| Részleg | Azonosító |
|---|---|
| Öltöző | 0 |
| Uszoda | 1 |
| Szaunák | 2 |
| Gyógyvizes medencék | 3 |
| Strand | 4 |
·;img
- A sor harmadik értéke 0, ha a vendég az adott részlegre belépett; és 1, ha kilépett a részlegből.
- A sor negyedik, ötödik és hatodik értéke az adott részlegbe való belépés vagy kilépés időpontja óra perc másodperc formában, 24 órás alakban.
Például:
\;img
A példában a 453-as és a 266-os azonosítóval rendelkező vendég néhány adata látható. A 453-as vendég 6:15:27-kor lépett ki az öltözőből és 6:17:19-kor lépett be az uszodába. Az uszodából 6:52:56-kor lépett ki, majd 6:56:32-kor bement az öltözőbe.
Készítsen programot, amely a furdoadat.txt állomány adatait felhasználva az alábbi kérdésekre válaszol! A program forráskódját mentse furdostat 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: 4. feladat)! Az ékezetmentes kiírás is elfogadott.
1.Olvassa be a furdoadat.txt fájl tartalmát!
2.Írja a képernyőre, hogy az első és az utolsó vendég mikor lépett ki az öltözőből!
3.Határozza meg és írja ki a képernyőre, hogy hány olyan fürdővendég volt, aki az öltözőn kívül csak egy részlegen járt és azt a részleget csak egyszer használta!
4.Határozza meg, hogy melyik vendég töltötte a legtöbb időt a fürdőben! A vendég azonosítóját és a fürdőben tartózkodás idejét írja ki a képernyőre! A fürdőben a legtöbb időt töltő vendégek közül elegendő egy vendég adatait megjelenítenie.
5.Készítsen statisztikát, hogy 06:00:00-08:59:59 óra között, 09:00:00-15:59:59 óra között és 16:00:00-19:59:59 óra között hány vendég érkezett a fürdőbe! Az eredményt írja ki a képernyőre a mintán látható formában!
6.Készítsen egy listát a szauna részlegen járt vendégekről és az általuk ott töltött időről! A vendég azonosítóját és a részlegen eltöltött időt a szauna.txt fájlba írja ki! A fájlban egy sorban a vendég azonosítója és szóközzel elválasztva a részlegen eltöltött idő szerepeljen óra:perc:másodperc formában! Ügyeljen arra, hogy egy vendég a szauna részlegben a nap folyamán többször is járhatott!
7.Készítsen egy listát, amelyben megadja, hogy az egyes részlegeket hányan használták! Az eredményt a minta szerint írja ki a képernyőre! Ha egy vendég egy részlegen többször is járt a nap folyamán, azt a statisztikában csak egynek számolja!
Minta a szöveges kimenetek kialakításához:
\;img
#include <iostream>
#include <fstream>
#include <vector>
#include <map>
#include <set>
#include <iomanip>
using namespace std;
struct Mozgas {
int vendeg, reszleg, irany, ido;
};
int mpbe(int o, int p, int mp) {
return o * 3600 + p * 60 + mp;
}
string idokiiras(int mp) {
ostringstream oss;
oss << mp / 3600 << ":"
<< setw(2) << setfill('0') << (mp % 3600) / 60 << ":"
<< setw(2) << setfill('0') << mp % 60;
return oss.str();
}
int main() {
ifstream f("furdoadat.txt");
vector<Mozgas> mozgasok;
int vendeg, reszleg, irany, o, p, mp;
while (f >> vendeg >> reszleg >> irany >> o >> p >> mp) {
mozgasok.push_back({vendeg, reszleg, irany, mpbe(o, p, mp)});
}
// 2. feladat
vector<Mozgas> oltki;
for (auto &m : mozgasok)
if (m.reszleg == 0 && m.irany == 1)
oltki.push_back(m);
cout << "Az első vendég " << idokiiras(oltki.front().ido) << "-kor lépett ki az öltözőből." << endl;
cout << "Az utolsó vendég " << idokiiras(oltki.back().ido) << "-kor lépett ki az öltözőből." << endl;
// Vendégek csoportosítása
map<int, vector<Mozgas>> vendeg_adatok;
for (auto &m : mozgasok)
vendeg_adatok[m.vendeg].push_back(m);
// 3. feladat
int egy_reszleg = 0;
for (auto &[k, v] : vendeg_adatok)
if (v.size() == 4)
egy_reszleg++;
cout << "A fürdőben " << egy_reszleg << " vendég járt csak egy részlegben." << endl;
// 4. feladat
int max_ido = 0, max_vendeg = 0;
for (auto &[k, v] : vendeg_adatok) {
int eltoltott_ido = v.back().ido - v.front().ido;
if (eltoltott_ido > max_ido) {
max_ido = eltoltott_ido;
max_vendeg = k;
}
}
cout << "A legtöbb időt eltöltő vendég:\n" << max_vendeg << ". vendég " << idokiiras(max_ido) << endl;
// 5. feladat
vector<int> savok = {6, 9, 16, 20};
vector<int> idopontok(3, 0);
for (auto &[_, v] : vendeg_adatok) {
int erkezes = v.front().ido / 3600;
for (int i = 0; i < 3; ++i)
if (savok[i] <= erkezes && erkezes < savok[i+1])
idopontok[i]++;
}
for (int i = 0; i < 3; ++i)
cout << savok[i] << "-" << savok[i+1] << " óra között " << idopontok[i] << " vendég" << endl;
// 6. feladat
ofstream sz("szauna.txt");
for (auto &[az, v] : vendeg_adatok) {
int szido = 0;
for (auto &m : v)
if (m.reszleg == 2)
szido += m.irany == 0 ? -m.ido : m.ido;
if (szido > 0)
sz << az << " " << idokiiras(szido) << endl;
}
cout << "A szauna.txt elkészült." << endl;
// 7. feladat
vector<string> reszleg_nevek = {"Öltöző", "Uszoda", "Szaunák", "Gyógyvizes medencék", "Strand"};
vector<int> reszleg_db(5, 0);
for (auto &[_, v] : vendeg_adatok) {
set<int> latogatott;
for (auto &m : v)
latogatott.insert(m.reszleg);
for (int r : latogatott)
reszleg_db[r]++;
}
for (int i = 1; i < 5; ++i)
cout << reszleg_nevek[i] << ": " << reszleg_db[i] << endl;
cout << "\n(Ellenőrzésképpen: " << reszleg_nevek[0] << ": " << reszleg_db[0] << ")" << endl;
return 0;
}
2017. május - Tesztverseny
[szerkesztés]
Egy közismereti versenyen a versenyzőknek 13+1, azaz összesen 14 tesztfeladatot tűznek ki. A versenyzőknek minden feladat esetén négy megadott lehetőség (A, B, C, D) közül kell a helyes választ megjelölniük. A versenybizottság garantálja, hogy tesztlapon minden kérdéshez pontosan egy helyes válasz tartozik. A kitöltött tesztlapokat elektronikusan rögzítik, a visszaélések elkerülése végett a versenyzőket betűkből és számokból álló kóddal azonosítják.
A helyes megoldást és a versenyzők válaszait a valaszok.txt szöveges állomány tartalmazza. A fájlban legfeljebb 500 versenyző adatai szerepelnek. A fájl első sorában a helyes válaszok szerepelnek. A fájl többi sora a versenyzők kódjával kezdődik, ezt egy szóköz, majd az adott versenyző által adott válaszok sorozata követi. A versenyzők kódja legfeljebb 5 karakterből áll. A válaszok a feladatokkal egyező sorrendben, elválasztójel nélkül, nagybetűvel szerepelnek. Ha a versenyző egy kérdésre nem válaszolt, akkor annak helyén X betű szerepel. Például:
\;img
A 2. kérdésre a helyes válasz a C volt, de erre a kérdésre az AB123 kódú versenyző nem válaszolt.
Készítsen programot tesztverseny néven az alábbi feladatok megoldására! (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: 2. feladat:)! Ha a felhasználótól kér be adatot, jelenítse meg a képernyőn, hogy milyen értéket vár! A képernyőn megjelenő üzenetek az adott környezet nyelvi sajátosságainak megfelelően a mintától eltérhetnek (pl. ékezetmentes betűk, tizedespont használata).
1.Olvassa be és tárolja el a valaszok.txt szöveges állomány adatait!
2.Jelenítse meg a képernyőn a mintának megfelelően, hogy hány versenyző vett részt a tesztversenyen!
3.Kérje be egy versenyző azonosítóját, és jelenítse meg a mintának megfelelően a hozzá eltárolt válaszokat! Feltételezheti, hogy a fájlban létező azonosítót adnak meg.
4.Írassa ki a képernyőre a helyes megoldást! A helyes megoldás alatti sorba „+” jelet tegyen, ha az adott feladatot az előző feladatban kiválasztott versenyző eltalálta, egyébként egy szóközt! A kiírást a mintának megfelelő módon alakítsa ki!
5.Kérje be egy feladat sorszámát, majd határozza meg, hogy hány versenyző adott a feladatra helyes megoldást, és ez a versenyzők hány százaléka! A százalékos eredményt a mintának megfelelően, két tizedesjeggyel írassa ki!
6.A verseny feladatai nem egyenlő nehézségűek: az 1-5. feladat 3 pontot, a 6-10. feladat 4 pontot, a 11-13. feladat 5 pontot, míg a 14. feladat 6 pontot ér. Határozza meg az egyes versenyzők pontszámát, és a listát írassa ki a pontok.txt nevű állományba! Az állomány minden sora egy versenyző kódját, majd szóközzel elválasztva az általa elért pontszámot tartalmazza!
7.A versenyen a három legmagasabb pontszámot elérő összes versenyzőt díjazzák. Például 5 indulónál előfordulhat, hogy 3 első és 2 második díjat adnak ki. Így megtörténhet az is, hogy nem kerül sor mindegyik díj kiadására. Írassa ki a mintának megfelelően a képernyőre a díjazottak kódját és pontszámát pontszám szerint csökkenő sorrendben!
Minta a szöveges kimenetek kialakításához:
(A képernyőre írt üzeneteknek tartalmilag meg kell felelniük az alábbi mintának. Képernyőre írást nem igénylő feladatok esetén nem szükséges a feladat számát sem kiíratnia.)
\;img
#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <iomanip>
using namespace std;
struct Versenyzo {
string azonosito;
string valasz;
int pont = 0;
};
vector<Versenyzo> versenyzok;
string helyesMegoldas;
const vector<int> pontok = {3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 6};
void Beolvasas() {
ifstream file("valaszok.txt");
if (!file) {
cerr << "Hiba: Nem sikerült megnyitni a valaszok.txt fájlt!" << endl;
exit(1);
}
file >> helyesMegoldas;
Versenyzo v;
while (file >> v.azonosito >> v.valasz) {
versenyzok.push_back(v);
}
file.close();
}
void KiirVersenyzoSzam() {
cout << "2. feladat: A vetélkedőn " << versenyzok.size() << " versenyző indult." << endl;
}
void KeresVersenyzo() {
cout << "3. feladat: A versenyző azonosítója = ";
string keresettAzonosito;
cin >> keresettAzonosito;
auto it = find_if(versenyzok.begin(), versenyzok.end(), [&](const Versenyzo& v) {
return v.azonosito == keresettAzonosito;
});
if (it != versenyzok.end()) {
cout << it->valasz << " (a versenyző válasza)" << endl;
} else {
cout << "Nincs ilyen versenyző!" << endl;
}
}
void KiirHelyesMegoldas() {
cout << "4. feladat:\n" << helyesMegoldas << " (a helyes megoldás)" << endl;
cout << string(helyesMegoldas.size(), ' ');
cout << " (a versenyző helyes válaszai)" << endl;
}
void FeladatStat() {
cout << "5. feladat: A feladat sorszáma = ";
int feladatSorszam;
cin >> feladatSorszam;
feladatSorszam--;
int helyesDb = count_if(versenyzok.begin(), versenyzok.end(), [&](const Versenyzo& v) {
return v.valasz[feladatSorszam] == helyesMegoldas[feladatSorszam];
});
double szazalek = (double) helyesDb / versenyzok.size() * 100;
cout << "A feladatra " << helyesDb << " fő, a versenyzők " << fixed << setprecision(2) << szazalek << "%-a adott helyes választ." << endl;
}
void Pontszamitas() {
ofstream outFile("pontok.txt");
if (!outFile) {
cerr << "Hiba: Nem sikerült létrehozni a pontok.txt fájlt!" << endl;
return;
}
for (auto& v : versenyzok) {
v.pont = 0;
for (size_t i = 0; i < helyesMegoldas.size(); i++) {
if (v.valasz[i] == helyesMegoldas[i]) {
v.pont += pontok[i];
}
}
outFile << v.azonosito << " " << v.pont << endl;
}
outFile.close();
}
void Dijazas() {
cout << "7. feladat: A verseny legjobbjai:" << endl;
sort(versenyzok.begin(), versenyzok.end(), [](const Versenyzo& a, const Versenyzo& b) {
return a.pont > b.pont;
});
int dij = 1, elozoPont = versenyzok[0].pont;
cout << dij << ". díj (" << versenyzok[0].pont << " pont): " << versenyzok[0].azonosito << endl;
for (size_t i = 1; i < versenyzok.size() && dij < 3; i++) {
if (versenyzok[i].pont < elozoPont) dij++;
if (dij <= 3) {
cout << dij << ". díj (" << versenyzok[i].pont << " pont): " << versenyzok[i].azonosito << endl;
elozoPont = versenyzok[i].pont;
}
}
}
int main() {
Beolvasas();
KiirVersenyzoSzam();
KeresVersenyzo();
KiirHelyesMegoldas();
FeladatStat();
Pontszamitas();
Dijazas();
return 0;
}
2017. október - Hiányzások
[szerkesztés]Egy osztály második félévi hiányzásai állnak rendelkezésére a naplo.txt fájlban. A hiányzások naponként csoportosítva szerepelnek, minden napot a # karakter kezd, majd egy-egy szóközzel elválasztva a hónap és a nap sorszáma következik. Az aznapi hiányzások tanulónként külön sorokban vannak, a tanuló napi hiányzásait egy hét karakterből álló karaktersorozat írja le. A karaktersorozat minden karaktere egy-egy órát ad meg. Értéke az O betű, ha a tanuló jelen volt az adott órán, az X utal az igazolt, az I az igazolatlan távollétre, végül N betű jelzi, ha a tanulónak akkor nem volt órája. Például:
\;img
A fenti példa a január 15-16-i hiányzásokat tartalmazza. Galagonya Alfonznak január 15‑én hat órája lett volna, de csak az első órán volt jelen, utána igazoltan hiányzott. Alma Hedvignek január 16-án hét órája lett volna, de a 6. óráról igazolatlanul távol maradt.
Az állomány legfeljebb 600 sort tartalmaz, az osztályba pedig legfeljebb 50 tanuló jár. Feltételezheti, hogy az osztályban nincs két azonos nevű tanuló, továbbá hogy minden tanulónak egy vezeték és egy utóneve van. Felhasználhatja, hogy a jelenlétre vonatkozó bejegyzés mindig 7 karakterből áll.
Készítsen programot, amely az állomány adatait felhasználva az alábbi kérdésekre válaszol! A program forráskódját hianyzasok néven mentse! (A program megírásakor a felhasználó által megadott adatok helyességét, érvényességét nem kell ellenőriznie, és 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 eredmények kiírásánál utaljon a kiírt adat jelentésére! A mintától eltérő, valamint az ékezetmentes kiírás is elfogadott.
- Olvassa be és tárolja el a naplo.txt fájl tartalmát!
- Határozza meg és írassa ki, hogy hány sor van a fájlban, ami hiányzást rögzít! (A fenti példában 3 ilyen bejegyzés van.)
- Számolja meg és írassa ki, hogy összesen hány óra igazolt és hány óra igazolatlan hiányzás volt a félév során!
Néhány tanár azt feltételezi, hogy a tanulók bizonyos órákról gyakrabban hiányoznak. A következő három feladatban ennek vizsgálatát kell előkészítenie.
- Készítsen függvényt hetnapja néven, amely a paraméterként megadott dátumhoz (hónap, nap) megadja, hogy az a hét melyik napjára esik (hétfő, kedd…). Tudjuk, hogy az adott év nem volt szökőév, továbbá azt is, hogy január elseje hétfőre esett. Használhatja az alábbi algoritmust is, ahol a tömbök indexelése 0-val kezdődik, de ettől eltérő megoldású függvényt is készíthet.
\;img
- Kérjen be egy dátumot (hónap, nap), és a hetnapja függvény felhasználásával írassa ki, hogy az a hét melyik napjára esett!
- Kérje be a hét egy tanítási napjának nevét és egy aznapi tanítási óra óraszámát (például: kedd 3)! Írassa ki a képernyőre, hogy a félév során az adott tanítási órára összesen hány hiányzás jutott!
- Írassa ki a képernyőre a legtöbb órát hiányzó tanuló nevét! Ha több ilyen tanuló is van, akkor valamennyi neve jelenjen meg szóközzel elválasztva!
Minta a szöveges kimenetek kialakításához
\;img
#include <iostream>
#include <fstream>
#include <vector>
#include <map>
#include <sstream>
#include <algorithm>
using namespace std;
struct Egyhianyzas {
int honap;
int nap;
string nev;
string jelen;
};
vector<Egyhianyzas> hianyzasok;
// Reads data from "naplo.txt"
void Feladat1() {
ifstream file("naplo.txt");
if (!file) {
cerr << "Hiba: Nem sikerült megnyitni a naplo.txt fájlt!\n";
return;
}
string line;
int honap = 0, nap = 0;
while (getline(file, line)) {
line = line.substr(line.find_first_not_of(" \t")); // Trim leading spaces
if (line[0] == '#') {
istringstream ss(line);
char ch;
ss >> ch >> honap >> nap;
} else {
istringstream ss(line);
string vezeteknev, keresztnev, jelen;
ss >> vezeteknev >> keresztnev >> jelen;
hianyzasok.push_back({honap, nap, vezeteknev + " " + keresztnev, jelen});
}
}
file.close();
}
// Counts the number of absence records
void Feladat2() {
cout << "2. feladat\nA naplóban " << hianyzasok.size() << " bejegyzés van.\n";
}
// Counts the total number of excused and unexcused absences
void Feladat3() {
int igazolt = 0, igazolatlan = 0;
for (const auto& h : hianyzasok) {
for (char c : h.jelen) {
if (c == 'X') igazolt++;
if (c == 'I') igazolatlan++;
}
}
cout << "3. feladat\nAz igazolt hiányzások száma: " << igazolt
<< ", az igazolatlanoké: " << igazolatlan << " óra.\n";
}
// Returns the name of the day of the week for a given date
string hetnapja(int honap, int nap) {
string napnevek[] = {"vasarnap", "hetfo", "kedd", "szerda", "csutortok", "pentek", "szombat"};
int napszam[] = {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 335}; // Days elapsed until the given month
int napsorszam = (napszam[honap - 1] + nap + 1) % 7; // Adjusted for Monday start
return napnevek[napsorszam];
}
// Gets a date and prints the day of the week
void Feladat5() {
cout << "5. feladat\nA hónap sorszáma: ";
int honap, nap;
cin >> honap;
cout << "A nap sorszáma: ";
cin >> nap;
cout << "Azon a napon " << hetnapja(honap, nap) << " volt.\n";
}
// Gets a day and lesson number, then counts absences for that lesson
void Feladat6() {
cout << "6. feladat\nA nap neve: ";
string napnev;
cin >> napnev;
cout << "Az óra sorszáma: ";
int ora;
cin >> ora;
ora--; // Convert to zero-based index
int db = 0;
for (const auto& h : hianyzasok) {
if (hetnapja(h.honap, h.nap) == napnev && (h.jelen[ora] == 'X' || h.jelen[ora] == 'I'))
db++;
}
cout << "Ekkor összesen " << db << " óra hiányzás történt.\n";
}
// Finds the students with the most absences
void Feladat7() {
map<string, int> studentAbsences;
for (const auto& h : hianyzasok) {
for (char c : h.jelen) {
if (c != 'O') studentAbsences[h.nev]++;
}
}
int maxAbsences = 0;
vector<string> mostAbsentStudents;
for (const auto& entry : studentAbsences) {
if (entry.second > maxAbsences) {
maxAbsences = entry.second;
mostAbsentStudents.clear();
mostAbsentStudents.push_back(entry.first);
} else if (entry.second == maxAbsences) {
mostAbsentStudents.push_back(entry.first);
}
}
cout << "7. feladat\nA legtöbbet hiányzó tanulók: ";
for (const string& name : mostAbsentStudents)
cout << name << " ";
cout << "\n";
}
int main() {
Feladat1();
Feladat2();
Feladat3();
Feladat5();
Feladat6();
Feladat7();
return 0;
}
2018. május - Fogadóóra
[szerkesztés]Egy iskolában a tanárok fogadóóráira egy webes felületen foglalhatnak időpontot a szülők. Ebben a feladatban az egyik fogadónap adataival kell dolgoznia. A fogadónap 16:00-tól 18:00‑ig tart, a lehetséges lefoglalható időpontok: 16:00, 16:10, 16:20 … 17:50. Egy-egy megbeszélés 10 percig tart. Időpontütközést a foglalást felügyelő program nem enged meg.
A fogado.txt fájl a tanárok foglaltsági adatait tartalmazza. Egy sorban a következő adatok találhatók szóközzel elválasztva: a tanár vezetékneve; utóneve; a lefoglalt időpont; a foglalás rögzítésének dátuma és időpontja. A tanár neve pontosan egy vezetéknévből és pontosan egy utónévből áll. Az óra, perc, hónap és nap adatok mindegyikét pontosan két számjeggyel tárolva találhatja meg a fájlban. A fájlban biztosan 500-nál kevesebb sor fordul elő, és az adatok sorrendje véletlenszerű.
Például:
\;img
A példa első sora szerint Nagy Marcell tanár úrnál a 16:30-as időpontot lefoglalták, mégpedig 2017. 10. 29-én 20:32-kor.
Készítsen programot, amely a fogado.txt állomány adatait felhasználva az alábbi kérdésekre válaszol! A program forráskódját mentse fogado 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 2. 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 és tárolja el a fogado.txt fájl tartalmát!
2. Írja a képernyőre, hogy hány foglalás adatait tartalmazza a fájl!
3. Kérje be a felhasználótól egy tanár nevét, majd jelenítse meg a mintának megfelelően a képernyőn, hogy a megadott tanárnak hány időpontfoglalása van! Ha a megadott tanárhoz – ilyen például Farkas Attila – még nem történt foglalás, akkor „A megadott néven nincs időpontfoglalás.” üzenetet jelenítse meg!
Kérjen be a felhasználótól egy érvényes időpontot a forrásfájlban található formátumban (pl. 17:40)! A program írja a képernyőre a megadott időpontban foglalt tanárok névsorát! Egy sorban egy név szerepeljen! A névsor ábécé szerint rendezett legyen! A rendezett névsort írja ki fájlba is, és ott is soronként egy név szerepeljen! Az időpontnak megfelelő fájlnevet használjon, például 17:40 esetén a 1740.txt fájlban tárolja el az adatokat! Ügyeljen arra, hogy a fájlnév a kettőspont karaktert ne tartalmazza! (Amennyiben ezen a néven nem tudja a fájlt létrehozni, használja az adatok.txt állománynevet!)
Határozza meg, majd írja ki a képernyőre a legkorábban lefoglalt időpont minden adatát! Az adatok megjelenítésénél pontosan kövesse a feladat végén szereplő mintát!
Írja ki a képernyőre „Barna Eszter” tanárnő szabad időpontjait! Tudjuk, hogy a tanárnőnek legalább egy foglalt és több szabad időpontja is van. A tanárnő a legutolsó szülő fogadása után távozhat az iskolából. Mikor távozhat legkorábban? Az időpontot azonosíthatóan írja ki a képernyőre!
Minta a szöveges kimenetek kialakításához:
;img
// Optimized C++ implementation of Fogadóóra task
#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <sstream>
using namespace std;
struct Foglalas {
string nev;
string idopont;
string foglalasIdeje;
};
int main() {
vector<Foglalas> foglalasok;
ifstream fin("fogado.txt");
// 1. feladat: Beolvasás
cout << "1. feladat" << endl;
string vezeteknev, keresztnev, idopont, foglalasIdeje;
while (fin >> vezeteknev >> keresztnev >> idopont >> foglalasIdeje) {
foglalasok.push_back({vezeteknev + " " + keresztnev, idopont, foglalasIdeje});
}
fin.close();
cout << "A beolvasás sikeres." << endl << endl;
// 2. feladat: Foglalások száma
cout << "2. feladat\nFoglalások száma: " << foglalasok.size() << "\n\n";
// 3. feladat: Tanár foglalásai
cout << "3. feladat\nAdjon meg egy nevet: ";
string keresettNev;
getline(cin, keresettNev);
int db = count_if(foglalasok.begin(), foglalasok.end(), [&](Foglalas f) { return f.nev == keresettNev; });
if (db > 0)
cout << keresettNev << " néven " << db << " időpontfoglalás van.\n\n";
else
cout << "A megadott néven nincs időpontfoglalás.\n\n";
// 4. feladat: Foglalt tanárok adott időpontban
cout << "4. feladat\nAdjon meg egy érvényes időpontot (pl. 17:10): ";
string keresettIdo;
getline(cin, keresettIdo);
vector<string> foglaltTanarok;
for (auto &f : foglalasok)
if (f.idopont == keresettIdo)
foglaltTanarok.push_back(f.nev);
sort(foglaltTanarok.begin(), foglaltTanarok.end());
for (auto &nev : foglaltTanarok)
cout << nev << endl;
string fajlnev = keresettIdo;
fajlnev.erase(remove(fajlnev.begin(), fajlnev.end(), ':'), fajlnev.end());
ofstream fout(fajlnev + ".txt");
for (auto &nev : foglaltTanarok)
fout << nev << endl;
fout.close();
cout << "\nAz adatok fájlba írása sikeres.\n\n";
// 5. feladat: Legkorábbi foglalás
cout << "5. feladat" << endl;
auto legkorabbi = *min_element(foglalasok.begin(), foglalasok.end(), [](Foglalas a, Foglalas b) { return a.foglalasIdeje < b.foglalasIdeje; });
cout << "Tanár neve: " << legkorabbi.nev << endl;
cout << "Foglalt időpont: " << legkorabbi.idopont << endl;
cout << "Foglalás ideje: " << legkorabbi.foglalasIdeje << "\n\n";
// 6. feladat: Barna Eszter szabad időpontjai
cout << "6. feladat" << endl;
vector<string> barnaFoglalt;
for (auto &f : foglalasok)
if (f.nev == "Barna Eszter")
barnaFoglalt.push_back(f.idopont);
vector<string> mindenIdopont;
for (int ora = 16; ora < 18; ++ora)
for (int perc = 0; perc < 60; perc += 10) {
ostringstream ido;
ido << ora << ":" << (perc < 10 ? "0" : "") << perc;
mindenIdopont.push_back(ido.str());
}
vector<string> barnaSzabad;
copy_if(mindenIdopont.begin(), mindenIdopont.end(), back_inserter(barnaSzabad), [&](string ido) {
return find(barnaFoglalt.begin(), barnaFoglalt.end(), ido) == barnaFoglalt.end();
});
for (auto &ido : barnaSzabad)
cout << ido << endl;
auto utolsoFoglalt = *max_element(barnaFoglalt.begin(), barnaFoglalt.end());
auto tavozas = find_if(barnaSzabad.begin(), barnaSzabad.end(), [&](string ido) { return ido > utolsoFoglalt; });
cout << "Barna Eszter legkorábban távozhat: " << *tavozas << endl;
return 0;
}
2018. május - Társalgó
[szerkesztés]Egy színház társalgójában még a délelőtti próbák alatt is nagy a forgalom. A színészek hosszabb-rövidebb beszélgetésekre térnek be ide, vagy éppen csak keresnek valakit. A feladatban a társalgó ajtajánál 9 és 15 óra között felvett adatokat kell feldolgoznia.
Az ajto.txt fájlban időrendben rögzítették, hogy ki és mikor lépett be vagy ki a társalgó egyetlen ajtaján. A fájl soraiban négy, szóközzel elválasztott érték található. Az első két szám az áthaladás időpontja (óra, perc), a harmadik a személy azonosítója, az utolsó az áthaladás iránya (be/ki). A sorok száma legfeljebb 1000, a személyek azonosítója egy 1 és 100 közötti egész szám. Biztosan tudjuk, hogy a megfigyelés kezdetén (9 órakor) a társalgó üres volt, de a megfigyelés végén (15 órakor) még lehettek benn a társalgóban. A társalgóba be- és kilépéseket azok sorrendjében tartalmazza az állomány, még akkor is, ha a perc pontossággal rögzített adatok alapján egyezőség áll fenn.
Például:
| Fájl adatai | Bentlévők száma |
|---|---|
| 9 1 2 be | 1 |
| 9 1 9 be | 2 |
| 9 3 15 be | 3 |
| 9 5 9 ki | 2 |
| 9 8 15 ki | 1 |
| 9 8 20 be | 2 |
| 9 8 26 be | 3 |
| 9 13 4 be | 4 |
| 9 13 26 ki | 3 |
| … | … |
A fenti példában a szürke mintázatú részen a bemeneti fájl első néhány sora látható. A második sora azt mutatja, hogy a 9-es azonosítójú személy 9 óra 1 perckor lépett be a társalgóba. A negyedik sorban olvasható, hogy 9 óra 5 perckor már ki is ment, tehát ekkor összesen 4 percet töltött bent. A szürke rész sorai mellett olvasható számok azt mutatják, hogy a be- vagy kilépést követően hányan vannak bent a társalgóban. Ez a szám egy percen belül akár többször is változhat.
Készítsen programot, amely az ajto.txt állomány adatait felhasználva az alábbi kérdésekre válaszol! A program forráskódját mentse tarsalgo 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: 4. 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.
- Olvassa be és tárolja el az ajto.txt fájl tartalmát!
- Írja a képernyőre annak a személynek az azonosítóját, aki a vizsgált időszakon belül először lépett be az ajtón, és azét, aki utoljára távozott a megfigyelési időszakban!
- Határozza meg a fájlban szereplő személyek közül, ki hányszor haladt át a társalgó ajtaján! A meghatározott értékeket azonosító szerint növekvő sorrendben írja az athaladas.txt fájlba! Soronként egy személy azonosítója, és tőle egy szóközzel elválasztva az áthaladások száma szerepeljen!
- Írja a képernyőre azon személyek azonosítóját, akik a vizsgált időszak végén a társalgóban tartózkodtak!
- Hányan voltak legtöbben egyszerre a társalgóban? Írjon a képernyőre egy olyan időpontot (óra:perc), amikor a legtöbben voltak bent!
- Kérje be a felhasználótól egy személy azonosítóját! A további feladatok megoldásánál ezt használja fel!
Feltételezheti, hogy a megadott azonosítóhoz tartozik adat a forrásfájlban.
- Írja a képernyőre, hogy a beolvasott azonosítóhoz tartozó személy mettől meddig tartózkodott a társalgóban!
A kiírást az alábbi, 22-es személyhez tartozó példának megfelelően alakítsa ki!
\;img
- Határozza meg, hogy a megfigyelt időszakban a beolvasott azonosítójú személy összesen hány percet töltött a társalgóban! Az előző feladatban példaként szereplő 22-es személy 5 alkalommal járt bent, a megfigyelés végén még bent volt. Róla azt tudjuk, hogy 18 percet töltött bent a megfigyelés végéig. A 39-es személy 6 alkalommal járt bent, a vizsgált időszak végén nem tartózkodott a helyiségben. Róla azt tudjuk, hogy 39 percet töltött ott. Írja ki, hogy a beolvasott azonosítójú személy mennyi időt volt a társalgóban, és a megfigyelési időszak végén bent volt-e még!
Minta a szöveges kimenetek kialakításához:
\;img
#include <iostream>
#include <fstream>
#include <vector>
#include <map>
using namespace std;
struct Tmozgas {
int ora, perc, id, ido;
string irany;
};
int main() {
vector<Tmozgas> mozgas;
ifstream be("ajto.txt");
// 1. feladat: Beolvasás
Tmozgas temp;
while (be >> temp.ora >> temp.perc >> temp.id >> temp.irany) {
temp.ido = temp.ora * 60 + temp.perc;
mozgas.push_back(temp);
}
be.close();
cout << "2. feladat" << endl;
cout << "Az elso belepo: " << mozgas.front().id << endl;
int utolso = 0;
for (int i = 0; i < mozgas.size(); i++) {
if (mozgas[i].irany == "ki") {
utolso = i;
}
}
cout << "Az utolso kilepo: " << mozgas[utolso].id << endl;
// 3. feladat: Áthaladások száma
map<int, int> athaladas;
for (const auto &m : mozgas) {
athaladas[m.id]++;
}
ofstream ki("athaladas.txt");
for (const auto &entry : athaladas) {
ki << entry.first << " " << entry.second << endl;
}
ki.close();
cout << "4. feladat" << endl;
cout << "A vegen a tarsalgoban voltak:";
for (const auto &entry : athaladas) {
if (entry.second % 2 == 1) {
cout << " " << entry.first;
}
}
cout << endl;
// 5. feladat: Maximum létszám és időpont
cout << "5. feladat" << endl;
int letszam = 0, maxletszam = 0, maxido = 0;
for (int i = 0; i < mozgas.size(); i++) {
letszam += (mozgas[i].irany == "be" ? 1 : -1);
if (letszam > maxletszam) {
maxletszam = letszam;
maxido = i;
}
}
cout << "Peldaul " << mozgas[maxido].ora << ":" << mozgas[maxido].perc << "-kor voltak a legtobben a tarsalgoban." << endl;
// 6. feladat: Felhasználói bemenet
int sz;
cout << "Adja meg a szemely azonositojat! ";
cin >> sz;
// 7. feladat: Személy tartózkodása
cout << "7. feladat" << endl;
bool bent = false;
for (const auto &m : mozgas) {
if (m.id == sz) {
if (m.irany == "be") {
cout << m.ora << ":" << m.perc << "-";
bent = true;
} else {
cout << m.ora << ":" << m.perc << endl;
bent = false;
}
}
}
if (bent) cout << "15:00" << endl;
// 8. feladat: Személy összes bent töltött ideje
cout << "8. feladat" << endl;
int osszido = 0;
int lastEntry = -1;
for (const auto &m : mozgas) {
if (m.id == sz) {
if (m.irany == "be") {
lastEntry = m.ido;
} else {
osszido += (m.ido - lastEntry);
lastEntry = -1;
}
}
}
if (lastEntry != -1) {
osszido += (15 * 60 - lastEntry);
cout << "A(z) " << sz << ". szemely osszesen " << osszido << " percet volt bent, a megfigyeles vegen a tarsalgoban volt." << endl;
} else {
cout << "A(z) " << sz << ". szemely osszesen " << osszido << " percet volt bent, a megfigyeles vegen nem volt a tarsalgoban." << endl;
}
return 0;
}
2018. október - Kerítés
[szerkesztés]Egy üdülőfalu újonnan nyitott utcájában a telkeket a saroktól kiindulva egymás után folyamatosan, kihagyások nélkül adják el. A vásárló kiválaszthatja az oldalt, amelyen vásárolni akar (ott csak a soron következő telket vásárolhatja meg), valamint megadhatja a telek utcafronti szélességét. Sok telket vettek meg az utcában, a legtöbben már kerítést is építettek, azok majd’ mindegyikét be is festették.
A kerites.txt fájl az utca telkeinek jelenlegi állapotát írja le. A telkek a vásárlás sorrendjében szerepelnek. Minden sorban három adat található. Az első szám megadja, hogy a telek a páros (0) vagy a páratlan (1) oldalán van az utcának; a második a telek szélességét adja meg méterben (egész szám, értéke 8 és 20 között lehet); a harmadik pedig az utcafronti kerítés színét leíró karakter. A szín az angol ábécé nagybetűje. Ha a kerítést már elkészítették, de nem festették be, akkor a „#” karakter, ha még nem készült el, akkor a „:” (kettőspont) karakter szerepel. Az utca hossza legfeljebb 1000 méter. Mindkét oldalon elkelt legalább 3-3 telek.
Például:
\;img
Az első telket a páros oldalon vették (házszáma: 2), 10 méter széles és már a kerítés is elkészült, amelyet P színnel festettek be. A második vásárló az első, aki a páratlan oldalon vett telket (házszáma: 1), 8 méter széles, K színű kerítése van. A harmadik vásárló is a páratlan oldalt választotta, ezért házszáma 3, 10 méteres a telke, de a kerítés még nem készült el.
Készítsen programot, amely a kerites.txt állomány adatait felhasználva az alábbi kérdésekre válaszol! A program forráskódját mentse utca 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 5. 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 és tárolja el a kerites.txt fájl tartalmát!
2. Írja a képernyőre, hogy hány telket adtak el az utcában!
3. Jelenítse meg a képernyőn, hogy az utolsó eladott telek
melyik (páros / páratlan) oldalon talált gazdára!
milyen házszámot kapott!
4. Írjon a képernyőre egy házszámot a páratlan oldalról, amely melletti telken ugyanolyan színű a kerítés! (A hiányzó és a festetlen kerítésnek nincs színe.) Feltételezheti, hogy van ilyen telek, a több ilyen közül elég az egyik ház számát megjeleníteni.
- Kérje be a felhasználótól egy eladott telek házszámát, majd azt felhasználva oldja meg a következő feladatokat!
Írja ki a házszámhoz tartozó kerítés színét, ha már elkészült és befestették, egyébként az állapotát a „#” vagy „:” karakter jelöli!
A házszámhoz tartozó kerítést szeretné tulajdonosa be- vagy átfesteni. Olyan színt akar választani, amely különbözik a mellette lévő szomszéd(ok)tól és a jelenlegi színtől is. Adjon meg egy lehetséges színt! A színt a teljes palettából (A–Z) szabadon választhatja meg.
- Jelenítse meg az utcakep.txt fájlban a páratlan oldal utcaképét az alábbi mintának megfelelően!
\;img
Az első sorban a páratlan oldal jelenjen meg, a megfelelő méternyi szakasz kerítésszínét (vagy állapotát) jelző karakterrel! A második sorban a telek első karaktere alatt kezdődően a házszám álljon!
Minta a szöveges kimenetek kialakításához:
\;img
#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <set>
using namespace std;
struct Plot {
int width;
char color;
};
struct StreetSide {
vector<Plot> plots;
};
int countDigits(int num) {
int count = 0;
while (num > 0) {
num /= 10;
count++;
}
return count;
}
int main() {
StreetSide sides[2];
ifstream input("kerites.txt");
if (!input) {
cerr << "Error opening file!" << endl;
return 1;
}
int side, width;
char color;
while (input >> side >> width >> color) {
sides[side].plots.push_back({width, color});
}
input.close();
cout << "2. feladat" << endl;
cout << "Az eladott telkek szama: " << sides[0].plots.size() + sides[1].plots.size() << endl;
cout << "3. feladat" << endl;
if (side == 0) {
cout << "A paros oldalon adtak el az utolso telket.\n";
cout << "Az utolso telek hazszama: " << sides[0].plots.size() * 2 << endl;
} else {
cout << "A paratlan oldalon adtak el az utolso telket.\n";
cout << "Az utolso telek hazszama: " << sides[1].plots.size() * 2 - 1 << endl;
}
cout << "4. feladat" << endl;
for (size_t i = 0; i < sides[1].plots.size() - 1; i++) {
if (sides[1].plots[i].color == sides[1].plots[i + 1].color &&
sides[1].plots[i].color != '#' && sides[1].plots[i].color != ':') {
cout << "Szomszedos telkek azonos szinnel: " << 2 * i + 1 << " " << 2 * i + 3 << endl;
break;
}
}
cout << "5. feladat" << endl;
cout << "Adjon meg egy hazszamot! ";
int houseNumber;
cin >> houseNumber;
int targetSide = houseNumber % 2;
int index = (houseNumber - 1) / 2;
cout << "A kerites szine / allapota: " << sides[targetSide].plots[index].color << endl;
set<char> forbiddenColors;
forbiddenColors.insert(sides[targetSide].plots[index].color);
if (index > 0)
forbiddenColors.insert(sides[targetSide].plots[index - 1].color);
if (index + 1 < sides[targetSide].plots.size())
forbiddenColors.insert(sides[targetSide].plots[index + 1].color);
for (char c = 'A'; c <= 'Z'; c++) {
if (forbiddenColors.find(c) == forbiddenColors.end()) {
cout << "Egy lehetseges festesi szin: " << c << endl;
break;
}
}
ofstream output("utcakep.txt");
for (const auto& plot : sides[1].plots) {
output << string(plot.width, plot.color);
}
output << endl;
int houseNumberCounter = 1;
for (const auto& plot : sides[1].plots) {
output << houseNumberCounter;
int spaces = plot.width - countDigits(houseNumberCounter);
output << string(spaces, ' ');
houseNumberCounter += 2;
}
output << endl;
output.close();
return 0;
}
2019. május - Tantárgyfelosztás
[szerkesztés]A tantárgyfelosztás a tanév tervezésének alapvető dokumentuma. A tantárgyfelosztás azt tartalmazza, hogy a tanárok a tantárgyaikat mely osztályokban, hány órában tanítják. Ebben a feladatban egy négy évfolyamos gimnázium tantárgyfelosztásának adatait kell elemeznie.
A tantárgyfelosztást ezúttal egy adatbázis-kezelő programmal előállított, egyszerű szerkezetű szöveges állományban kapja az alábbi minta szerint (Minden bejegyzést négy sor tárol.):
\;img
Az első bejegyzés megadja, hogy Albatrosz Aladin tanár úr biológiát (biologia) fog tanítani a 9.a osztályban heti 2 órában. Ha az osztály betűjele x, akkor évfolyam szintű csoportról van szó. Példánkban Csincsilla Csilla tanárnő a 9. évfolyam részére heti 2 órás matematika órát tart. Az osztályfőnököket arról ismerhetjük fel, hogy ők tartják az osztályfőnöki (osztalyfonoki) órát.
A megoldás során felhasználhatja, hogy a fájl maximum 1000 bejegyzést (azaz legfeljebb 4000 sort) tartalmaz. Az iskolában legfeljebb 100 tanár és legfeljebb 50 osztály van, továbbá minden osztálynak pontosan egy osztályfőnöke van.
Készítsen programot, amely a beosztas.txt állomány adatait felhasználva az alábbi kérdésekre válaszol! A program forráskódját mentse tanfel néven! (A program megírásakor a felhasználó által megadott adatok helyességét, érvényességét nem kell ellenőriznie, és feltételezheti, hogy a rendelkezésre álló adatok a leírtaknak megfelelnek.)
A képernyőre írást igénylő részfeladatok esetén – a mintához tartalmában hasonlóan – írja ki a képernyőre a feladat sorszámát (például: 3. feladat:), és utaljon a kiírt tartalomra is! Ha a felhasználótól kér be adatot, jelenítse meg a képernyőn, hogy milyen értéket vár! Mindkét esetben az ékezetmentes kiírás is elfogadott.
1. Olvassa be és tárolja el a beosztas.txt állományban talált adatokat, és annak felhasználásával oldja meg a következő feladatokat!
2. Hány bejegyzés található az állományban? Az eredményt írassa ki a képernyőre!
3. A fenntartó számára fontos információ, hogy az iskolában hetente összesen hány tanítási óra van. Határozza meg ezt az adatot és írassa ki a képernyőre!
4. Kérje be a felhasználótól egy tanár nevét, és írassa ki a képernyőre, hogy hetente hány órában tanít!
5. Készítse el az _of.txt f_ájlt, amely az osztályfőnökök nevét tartalmazza osztályonként az alábbi formában (az osztályok megjelenítésének sorrendje a mintától eltérhet):
\;img
- Egyes osztályokban bizonyos tantárgyakat a tanulók csoportbontásban tanulnak: ekkor az adott tantárgyra és osztályra két bejegyzést is tartalmaz a tantárgyfelosztás. Kérje be egy osztály azonosítóját, valamint egy tantárgy nevét, és írassa ki a képernyőre, hogy az adott osztály a megadott tantárgyat csoportbontásban vagy osztályszinten tanulja-e! (Feltételezheti, hogy a megadott osztály tanulja a megadott tantárgyat.)
7. A fenntartó számára az is fontos információ, hogy hány tanár dolgozik az iskolában. Írassa ki ezt az adatot a képernyőre!
Példa a szöveges kimenetek kialakításához:
\;img
#include <iostream>
#include <fstream>
#include <vector>
#include <set>
#include <map>
using namespace std;
struct Beosztas {
string nev;
string tantargy;
string osztaly;
int oraszam;
};
int main() {
vector<Beosztas> beosztasok;
ifstream fin("beosztas.txt");
string nev, tantargy, osztaly;
int oraszam;
while (getline(fin, nev)) {
getline(fin, tantargy);
getline(fin, osztaly);
fin >> oraszam;
fin.ignore(); // consume leftover newline
beosztasok.push_back({nev, tantargy, osztaly, oraszam});
}
fin.close();
// 2. feladat
cout << "2. feladat\nA fájlban " << beosztasok.size() << " bejegyzés van.\n";
// 3. feladat
int osszOra = 0;
for (auto &b : beosztasok) osszOra += b.oraszam;
cout << "\n3. feladat\nAz iskolában a heti összóraszám: " << osszOra << '\n';
// 4. feladat
cout << "\n4. feladat\nEgy tanár neve= ";
string tanar;
getline(cin, tanar);
int tanarOraszam = 0;
for (auto &b : beosztasok)
if (b.nev == tanar)
tanarOraszam += b.oraszam;
cout << "A tanár heti óraszáma: " << tanarOraszam << '\n';
// 5. feladat
ofstream fout("of.txt");
for (auto &b : beosztasok)
if (b.tantargy == "osztalyfonoki")
fout << b.osztaly << " - " << b.nev << '\n';
fout.close();
// 6. feladat
cout << "\n6. feladat\nOsztály= ";
string aktOsztaly;
getline(cin, aktOsztaly);
cout << "Tantárgy= ";
string aktTantargy;
getline(cin, aktTantargy);
int csoportDb = 0;
for (auto &b : beosztasok)
if (b.osztaly == aktOsztaly && b.tantargy == aktTantargy)
csoportDb++;
cout << (csoportDb > 1 ? "Csoportbontásban tanulják.\n" : "Osztályszinten tanulják.\n");
// 7. feladat
set<string> tanarok;
for (auto &b : beosztasok) tanarok.insert(b.nev);
cout << "\n7. feladat\nAz iskolában " << tanarok.size() << " tanár tanít.\n";
cout << "\nA befejezéshez nyomd meg az ENTER billentyűt!";
cin.get();
return 0;
}
2019. május - Céges autók
[szerkesztés]Egy cég 10 olyan autóval rendelkezik, amelyet a dolgozók igénybe vehetnek az üzleti ügyeik intézésére. Az autókat akár többnapos útra is elvihetik, illetve egy autót egy nap több dolgozó is elvihet. A rendszer az autók parkolóból való ki- és behajtását rögzíti. A parkoló a hónap minden napján 7-23 óra között van nyitva, csak ebben az időszakban lehet elvinni és visszahozni az autókat. Az autót mindig annak a dolgozónak kell visszahoznia, amelyik elvitte. Egyszerre csak egy autó lehet minden dolgozónál.
Az autok.txt fájl egy hónap (30 nap) adatait rögzíti. Egy sorban szóközökkel elválasztva 6 adat található az alábbi sorrendben.
| nap | egész szám (1-30) | a hónap adott napja |
|---|---|---|
| óra:perc | szöveg (óó:pp formátumban) | a ki- vagy a behajtás időpontja |
| rendszám | 6 karakteres szöveg (CEG300-CEG309) | az autó rendszáma |
| személy azonosítója | egész szám (500-600) | az autót igénybe vevő dolgozó azonosítója |
| km számláló | egész szám | a km számláló állása |
| ki/be hajtás | egész szám (0 vagy 1) | a parkolóból kihajtáskor 0, a behajtáskor 1 |
A sorok száma legfeljebb 500. Az adatok a napok szerint, azon belül óra és perc szerint rendezettek. Továbbá tudjuk, hogy a hónap első napján a cég mind a tíz autója a parkolóban volt.
Például:
\;img
A példában látható, hogy a CEG300 rendszámú autót az 5. napon kétszer is elvitték. Először 7:30-kor vitték el és 14:16-kor hozta vissza az 590-es dolgozó. A kivitelkor a kilométerszámláló állása 30 580 km volt, amikor visszahozta 30 656 km volt. Másodszor 17:00-kor vitte el az 534‑es dolgozó az autót és 19:03-kor hozta vissza. A CEG308 rendszámú autót pedig a 15. napon vitte el az 543-as dolgozó és a 17. napon hozta vissza.
Készítsen programot, amely az autok.txt állomány adatait felhasználva az alábbi kérdésekre válaszol! A program forráskódját mentse cegesauto 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.
Az eredmény megjelenítését és a felhasználóval való kommunikációt a feladatot követő minta alapján valósítsa meg!
1. Olvassa be és tárolja el az autok.txt fájl tartalmát!
2. Adja meg, hogy melyik autót vitték el utoljára a parkolóból! Az eredményt a mintának megfelelően írja a képernyőre!
3. Kérjen be egy napot és írja ki a képernyőre a minta szerint, hogy mely autókat vitték ki és hozták vissza az adott napon!
4. Adja meg, hogy hány autó nem volt bent a hónap végén a parkolóban!
5. Készítsen statisztikát, és írja ki a képernyőre mind a 10 autó esetén az ebben a hónapban megtett távolságot kilométerben! A hónap végén még kint lévő autók esetén az utolsó rögzített kilométerállással számoljon! A kiírásban az autók sorrendje tetszőleges lehet.
6. Határozza meg, melyik személy volt az, aki az autó egy elvitele alatt a leghosszabb távolságot tette meg! A személy azonosítóját és a megtett kilométert a minta szerint írja a képernyőre! (Több legnagyobb érték esetén bármelyiket kiírhatja.)
- Az autók esetén egy havi menetlevelet kell készíteni! Kérjen be a felhasználótól egy rendszámot! Készítsen egy X_menetlevel.txt állományt, amelybe elkészíti az adott rendszámú autó menetlevelét! (Az X helyére az autó rendszáma kerüljön!) A fájlba soronként tabulátorral elválasztva a személy azonosítóját, a kivitel időpontját (nap. óra:perc), a kilométerszámláló állását, a visszahozatal időpontját (nap. óra:perc), és a kilométerszámláló állását írja a minta szerint! (A tabulátor karakter ASCII-kódja: 9.)
;img
A CEG304_menetlevel.txt fájl tartalma:
\;img
#include <iostream>
#include <fstream>
#include <vector>
#include <map>
#include <algorithm>
#include <sstream>
using namespace std;
struct Auto {
int nap;
string ido;
string rendszam;
int szemelyAzonosito;
int kmSzamlalo;
bool kiBe;
};
vector<Auto> forgalom;
void beolvas() {
ifstream file("autok.txt");
if (!file) {
cerr << "Hiba: Nem lehet megnyitni a fajlt!" << endl;
return;
}
Auto adat;
while (file >> adat.nap >> adat.ido >> adat.rendszam >> adat.szemelyAzonosito >> adat.kmSzamlalo) {
int kibe;
file >> kibe;
adat.kiBe = (kibe == 1);
forgalom.push_back(adat);
}
file.close();
}
Auto utolsoAutoKi() {
for (auto it = forgalom.rbegin(); it != forgalom.rend(); ++it) {
if (!it->kiBe) return *it;
}
return {};
}
vector<Auto> forgalomAdottNapon(int nap) {
vector<Auto> eredmeny;
for (const auto& a : forgalom) {
if (a.nap == nap) eredmeny.push_back(a);
}
return eredmeny;
}
int kintLevoAutokSzama() {
map<string, bool> allapot;
for (const auto& a : forgalom) {
allapot[a.rendszam] = a.kiBe;
}
return count_if(allapot.begin(), allapot.end(), [](const pair<string, bool>& p) { return !p.second; });
}
map<string, int> haviKmOsszegzes() {
map<string, int> km;
map<string, int> kezdoKm;
for (const auto& a : forgalom) {
if (!kezdoKm.count(a.rendszam)) kezdoKm[a.rendszam] = a.kmSzamlalo;
if (a.kiBe) km[a.rendszam] = a.kmSzamlalo - kezdoKm[a.rendszam];
}
return km;
}
pair<int, int> legnagyobbTavolsag() {
int maxKm = 0, szemely = 0;
map<string, Auto> aktivAuto;
for (const auto& a : forgalom) {
if (!a.kiBe) aktivAuto[a.rendszam] = a;
else if (aktivAuto.count(a.rendszam)) {
int tav = a.kmSzamlalo - aktivAuto[a.rendszam].kmSzamlalo;
if (tav > maxKm) {
maxKm = tav;
szemely = aktivAuto[a.rendszam].szemelyAzonosito;
}
}
}
return {maxKm, szemely};
}
void menetlevelKeszit(const string& rendszam) {
ofstream file(rendszam + "_menetlevel.txt");
for (const auto& a : forgalom) {
if (a.rendszam == rendszam) {
file << a.szemelyAzonosito << "\t" << a.nap << ". " << a.ido << "\t" << a.kmSzamlalo << " km";
if (a.kiBe) file << endl;
}
}
file.close();
cout << "Menetlevél kész." << endl;
}
int main() {
beolvas();
cout << "2. feladat" << endl;
Auto utolso = utolsoAutoKi();
cout << utolso.nap << ". nap rendszám: " << utolso.rendszam << endl;
cout << "3. feladat" << endl;
cout << "Nap: ";
int nap;
cin >> nap;
vector<Auto> napiForgalom = forgalomAdottNapon(nap);
cout << "Forgalom a(z) " << nap << ". napon:" << endl;
for (const auto& a : napiForgalom) {
cout << a.ido << " " << a.rendszam << " " << a.szemelyAzonosito << " " << (a.kiBe ? "be" : "ki") << endl;
}
cout << "4. feladat" << endl;
cout << "A hónap végén " << kintLevoAutokSzama() << " autót nem hoztak vissza." << endl;
cout << "5. feladat" << endl;
map<string, int> kmStat = haviKmOsszegzes();
for (const auto& [rendszam, km] : kmStat) {
cout << rendszam << " " << km << " km" << endl;
}
cout << "6. feladat" << endl;
auto [maxKm, szemely] = legnagyobbTavolsag();
cout << "Leghosszabb út: " << maxKm << " km, személy: " << szemely << endl;
cout << "7. feladat" << endl;
cout << "Rendszám: ";
string rendszam;
cin >> rendszam;
menetlevelKeszit(rendszam);
return 0;
}
2019. október - eUtazas
[szerkesztés]Egyre több országban fordul elő, hogy a közlekedési eszközökön használatos bérleteket és jegyeket valamilyen elektronikus eszközön (például: chipes kártya) tárolják. Egy nagyváros ilyen rendszert szeretne bevezetni a helyi közlekedésben, amelyet néhány buszjáraton tesztelnek. Ezekre a buszokra csak az első ajtónál lehet felszállni, ahol egy ellenőrző eszközhöz kell érinteni a kártyát, amelynek chipje tartalmazza a jegy vagy bérlet információkat.
A busz ellenőrző eszköze statisztikai és fejlesztési célból rögzíti a felszállók kártyájának adatait. Az utasadat.txt szóközökkel tagolt állomány egy, a tesztelésben részt vevő busz végállomástól-végállomásig tartó útjának adatait tartalmazza.
Az utasadat.txt állomány legfeljebb 2000 sort tartalmaz és minden sorában 5 adat szerepel. Ezek:
- a megálló sorszáma (0-29; 0 az indulás helye és a 30 a végállomás, ahol már nem lehet felszállni.)
- a felszállás dátuma és időpontja (ééééhhnn-óópp formátumban, kötőjellel elválasztva a dátum és az idő)
- a kártya egyedi azonosítója (hétjegyű szám), egy utas a járaton legfeljebb egyszer utazik
- a jegy vagy bérlet típusa:
| Azonosító | Megnevezés |
|---|---|
| FEB | Felnőtt bérlet |
| TAB | Tanulóbérlet (kedvezményes) |
| NYB | Nyugdíjas bérlet (kedvezményes) |
| NYP | 65 év feletti bérlet (ingyenes) |
| RVS | Rokkant, vak, siket vagy kísérő bérlet (ingyenes) |
| GYK | Iskolakezdés előtti gyerekbérlet (ingyenes) |
| JGY | Jegy |
- ·a bérlet érvényességi ideje, vagy a felhasználható jegyek száma. A bérlet esetén a dátum ééééhhnn formátumban szerepel, jegy esetén egy 0-10 közötti szám szerepel.
Például:
0 20190326-0700 6572582 RVS 20210101
0 20190326-0700 8808290 JGY 7
0 20190326-0700 1680423 TAB 20190420
12 20190326-0716 3134404 FEB 20190301
12 20190326-0716 9529716 JGY 0
A fenti példában szereplő adatoknál látható, hogy az induló állomáson (0. állomás) 2019. 03. 26-án 7:00-kor a 1680423 kártyaazonosítójú utas tanulóbérlettel szállt fel, amely 2019. 04. 20-ig érvényes. A 12. állomáson 2019. 03. 26-án 7:16-kor a 9529716 kártyaazonosítójú utas jeggyel szállt volna fel, de már elhasználta az összes jegyét (0).
Készítsen programot, amely az utasadat.txt állomány felhasználásával a következő kérdésekre válaszol! A program forráskódját eutazas néven mentse! (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 2. feladat)! A részfeladatok eredményeit a mintán látható formában jelenítse meg! Az ékezetmentes kiírás is elfogadott.
1. Olvassa be és tárolja el az utasadat.txt fájl tartalmát!
- Adja meg, hogy hány utas szeretett volna felszállni a buszra!
3. A közlekedési társaság szeretné, ha a járművőn csak az érvényes jeggyel vagy bérlettel rendelkezők utaznának. Ezért a jegyeket és bérleteket a buszvezető a felszálláskor ellenőrzi. (A bérlet még érvényes a lejárat napján.) Adja meg, hogy hány esetben kellett a buszvezetőnek elutasítania az utas felszállását, mert lejárt a bérlete vagy már nem volt jegye!
Adja meg, hogy melyik megállóban próbált meg felszállni a legtöbb utas! (Több azonos érték esetén a legkisebb sorszámút adja meg!)
A közlekedési társaságnak kimutatást kell készítenie, hogy hányszor utaztak valamilyen kedvezménnyel a járművön. Határozza meg, hogy hány kedvezményes és hány ingyenes utazó szállt fel a buszra! (Csak az érvényes bérlettel rendelkező szállhatott fel a buszra!)
Készítsen függvényt napokszama néven az alábbi algoritmus alapján. Az algoritmus a paraméterként megadott két dátumhoz (év, hónap, nap) megadja a közöttük eltelt napok számát! (A MOD a maradékos osztást, a DIV az egészrészes osztást jelöli.) Az algoritmust a fuggveny.txt fájlban is megtalálja. A függvényt a következő feladat megoldásához felhasználhatja.
Függvény napokszama(e1:egész, h1:egész, n1: egész, e2:egész,
h2: egész, n2: egész): egész
h1 = (h1 + 9) MOD 12
e1 = e1 - h1 DIV 10
d1 = 365*e1 + e1 DIV 4 - e1 DIV 100 + e1 DIV 400 +
(h1*306 + 5) DIV 10 + n1 - 1
h2 = (h2 + 9) MOD 12
e2 = e2 - h2 DIV 10
d2 = 365*e2 + e2 DIV 4 - e2 DIV 100 + e2 DIV 400 +
(h2*306 + 5) DIV 10 + n2 - 1
napokszama:= d2-d1
Függvény vége
- A közlekedési társaság azoknak az utasoknak, akiknek még érvényes, de 3 napon belül lejár a bérlete, figyelmeztetést szeretne küldeni e-mailben. (Például, ha a felszállás időpontja 2019. február 5., és a bérlet érvényessége 2019. február 8., akkor már kap az utas levelet, ha 2019. február 9. az érvényessége, akkor még nem kap levelet.) Válogassa ki és írja a figyelmeztetes.txt állományba ezen utasok kártyaazonosítóját és a bérlet érvényességi idejét (éééé-hh-nn formátumban) szóközzel elválasztva!
Minta a szöveges kimenetek kialakításához:
2. feladat
A buszra 699 utas akart felszállni.
3. feladat
A buszra 21 utas nem szállhatott fel.
4. feladat
A legtöbb utas (39 fő) a 8. megállóban próbált felszállni.
5. feladat
Ingyenesen utazók száma: 133 fő
A kedvezményesen utazók száma: 200 fő
Minta a figyelmeztetes.txt állomány kialakításához:
3023275 2019-03-29
2960983 2019-03-26
1581897 2019-03-27
2761792 2019-03-28
..
#include <iostream>
#include <fstream>
#include <vector>
#include <unordered_map>
#include <sstream>
#include <iomanip>
#include <algorithm>
using namespace std;
struct UtasAdat {
int megallo;
string menetDatum;
string kartyaAzon;
string berletAzon;
string ervDatum;
bool ervenyessegEllenorzes() const {
if (ervDatum.length() <= 2) {
return ervDatum != "0";
}
int menetEv = stoi(menetDatum.substr(0, 4));
int menetHonap = stoi(menetDatum.substr(4, 2));
int menetNap = stoi(menetDatum.substr(6, 2));
int ervEv = stoi(ervDatum.substr(0, 4));
int ervHonap = stoi(ervDatum.substr(4, 2));
int ervNap = stoi(ervDatum.substr(6, 2));
return (ervEv > menetEv) || (ervEv == menetEv && ervHonap > menetHonap) ||
(ervEv == menetEv && ervHonap == menetHonap && ervNap >= menetNap);
}
bool ingyenes() const {
return berletAzon == "NYP" || berletAzon == "RVS" || berletAzon == "GYK";
}
bool kedvezmenyes() const {
return berletAzon == "TAB" || berletAzon == "NYB";
}
int napokSzama(int e1, int h1, int n1, int e2, int h2, int n2) const {
h1 = (h1 + 9) % 12;
e1 -= h1 / 10;
int d1 = 365 * e1 + e1 / 4 - e1 / 100 + e1 / 400 + (h1 * 306 + 5) / 10 + n1 - 1;
h2 = (h2 + 9) % 12;
e2 -= h2 / 10;
int d2 = 365 * e2 + e2 / 4 - e2 / 100 + e2 / 400 + (h2 * 306 + 5) / 10 + n2 - 1;
return d2 - d1;
}
bool figyelmeztetni() const {
if (ervDatum.length() > 2) {
int menetEv = stoi(menetDatum.substr(0, 4));
int menetHonap = stoi(menetDatum.substr(4, 2));
int menetNap = stoi(menetDatum.substr(6, 2));
int ervEv = stoi(ervDatum.substr(0, 4));
int ervHonap = stoi(ervDatum.substr(4, 2));
int ervNap = stoi(ervDatum.substr(6, 2));
int napKulonbseg = napokSzama(menetEv, menetHonap, menetNap, ervEv, ervHonap, ervNap);
return napKulonbseg >= 0 && napKulonbseg <= 3;
}
return false;
}
};
vector<UtasAdat> adatok;
void beolvasas() {
ifstream file("utasadat.txt");
if (!file) {
cerr << "Hiba a fájl megnyitásakor!\n";
return;
}
string sor;
while (getline(file, sor)) {
stringstream ss(sor);
UtasAdat utas;
ss >> utas.megallo >> utas.menetDatum >> utas.kartyaAzon >> utas.berletAzon >> utas.ervDatum;
adatok.push_back(utas);
}
file.close();
}
void feladat2() {
cout << "2. feladat\n";
cout << "A buszra " << adatok.size() << " utas akart felszállni.\n";
}
void feladat3() {
int ervenytelenek = count_if(adatok.begin(), adatok.end(), [](const UtasAdat& utas) {
return !utas.ervenyessegEllenorzes();
});
cout << "3. feladat\n";
cout << "A buszra " << ervenytelenek << " utas nem szállhatott fel.\n";
}
void feladat4() {
unordered_map<int, int> megalloCount;
for (const auto& utas : adatok) {
megalloCount[utas.megallo]++;
}
auto maxMegallo = min_element(megalloCount.begin(), megalloCount.end(), [](const auto& a, const auto& b) {
return a.second == b.second ? a.first < b.first : a.second > b.second;
});
cout << "4. feladat\n";
cout << "A legtöbb utas (" << maxMegallo->second << " fő) a " << maxMegallo->first << ". megállóban próbált felszállni.\n";
}
void feladat5() {
int ingyenesDb = count_if(adatok.begin(), adatok.end(), [](const UtasAdat& utas) {
return utas.ervenyessegEllenorzes() && utas.ingyenes();
});
int kedvezmenyDb = count_if(adatok.begin(), adatok.end(), [](const UtasAdat& utas) {
return utas.ervenyessegEllenorzes() && utas.kedvezmenyes();
});
cout << "5. feladat\n";
cout << "Ingyenesen utazók száma: " << ingyenesDb << " fő\n";
cout << "A kedvezményesen utazók száma: " << kedvezmenyDb << " fő\n";
}
void feladat7() {
ofstream file("figyelmeztetes.txt");
if (!file) {
cerr << "Hiba a fájl írásakor!\n";
return;
}
for (const auto& utas : adatok) {
if (utas.figyElmeztetni()) {
file << utas.kartyaAzon << " "
<< utas.ervDatum.substr(0, 4) << "-"
<< utas.ervDatum.substr(4, 2) << "-"
<< utas.ervDatum.substr(6, 2) << "\n";
}
}
file.close();
}
int main() {
beolvasas();
feladat2();
feladat3();
feladat4();
feladat5();
feladat7();
return 0;
}
2020. május - Menetrend
[szerkesztés]Az ország keleti felében évekkel ezelőtt bevezették az ütemes menetrendet. Ez azt jelenti, hogy a végállomásról minden órában ugyanakkor indulnak a vonatok és menetrend szerint minden állomásra ugyanakkor érkeznek. A jól tervezhető utazás miatt nőtt az utazók száma.
A vonat.txt fájlban rögzítették a Szeged-Budapest vonal néhány vonatának indulási és érkezési adatait. A fájl soraiban öt, tabulátorral elválasztott érték található, négy egész szám és egy karakter. Az első szám a vonatazonosító, a második az állomásazonosító, a harmadik és negyedik egy időpont órája és perce. A karakter pedig azt jelzi, hogy a vonat az adott állomásra érkezik (E) vagy éppen indul (I) a megadott időben.
A sorok száma legfeljebb 1000, a vonatok és az állomások azonosítója pedig egy 0 és 20 közötti egész szám. Az óra értéke 0 és 23, a perc 0 és 59 közötti érték. Az állomások 0-tól távolság, a vonatok 1-től indulási idő szerint növekvően sorszámozottak, minden értéket felvesznek.
A fájl a vonatok tényleges útját rögzíti. Az adatok időrendben szerepelnek, azon belül pedig – az induló állomás kivételével – az érkezés mindig megelőzi az indulást. Tudjuk, hogy minden vonat a 0. állomásról indul, és eléri a végállomást, közben minden állomáson megáll, és egyik vonat sem előzi meg a másikat.
Például:
\;img
Az első sorból leolvasható, hogy a 2. vonat a kiinduló állomásról 6 óra 45 perckor indul. A következő sorban pedig az szerepel, hogy az 1. vonat 6 óra 49 perckor érkezik a 4. állomásra.
Készítsen programot, amely a vonat.txt állomány adatait felhasználva az alábbi kérdésekre válaszol! A program forráskódját mentse menetrend 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: 5. 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 és tárolja el a vonat.txt fájl tartalmát!
2. Írja a képernyőre a fájlban tárolt vonatok és állomások darabszámát – a kezdő és végállomást is beleértve!
3. Határozza meg, hogy melyik állomáson állt legtöbbet vonat! Adja meg a vonat és az állomás azonosítóját, valamint az állás idejét! Ha több ilyen volt, elég csak az egyiket megadnia.
4. Olvassa be egy vonat azonosítóját, valamint egy időpont óra és perc értékét! A későbbi feladatokban használja ezeket!
5. Ezen a vonalon az előírt menetidő 2 óra 22 perc. Írja a képernyőre, hogy a beolvasott azonosítójú vonat hány perccel tért el ettől! Például: „A(z) 5. vonat útja 2 perccel rövidebb volt az előírtnál.”, „A(z) 5. vonat útja pontosan az előírt ideig tartott.” vagy „A(z) 5. vonat útja 3 perccel hosszabb volt az előírtnál.”
6. Írja a haladX.txt fájlba, hogy a beolvasott azonosítójú vonat melyik állomásra mikor érkezett! A fájlnévben az X helyére a beolvasott vonatazonosító kerüljön!
7. Adja meg, hogy a beolvasott időpontban úton lévő, azaz a már elindult, de a végállomást még el nem érő vonatok közül melyik hol tartott! A tesztelés során a következő időpontokra érdemes figyelni: 6:50, 8:45, 9:05, 10:04, 10:20.
Minta a szöveges kimenetek kialakításához:
\;img
A halad2.txt fájl tartalma:
\;img
#include <iostream>
#include <fstream>
#include <vector>
#include <sstream>
#include <algorithm>
#include <iomanip>
using namespace std;
struct Vonat {
int vonat_id;
int allomas_id;
int ido;
char status;
};
int main() {
ifstream input("vonat.txt");
vector<Vonat> vonatok;
string line;
cout << "1. feladat" << endl;
while (getline(input, line)) {
stringstream ss(line);
int vonat, allomas, ora, perc;
char status;
ss >> vonat >> allomas >> ora >> perc >> status;
vonatok.push_back({vonat, allomas, ora * 60 + perc, status});
}
input.close();
cout << "A beolvasas es a szovegfajl lezarasa sikeresen befejezodott." << endl;
cout << "\n2. feladat" << endl;
int allomas_szam = 0, vonat_szam = 0;
for (const auto &v : vonatok) {
allomas_szam = max(allomas_szam, v.allomas_id);
vonat_szam = max(vonat_szam, v.vonat_id);
}
cout << "Az allomasok szama: " << allomas_szam + 1 << endl;
cout << "A vonatok szama: " << vonat_szam << endl;
cout << "\n3. feladat" << endl;
int max_varakozas = 0, max_vonat = 0, max_allomas = 0;
for (int v_id = 1; v_id <= vonat_szam; ++v_id) {
vector<Vonat> akt;
copy_if(vonatok.begin(), vonatok.end(), back_inserter(akt), [v_id](Vonat v){return v.vonat_id == v_id;});
for (size_t i = 1; i < akt.size()-1; i+=2) {
int varakozas = akt[i+1].ido - akt[i].ido;
if (varakozas > max_varakozas) {
max_varakozas = varakozas;
max_vonat = v_id;
max_allomas = akt[i].allomas_id;
}
}
}
cout << "A(z) " << max_vonat << ". vonat a(z) " << max_allomas << ". allomason " << max_varakozas << " percet allt." << endl;
cout << "\n4. feladat" << endl;
int v_azon, ora, perc;
cout << "Adja meg egy vonat azonositojat! "; cin >> v_azon;
cout << "Adjon meg egy idopontot (ora perc)! "; cin >> ora >> perc;
int idopont = ora * 60 + perc;
cout << "\n5. feladat" << endl;
vector<Vonat> akt_vonat;
copy_if(vonatok.begin(), vonatok.end(), back_inserter(akt_vonat), [v_azon](Vonat v){return v.vonat_id == v_azon;});
int eloirt_ido = 142;
int tenyleges_ido = akt_vonat.back().ido - akt_vonat.front().ido;
int elteres = tenyleges_ido - eloirt_ido;
if (elteres < 0)
cout << "A(z) " << v_azon << ". vonat utja " << -elteres << " perccel rovidebb volt az eloirtnal." << endl;
else if (elteres == 0)
cout << "A(z) " << v_azon << ". vonat utja pontosan az eloirt ideig tartott." << endl;
else
cout << "A(z) " << v_azon << ". vonat utja " << elteres << " perccel hosszabb volt az eloirtnal." << endl;
cout << "\n6. feladat" << endl;
ofstream output("halad" + to_string(v_azon) + ".txt");
for (const auto &allomas : akt_vonat) {
if(allomas.line[0] == 'E')
output << allomas.allomas_id << ". allomas: " << allomas.ido / 60 << ":" << allomas.ido % 60 << endl;
}
cout << "A fajl kiirasa sikeresen befejezodott." << endl;
cout << "\n7. feladat" << endl;
for (int id = 1; id <= vonat_szam; ++id) {
vector<Vonat> adat;
copy_if(vonatok.begin(), vonatok.end(), back_inserter(adat), [id](Vonat v){return v.vonat_id == id;});
bool utkozben = false;
for (size_t i = 0; i < adat.size()-1; i+=2) {
if (adat[i].ido <= idopont && adat[i+1].ido > idopont) {
cout << "A(z) " << id << ". vonat a " << adat[i].allomas_id << ". allomason allt." << endl;
break;
}
if (adat[i+1].ido <= idopont && adat[i+2].ido > idopont) {
cout << "A(z) " << id << ". vonat a " << adat[i].allomas_id << ". es a " << adat[i+2].allomas_id << ". allomas kozott jart." << endl;
break;
}
}
}
return 0;
}
2020. május - Meteorológiai jelentés
[szerkesztés]Az ország területén néhány városból rendszeres időközönként időjárás táviratokat küldenek. A távirat egy rövid szöveges üzenet, amely a főbb időjárási információkat tartalmazza. Rendelkezésünkre áll az ország területéről egy adott nap összes távirata.
A tavirathu13.txt szövegállomány egy adott hónap 13. napjának időjárás adatait tartalmazza. Egy távirat adatai egy sorban találhatóak egymástól szóközzel elválasztva. Egy sorban 4 adat szerepel a következőképpen.
| település | szöveg (2 karakter) | A település kétbetűs kódja |
|---|---|---|
| idő | szöveg (óópp formátumban) | A mérés időpontja |
| szélirány és ‑erősség | szöveg (5 karakter) szélirány 3 karakter, ‑erősség 2 karakter | A szél iránya fokban vagy szöveggel és sebessége csomóban megadva |
| hőmérséklet | egész szám (2 karakter) | Mért hőmérséklet (nem negatív) |
A sorok száma legfeljebb 500. Az adatok idő szerint rendezettek
Például:
\;img
A példában látható, hogy 03:15-kor PR településen 320 fokos irányból 9 csomós szél fújt. A hőmérséklet 19 °C volt. Ugyanekkor DC településen változó (VRB) szélirány volt 1 csomós szélsebességgel, a hőmérséklet 21 °C volt.
Készítsen programot, amely a tavirathu13.txt állomány adatait felhasználva az alábbi kérdésekre válaszol! A program forráskódját mentse metjelentes 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.
Az eredmény megjelenítését és a felhasználóval való kommunikációt a feladatot követő minta alapján valósítsa meg!
- Olvassa be és tárolja el a tavirathu13.txt állomány adatait!
- Kérje be a felhasználótól egy város kódját! Adja meg, hogy az adott városból mikor érkezett az utolsó mérési adat! A kiírásban az időpontot óó:pp formátumban jelenítse meg!
- Határozza meg, hogy a nap során mikor mérték a legalacsonyabb és a legmagasabb hőmérsékletet! Jelenítse meg a méréshez kapcsolódó település nevét, az időpontot és a hőmérsékletet! Amennyiben több legnagyobb vagy legkisebb érték van, akkor elég az egyiket kiírnia.
- Határozza meg, azokat a településeket és időpontokat, ahol és amikor a mérések idején szélcsend volt! (A szélcsendet a táviratban 00000 kóddal jelölik.) Ha nem volt ilyen, akkor a „Nem volt szélcsend a mérések idején.” szöveget írja ki! A kiírásnál a település kódját és az időpontot jelenítse meg.
- Határozza meg a települések napi középhőmérsékleti adatát és a hőmérséklet-ingadozását! A kiírásnál a település kódja szerepeljen a sor elején a minta szerint! A kiírásnál csak a megoldott feladatrészre vonatkozó szöveget és értékeket írja ki!
A középhőmérséklet azon hőmérsékleti adatok átlaga, amikor a méréshez tartozó óra értéke 1., 7., 13., 19. Ha egy településen a felsorolt órák valamelyikén nem volt mérés, akkor a kiírásnál az „NA” szót jelenítse meg! Az adott órákhoz tartozó összes adat átlagaként határozza meg a középhőmérsékletet, azaz minden értéket azonos súllyal vegyen figyelembe! A középhőmérsékletet egészre kerekítve jelenítse meg!
A hőmérséklet-ingadozás számításhoz az adott településen a napi legmagasabb és legalacsonyabb hőmérséklet különbségét kell kiszámítania! (Feltételezheti, hogy minden település esetén volt legalább két mérési adat.)
- Hozzon létre településenként egy szöveges állományt, amely első sorában a település kódját tartalmazza! A további sorokban a mérési időpontok és a hozzá tartozó szélerősségek jelenjenek meg! A szélerősséget a minta szerint a számértéknek megfelelő számú kettőskereszttel (#) adja meg! A fájlban az időpontokat és a szélerősséget megjelenítő kettőskereszteket szóközzel válassza el egymástól! A fájl neve X.txt legyen, ahol az X helyére a település kódja kerüljön!
Minta a szöveges kimenetek kialakításához:
\;img
A BC.txt fájl tartalma:
\;img
#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <unordered_map>
#include <algorithm>
#include <cmath>
using namespace std;
// Structure to store weather data
struct WeatherData {
string city;
string time;
string wind;
int temperature;
};
// Global list to store weather data
vector<WeatherData> weatherRecords;
// Function to read data from file
void readData(const string& filename) {
ifstream file(filename);
if (!file) {
cerr << "Error opening file!\n";
exit(1);
}
string line;
while (getline(file, line)) {
istringstream iss(line);
WeatherData data;
iss >> data.city >> data.time >> data.wind >> data.temperature;
weatherRecords.push_back(data);
}
file.close();
}
// Function to get the last measurement time for a city
string getLastMeasurement(const string& city) {
for (int i = weatherRecords.size() - 1; i >= 0; i--) {
if (weatherRecords[i].city == city) {
return weatherRecords[i].time.insert(2, ":"); // Format as hh:mm
}
}
return "N/A";
}
// Function to get the min/max temperature records
void getMinMaxTemperature() {
auto minTemp = min_element(weatherRecords.begin(), weatherRecords.end(),
[](const WeatherData& a, const WeatherData& b) { return a.temperature < b.temperature; });
auto maxTemp = max_element(weatherRecords.begin(), weatherRecords.end(),
[](const WeatherData& a, const WeatherData& b) { return a.temperature > b.temperature; });
cout << "3. feladat\n";
cout << "A legalacsonyabb hőmérséklet: " << minTemp->city << " "
<< minTemp->time.insert(2, ":") << " " << minTemp->temperature << " fok.\n";
cout << "A legmagasabb hőmérséklet: " << maxTemp->city << " "
<< maxTemp->time.insert(2, ":") << " " << maxTemp->temperature << " fok.\n";
}
// Function to find windless records (wind == "00000")
void findWindlessRecords() {
cout << "4. feladat\n";
bool found = false;
for (const auto& record : weatherRecords) {
if (record.wind == "00000") {
cout << record.city << " " << record.time.insert(2, ":") << endl;
found = true;
}
}
if (!found) {
cout << "Nem volt szélcsend a mérések idején.\n";
}
}
// Function to calculate average temperature for specific hours
int calculateAvgTemperature(const string& city) {
vector<int> temps;
vector<string> targetHours = {"01", "07", "13", "19"};
for (const auto& record : weatherRecords) {
if (record.city == city) {
string hour = record.time.substr(0, 2);
if (find(targetHours.begin(), targetHours.end(), hour) != targetHours.end()) {
temps.push_back(record.temperature);
}
}
}
if (temps.empty()) return -1; // NA case
int sum = accumulate(temps.begin(), temps.end(), 0);
return round(static_cast<double>(sum) / temps.size());
}
// Function to calculate temperature fluctuation (max - min)
int temperatureFluctuation(const string& city) {
vector<int> temps;
for (const auto& record : weatherRecords) {
if (record.city == city) {
temps.push_back(record.temperature);
}
}
return *max_element(temps.begin(), temps.end()) - *min_element(temps.begin(), temps.end());
}
// Function to generate output for temperature statistics
void generateTemperatureStats() {
cout << "5. feladat\n";
unordered_map<string, bool> cityProcessed;
for (const auto& record : weatherRecords) {
if (!cityProcessed[record.city]) {
cityProcessed[record.city] = true;
int avgTemp = calculateAvgTemperature(record.city);
string avgTempStr = (avgTemp == -1) ? "NA" : to_string(avgTemp);
cout << record.city << " Középhőmérséklet: " << avgTempStr
<< "; Hőmérséklet-ingadozás: " << temperatureFluctuation(record.city) << endl;
}
}
}
// Function to create wind strength files per city
void createWindStrengthFiles() {
cout << "6. feladat\n";
unordered_map<string, ofstream> cityFiles;
for (const auto& record : weatherRecords) {
if (cityFiles.find(record.city) == cityFiles.end()) {
cityFiles[record.city].open(record.city + ".txt");
cityFiles[record.city] << record.city << endl;
}
int windStrength = stoi(record.wind.substr(3, 2));
cityFiles[record.city] << record.time.insert(2, ":") << " " << string(windStrength, '#') << endl;
}
for (auto& file : cityFiles) {
file.second.close();
}
cout << "A fájlok elkészültek.\n";
}
// Main function
int main() {
// 1. Read file data
readData("tavirathu13.txt");
// 2. Get last measurement for a city
cout << "2. feladat\nAdja meg egy település kódját! Város: ";
string city;
cin >> city;
cout << "Az utolsó mérési adat a megadott településről " << getLastMeasurement(city) << "-kor érkezett.\n";
// 3. Min/max temperature
getMinMaxTemperature();
// 4. Windless records
findWindlessRecords();
// 5. Temperature statistics
generateTemperatureStats();
// 6. Create wind strength files
createWindStrengthFiles();
return 0;
}
2020. október - Sorozatok
[szerkesztés]Sok olyan sorozatrajongó van, aki folyamatosan követi a kedvelt sorozatait. Egy, az angol nyelvű sorozatokért rajongó személy feljegyzést készített egy nyolc hónapos időszak kedvenc sorozatairól.
A lista.txt fájl a rajongó által kedvelt sorozatok adásba kerülésének dátumát, a sorozat angol címét, az évadot és az epizód számát, az epizód hosszát percben és egy jelzést tartalmaz, hogy a lista készítője megnézte-e már azt az epizódot. Ezek az adatok egymás után külön sorokban szerepelnek. A fájlban biztosan 400-nál kevesebb epizódról van adat, epizódonként 5 sorban.
Például:
\;img
- A példában látható, hogy a Puzzles című sorozat 3. évadának 10. epizódja 2018. 01. 19-én került adásba. Az epizód 43 perces, és még nem nézte meg a lista készítője. A dátumokat mindig „éééé.hh.nn” formátumban rögzítették. Vannak olyan sorozatrészek, amelyeknek a lista rögzítésekor még nem tudták az adásba kerülésük idejét. Ezeknél a dátum helyett mindig az „NI” rövidítés szerepel.
- Az évad jelzése vezető nullák nélkül történik, az epizód számát pedig mindig két számjeggyel rögzítették. Az évad és az epizód számát egy „x” választja el egymástól.
- Az egyes sorozatok epizódjai mindig ugyanolyan hosszúak.
- Az epizóddal kapcsolatos utolsó adat értéke „0” vagy „1”. Az 1-es számjegy jelöli, hogy az adott részt már megtekintette a lista készítője, a 0 pedig azt, hogy még nem látta.
Készítsen programot a lista.txt állomány adatainak feldolgozására! A program forráskódját mentse sorozatok 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 2. 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.
- Olvassa be és tárolja el a lista.txt fájl tartalmát!
- Írassa ki a képernyőre, hogy hány olyan epizód adatait tartalmazza a fájl, amelynek ismert az adásba kerülési dátuma!
- Határozza meg, hogy a fájlban lévő epizódok hány százalékát látta már a listát rögzítő személy! A százalékértéket a minta szerint, két tizedesjeggyel jelenítse meg a képernyőn!
- Számítsa ki, hogy összesen mennyi időt töltött a személy az epizódok megnézésével! Az eredményt a minta szerint nap, óra, perc formában adja meg!
- Kérjen be a felhasználótól egy dátumot „éééé.hh.nn” formában! Határozza meg, hogy az adott dátumig megjelent epizódokból melyeket nem látta még! Az aznapi epizódokat is számolja bele! A feltételnek megfelelő epizódok esetén írja a képernyőre tabulátorral elválasztva az évad- és az epizódszámot, valamint a sorozat címét a minta szerint!
- Készítse el az alábbi algoritmus alapján a hét napját meghatározó függvényt! A függvény neve Hetnapja legyen! A függvény az év, hónap és nap megadása után szöveges eredményként visszaadja, hogy az adott nap a hét melyik napja volt. (Az a és b egész számok maradékos osztása esetén az a div b kifejezés adja meg a hányadost, az a mod b pedig a maradékot, például 17 div 7 = 2 és 17 mod 7 = 3.)
- Kérjen be a felhasználótól egy napot az előző feladatban látható rövidített alakban! A napokat egy (h, k, p, v), kettő (cs), vagy három (sze, szo) karakterrel adja meg! Határozza meg, hogy a fájlban lévő sorozatok közül melyike(ke)t vetítik az adott napon! A sorozatok nevét a minta szerint jelenítse meg a képernyőn! Ha az adott napon egy sorozatot sem adtak adásba, akkor „Az adott napon nem kerül adásba sorozat.” üzenetet jelenítse meg!
- Határozza meg sorozatonként az epizódok összesített vetítési idejét és az epizódok számát! A számításnál vegye figyelembe a vetítési dátummal nem rendelkező epizódokat is! A megoldás során felhasználhatja, hogy egy sorozat epizódjainak adatai egymást követik a forrásállományban. A listát írja ki a summa.txt fájlba! A fájl egy sorában a sorozat címe, az adott sorozatra vonatkozó összesített vetítési idő percben és az epizódok száma szerepeljen szóközzel elválasztva!
Minta a szöveges kimenetek kialakításához:
\;img
Minta a summa.txt fájl kialakításához:
\;img
#include <iostream>
#include <fstream>
#include <vector>
#include <sstream>
#include <map>
#include <iomanip>
#include <algorithm>
using namespace std;
struct SorozatInfo {
string datum;
string cim;
string resz;
int hossz;
bool latta;
};
vector<SorozatInfo> sorozatok;
void Beolvasas(const string& filename) {
ifstream file(filename);
if (!file) {
cerr << "Hiba: Nem lehet megnyitni a fájlt!" << endl;
exit(1);
}
while (!file.eof()) {
SorozatInfo sor;
getline(file, sor.datum);
getline(file, sor.cim);
getline(file, sor.resz);
file >> sor.hossz;
int latta;
file >> latta;
file.ignore();
sor.latta = (latta == 1);
sorozatok.push_back(sor);
}
file.close();
}
void Feladat2() {
int db = count_if(sorozatok.begin(), sorozatok.end(), [](const SorozatInfo& s) {
return s.datum != "NI";
});
cout << "2. feladat" << endl;
cout << "A listaban " << db << " db vetitesi datummal rendelkezo epizod van." << endl;
}
void Feladat3() {
int latott = count_if(sorozatok.begin(), sorozatok.end(), [](const SorozatInfo& s) {
return s.latta;
});
double szazalek = (double)latott / sorozatok.size() * 100;
cout << "\n3. feladat" << endl;
cout << "A listaban levo epizodok " << fixed << setprecision(2) << szazalek << "%-at latta." << endl;
}
void Feladat4() {
int osszido = 0;
for (const auto& sor : sorozatok) {
if (sor.latta) osszido += sor.hossz;
}
cout << "\n4. feladat" << endl;
cout << "Sorozatnezessel " << osszido / 1440 << " napot "
<< (osszido % 1440) / 60 << " orat es "
<< osszido % 60 << " percet toltott." << endl;
}
void Feladat5() {
cout << "\n5. feladat - Adjon meg egy datumot (eeee.hh.nn): ";
string inputDatum;
cin >> inputDatum;
cout << "Nem latott epizodok:" << endl;
for (const auto& sor : sorozatok) {
if (sor.datum != "NI" && sor.datum <= inputDatum && !sor.latta) {
cout << sor.resz << "\t" << sor.cim << endl;
}
}
}
void Feladat8(const string& filename) {
ofstream file(filename);
if (!file) {
cerr << "Hiba: Nem lehet megnyitni a fajlt!" << endl;
return;
}
map<string, pair<int, int>> sorozatOsszesites;
for (const auto& sor : sorozatok) {
sorozatOsszesites[sor.cim].first += sor.hossz;
sorozatOsszesites[sor.cim].second++;
}
for (const auto& [cim, adat] : sorozatOsszesites) {
file << cim << " " << adat.first << " " << adat.second << endl;
}
file.close();
}
int main() {
Beolvasas("lista.txt");
Feladat2();
Feladat3();
Feladat4();
Feladat5();
Feladat8("summa.txt");
return 0;
}
2021. május - Gödrök
[szerkesztés]Egy teljesen sík terepen a talaj olyan anyagból van, ami nem ereszti át a vizet. Ezen a területen egy egyenes mentén munkagépekkel 10 méter széles csatornát építenek. A munka még nem készült el, ezért a csatorna mélysége nem állandó, helyenként a felszín is érintetlen. A már elkészült résszel, mint különálló gödrök sorozatával foglalkozik a feladat. Az egyszerűbb kezelés érdekében a gödröket úgy tekintjük, hogy oldalfaluk függőleges, teljes szélességben azonos mélységű, így a keresztmetszeti kép jól leírja a terepviszonyokat.
A melyseg.txt fájlban méterenként rögzítették, hogy azon a szakaszon milyen mélyen van a gödör alja. Minden sor egy-egy egész számot tartalmaz, amely a mélység értékét mutatja – szintén méterben. A fájl legfeljebb 2000 számot tartalmaz, értékük legfeljebb 30 lehet. Tudjuk, hogy az első és az utolsó méteren sértetlen a felszín, tehát ott biztosan a 0 szám áll. ### Például:
| 0 | 0 | 0 | 0 | 0 | 0 | 2 | 2 | 2 | 2 | 4 | 4 | 3 | 2 | 2 | 3 | 3 | 4 | 4 | 3 | 2 | 2 | 0 | 0 | 0 | 2 | 2 | 2 | 0 | 0 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| █ | █ | █ | █ | █ | █ | █ | █ | █ | █ | █ | █ | █ | █ | █ | █ | █ | █ | █ | |||||||||||
| █ | █ | █ | █ | █ | █ | █ | █ | █ | █ | █ | █ | █ | █ | █ | █ | █ | █ | █ | |||||||||||
| █ | █ | █ | █ | █ | █ | █ | █ | ||||||||||||||||||||||
| █ | █ | █ | █ |
A fenti példában látható keresztmetszeti képen a melyseg.txt bemeneti fájl tartalmának a kezdete látható. Az egyszerűbb szemléltetés miatt a forrásfájlban külön sorokban szereplő értékeket itt az ábrán egymás mellett szerepeltetjük. Leolvasható, hogy az első méteren 0 a mélység. Az első gödör a 7. méteren kezdődik. Az első gödör 16 méter hosszan tart, legnagyobb mélysége 4 méter, térfogata 440 m3. A második gödör a 26. méternél kezdődik, 3 méter hosszan tart, térfogata 60 m3.
Készítsen programot, amely a melyseg.txt állományt felhasználva az alábbi kérdésekre válaszol! A program forráskódját mentse godor 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: 2. 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.
- Olvassa be és tárolja el a melyseg.txt fájl tartalmát! Írja ki a képernyőre, hogy az adatforrás hány adatot tartalmaz!
- Olvasson be egy távolságértéket, majd írja a képernyőre, hogy milyen mélyen van a gödör alja azon a helyen! Ezt a távolságértéket használja majd a 6. feladat megoldása során is!
- Határozza meg, hogy a felszín hány százaléka maradt érintetlen és jelenítse meg 2 tizedes pontossággal!
- Írja ki a godrok.txt fájlba a gödrök leírását, azaz azokat a számsorokat, amelyek egy-egy gödör méterenkénti mélységét adják meg! Minden gödör leírása külön sorba kerüljön! Az állomány pontosan a gödrök számával egyező számú sort tartalmazzon!
A godrok.txt fájl első két sorának tartalma:
2 2 2 2 4 4 3 2 2 3 3 4 4 3 2 2 2 2 2 ...
Határozza meg a gödrök számát és írja a képernyőre!
Ha a 2. feladatban beolvasott helyen nincs gödör, akkor „
Az adott helyen nincs gödör.” üzenetet jelenítse meg, ha ott gödör található, akkor határozza meg, hogy a.) mi a gödör kezdő és végpontja! A meghatározott értékeket írja a képernyőre! (Ha nem tudja meghatározni, használja a további részfeladatoknál a 7 és 22 értéket, mint a kezdő és a végpont helyét) b.) a legmélyebb pontja felé mindkét irányból folyamatosan mélyül-e! Azaz a gödör az egyik szélétől monoton mélyül egy pontig, és onnantól monoton emelkedik a másik széléig. Az eredménytől függően írja ki a képernyőre a „Nem mélyül folyamatosan.” vagy a „Folyamatosan mélyül.” mondatot! c.) mekkora a legnagyobb mélysége! A meghatározott értéket írja a képernyőre! d.) mekkora a térfogata, ha szélessége minden helyen 10 méternyi! A meghatározott értéket írja a képernyőre! e.) a félkész csatorna esőben jelentős mennyiségű vizet fogad be. Egy gödör annyi vizet képes befogadni anélkül, hogy egy nagyobb szélvihar hatására se öntsön ki, amennyi esetén a víz felszíne legalább 1 méter mélyen van a külső felszínhez képest. Írja a képernyőre ezt a vízmennyiséget!
- Minta a szöveges kimenetek kialakításához
1. feladat A fájl adatainak száma: 694 2. feladat Adjon meg egy távolságértéket! 9 Ezen a helyen a felszín 2 méter mélyen van. 3. feladat Az érintetlen terület aránya 10.09%. 5. feladat A gödrök száma: 22 6. feladat a) A gödör kezdete: 7 méter, a gödör vége: 22 méter. b) Nem mélyül folyamatosan. c) A legnagyobb mélysége 4 méter. d) A térfogata 440 m^3. e) A vízmennyiség 280 m^3.
#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <numeric>
using namespace std;
vector<int> read_depths(const string &filename) {
ifstream file(filename);
vector<int> depths;
int depth;
while (file >> depth) {
depths.push_back(depth);
}
return depths;
}
double count_untouched_surface(const vector<int> &depths) {
int untouched = count(depths.begin(), depths.end(), 0);
return (static_cast<double>(untouched) / depths.size()) * 100;
}
vector<vector<int>> find_pits(const vector<int> &depths) {
vector<vector<int>> pits;
vector<int> current_pit;
for (int depth : depths) {
if (depth > 0) {
current_pit.push_back(depth);
} else if (!current_pit.empty()) {
pits.push_back(current_pit);
current_pit.clear();
}
}
return pits;
}
void save_pits_to_file(const vector<vector<int>> &pits, const string &filename) {
ofstream file(filename);
for (const auto &pit : pits) {
for (int depth : pit) {
file << depth << " ";
}
file << endl;
}
}
pair<int, int> find_pit_boundaries(const vector<int> &depths, int position) {
if (depths[position] == 0) {
return {-1, -1};
}
int start = position;
while (start > 0 && depths[start - 1] > 0) {
--start;
}
int end = position;
while (end < depths.size() - 1 && depths[end + 1] > 0) {
++end;
}
return {start + 1, end + 1};
}
bool is_monotonic(const vector<int> &depths, int start, int end) {
bool increasing = true, decreasing = true;
for (int i = start; i < end - 1; ++i) {
if (depths[i] > depths[i + 1]) increasing = false;
}
for (int i = start + 1; i < end; ++i) {
if (depths[i] < depths[i - 1]) decreasing = false;
}
return increasing && decreasing;
}
int max_depth(const vector<int> &depths, int start, int end) {
return *max_element(depths.begin() + start - 1, depths.begin() + end);
}
int calculate_volume(const vector<int> &depths, int start, int end) {
return accumulate(depths.begin() + start - 1, depths.begin() + end, 0) * 10;
}
int calculate_water_capacity(const vector<int> &depths, int start, int end) {
int capacity = 0;
for (int i = start - 1; i < end; ++i) {
capacity += max(0, depths[i] - 1);
}
return capacity * 10;
}
int main() {
string filename = "melyseg.txt";
vector<int> depths = read_depths(filename);
cout << "1. feladat" << endl;
cout << "A fájl adatainak száma: " << depths.size() << endl;
cout << "2. feladat" << endl;
int position;
cout << "Adjon meg egy távolságértéket! ";
cin >> position;
cout << "Ezen a helyen a felszín " << depths[position - 1] << " méter mélyen van." << endl;
cout << "3. feladat" << endl;
cout << "Az érintetlen terület aránya " << fixed << count_untouched_surface(depths) << "%." << endl;
vector<vector<int>> pits = find_pits(depths);
save_pits_to_file(pits, "godrok.txt");
cout << "5. feladat" << endl;
cout << "A gödrök száma: " << pits.size() << endl;
cout << "6. feladat" << endl;
auto [start, end] = find_pit_boundaries(depths, position - 1);
if (start == -1) {
cout << "Az adott helyen nincs gödör." << endl;
} else {
cout << "a)" << endl;
cout << "A gödör kezdete: " << start << " méter, a gödör vége: " << end << " méter." << endl;
cout << "b)" << endl;
cout << (is_monotonic(depths, start - 1, end) ? "Folyamatosan mélyül." : "Nem mélyül folyamatosan.") << endl;
cout << "c)" << endl;
cout << "A legnagyobb mélysége " << max_depth(depths, start, end) << " méter." << endl;
cout << "d)" << endl;
cout << "A térfogata " << calculate_volume(depths, start, end) << " m^3." << endl;
cout << "e)" << endl;
cout << "A vízmennyiség " << calculate_water_capacity(depths, start, end) << " m^3." << endl;
}
return 0;
}
2021. május - Bányató
[szerkesztés]A bányató egy elhagyott külszíni bánya, amely egy idő után megtelik vízzel. Ebben a feladatban egy bányató mélységét kell elemeznie.
A tó felszínét sakktáblaszerűen 1 m oldalhosszúságú négyzetekre bontották, és minden ilyen négyzetben megmérték a tó mélységét. A mérést deciméter pontossággal végezték. A szárazföldet a 0 érték jelzi. A mérési adatokat egy téglalap alakú táblázatban rögzítették, például:
| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 2 | 0 | 0 | 0 | 0 | 0 | 3 | 0 | 0 | 0 | 0 | 0 | 8 | 10 | 10 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 3 | 0 | 0 | 0 | 0 | 0 | 19 | 10 | 0 | 11 | 16 | 18 | 10 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 4 | 0 | 0 | 0 | 9 | 17 | 35 | 5 | 11 | 11 | 22 | 18 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 5 | 0 | 0 | 0 | 19 | 75 | 64 | 53 | 61 | 25 | 0 | 10 | 4 | 11 | 17 | 17 | 0 | 27 | 61 | 13 | 0 | 0 | 0 | 0 | 0 | 0 |
| 6 | 0 | 2 | 0 | 18 | 75 | 58 | 64 | 25 | 49 | 0 | 0 | 34 | 74 | 73 | 67 | 20 | 55 | 75 | 3 | 15 | 2 | 10 | 0 | 0 | 0 |
| 7 | 0 | 18 | 25 | 23 | 71 | 32 | 34 | 62 | 24 | 0 | 0 | 43 | 55 | 58 | 51 | 28 | 75 | 58 | 2 | 22 | 35 | 9 | 3 | 10 | 0 |
| 8 | 0 | 6 | 12 | 35 | 76 | 47 | 51 | 62 | 0 | 0 | 0 | 32 | 65 | 40 | 84 | 51 | 40 | 40 | 47 | 65 | 0 | 0 | 26 | 21 | 0 |
| 9 | 0 | 6 | 29 | 40 | 76 | 43 | 73 | 88 | 0 | 0 | 0 | 33 | 88 | 76 | 73 | 38 | 56 | 28 | 4 | 86 | 80 | 0 | 15 | 16 | 0 |
| 10 | 0 | 0 | 14 | 31 | 24 | 42 | 52 | 63 | 42 | 27 | 0 | 50 | 50 | 42 | 67 | 84 | 51 | 53 | 33 | 46 | 0 | 0 | 7 | 3 | 0 |
| 11 | 0 | 13 | 29 | 27 | 80 | 34 | 38 | 57 | 68 | 72 | 26 | 55 | 22 | 81 | 76 | 60 | 34 | 51 | 4 | 13 | 0 | 0 | 0 | 0 | 0 |
| 12 | 0 | 12 | 26 | 27 | 65 | 33 | 77 | 49 | 73 | 38 | 89 | 35 | 80 | 36 | 76 | 77 | 88 | 79 | 18 | 13 | 18 | 10 | 0 | 0 | 0 |
| 13 | 0 | 12 | 25 | 37 | 59 | 65 | 20 | 57 | 33 | 48 | 84 | 75 | 48 | 33 | 34 | 92 | 86 | 97 | 89 | 93 | 82 | 86 | 3 | 11 | 0 |
| 14 | 0 | 0 | 0 | 35 | 53 | 59 | 38 | 37 | 69 | 36 | 54 | 52 | 55 | 36 | 36 | 96 | 81 | 92 | 95 | 98 | 82 | 90 | 0 | 0 | 0 |
| 15 | 0 | 0 | 6 | 56 | 62 | 47 | 47 | 60 | 58 | 25 | 20 | 38 | 64 | 47 | 29 | 40 | 44 | 23 | 25 | 0 | 0 | 0 | 0 | 0 | 0 |
| 16 | 0 | 0 | 0 | 36 | 54 | 21 | 62 | 59 | 26 | 34 | 49 | 40 | 63 | 36 | 63 | 38 | 52 | 67 | 60 | 52 | 34 | 27 | 2 | 0 | 0 |
| 17 | 0 | 0 | 2 | 44 | 46 | 41 | 26 | 42 | 46 | 34 | 29 | 33 | 60 | 16 | 63 | 67 | 18 | 62 | 63 | 51 | 35 | 12 | 18 | 0 | 0 |
| 18 | 0 | 4 | 12 | 31 | 25 | 24 | 25 | 22 | 57 | 67 | 0 | 44 | 40 | 36 | 45 | 58 | 51 | 29 | 45 | 12 | 46 | 37 | 13 | 0 | 0 |
| 19 | 0 | 5 | 19 | 10 | 58 | 40 | 42 | 41 | 20 | 41 | 0 | 13 | 19 | 19 | 27 | 24 | 53 | 54 | 27 | 29 | 55 | 0 | 0 | 0 | 0 |
| 20 | 0 | 4 | 16 | 25 | 35 | 39 | 52 | 74 | 52 | 66 | 0 | 0 | 40 | 53 | 46 | 23 | 36 | 23 | 26 | 22 | 30 | 0 | 0 | 0 | 0 |
| 21 | 0 | 19 | 10 | 24 | 35 | 68 | 76 | 72 | 44 | 35 | 0 | 0 | 16 | 46 | 21 | 35 | 59 | 56 | 38 | 56 | 27 | 22 | 1 | 0 | 0 |
| 22 | 0 | 0 | 0 | 16 | 36 | 88 | 58 | 83 | 33 | 27 | 0 | 0 | 0 | 45 | 58 | 25 | 25 | 68 | 25 | 0 | 46 | 52 | 8 | 0 | 0 |
| 23 | 0 | 0 | 0 | 17 | 38 | 80 | 55 | 67 | 96 | 77 | 0 | 0 | 0 | 0 | 61 | 76 | 52 | 36 | 25 | 0 | 30 | 21 | 9 | 0 | 0 |
| 24 | 0 | 18 | 15 | 22 | 30 | 73 | 56 | 64 | 54 | 67 | 96 | 84 | 62 | 73 | 68 | 68 | 72 | 66 | 49 | 0 | 0 | 0 | 0 | 0 | 0 |
| 25 | 0 | 9 | 26 | 32 | 25 | 68 | 66 | 66 | 76 | 62 | 84 | 82 | 67 | 53 | 83 | 90 | 63 | 57 | 48 | 0 | 0 | 0 | 0 | 0 | 0 |
| 26 | 0 | 0 | 0 | 0 | 35 | 88 | 68 | 73 | 67 | 88 | 98 | 75 | 74 | 70 | 72 | 72 | 75 | 79 | 26 | 0 | 0 | 0 | 0 | 0 | 0 |
| 27 | 0 | 11 | 0 | 0 | 29 | 74 | 62 | 75 | 71 | 72 | 52 | 75 | 67 | 65 | 88 | 58 | 76 | 59 | 69 | 0 | 0 | 23 | 0 | 0 | 0 |
| 28 | 0 | 11 | 21 | 39 | 20 | 94 | 96 | 94 | 67 | 80 | 70 | 66 | 61 | 77 | 62 | 74 | 94 | 67 | 24 | 0 | 0 | 36 | 0 | 0 | 0 |
| 29 | 0 | 12 | 18 | 23 | 22 | 39 | 52 | 77 | 83 | 67 | 97 | 68 | 67 | 56 | 20 | 26 | 6 | 0 | 0 | 0 | 0 | 29 | 0 | 0 | 0 |
| 30 | 0 | 0 | 18 | 35 | 32 | 45 | 83 | 58 | 80 | 57 | 84 | 86 | 68 | 60 | 49 | 25 | 20 | 5 | 11 | 26 | 14 | 11 | 0 | 0 | 0 |
| 31 | 0 | 0 | 5 | 36 | 46 | 12 | 97 | 63 | 50 | 92 | 50 | 21 | 29 | 53 | 46 | 31 | 26 | 35 | 2 | 0 | 5 | 0 | 0 | 0 | 0 |
| 32 | 0 | 0 | 12 | 8 | 59 | 45 | 76 | 83 | 68 | 81 | 29 | 18 | 41 | 64 | 56 | 98 | 45 | 8 | 8 | 0 | 0 | 0 | 0 | 0 | 0 |
| 33 | 0 | 0 | 0 | 15 | 42 | 28 | 82 | 69 | 64 | 85 | 45 | 52 | 45 | 62 | 45 | 31 | 19 | 6 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 34 | 0 | 0 | 0 | 8 | 55 | 46 | 61 | 54 | 79 | 69 | 49 | 48 | 34 | 33 | 37 | 13 | 33 | 29 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 35 | 0 | 0 | 0 | 7 | 50 | 24 | 25 | 45 | 40 | 35 | 50 | 41 | 35 | 14 | 0 | 20 | 35 | 25 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 36 | 0 | 0 | 0 | 0 | 0 | 0 | 10 | 43 | 21 | 23 | 50 | 31 | 54 | 13 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 37 | 0 | 0 | 0 | 3 | 9 | 4 | 19 | 69 | 59 | 28 | 53 | 57 | 33 | 11 | 28 | 40 | 16 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 38 | 0 | 0 | 12 | 39 | 44 | 38 | 42 | 58 | 19 | 23 | 48 | 61 | 15 | 51 | 11 | 24 | 18 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 39 | 0 | 0 | 16 | 33 | 37 | 43 | 43 | 2 | 10 | 32 | 2 | 46 | 31 | 41 | 39 | 9 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 40 | 0 | 0 | 0 | 20 | 29 | 23 | 11 | 12 | 23 | 37 | 4 | 32 | 25 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 41 | 0 | 0 | 0 | 10 | 17 | 8 | 0 | 1 | 0 | 22 | 0 | 28 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 42 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
Az ábrán az első oszlop, illetve az első sor a mérési adatok koordinátáját adja meg, például 12. sor 6. oszlopában lévő mérési eredmény 33 dm. (A tó medrét a nemnulla értékek jelzik.)
Rendelkezésére áll a melyseg.txt nevű adatfájl, amelynek első két sorában az adatokat tartalmazó táblázat sorainak majd oszlopainak száma található. A fájlban ezt a mérési adatok követik soronként, az adatokat szóköz választja el egymástól. A fájlban a sorok és oszlopok azonosítói nem szerepelnek. Például egy 42 sorból és 25 oszlopból álló táblázat esetén az első 4 sor adatai a fájlban:
42 25 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 3 0 0 0 0 0 8 10 10 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 19 10 0 11 16 18 10 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 9 17 35 5 11 11 22 18 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ...
Készítsen programot, amely az állomány adatait felhasználva az alábbi kérdésekre válaszol! A program forráskódját mentse banyato néven! A megoldás során felhasználhatja, hogy a fájl legfeljebb 99 sort és legfeljebb 99 oszlopot tartalmaz. A program megírásakor a felhasználó által megadott adatok helyességét, érvényességét nem kell ellenőriznie, és feltételezheti, hogy a rendelkezésre álló adatok a leírtaknak megfelelnek.
A képernyőre írást igénylő részfeladatok esetén – a mintához tartalmában hasonlóan – írja ki a képernyőre a feladat sorszámát (például: 3. feladat), és utaljon a kiírt tartalomra is! Ha a felhasználótól kér be adatot, jelenítse meg a képernyőn, hogy milyen értéket vár! Mindkét esetben az ékezetmentes kiírás is elfogadott.
- Olvassa be és tárolja el a melyseg.txt állomány adatait, és annak felhasználásával oldja meg a következő feladatokat!
- Kérje be egy mérési eredmény sor- és oszlopazonosítóját, majd írassa ki az adott helyen mért adatot a képernyőre! (A sorok és oszlopok számozása kezdődjön 1-gyel!)
- Határozza meg a tó felszínének területét, valamint a tó átlagos mélységét! Írassa ki a két eredményt a mintának megfelelően a képernyőre! A tó átlagos mélysége méterben kifejezve, két tizedesjegy pontossággal jelenjen meg!
- Mekkora a tó legnagyobb mélysége, és hol a legmélyebb a tó? Jelenítse meg a választ a képernyőn! A legmélyebb pont koordinátáit a mintának megfelelően ( sor ; oszlop ) formában írassa ki! Ha több ilyen mérési eredmény is van, mindegyik koordinátapárja jelenjen meg!
- Milyen hosszú a tó partvonala (nemnulla és nulla értékek által határot vízszintes és függőleges vonalak száma)? A partvonalhoz vegye hozzá a tóban lévő szigetek kerületét is! Írassa ki az eredményt a mintának megfelelően a képernyőre! (A megoldás során felhasználhatja, hogy a táblázat első és utolsó sorában és oszlopában minden adat 0.)
- Kérje be a felhasználótól egy oszlop azonosítóját, és szemléltesse a diagram.txt szöveges állományban „sávdiagramon” a tó mélységét az adott oszlopban a következő módon! A sor elején jelenjen meg a mérési adat sorának azonosítója pontosan két számjeggyel, majd tegyen egymás mellé annyi csillagot (*), ahány méter az adott helyen a tó mélysége! A mérési adatokat a matematika szabályainak megfelelően kerekítse!
- Példa a szöveges kimenetek kialakításához (a tizedesjel az alkalmazott fejlesztői környezettől függően eltérhet)
2. feladat A mérés sorának azonosítója = 12 A mérés oszlopának azonosítója = 6 A mért mélység az adott helyen 33 dm 3. feladat A tó felszíne: 646 m2, átlagos mélysége: 4,28 m 4. feladat A tó legnagyobb mélysége: 98 dm A legmélyebb helyek sor-oszlop koordinátái: (14; 20) (26; 11) (32; 16) 5. feladat A tó partvonala 270 m hosszú 6. feladat A vizsgált szelvény oszlopának azonosítója = 6
- Példa a diagram. txt szöveges állomány tartalmára
01 02 03** 04**** 05****** 06****** 07*** 08***** ...
#include <iostream>
#include <fstream>
#include <vector>
#include <iomanip>
using namespace std;
vector<vector<int>> read_data(const string& filename, int &rows, int &cols) {
ifstream file(filename);
file >> rows >> cols;
vector<vector<int>> depths(rows, vector<int>(cols));
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
file >> depths[i][j];
}
}
return depths;
}
int get_depth(const vector<vector<int>>& depths, int row, int col) {
return depths[row - 1][col - 1];
}
pair<int, double> lake_surface_and_avg(const vector<vector<int>>& depths) {
int total_depth = 0, lake_surface = 0;
for (const auto& row : depths) {
for (int cell : row) {
if (cell > 0) {
total_depth += cell;
lake_surface++;
}
}
}
double avg_depth = lake_surface > 0 ? total_depth / (10.0 * lake_surface) : 0;
return {lake_surface, avg_depth};
}
pair<int, vector<pair<int, int>>> max_depth_locations(const vector<vector<int>>& depths) {
int max_depth = 0;
vector<pair<int, int>> locations;
for (int i = 0; i < depths.size(); i++) {
for (int j = 0; j < depths[i].size(); j++) {
if (depths[i][j] > max_depth) {
max_depth = depths[i][j];
locations.clear();
locations.emplace_back(i + 1, j + 1);
} else if (depths[i][j] == max_depth) {
locations.emplace_back(i + 1, j + 1);
}
}
}
return {max_depth, locations};
}
int coastline_length(const vector<vector<int>>& depths, int rows, int cols) {
int coast = 0;
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
if (depths[i][j] > 0) {
if (i == 0 || depths[i-1][j] == 0) coast++;
if (i == rows-1 || depths[i+1][j] == 0) coast++;
if (j == 0 || depths[i][j-1] == 0) coast++;
if (j == cols-1 || depths[i][j+1] == 0) coast++;
}
}
}
return coast;
}
void create_diagram_file(const vector<vector<int>>& depths, int column, const string& filename) {
ofstream file(filename);
for (int i = 0; i < depths.size(); i++) {
file << setw(2) << setfill('0') << i+1;
file << string(round(depths[i][column-1] / 10), '*') << "\n";
}
file.close();
}
int main() {
int rows, cols;
auto depths = read_data("melyseg.txt", rows, cols);
cout << "1. feladat" << endl;
cout << "A beolvasás sikeresen befejeződött." << endl;
cout << "\n2. feladat" << endl;
int row_id, col_id;
cout << "A mérés sorának azonosítója (max. " << rows << ") = ";
cin >> row_id;
cout << "A mérés oszlopának azonosítója (max. " << cols << ") = ";
cin >> col_id;
cout << "A mért mélység az adott helyen " << get_depth(depths, row_id, col_id) << " dm." << endl;
cout << "\n3. feladat" << endl;
auto [surface, avg_depth] = lake_surface_and_avg(depths);
cout << "A tó felszíne " << surface << " m², átlagos mélysége: " << fixed << setprecision(2) << avg_depth << " m." << endl;
cout << "\n4. feladat" << endl;
auto [max_depth, locations] = max_depth_locations(depths);
cout << "A tó legnagyobb mélysége: " << max_depth << " dm." << endl;
cout << "A legmélyebb helyek sor-oszlop koordinátái:" << endl;
for (const auto& [r, c] : locations) {
cout << "(" << r << "; " << c << ") ";
}
cout << endl;
cout << "\n5. feladat" << endl;
cout << "A tó partvonala " << coastline_length(depths, rows, cols) << " m hosszú." << endl;
cout << "\n6. feladat" << endl;
int column;
cout << "A vizsgált szelvény oszlopának azonosítója (max. " << cols << ") = ";
cin >> column;
create_diagram_file(depths, column, "diagram.txt");
cout << "A diagram.txt létrehozása sikeresen befejeződött." << endl;
return 0;
}
2021. október - Sudoku
[szerkesztés]A sudoku egy logikai játék, melyben megadott szabályok szerint számjegyeket kell elhelyezni egy táblázatban. Ebben a feladatban 9×9-es táblázatot használunk.
A táblázat – az alábbi ábrának megfelelően – 9 darab 3×3-as résztáblázatra van felosztva.
| 0 | 0 | 0 | 0 | 0 | 7 | 3 | 8 | 9 | ||
| 0 | 0 | 0 | 0 | 0 | 0 | 5 | 0 | 0 | ||
| 0 | 0 | 6 | 2 | 0 | 0 | 0 | 0 | 0 | ||
| 6 | 0 | 0 | 1 | 2 | 8 | 0 | 0 | 0 | ||
| 0 | 0 | 7 | 4 | 9 | 0 | 0 | 0 | 0 | ||
| 7 | 0 | 0 | 0 | 3 | 0 | 0 | 0 | 9 | ||
| 0 | 5 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | ||
| 0 | 0 | 0 | 0 | 0 | 3 | 0 | 8 | 0 | ||
| 0 | 4 | 0 | 0 | 9 | 1 | 0 | 0 | 0 |
Minden résztáblázatot az 1, 2, 3, 4, 5, 6, 7, 8, 9 számokkal kell kitölteni úgy, hogy az egész
9×9-es táblázat minden sorában és minden oszlopában az 1...9 számok mindegyike pontosan
egyszer forduljon elő. A rejtvény készítője előre ki szokta tölteni a táblázat bizonyos celláit. A
rejtvényfejtő feladata kitölteni a maradék cellákat a leírt szabályoknak megfelelően.
A bemenetet tartalmazó szövegfájlok első 9 sorának mindegyike 9 egész számot tartalmaz, a játék kiindulási állapotának megfelelően. A kitöltetlen mezők helyén a 0 szám olvasható. A következő néhány sorban a játékos egy-egy lehetséges kitöltési lépését rögzítették. Egy lépést három egész szám ír le: a számot, amelyet a játékos be akar írni, majd a sor és az oszlop számát, ahova írni szeretné. A bemeneti fájl egy-egy sorában a számokat egy-egy szóköz választja el egymástól. A táblázat ellentmondásmentes, tehát megoldható feladatot ír le. A játékos által megtett lépések száma legalább 1, legfeljebb 10, közöttük lehet hibás.
Például:
0 0 0 0 0 0 0 0 6 0 0 7 0 0 0 2 0 0 3 8 9 5 0 0 0 0 0 6 0 0 0 0 0 7 0 0 1 2 8 4 9 0 0 3 0 0 0 0 0 0 0 0 0 9 0 5 1 0 0 0 0 4 0 0 0 0 0 0 3 0 9 1 0 0 0 0 8 0 0 0 0 9 2 4 1 2 1 5 9 9 7 2 2
A fenti példában a nehez.txt bemeneti fájl tartalma látható. A 10. sorban szereplő számok azt jelentik, hogy a 9-es értéket kell a 2. sor 4. helyére beírni. Az adott sorban és az adott oszlopban nem szerepel még a 9-es, sőt, az érintett négyzetben sem, így a lépéssel nem alakul ki hiba, megtehető. A 11. sorbeli lépés is megtehető. A 13. sor hibás lépést tartalmaz, mert a 2. sorban már szerepel a 7-es szám.
A jobb oldalon látható képen a körbe írt számok megadják, hogy az egyes 3×3 méretű résztáblákat milyen számmal azonosítjuk.
Készítsen programot, amely a bemeneti állományok egyikét felhasználva (konnyu.txt, kozepes.txt, nehez.txt) az alábbi kérdésekre válaszol! A program forráskódját mentse sudoku 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: 4. 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.
- Olvassa be egy fájl nevét, egy sor és egy oszlop sorszámát (1 és 9 közötti számot)! A későbbi feladatokat ezen értékek felhasználásával kell megoldania!
- Az előző feladatban beolvasott névnek megfelelő fájl tartalmát olvassa be, és tárolja el a táblázat adatait! Ha ezt nem tudja megtenni, akkor használja forrásként a rendelkezésre álló állományok egyikét!
- Írja ki a képernyőre, hogy a beolvasott sor és oszlop értékének megfelelő hely…
- a. milyen értéket tartalmaz! Ha az adott helyen a 0 olvasható, akkor az „Az adott helyet még nem töltötték ki.” szöveget jelenítse meg!
- b. melyik résztáblázathoz tartozik!
- Határozza meg a táblázat hány százaléka nincs még kitöltve! Az eredményt egy tizedesjegy pontossággal jelenítse meg a képernyőn!
- Vizsgálja meg, hogy a fájlban szereplő lépések lehetségesek-e a beolvasott táblázaton! Tekintse mindegyiket úgy, mintha az lenne az egyetlen lépés az eredeti táblázaton, de ne hajtsa azt végre! Állapítsa meg, hogy okoz-e valamilyen ellentmondást a lépés végrehajtása! Írja ki a lépéshez tartozó három értéket, majd a következő sorba írja az alábbi megállapítások egyikét! Ha több megállapítás is igaz, elegendő csak egyet megjelenítenie.
- „A helyet már kitöltötték”
- „Az adott sorban már szerepel a szám”
- „Az adott oszlopban már szerepel a szám”
- „Az adott résztáblázatban már szerepel a szám”
- „A lépés megtehető”
Minta a szöveges kimenetek kialakításához:
1. feladat Adja meg a bemeneti fájl nevét! konnyu.txt Adja meg egy sor számát! 1 Adja meg egy oszlop számát! 1 3. feladat Az adott helyen szereplő szám: 5 A hely a(z) 1 résztáblázathoz tartozik. 4. feladat Az üres helyek aránya: 17.3% 5. feladat A kiválasztott sor: 2 oszlop: 4 a szám: 9 A helyet már kitöltötték. A kiválasztott sor: 3 oszlop: 6 a szám: 7 A lépés megtehető. A kiválasztott sor: 6 oszlop: 6 a szám: 3 A résztáblázatban már szerepel a szám. A kiválasztott sor: 7 oszlop: 9 a szám: 8 Az adott oszlopban már szerepel a szám.
#include <iostream>
#include <fstream>
#include <vector>
#include <set>
using namespace std;
// Function to check if a move is valid
string isValidMove(const vector<vector<int>>& grid, int num, int row, int col) {
if (grid[row][col] > 0)
return "A helyet már kitöltötték.";
// Check row
if (find(grid[row].begin(), grid[row].end(), num) != grid[row].end())
return "Az adott sorban már szerepel a szám.";
// Check column
for (int i = 0; i < 9; i++) {
if (grid[i][col] == num)
return "Az adott oszlopban már szerepel a szám.";
}
// Check subgrid
int startRow = (row / 3) * 3, startCol = (col / 3) * 3;
for (int r = startRow; r < startRow + 3; r++) {
for (int c = startCol; c < startCol + 3; c++) {
if (grid[r][c] == num)
return "A résztáblázatban már szerepel a szám.";
}
}
return "A lépés megtehető.";
}
int main() {
string fileName;
int row, col;
cout << "1. feladat" << endl;
cout << "Adja meg a bemeneti fájl nevét! ";
cin >> fileName;
cout << "Adja meg egy sor számát! ";
cin >> row;
cout << "Adja meg egy oszlop számát! ";
cin >> col;
row--; col--; // Adjust for 0-based indexing
ifstream file(fileName);
vector<vector<int>> sudokuGrid(9, vector<int>(9));
vector<vector<int>> steps;
if (!file) {
cerr << "Hiba a fájl megnyitásakor!" << endl;
return 1;
}
// Read Sudoku grid
for (int i = 0; i < 9; i++) {
for (int j = 0; j < 9; j++) {
file >> sudokuGrid[i][j];
}
}
// Read steps
int num, r, c;
while (file >> num >> r >> c) {
steps.push_back({num, r - 1, c - 1});
}
file.close();
// 3. feladat
cout << "3. feladat" << endl;
if (sudokuGrid[row][col] == 0)
cout << "Az adott helyet még nem töltötték ki." << endl;
else
cout << "Az adott helyen szereplő szám: " << sudokuGrid[row][col] << endl;
int region = 3 * (row / 3) + (col / 3) + 1;
cout << "A hely a(z) " << region << " résztáblázathoz tartozik." << endl;
// 4. feladat
int emptyCells = 0;
for (const auto& row : sudokuGrid) {
for (int cell : row) {
if (cell == 0) emptyCells++;
}
}
double percentageEmpty = (emptyCells / 81.0) * 100;
cout << "4. feladat" << endl;
cout << "Az üres helyek aránya: " << fixed << setprecision(1) << percentageEmpty << "%" << endl;
// 5. feladat
cout << "5. feladat" << endl;
for (const auto& step : steps) {
cout << "A kiválasztott sor: " << step[1] + 1 << ", oszlop: " << step[2] + 1 << ", a szám: " << step[0] << endl;
cout << isValidMove(sudokuGrid, step[0], step[1], step[2]) << endl;
}
return 0;
}
2022. május - Építményadó
[szerkesztés]Egy Balaton-parti önkormányzat építményadót vezet be. Az adó mértéke a telken lévő építmény alapterületétől és a teleknek a Balatontól mért távolságától függ.
A telkeket a Balatonparttól mért távolságtól függően három sávba sorolták be. Az A sávba azok a telkek kerültek, amelyek 300 méternél közelebb vannak a tóhoz a B sáv az előzőn túl 600 méter távolságig terjed, a többi telek a C sávba tartozik. Az építmény után négyzetméterenként fizetendő összeg sávonként eltérő, azonban, ha az így kiszámított összeg nem éri el a 10.000 Ft-ot, akkor az adott építmény után nem kell adót fizetni.
A testületi döntést az Adó Ügyosztály egy mintával készítette elő, amely csupán néhány utca adatait tartalmazza. Ezek az adatok az utca.txt fájlban vannak. A fájl első sorában a három adósávhoz tartozó négyzetméterenként fizetendő összeg található A, B, C sorrendben, egy-egy szóközzel elválasztva:
800 600 100
…
33366 Aradi 8A C 180
22510 Aradi 8B C 137
90561 Aradi 10 C 168
…
A többi sorban egy-egy építmény adatai szerepelnek egy-egy szóközzel elválasztva. Az első a telek tulajdonosának ötjegyű adószáma; egy tulajdonosnak több telke is lehet. A második adat az utca neve, amely nem tartalmazhat szóközt. A harmadik adat a házszám, majd az adósáv megnevezése, végül az építmény alapterülete következik. A minta harmadik sorában például azt látjuk, hogy a 33366 adószámú tulajdonos telke az Aradi utca 8A-ban található, és a C sávba eső telken álló építmény alapterülete 180 m2.
A fájl legfeljebb 1000 telek adatait tartalmazza. A feladat megoldása során kihasználhatja, hogy a fájlban az adatok utca, azon belül pedig házszám szerinti sorrendben következnek.
Készítsen programot, amely az utca.txt állomány adatait felhasználva az alábbi kérdésekre válaszol! A program forráskódját mentse epitmenyado néven! (A program megírásakor a felhasználó által megadott adatok helyességét, érvényességét nem kell ellenőriznie, és feltételezheti, hogy a rendelkezésre álló adatok a leírtaknak megfelelnek.)
A képernyőre írást igénylő részfeladatok esetén – a mintához tartalmában hasonlóan – írja ki a képernyőre a feladat sorszámát (például: 3. feladat), és utaljon a kiírt tartalomra is! Ha a felhasználótól kér be adatot, jelenítse meg a képernyőn, hogy milyen értéket vár! Mindkét esetben az ékezetmentes kiírás is elfogadott.
- Olvassa be és tárolja el az utca.txt állományban talált adatokat, és annak felhasználásával oldja meg a következő feladatokat!
- Hány telek adatai találhatók az állományban? Az eredményt írassa ki a mintának megfelelően a képernyőre!
- Kérje be egy tulajdonos adószámát, és írassa ki a mintához hasonlóan, hogy melyik utcában, milyen házszám alatt van építménye! Ha a megadott azonosító nem szerepel az adatállományban, akkor írassa ki a „
Nem szerepel az adatállományban.” hibaüzenetet! - Készítsen függvényt
adonéven, amely meghatározza egy adott építmény után fizetendő adót! A függvény paraméterlistájában szerepeljen az adósáv és az alapterület, visszaadott értéke pedig legyen a fizetendő adó! A következő feladatokban ezt a függvényt is felhasználhatja. - Határozza meg, hogy hány építmény esik az egyes adósávokba, és mennyi az adó összege adósávonként! Az eredményt a mintának megfelelően írassa ki a képernyőre!
- Bár az utcák többé-kevésbé párhuzamosak a tó partjával, az egyes porták távolsága a parttól az utcában nem feltétlenül ugyanannyi. Emiatt néhány utcában – az ottani tulajdonosok felháborodására – egyes telkek eltérő sávba esnek. Listázza ki a képernyőre, hogy melyek azok az utcák, ahol a telkek sávokba sorolását emiatt felül kell vizsgálni! Feltételezheti, hogy minden utcában van legalább két telek.
- Határozza meg a fizetendő adót tulajdonosonként! A tulajdonos adószámát és a fizetendő összeget írassa ki a mintának megfelelően a fizetendo.txt állományba! A fájlban minden tulajdonos adatai új sorban szerepeljenek, a tulajdonos adószámát egy szóközzel elválasztva kövesse az általa fizetendő adó teljes összege.
- Minta
Példa a szöveges kimenetek kialakításához
2. feladat. A mintában 543 telek szerepel.
3. feladat. Egy tulajdonos adószáma: 68396
Harmat utca 22
Szepesi utca 17
5. feladat
A sávba 165 telek esik, az adó 20805600 Ft.
B sávba 144 telek esik, az adó 13107000 Ft.
C sávba 234 telek esik, az adó 3479600 Ft.
6. feladat. A több sávba sorolt utcák:
Besztercei
Gyurgyalag
Icce
Kurta
Rezeda
Szepesi
Példa a fizetendo.txt fájl kialakításához
38522 18000
86379 0
79906 12300
…
73850 204000
74143 100000
59801 563200
73011 70400
…
Megjegyzés
A fizetendo.txt fájl a megadott forrásállomány esetén 519 adatsort fog tartalmazni.
#include <iostream>
#include <fstream>
#include <vector>
#include <map>
#include <set>
using namespace std;
struct Telek {
int adoszam;
string utca;
string hazszam;
char sav;
int alapterulet;
};
vector<Telek> telkek;
map<char, int> savDij;
void beolvas() {
ifstream fin("utca.txt");
fin >> savDij['A'] >> savDij['B'] >> savDij['C'];
Telek t;
while (fin >> t.adoszam >> t.utca >> t.hazszam >> t.sav >> t.alapterulet)
telkek.push_back(t);
fin.close();
cout << "1. feladat. Adatok beolvasva.\n";
}
void telekSzam() {
cout << "2. feladat. A mintaban " << telkek.size() << " telek szerepel.\n";
}
void tulajdonosLekerdezes() {
cout << "3. feladat. Egy tulajdonos adoszama: ";
int ado;
cin >> ado;
bool talalt = false;
for (const auto &t : telkek)
if (t.adoszam == ado) {
cout << t.utca << " utca " << t.hazszam << '\n';
talalt = true;
}
if (!talalt)
cout << "Nem szerepel az adatallomanyban.\n";
}
int ado(char sav, int terulet) {
int osszeg = savDij[sav] * terulet;
return (osszeg < 10000) ? 0 : osszeg;
}
void savokAdoja() {
map<char, int> db, osszeg;
for (const auto &t : telkek) {
db[t.sav]++;
osszeg[t.sav] += ado(t.sav, t.alapterulet);
}
cout << "5. feladat\n";
for (char sav = 'A'; sav <= 'C'; sav++)
cout << sav << " savba " << db[sav] << " telek esik, az ado " << osszeg[sav] << " Ft.\n";
}
void tobbSavUtak() {
set<string> problemUtak;
map<string, set<char>> utcaSavok;
for (const auto &t : telkek)
utcaSavok[t.utca].insert(t.sav);
for (const auto &[utca, savok] : utcaSavok)
if (savok.size() > 1)
problemUtak.insert(utca);
cout << "6. feladat. A tobb savba sorolt utcak:\n";
for (const auto &utca : problemUtak)
cout << utca << '\n';
}
void fizetendoAdok() {
map<int, int> tulajdonosAdok;
for (const auto &t : telkek)
tulajdonosAdok[t.adoszam] += ado(t.sav, t.alapterulet);
ofstream fout("fizetendo.txt");
for (const auto &[adoszam, osszeg] : tulajdonosAdok)
fout << adoszam << ' ' << osszeg << '\n';
fout.close();
cout << "7. feladat. A fizetendo.txt allomany letrehozva.\n";
}
int main() {
beolvas();
telekSzam();
tulajdonosLekerdezes();
savokAdoja();
tobbSavUtak();
fizetendoAdok();
return 0;
}
2022. május - Szakaszsebesség-ellenőrzés
[szerkesztés]
A szakaszsebesség-ellenőrzést már több országban is alkalmazzák a közlekedés ellenőrzésére.
Ennek lényege, hogy a járművek elhaladnak két egymástól több kilométerre lévő ellenőrzőkapunál.
Mindkét ponton rögzítik a jármű rendszámát és az elhaladás időpontját. Majd a két időérték
segítségével kiszámítják az átlagsebességet. Ha ez meghaladja az útszakaszon megengedett
legnagyobb sebességet, akkor a jármű vezetője szabálysértést követ el. Rendelkezésünkre állnak
egy 10 km-es kétszer egysávos főútvonal egyik sávjában rögzített szakaszsebesség mérésének
adatai. Az adott szakasz zárt, azaz nincs felhajtási és lehajtási lehetőség.
A meresek.txt szövegállomány egy adott nap reggel 8 órától végzett 1 órányi mérés adatait tartalmazza. Minden egyes jármű csak egyszer szerepel a mérési adatok között. Egy jármű mérési adatai egy sorban szerepelnek egymástól szóközzel elválasztva. Egy sorban 9 adat szerepel, a jármű rendszáma (6 karakteren), a szakasz kezdeti- és végpontján rögzített időpont óra, perc, másodperc, ezredmásodperc formában. (A fájl olyan járművek adatait nem tartalmazza, amelyeknek a szakasz kezdeti- vagy végpontján nem volt mérési értéke.)
A sorok száma legfeljebb 1000. Az adatok a belépési ponton mért idő szerint rendezettek.
Például:
OXZ648 8 4 44 861 8 11 53 432 QUT385 8 4 53 376 8 9 28 185 QTS988 8 5 0 854 8 12 19 879 OTP604 8 5 2 263 8 12 21 288
A példában látható, hogy az QTS988 rendszámú jármű 8:5:0,854-kor haladt el a szakasz kezdetén lévő mérőnél és 8:12:19,879-kor a szakasz végén lévő mérőnél. Az átlagsebessége 82 km/h, ami a megtett út (10 km) és a megtételhez szükséges idő (0,1219 óra) hányadosa. Készítsen programot, amely a meresek.txt állomány adatait felhasználva az alábbi kérdésekre válaszol! A program forráskódját mentse ellenorzes 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. A tizedesszámok megjelenítésekor a használt programozási nyelvben alapértelmezett megjelenítési módot használja!
Az eredmény megjelenítését és a felhasználóval való kommunikációt a feladatot követő minta alapján valósítsa meg!
- Olvassa be és tárolja el a meresek.txt állomány adatait!
- Írja ki a képernyőre, hogy hány jármű adatait rögzítették a mérés során!
- Határozza meg a rendelkezésre álló adatok segítségével, hogy 9 óra előtt hány jármű haladt át a szakasz végpontján! A kapott értéket írja ki a képernyőre!
- Kérjen be a felhasználótól egy óra, perc értéket!
- a. Határozza meg, hogy abban a percben hány jármű haladt el a kezdő méréspontnál! Ha az adott percben nem haladt el jármű a méréspontnál, akkor a 0 értéket jelenítse meg!
- b. Számítsa ki a forgalomsűrűséget, amely a megadott időpontban kezdődő percben (pl.: ha a megadott óra perc 08:09 volt, akkor 08:09:00,000- 08:09:59,999 között) az útszakaszon lévő járművek száma és az útszakasz hosszának hányadosa. Az értéket tizedes tört alakban jelenítse meg.
- Mekkora volt a legnagyobb átlagsebességgel haladó járműnek a sebessége, és hány járművet hagyott le a mért szakasz végére? Amennyiben több legnagyobb átlagsebesség érték van, akkor elég az egyiket kiírnia. Az autó rendszámát, az átlagsebességet egész számként és a lehagyott járművek számát jelenítse meg!
- Határozza meg, hogy a járművek hány százalékának az átlagsebessége haladta meg az útszakaszon megengedett legnagyobb sebességet (90 km/h)! Az értéket tizedes tört alakban jelenítse meg a minta szerint!
- Készítsen egy szöveges állományt buntetes.txt néven, amely a gyorshajtók adatait tartalmazza! Ebbe a szöveges állományba azon járművek adatai kerüljenek be, amelyek átlagsebessége 104 km/h-nál nagyobb! A fájlban a jármű rendszáma, az átlagsebesség egész számként megjelenítve és a büntetés összege szerepeljen mértékegységgel, pontosvesszővel vagy tabulátorokkal elválasztottan! A büntetési tételeket a következő táblázat tartalmazza!
| Átlagsebesség | Büntetés |
|---|---|
| 104 km/h felett – 121 km/h-ig | 30 000 Ft |
| 121 km/h felett – 136 km/h-ig | 45 000 Ft |
| 136 km/h felett – 151 km/h-ig | 60 000 Ft |
| 151 km/h felett | 200 000 Ft |
Minta a szöveges kimenetek kialakításához:
2. feladat A mérés során 687 jármű adatait rögzítették. 3. feladat 9 óra előtt 603 jármű haladt el a végponti mérőnél. 4. feladat Adjon meg egy óra és perc értéket! 8 20 a. A kezdeti méréspontnál elhaladt járművek száma: 12 b. A forgalomsűrűség: 9,4 5. feladat A legnagyobb sebességgel haladó jármű rendszáma: OKL564 átlagsebessége: 137 km/h által lehagyott járművek száma: 33 6. feladat A járművek 11,94%-a volt gyorshajtó. A fájl elkészült.
A buntetes.txt fájl tartalma:
QZV314 128 km/h 45000 Ft OJW811 107 km/h 30000 Ft QUT385 131 km/h 45000 Ft QRC440 128 km/h 45000 Ft QJQ854 109 km/h 30000 Ft
#include <iostream>
#include <fstream>
#include <vector>
#include <sstream>
#include <iomanip>
#include <algorithm>
using namespace std;
struct Jarmu {
string rsz;
int belepes, kilepes;
};
vector<Jarmu> meresek;
int idoMasodpercben(int ora, int perc, int mp, int ezred) {
return ora * 3600000 + perc * 60000 + mp * 1000 + ezred;
}
void beolvasas() {
ifstream file("meresek.txt");
string sor;
while (getline(file, sor)) {
istringstream iss(sor);
Jarmu j;
int ora, perc, mp, ezred;
iss >> j.rsz >> ora >> perc >> mp >> ezred;
j.belepes = idoMasodpercben(ora, perc, mp, ezred);
iss >> ora >> perc >> mp >> ezred;
j.kilepes = idoMasodpercben(ora, perc, mp, ezred);
meresek.push_back(j);
}
file.close();
}
void feladat2() {
cout << "2. feladat" << endl;
cout << "A meres soran " << meresek.size() << " jarmu adatait rogzitettek." << endl;
}
void feladat3() {
cout << "3. feladat" << endl;
int aktki = 9 * 3600000;
int count = count_if(meresek.begin(), meresek.end(), [aktki](const Jarmu& j) {
return j.kilepes < aktki;
});
cout << "9 ora elott " << count << " jarmu haladt el a vegponti meronel." << endl;
}
void feladat4() {
cout << "4. feladat" << endl;
int ora, perc;
cout << "Adjon meg egy ora es perc erteket: ";
cin >> ora >> perc;
int kezd = idoMasodpercben(ora, perc, 0, 0);
int vege = kezd + 60000;
int kezdetiCount = count_if(meresek.begin(), meresek.end(), [kezd, vege](const Jarmu& j) {
return j.belepes >= kezd && j.belepes < vege;
});
int utszakaszonCount = count_if(meresek.begin(), meresek.end(), [kezd, vege](const Jarmu& j) {
return j.belepes < vege && j.kilepes >= kezd;
});
cout << "\ta. A kezdeti meresi pontnal elhaladt jarmuvek szama: " << kezdetiCount << endl;
cout << "\tb. A forgalomsuruseg: " << fixed << setprecision(1) << (double)utszakaszonCount / 10 << " jarmu/km." << endl;
}
void feladat5() {
cout << "5. feladat" << endl;
auto leggyorsabb = min_element(meresek.begin(), meresek.end(), [](const Jarmu& a, const Jarmu& b) {
return (a.kilepes - a.belepes) < (b.kilepes - b.belepes);
});
int maxseb = 10 * 3600000 / (leggyorsabb->kilepes - leggyorsabb->belepes);
int lehagyottak = count_if(meresek.begin(), meresek.end(), [leggyorsabb](const Jarmu& j) {
return leggyorsabb->belepes > j.belepes && leggyorsabb->kilepes < j.kilepes;
});
cout << "A legnagyobb sebesseggel halado jarmu" << endl;
cout << "\trendszama: " << leggyorsabb->rsz << endl;
cout << "\tatlagsebessege: " << maxseb << " km/h" << endl;
cout << "\taltal lehagyott jarmuvek szama: " << lehagyottak << endl;
}
void feladat6() {
cout << "6. feladat" << endl;
double minido = 3600000.0 * 10 / 90;
int gyorshajtok = count_if(meresek.begin(), meresek.end(), [minido](const Jarmu& j) {
return (j.kilepes - j.belepes) < minido;
});
cout << "A jarmuvek " << fixed << setprecision(2) << (100.0 * gyorshajtok / meresek.size()) << "%-a volt gyorshajto." << endl;
}
void feladat7() {
cout << "7. feladat" << endl;
ofstream kitxt("buntetes.txt");
for (const auto& j : meresek) {
int seb = 10 * 3600000 / (j.kilepes - j.belepes);
int buntetes = 0;
if (seb > 151) buntetes = 200000;
else if (seb > 136) buntetes = 60000;
else if (seb > 121) buntetes = 45000;
else if (seb > 104) buntetes = 30000;
if (buntetes > 0) {
kitxt << j.rsz << "\t" << seb << " km/h\t" << buntetes << " Ft\n";
}
}
kitxt.close();
cout << "A buntetes.txt fajl elkészült." << endl;
}
int main() {
beolvasas();
feladat2();
feladat3();
feladat4();
feladat5();
feladat6();
feladat7();
cout << "\nA befejezeshez nyomd meg az ENTER billentyut!";
cin.ignore();
cin.get();
return 0;
}
2022. október - Jeladó
[szerkesztés]Az állatok mozgását ma már rutinszerűen figyelik a rájuk rögzített jeladók segítségével. Ebben a feladatban egy ilyen jeladó által továbbított adatokat kell feldolgoznia.
Az itt használt jeladó úgy működik, hogy helyének x és y koordinátáját továbbítja. Jelet küld, ha a legutolsó küldés óta bármely koordináta változása elérte a 10 egységet. Ha nem történt ekkora elmozdulás, 5 perc elteltével akkor is mindenképpen jelenti helyét. A vevőegység egy fájlban rögzíti a jel érkezési idejét és a pozíciót. Előfordulhat, hogy a vétel meghiúsul, ezért lehetnek egymást követő adatsorok, amelyek között 5 percnél több idő telik el, vagy a koordináták változása 10 egységnél nagyobb.
Rendelkezésére áll a jel.txt nevű adatfájl, amely egy napról tartalmaz adatokat időrendben. Soraiban öt egész szám található, egymástól egy-egy szóközzel elválasztva. Az első három szám a jeladás időpontját (óra, perc, másodperc) adja meg, a negyedik szám az x, az ötödik az y koordináta. A sorok száma legfeljebb 1000, a koordináták -10 000 és 10 000 közötti értékek lehetnek.
Például:
... 3 21 19 126 639 3 26 19 131 641 3 27 55 124 651 3 31 50 134 649 ... 4 19 11 126 42 4 29 11 128 36 4 32 21 130 7 ...
A példa első csoportjában a második sor megmutatja, hogy a jeladó 5 egységnyit mozdult x, 2 egységnyit pedig y irányban 5 perc alatt. A harmadik bejegyzés azért született, mert y irányban 10 egységnyit mozdult el a jeladó, a negyedik bejegyzés pedig egy x irányú 10 egységnyi elmozdulást jelez.
A példa második csoportjában a második sor adataiból látszik, hogy legalább egyszer nem jutott el a jel a vevőhöz, mert 5 percnél több idő telt el az előző vételtől, de az eltelt idő a 10 percet nem haladja meg. A második és harmadik vétel által jelzett pozíciók y koordinátája 29 egységnyivel eltér, ezért legalább két vétel nem került rögzítésre.
Készítsen programot, amely az állomány adatait felhasználva az alábbi kérdésekre válaszol! A program forráskódját mentse jelado néven! A program megírásakor a felhasználó által megadott adatok helyességét, érvényességét nem kell ellenőriznie, és feltételezheti, hogy a rendelkezésre álló adatok a leírtaknak megfelelnek.
A képernyőre írást igénylő részfeladatok esetén – a mintához tartalmában hasonlóan – írja ki a képernyőre a feladat sorszámát (például: 5. feladat), és utaljon a kiírt tartalomra is! Ha a felhasználótól kér be adatot, jelenítse meg a képernyőn, hogy milyen értéket vár! Mindkét esetben az ékezetmentes kiírás is elfogadott.
- Olvassa be a
jel.txtállomány tartalmát, tárolja el a rögzített jelek adatait, és azok felhasználásával oldja meg a következő feladatokat! - Kérje be a felhasználótól egy jel sorszámát (a sorszámozás 1-től indul), és írja a képernyőre az adott jeladáshoz tartozó
xésykoordinátát! - Készítsen függvényt
elteltnéven, amely megadja, hogy a paraméterként átadott két időpont között hány másodperc telik el! A két időpontot, mint paramétert tetszőleges módon átadhatja. Használhat három-három számértéket, két tömböt vagy listát, de más, a célnak megfelelő típusú változót is. Ezt a függvényt később használja fel legalább egy feladat megoldása során! - Adja meg, mennyi idő telt el az első és az utolsó észlelés között! Az időt
óra:perc:mpercalakban írja a képernyőre! - Határozza meg azt a legkisebb, a koordináta-rendszer tengelyeivel párhuzamos oldalú téglalapot, amelyből nem lépett ki a jeladó! Adja meg a téglalap bal alsó és jobb felső sarkának koordinátáit!
- Írja a képernyőre, hogy mennyi volt a jeladó elmozdulásainak összege! Úgy tekintjük, hogy a jeladó két pozíciója közötti elmozdulása a pozíciókat összekötő egyenes mentén történt. Az összeget három tizedes pontossággal jelenítse meg! A kiírásnál a tizedesvessző és tizedespont kiírása is elfogadott. Az
i-edik és azi+1-edik pontok távolságát a Pitagorasz képlet segítségével határozhatja meg: - Írja a
kimaradt.txtfájlba a kimaradt észlelésekkel kapcsolatos adatokat! A kimeneti fájlban azok a bemeneti állományban rögzített vételi időpontok jelenjenek meg, amelyek előtt közvetlenül egy vagy több észlelés kimaradt! Az időpont mellett – a mintának megfelelően – jelenjen meg, hogy legalább hány jel maradt ki, és az is, hogy miből következtet a hiányra! Ha idő- és koordináta-eltérésből is adódik jelkimaradás, akkor a nagyobb értéket írja ki! Ha az időeltérés és a koordináták eltérése alapján is ugyanannyi jelkimaradásra következtetünk, akkor bármelyiket kiírhatja.
- Példa a szöveges kimenetek kialakításához
2. feladat Adja meg a jel sorszámát! 3 x=126 y=639 4. feladat Időtartam: 18:52:40 5. feladat Bal alsó: 4 639, jobb felső: 147 727 6. feladat Elmozdulás: 2007.677 egység
- Minta a kimaradt.txt fájl tartalmára
4 25 33 időeltérés 1 4 55 33 koordináta-eltérés 1 5 5 33 időeltérés 1 6 22 42 időeltérés 2 6 32 42 koordináta-eltérés 2
#include <iostream>
#include <fstream>
#include <vector>
#include <cmath>
#include <limits>
using namespace std;
struct Jel {
int ora, perc, mp, x, y;
};
vector<Jel> beolvas(const string &filename) {
vector<Jel> jelek;
ifstream file(filename);
if (!file) {
cerr << "Hiba a fajl megnyitasa kozben!" << endl;
exit(1);
}
Jel jel;
while (file >> jel.ora >> jel.perc >> jel.mp >> jel.x >> jel.y) {
jelek.push_back(jel);
}
return jelek;
}
int eltelt(const Jel &jel1, const Jel &jel2) {
return abs((jel2.ora - jel1.ora) * 3600 + (jel2.perc - jel1.perc) * 60 + (jel2.mp - jel1.mp));
}
double tavolsag(const Jel &jel1, const Jel &jel2) {
return sqrt(pow(jel2.x - jel1.x, 2) + pow(jel2.y - jel1.y, 2));
}
int main() {
vector<Jel> jelek = beolvas("jel.txt");
int n = jelek.size();
// 2. feladat
cout << "2. feladat" << endl;
int sorszam;
cout << "Adja meg a jel sorszamat! ";
cin >> sorszam;
if (sorszam >= 1 && sorszam <= n) {
cout << "x=" << jelek[sorszam - 1].x << " y=" << jelek[sorszam - 1].y << endl;
} else {
cout << "Hibas sorszam!" << endl;
}
// 4. feladat
cout << "4. feladat" << endl;
int idokulonbseg = eltelt(jelek[0], jelek[n - 1]);
cout << "Idotartam: " << idokulonbseg / 3600 << ":"
<< (idokulonbseg % 3600) / 60 << ":"
<< idokulonbseg % 60 << endl;
// 5. feladat
cout << "5. feladat" << endl;
int minx = numeric_limits<int>::max(), maxx = numeric_limits<int>::min();
int miny = numeric_limits<int>::max(), maxy = numeric_limits<int>::min();
for (const auto &jel : jelek) {
minx = min(minx, jel.x);
maxx = max(maxx, jel.x);
miny = min(miny, jel.y);
maxy = max(maxy, jel.y);
}
cout << "Bal also: " << minx << " " << miny << ", jobb felso: " << maxx << " " << maxy << endl;
// 6. feladat
cout << "6. feladat" << endl;
double osszes_tav = 0;
for (int i = 0; i < n - 1; ++i) {
osszes_tav += tavolsag(jelek[i], jelek[i + 1]);
}
cout << "Elmozdulas: " << fixed << osszes_tav << " egyseg" << endl;
// 7. feladat
cout << "7. feladat" << endl;
ofstream kimaradt_file("kimaradt.txt");
for (int i = 0; i < n - 1; ++i) {
int idokulonbseg = eltelt(jelek[i], jelek[i + 1]);
int max_elteres = max(abs(jelek[i + 1].x - jelek[i].x), abs(jelek[i + 1].y - jelek[i].y));
int kimaradt_ido = idokulonbseg > 300 ? (idokulonbseg - 1) / 300 : 0;
int kimaradt_tav = max_elteres > 10 ? (max_elteres - 1) / 10 : 0;
if (kimaradt_tav > kimaradt_ido) {
kimaradt_file << jelek[i + 1].ora << " " << jelek[i + 1].perc << " " << jelek[i + 1].mp
<< " koordinata-elteres " << kimaradt_tav << endl;
} else if (kimaradt_ido > kimaradt_tav) {
kimaradt_file << jelek[i + 1].ora << " " << jelek[i + 1].perc << " " << jelek[i + 1].mp
<< " idoelteres " << kimaradt_ido << endl;
}
}
kimaradt_file.close();
return 0;
}
2023. május - Szállítószalag
[szerkesztés]Egy speciális, kör alakú üzemcsarnokban különböző anyagok szállításához körpályán mozgó szállítószalagot állítottak üzembe. Erre a szalagra bárhol feltehetnek bármilyen anyagot egy rekeszbe zárva, annak beállításával, hogy hova szánják. A célhelyen a szalagról automatikusan lekerül a rekesz. A szalag az óramutató járásával egyező irányban mozog, akkor indul el, ha rekesz kerül rá és addig mozog, amíg van rajta szállítandó rekesz. Az ilyen szállítási feladatokat kell feldolgoznia.
Rendelkezésére áll a szallit.txt nevű adatfájl, amelynek első sorában két egész szám található, egymástól egy szóközzel elválasztva. Az első a szállítószalag hossza, a második a szállítószalag egy egységnyi elmozdulásához szükséges idő. A fájl további legfeljebb 1000 sorában soronként négy egész szám található, egymástól szóközzel elválasztva. Az első szám megadja, hogy mikor tették a szalagra a rekeszt. A következő kettő megmutatja, hogy honnan hova tart a szállítás (a megtett út a szalag hosszánál mindig kevesebb). Az utolsó pedig a szállítandó tömeget jelenti. A hosszúságot és a pozíciókat távolságegységben, az időt időegységben, a tömeget pedig tömegegységben adták meg. Az adatfájl egyetlen adata sem nagyobb 500-nál.
Például:
200 3 1 134 64 34 14 22 129 83 14 135 54 21 23 31 40 61 …
A példában a fájl első 5 sora látható. Az első sor mutatja, hogy 200 egység hosszú a szalag, és egy egységnyi távolságot 3 időegység alatt tesz meg. A 2. sor tartalmazza az első rekesz adatait. A 3. sor szerint a 14. időegységben a 22-es hosszúságegységnél felhelyeznek egy rekeszt, amely a 129-es hosszúságegységnél kerül le. A rekesz 83 egység tömegű. A rekesz tehát 129-22=107 egység utat tesz meg, és a 14+107*3=335-ös időegységben ér célba.
A következő sorban szereplő rekesz szintén a 14. időegységben kerül a szalagra, a 135-ös hosszúságegységtől az 54-es hosszúságegységig halad. A megtett távolság ezért a 0 hosszúságegységig 200-135 egység, azt követően pedig 54 egység, azaz összesen 119 egységnyi távolságot tesz meg a 21 egység tömegű rekesz.
Készítsen programot, amely az állomány adatait felhasználva az alábbi kérdésekre válaszol! A program forráskódját mentse szalag néven! A program megírásakor a felhasználó által megadott adatok helyességét, érvényességét nem kell ellenőriznie, és feltételezheti, hogy a rendelkezésre álló adatok a leírtaknak megfelelnek.
A képernyőre írást igénylő részfeladatok esetén – a mintához tartalmában hasonlóan – írja ki a képernyőre a feladat sorszámát (például: 2. feladat), és utaljon a kiírt tartalomra is! Ha a felhasználótól kér be adatot, jelenítse meg a képernyőn, hogy milyen értéket vár! Mindkét esetben az ékezetmentes kiírás is elfogadott.
- Olvassa be a szallit.txt állomány adatait, és annak felhasználásával oldja meg a következő feladatokat!
- Kérje be egy szállítás sorszámát, majd írassa ki annak indulási és célhelyét! (A szállításokat 1-től sorszámozzuk.)
- Készítsen függvényt tav néven, amely megadja a szállítás távolságát a szalag hosszának, valamint az indulási és a célhelynek ismeretében! A függvényt használja fel a későbbi feladatok megoldása során. A függvényfejet az alábbiaknak megfelelően készítse el, megoldásában az ott szereplő változóneveket használja! Függvény tav(szalaghossz, indulashelye, erkezeshelye : egész szám): egész szám
- Határozza meg, hogy a rendelkezésre álló szállítások során mekkora volt a legnagyobb szállítási távolság! Írja a képernyőre a maximális távolságot és az összes ilyen hosszúságú szállítás sorszámát!
- Adja meg, mekkora tömeg haladt el összesen a 0 pozíciójú hely előtt! Az onnan induló vagy oda érkező rekeszeket ne vegye figyelembe!
- Kérjen be egy időpontot, és határozza meg az adott időpontban szállított rekeszek sorszámát! Az éppen akkor induló rekeszeket vegye figyelembe, de a célba érőket ne! Ha nem volt szállított rekesz, akkor a rekeszek sorszáma helyett az „üres” szót írja ki!
- Hozza létre a tomeg.txt fájlt, amely megadja, hogy az egyes helyekről összességében mennyi tömeget szállítottak el! Azok a helyek ne jelenjenek meg a fájlban, ahonnan nem történt szállítás! (A fájlba írt adatok sorrendje tetszőleges.)
Példa a szöveges kimenetek kialakításához:
2. feladat Adja meg, melyik adatsorra kíváncsi! 3 Honnan: 135 Hova: 54 4. feladat A legnagyobb távolság: 195 A maximális távolságú szállítások sorszáma: 31 33 5. feladat A kezdőpont előtt elhaladó rekeszek össztömege: 957 6. feladat Adja meg a kívánt időpontot! 300 A szállított rekeszek halmaza: 1 2 3 6 7 10 11
Példa az tomeg.txt szöveges állomány tartalmára:
5 37 12 35 16 26 17 33 18 41 22 83 …
#include <iostream>
#include <fstream>
#include <vector>
#include <map>
#include <algorithm>
using namespace std;
struct Rekesz {
int ido, fel, le, tomeg;
};
// 3. feladat: Távolság számítása
int tav(int szalaghossz, int indulashelye, int erkezeshelye) {
return (erkezeshelye - indulashelye + szalaghossz) % szalaghossz;
}
int main() {
cout << "1. feladat" << endl;
ifstream file("szallit.txt");
int szalaghossz, eido;
file >> szalaghossz >> eido;
vector<Rekesz> adatok;
Rekesz temp;
while (file >> temp.ido >> temp.fel >> temp.le >> temp.tomeg) {
adatok.push_back(temp);
}
file.close();
cout << szalaghossz << "\n" << eido << endl;
// 2. feladat
cout << "2. feladat" << endl;
int bekert_adat;
cout << "Adja meg, melyik adatsorra kivancsi! ";
cin >> bekert_adat;
cout << "Honnan: " << adatok[bekert_adat - 1].fel << " Hova: " << adatok[bekert_adat - 1].le << endl;
// 4. feladat
cout << "4. feladat" << endl;
int maxtav = 0;
vector<int> max_tav_sorsz;
for (size_t i = 0; i < adatok.size(); ++i) {
int t = tav(szalaghossz, adatok[i].fel, adatok[i].le);
if (t > maxtav) {
maxtav = t;
max_tav_sorsz.clear();
max_tav_sorsz.push_back(i + 1);
} else if (t == maxtav) {
max_tav_sorsz.push_back(i + 1);
}
}
cout << "A legnagyobb tavolsag: " << maxtav << endl;
cout << "A maximalis tavolsagu szallitasok sorszama: ";
for (int idx : max_tav_sorsz) cout << idx << " ";
cout << endl;
// 5. feladat
cout << "5. feladat" << endl;
int ossztomeg = 0;
for (const auto& r : adatok) {
if ((r.fel < r.le && r.le >= szalaghossz) || (r.fel > r.le && r.fel >= szalaghossz)) {
ossztomeg += r.tomeg;
}
}
cout << "A kezdopont elott elhalado rekeszek ossztomege: " << ossztomeg << endl;
// 6. feladat
cout << "6. feladat" << endl;
int bekert_ido;
cout << "Adja meg a kivant idopontot! ";
cin >> bekert_ido;
vector<int> aktiv_rekeszek;
for (size_t i = 0; i < adatok.size(); ++i) {
int vegido = adatok[i].ido + tav(szalaghossz, adatok[i].fel, adatok[i].le) * eido;
if (adatok[i].ido <= bekert_ido && bekert_ido < vegido) {
aktiv_rekeszek.push_back(i + 1);
}
}
if (aktiv_rekeszek.empty()) {
cout << "ures" << endl;
} else {
cout << "A szallitott rekeszek halmaza: ";
for (int idx : aktiv_rekeszek) cout << idx << " ";
cout << endl;
}
// 7. feladat - tomeg.txt létrehozása
cout << "7. feladat" << endl;
map<int, int> ossz_tomegek;
for (const auto& r : adatok) {
ossz_tomegek[r.fel] += r.tomeg;
}
ofstream output("tomeg.txt");
for (const auto& [hely, tomeg] : ossz_tomegek) {
output << hely << " " << tomeg << "\n";
}
output.close();
return 0;
}
2023. május - RGB színek
[szerkesztés]Fényképek számítógépes tárolására sokféle képformátumot ismerünk. A legegyszerűbb típusok az eredeti kép pixeleihez tartozó színértékeket tárolják, például ilyen a BMP vagy a fényképezőgépek által használt RAW formátum. Az ilyen képállomány bináris, melynek első néhány bájtja a kép jellemzőit írja le, míg a további bájtok sorfolytonosan a kép egy-egy pixelének színét adják meg.
Ebben a feladatban egy RAW formátumú fájlból átalakított szöveges állományt kell feldolgoznia. A kep.txt szöveges állomány egy 640×360 méretű, RGB kódolású képet ír le. Az állomány csak a képpontok színét tartalmazza sorfolytonosan, azaz a fájl 360 sorának mindegyike 640 képpontból, képpontonként három színértékből áll. Az első szám a piros (Red), a második szám a zöld (Green) és a harmadik szám a kék (Blue) értéket tartalmazza. Az RGB értékek 0 és 255 közötti egészek, melyeket a fájlban egy-egy szóköz választ el.
Részlet az állomány első néhány sorából (az alábbi példákban szereplő számhármasok félkövér betűstílussal vannak kiemelve):
0 85 112 0 86 113 0 86 113 0 86 113 0 86 113 0 86 113 …
0 86 111 0 86 111 0 86 113 0 86 113 0 86 113 0 86 113 …
0 86 113 0 86 113 0 86 113 0 86 113 0 86 113 1 87 114 …
0 86 113 0 86 113 0 86 113 0 86 113 1 87 114 1 87 114 …
…
Az első sor első három száma a kép bal felső képpontjának színe, azaz RGB(0, 85, 112), míg a második sor harmadik pixelének színe RGB(0, 86, 113), a negyedik sor hatodik oszlopában lévő képpont színe RGB(1, 87, 114).
A szöveges állomány által leírt kép:
Készítsen programot, amely az állomány adatait felhasználva megoldja az alábbi feladatokat! A program forráskódját mentse rgb néven! A program megírásakor a felhasználó által megadott adatok helyességét, érvényességét nem kell ellenőriznie, és feltételezheti, hogy a beolvasandó adatok a leírtaknak megfelelnek.
A képernyőre írást igénylő részfeladatok esetén – a mintához tartalmában hasonlóan – írja ki a képernyőre a feladat sorszámát (például: 2. feladat:), és utaljon a kiírt tartalomra is! Ha a felhasználótól kér be adatot, jelenítse meg a képernyőn, hogy milyen értéket vár! Mindkét esetben az ékezetmentes kiírás is elfogadott.
- Olvassa be a kep.txt állomány tartalmát, és tárolja el a 640×360 képpont színét!
- Kérje be a felhasználótól a kép egy pontjának sor- és oszlopszámát (a számozás mindkét esetben 1-től indul), és írja a képernyőre az adott képpont RGB színösszetevőit a minta szerint!
- Világosnak tekintjük az olyan képpontot, amely RGB-értékeinek összege 600-nál nagyobb. Számolja meg és írja ki, hogy a teljes képen hány világos képpont van!
- A kép legsötétebb pontjainak azokat a pontokat tekintjük, amelyek RGB-értékeinek összege a legkisebb. Adja meg, hogy mennyi a legkisebb összeg, illetve keresse meg az ilyen RGB összegű pixeleket, és írja ki mindegyik színét
RGB(r,g,b)formában a mintának megfelelően! - A képen a kék ég látható közepén egy felhővel. Az ég és a felhő színe között jelentős különbség van, így az ég-felhő határvonal programmal is felismerhető. Ennek megtalálásához készítsen függvényt hatar néven, amely megadja, hogy egy adott sorban van-e olyan hely a képen, ahol az egymás melletti képpontok kék színösszetevőinek eltérése meghalad egy adott értéket! A függvény kapja meg paraméterként a sor számát, illetve az eltérés értékét, melyek egészek! A függvény visszatérési értéke egy logikai érték legyen, amely megadja, hogy az adott sorban volt-e az eltérést meghaladó különbség az egymás melletti képpontok kék színében!
- Keresse meg a képen a felhő első és utolsó sorát az előzőleg elkészített függvény segítségével úgy, hogy eltérésként 10-et ad meg a függvénynek bemenetként! Adja meg az első és az utolsó olyan sor sorszámát, ahol az eltérés a soron belül valahol 10-nél nagyobb!
Minta
Példa a szöveges kimenetek kialakításához:
2. feladat: Kérem egy képpont adatait! Sor:180 Oszlop:320 A képpont színe RGB(184,183,181) 3. feladat: A világos képpontok száma: 7837 4. feladat: A legsötétebb pont RGB összege: 197 A legsötétebb pixelek színe: RGB(0,85,112) RGB(0,86,111) RGB(0,86,111) 6. feladat: A felhő legfelső sora: 103 A felhő legalsó sora: 280
#include <iostream>
#include <fstream>
#include <vector>
#include <array>
#include <sstream>
#include <algorithm>
using namespace std;
const int WIDTH = 640;
const int HEIGHT = 360;
vector<vector<array<int, 3>>> kep; // 2D vector to store RGB values
// Function to read the image from kep.txt
void fel1() {
ifstream file("kep.txt");
if (!file) {
cerr << "Hiba: Nem lehet megnyitni a kep.txt fájlt!" << endl;
exit(1);
}
kep.resize(HEIGHT, vector<array<int, 3>>(WIDTH));
string line;
for (int row = 0; row < HEIGHT; ++row) {
getline(file, line);
stringstream ss(line);
for (int col = 0; col < WIDTH; ++col) {
ss >> kep[row][col][0] >> kep[row][col][1] >> kep[row][col][2];
}
}
file.close();
}
// Function to get an RGB pixel at a given coordinate
void fel2() {
cout << "2. feladat:" << endl;
cout << "Kérem egy képpont adatait!" << endl;
int sor, oszlop;
cout << "Sor: ";
cin >> sor;
cout << "Oszlop: ";
cin >> oszlop;
--sor; --oszlop; // Adjusting for zero-based indexing
if (sor < 0 || sor >= HEIGHT || oszlop < 0 || oszlop >= WIDTH) {
cout << "Hiba: Érvénytelen koordináták!" << endl;
return;
}
cout << "A képpont színe RGB("
<< kep[sor][oszlop][0] << ","
<< kep[sor][oszlop][1] << ","
<< kep[sor][oszlop][2] << ")" << endl;
}
// Function to count bright pixels (RGB sum > 600)
void fel3() {
cout << "3. feladat:" << endl;
int bright_count = 0;
for (const auto& row : kep) {
for (const auto& pixel : row) {
if (pixel[0] + pixel[1] + pixel[2] > 600) {
++bright_count;
}
}
}
cout << "A világos képpontok száma: " << bright_count << endl;
}
// Function to find the darkest pixels
void fel4() {
cout << "4. feladat:" << endl;
int min_sum = 255 * 3; // Maximum possible RGB sum
for (const auto& row : kep) {
for (const auto& pixel : row) {
int sum = pixel[0] + pixel[1] + pixel[2];
min_sum = min(min_sum, sum);
}
}
cout << "A legsötétebb pont RGB összege: " << min_sum << endl;
cout << "A legsötétebb pixelek színe:" << endl;
for (const auto& row : kep) {
for (const auto& pixel : row) {
if (pixel[0] + pixel[1] + pixel[2] == min_sum) {
cout << "RGB(" << pixel[0] << "," << pixel[1] << "," << pixel[2] << ")" << endl;
}
}
}
}
// Function to detect boundary between sky and cloud
bool hatar(int sor, int elteres) {
if (sor < 1 || sor > HEIGHT) return false; // Check bounds
--sor; // Convert to zero-based index
for (int i = 0; i < WIDTH - 1; ++i) {
if (abs(kep[sor][i][2] - kep[sor][i + 1][2]) > elteres) {
return true;
}
}
return false;
}
// Function to find cloud's first and last row
void fel6() {
cout << "6. feladat:" << endl;
int felso = -1, also = -1;
for (int i = 1; i <= HEIGHT; ++i) {
if (hatar(i, 10)) {
felso = i;
break;
}
}
for (int i = HEIGHT; i >= 1; --i) {
if (hatar(i, 10)) {
also = i;
break;
}
}
if (felso != -1) cout << "A felhő legfelső sora: " << felso << endl;
if (also != -1) cout << "A felhő legalsó sora: " << also << endl;
}
// Main function
int main() {
fel1(); // Read the image file
fel2(); // Get a pixel's RGB value
fel3(); // Count bright pixels
fel4(); // Find darkest pixels
fel6(); // Find cloud boundaries
return 0;
}
2023. október - Társas
[szerkesztés]Mi sem izgalmasabb a gyerekeknek, mint a nagyszülők szekrényeiben való kutakodás. Egy ilyen alkalommal az öt unoka egy régi dobozra bukkant. A doboz egy társasjáték kellékeit rejtette: a játék tábláját, egy dobókockát és hat különböző színű, lúd formájú bábut. A táblán több ösvényen lehet eljuttatni a ludat az itatóhoz. A játékosok a kezdés előtt kiválasztják a közös ösvényt, amelyen haladni fognak.
A ludak annyi mezőt ugorhatnak előre, amennyit a játékosok dobnak a kockával.
Az ösvényen lehetnek különleges mezők, amelyekre érkezve:
- a lúd előreugorhat még egyszer annyit, mint amennyit dobott a játékos,
- vissza kell térnie arra a mezőre, amelyről indította az ugrást.
Az osvenyek.txt fájl soronként egy ösvény adatait tartalmazza. Az ösvények sorszámozása 1-től kezdődik. Az állomány legfeljebb 50 sorból, soronként legfeljebb 250 karakterből áll. Minden sorban egy-egy karaktersorozat van. A karakterek az M, E, V nagybetűk. Az M karakter egy mindenféle különleges tulajdonságtól mentes mezőt jelent. Ha valaki az E karakterű mezőre lép, előreugorhat még ugyanannyit, mint amennyivel ide jutott. Ha a V karakterű mezőre lép, a bábunak vissza kell térnie oda, ahonnan ide ugrott. Két egymást követő különleges karakter között mindig legalább 6 darab M karakter van. A játék akkor ér véget, ha mindenki ugyanannyiszor dobott, és legalább egy játékos elérte az utolsó mezőt, vagy túllépett rajta. Azok a nyertesek, akik elérték az utolsó mezőt vagy túlléptek rajta. A dobasok.txt fájl egyetlen, szóközökkel tagolt sorból áll, amely a kockával egymást követően dobott értékeket tartalmazza. A fájlban 1 és 6 közötti számokból legfeljebb 2000 található. Tudjuk, hogy ennyi dobás biztosan elegendő a játék befejezéséhez. Azt nem rögzítettük, hogy melyik értéket melyik játékos dobta.
Részlet a dobasok.txt állomány első sorából:
2 4 6 5 6 1 …
Ha két játékos játszik, akkor dobásaik értékei felváltva szerepelnek a dobasok.txt állományban. Tehát az első játékos először 2-t dob, majd a második játékos 4-et, utána az első játékos 6-ot, a második játékos 5-öt, és így tovább.
Részlet az osvenyek.txt állomány első néhány sorából:
MMMMMMMMMMM…M MEMMMMMMEMMMMMMMMMMM… …
Ha a második ösvényen játszanak (az MEMM kezdetűn), akkor az első játékos 2-es dobásával a második mezőre lép. Ez E típusú mező, ezért azonnal, dobás nélkül még két mezővel előrelép, így jut az első dobásával először a kettes, majd a négyes mezőre. Ezt követően a második játékos a 4-es dobásával a negyedik mezőre lép. Ez M típusú, azaz mindenféle különleges tulajdonságtól mentes, így játékosunk a következő dobásig itt marad. Ismét az első játékos jön. Ő a 6-os dobásával a tizedik mezőre léphet tovább. Ez M típusú, ezért nem lép innen el, a második játékos jön. Ő az 5-ös dobásával a negyedik mezőről a kilencedik mezőre lép. Ez E típusú, tehát rögtön előreléphet a dobásának megfelelően újabb öt mezőt. A következő ábra ezeket a lépéseket szemlélteti: Készítsen programot, amely az állományok adatait felhasználva megoldja az alábbi feladatokat! A program forráskódját mentse lud néven! A program megírásakor a felhasználó által megadott adatok helyességét, érvényességét nem kell ellenőriznie, és feltételezheti, hogy a beolvasandó adatok a leírtaknak megfelelnek.
A képernyőre írást igénylő részfeladatok esetén – a mintához tartalmában hasonlóan – írja ki a képernyőre a feladat sorszámát (például: 5. feladat), és utaljon a kiírt tartalomra is! Ha a felhasználótól kér be adatot, jelenítse meg a képernyőn, hogy milyen értéket vár! Mindkét esetben elfogadott az ékezetmentes kiírás is.
- Olvassa be és tárolja el az osvenyek.txt és a dobasok.txt állományok tartalmát!
- Jelenítse meg a képernyőn, hogy hány ösvény adatait tartalmazza az osvenyek.txt fájl, és mennyi dobás szerepel a dobasok.txt fájlban!
- Határozza meg, hogy melyik ösvény áll a legtöbb mezőből, és jelenítse meg az ösvény sorszámát és a mezők számát! Ha több ilyen is van, elegendő egyet megjelenítenie.
- Olvassa be és tárolja el egy ösvény sorszámát és a játékot játszók számát (legalább 2, legfeljebb 5)! A későbbiekben ezekkel az adatokkal dolgozzon!
- Készítsen statisztikát a megadott sorszámú ösvény mezőiből! Jelenítse meg, hogy ez milyen típusú mezőből mennyit tartalmaz! Ha egy adott típusú mező nem szerepel, akkor azt ne jelenítse meg! (Megoldása teszteléséhez használja az első három ösvényt is, ezek ugyanis nem tartalmaznak minden karaktert!)
- Írja a kulonleges.txt fájlba, hogy a választott ösvény mely mezői különlegesek! Soronként egy mezőt adjon meg a mező sorszámával és a mező típusát megadó karakterrel! A két értéket egy tabulátor karakterrel válassza el egymástól!
- Határozza meg, hogy melyik játékos jutna a legmesszebb, ha a választott ösvényen minden mező M típusú lenne! Jelenítse meg a legtávolabb jutó(k) sorszámát és azt, hogy a dobások hányadik körében alakult ki a végeredmény! Ha több ilyen játékos van, elegendő csak egyet megjelenítenie.
- Határozza meg, ki nyer, ha figyelembe veszi a mezők típusát is! Jelenítse meg a nyertes(ek) sorszámát és azt, hogy a többi bábu milyen sorszámú mezőn áll az utolsó teljes kör végén!
Példa a szöveges kommunikáció kialakításához:
2. feladat A dobások száma: 1956 Az ösvények száma: 43 3. feladat Az egyik leghosszabb a(z) 11. ösvény, hossza: 206 4. feladat Adja meg egy ösvény sorszámát! 9 Adja meg a játékosok számát! 5 5. feladat M: 185 darab V: 8 darab E: 8 darab 7. feladat A játék a(z) 54. körben fejeződött be. A legtávolabb jutó(k) sorszáma: 5 8. feladat Nyertes(ek): 4 5 A többiek pozíciója: 1. játékos, 153. mező 2. játékos, 185. mező 3. játékos, 183. mező
#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <sstream>
#include <map>
#include <algorithm>
using namespace std;
int main() {
vector<string> osvenyek;
vector<int> dobasok;
// Read paths from file
ifstream osvenyFile("osvenyek.txt");
string line;
while (getline(osvenyFile, line)) {
osvenyek.push_back(line);
}
osvenyFile.close();
// Read dice rolls from file
ifstream dobasFile("dobasok.txt");
if (dobasFile) {
int number;
while (dobasFile >> number) {
dobasok.push_back(number);
}
}
dobasFile.close();
// 2. Task: Display counts
cout << "2. feladat" << endl;
cout << "A dobások száma: " << dobasok.size() << endl;
cout << "Az ösvények száma: " << osvenyek.size() << endl;
// 3. Task: Find the longest path
int maxLengthIndex = 0;
for (size_t i = 1; i < osvenyek.size(); ++i) {
if (osvenyek[i].length() > osvenyek[maxLengthIndex].length()) {
maxLengthIndex = i;
}
}
cout << "\n3. feladat" << endl;
cout << "Az egyik leghosszabb a(z) " << maxLengthIndex + 1 << ". ösvény, hossza: " << osvenyek[maxLengthIndex].length() << endl;
// 4. Task: Get user input
int osvenyIndex, jatekosokSzama;
cout << "\n4. feladat" << endl;
cout << "Adja meg egy ösvény sorszámát! ";
cin >> osvenyIndex;
cout << "Adja meg a játékosok számát! ";
cin >> jatekosokSzama;
string osveny = osvenyek[osvenyIndex - 1];
// 5. Task: Count special fields
map<char, int> mezokSzamlalo;
for (char mez : osveny) {
mezokSzamlalo[mez]++;
}
cout << "\n5. feladat" << endl;
for (const auto &p : mezokSzamlalo) {
cout << p.first << ": " << p.second << " darab" << endl;
}
// 6. Task: Save special fields
ofstream kulonlegesFile("kulonleges.txt");
for (size_t i = 0; i < osveny.size(); ++i) {
if (osveny[i] != 'M') {
kulonlegesFile << i + 1 << "\t" << osveny[i] << endl;
}
}
kulonlegesFile.close();
// 7. Task: Simulate movement without special fields
cout << "\n7. feladat" << endl;
vector<int> poziciok(jatekosokSzama, 0);
int kor = 0;
while (*max_element(poziciok.begin(), poziciok.end()) < osveny.length()) {
for (int i = 0; i < jatekosokSzama; i++) {
poziciok[i] += dobasok[kor * jatekosokSzama + i];
}
kor++;
}
cout << "A játék a(z) " << kor << ". körben fejeződött be. A legtávolabb jutó(k) sorszáma: ";
int maxTav = *max_element(poziciok.begin(), poziciok.end());
for (int i = 0; i < jatekosokSzama; i++) {
if (poziciok[i] == maxTav) {
cout << i + 1 << " ";
}
}
cout << endl;
// 8. Task: Simulate movement with special fields
cout << "\n8. feladat" << endl;
fill(poziciok.begin(), poziciok.end(), 0);
kor = 0;
while (*max_element(poziciok.begin(), poziciok.end()) < osveny.length()) {
for (int i = 0; i < jatekosokSzama; i++) {
int dobas = dobasok[kor * jatekosokSzama + i];
int ujPoz = poziciok[i] + dobas;
if (ujPoz <= osveny.length()) {
if (osveny[ujPoz - 1] == 'E') {
ujPoz += dobas;
} else if (osveny[ujPoz - 1] == 'V') {
ujPoz -= dobas;
}
}
poziciok[i] = ujPoz;
}
kor++;
}
cout << "Nyertes(ek): ";
for (int i = 0; i < jatekosokSzama; i++) {
if (poziciok[i] >= osveny.length()) {
cout << i + 1 << " ";
}
}
cout << "\nA többiek pozíciója:" << endl;
for (int i = 0; i < jatekosokSzama; i++) {
if (poziciok[i] < osveny.length()) {
cout << i + 1 << ". játékos, " << poziciok[i] << ". mező" << endl;
}
}
return 0;
}