Wolisz obejrzeć?
Olimpijskie Koło Informatyczne nagrywa swoje zajęcia i udostępnia je za darmo. Poniżej 2 odcinki o tym temacie — dobre uzupełnienie, jeśli wolisz obejrzeć niż przeczytać.
Co już umiesz i czego się nauczysz
Ta lekcja zakłada, że przerobiłeś wszystkie poprzednie: Typy zmiennych, Input / Output, If / Else, While loop, For loop, Modulo, Tablice, String, Pair, Vector, Sortowanie, Max / Min, Zaokrąglanie, Silnia, Wartość bezwzględna, Złożoność czasowa i Zbiór.
Najważniejsza jest tu druga z nich — Input / Output. Stamtąd znasz taśmę wejścia: cin >> przeskakuje spacje i entery, czyta tyle znaków, ile pasuje do typu zmiennej, i nigdy się nie cofa. Znasz też separatory wczytywane do char (12:30), getline z pułapką po cin >> n, fixed i setprecision, setw i setfill, printf i scanf oraz dwie linijki przyspieszające. Wtedy nie znałeś jeszcze pętli, tablic, napisów, vectorów ani zbiorów. Teraz znasz — i z ich pomocą przeczytasz dane, z którymi poprzednia lekcja by sobie nie poradziła.
Wejście i wyjście to część każdego zadania. Zły format to najgłupszy sposób na stracenie punktów: program liczy dobrze, a sprawdzarka mówi „zła odpowiedź”, bo zabrakło spacji, wiersz się przesunął albo program przeczytał o jedną liczbę za dużo. Po tej lekcji takie błędy przestaną Ci się zdarzać. Uczymy się tak jak dotąd: przepisuj przykłady, rozpisuj taśmę na kartce, zanim klikniesz „Pokaż odpowiedź”, i rób ćwiczenia po każdej części.
Ile danych i ile testów
Liczba n, wartość kończąca, koniec danych, stan strumienia — a potem wiele testów w jednym wejściu.
Wypisywanie i znaki
Separatory, kolumny i tabele, a potem czytanie znak po znaku: cin.get, peek i plansze.
Wiersze i ich wnętrze
getline od środka, a potem rozbieranie wiersza: stringstream, separatory i liczby ukryte w tekście.
Polecenia i duże dane
Polecenia z różną liczbą danych, a na koniec bufor, sync_with_stdio, generatory, sumy kontrolne i pliki.
Jak sprawdzarka podaje dane i czyta wynik
W tej lekcji szczegóły formatu są najważniejsze, więc zacznijmy od tego, co dokładnie robi sprawdzarka.
Dane trafiają do programu jako jeden ciąg znaków — taśma. Twój program nie wie, że dane „przyszły w trzech wierszach”: widzi znaki, wśród których stoją znaki końca wiersza. W sprawdzarce na samym końcu danych nie ma dodatkowego entera, a przy pisaniu na klawiaturze — zwykle jest. Dobry program działa w obu przypadkach; w części 1 zobaczysz, jak to zapewnić.
Wynik sprawdzarka porównuje z oczekiwanym znak po znaku, ale wcześniej wybacza dwie drobnostki: usuwa spacje z końca każdego wiersza i puste wiersze z końca całego wyniku. Wszystko inne musi się zgadzać: spacje w środku i na początku wiersza, przecinki, wielkość liter, kolejność wierszy. Dlatego 1 2 3␣ przejdzie, a 1, 2, 3, — już nie.
Mapa lekcji
Ile jest danych? n, znak końca i koniec danych
Zanim program przeczyta pierwszą liczbę, musi wiedzieć, kiedy przestać czytać. Każda treść zadania mówi to w sekcji „Wejście” — tylko na trzy różne sposoby. Weźmy proste zadanie: zsumuj liczby z wejścia. Oto te same cztery liczby podane w trzech formatach:
| format | wejście | skąd program wie, kiedy skończyć | pętla |
|---|---|---|---|
| A · liczba n na początku | 4↵10 20 30 40 | pierwsza liczba mówi, ile będzie pozostałych | for (int i = 0; i < n; i++) |
| B · wartość kończąca | 10 20 30 40 0 | umówiona wartość (tu 0) oznacza koniec | while (cin >> x && x != 0) |
| C · do końca danych | 10 20 30 40 | czytamy, dopóki się da | while (cin >> x) |
int n;
cin >> n;
long long suma = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
suma += x;
}
cout << suma << "\n";
int x;
long long suma = 0;
while (cin >> x && x != 0) {
suma += x;
}
cout << suma << "\n";
int x;
long long suma = 0;
while (cin >> x) {
suma += x;
}
cout << suma << "\n";
Format A znasz od lekcji o pętli for — to najczęstszy format na olimpiadzie. Format B pojawił się w lekcji o pętli while. Format C widziałeś przy vectorze i zbiorze. W tej części zrozumiesz, dlaczego B i C działają — i jakie pułapki się w nich kryją.
Zwróć uwagę na prawy dolny program: liczby stoją w trzech wierszach, a wynik jest ten sam. cin >> przeskakuje spacje i entery tak samo, więc przy czytaniu liczb układ w wierszach nie ma znaczenia — to znasz z lekcji Input / Output.
cin >> x to pytanie: „udało się?”
Wyrażenie cin >> x robi dwie rzeczy. Najpierw próbuje wczytać liczbę do x. Potem zwraca sam strumień cin — a strumień postawiony w warunku (w if albo w while) odpowiada na pytanie: czy wszystkie dotychczasowe wczytania się udały? Dlatego można napisać tak:
int x;
if (cin >> x) cout << "Wczytano " << x << "\n";
else cout << "Nie ma liczby\n";
Wczytanie nie udaje się w dwóch sytuacjach:
1. Taśma się skończyła. cin >> przeskoczył białe znaki i nie znalazł już nic do czytania. Tak jest w wejściu 2 — i tak kończy się każda pętla while (cin >> x): po ostatniej liczbie przychodzi jeszcze jeden obrót, w którym wczytanie się nie udaje, i warunek staje się fałszywy.
2. Na taśmie stoi coś, co nie pasuje do typu. W wejściu 3 stoi słowo „kot”, a x jest liczbą. Tę sytuację omówimy za chwilę dokładniej, bo ma ważny skutek uboczny.
Zobacz to w ruchu. Ramka poniżej wykonuje pętlę while (cin >> x) obrót po obrocie na wejściu 4 8↵15. Klikaj Krok i patrz na kursor (pomarańczowa kreska), na zmienną x i na stan strumienia. W czwartym obrocie wczytanie się nie uda — strumień dostanie flagi eof (koniec danych) i fail (nieudane wczytanie), a x zostanie bez zmian.
Wpisz własne dane
Prześledźmy: ile razy obróci się while (cin >> x)?
| obrót | taśma przed | co zrobiło cin >> x | x | warunek |
|---|---|---|---|---|
| 1 | 4␣8↵15 | wczytało 4, stanęło na spacji | 4 | prawda — wchodzimy |
| 2 | ␣8↵15 | przeskoczyło spację, wczytało 8 | 8 | prawda — wchodzimy |
| 3 | ↵15 | przeskoczyło enter, wczytało 15, doszło do końca danych | 15 | prawda — wchodzimy |
| 4 | (pusta) | nic nie wczytało: eof i fail | 15 | fałsz — koniec pętli |
Pętla obróciła się trzy razy z danymi, a czwarte sprawdzenie warunku ją zakończyło. Ważne: w czwartym obrocie nie wchodzimy do środka pętli, więc stara wartość x (15) nie zostanie policzona drugi raz. Tak działa każda pętla, w której wczytanie stoi w warunku.
Wartość kończąca: najpierw wczytaj, potem sprawdź
int x, ile = 0;
long long suma = 0;
while (cin >> x && x != 0) {
ile++;
suma += x;
}
cout << ile << " " << suma << "\n";
Warunek cin >> x && x != 0 czyta się od lewej: najpierw wczytaj liczbę, a dopiero potem sprawdź, czy to nie zero. Operator && sprawdza prawą stronę tylko wtedy, gdy lewa jest prawdziwa — więc gdy danych zabraknie, nikt nie porówna śmieci z zerem.
Liczby 100 i 200 stoją za zerem. Program ich nie czyta i nie musi: po wyjściu z pętli po prostu wypisuje wynik. Nieprzeczytane dane na taśmie nikomu nie przeszkadzają — sprawdzarka patrzy tylko na to, co program wypisał.
int x = -1, ile = 0;
while (x != 0) {
cin >> x;
ile++;
}
cout << ile << "\n"; // ile było liczb przed zerem?
A tak wygląda klasyczny błąd: warunek sprawdza x, zanim w ogóle cokolwiek wczytamy (dlatego trzeba było wymyślić start x = -1), a wczytanie stoi w środku pętli. Gdy przychodzi zero, licznik zdąży się jeszcze zwiększyć — i program mówi, że liczb było 4, a były 3.
Ten sam kłopot ma każda pętla, w której najpierw sprawdzamy, potem czytamy. Rozwiązanie jest zawsze to samo: wczytanie przenieś do warunku, tak jak w programie wyżej.
Para kończąca i słowo kończące
int x, y, ile = 0;
while (cin >> x >> y && !(x == 0 && y == 0)) {
ile++;
cout << "(" << x << ", " << y << ")\n";
}
cout << "Punktow: " << ile << "\n";
string s;
vector<string> lista;
while (cin >> s && s != "KONIEC") {
lista.push_back(s);
}
cout << lista.size() << ": ";
for (string w : lista) cout << w << " ";
cout << "\n";
Gdy koniec oznacza para liczb, warunek końca to obie liczby naraz: x == 0 && y == 0. W pętli potrzebujemy zaprzeczenia — „dopóki to nie jest para 0 0” — czyli !(x == 0 && y == 0). Częsty błąd to x != 0 && y != 0: zatrzyma pętlę już na punkcie (0, 5), który przecież jest zwykłym punktem na osi.
Gdy koniec oznacza słowo, porównujemy całe napisy przez !=. Słowo KONIECZNIE to inne słowo niż KONIEC, więc nie kończy danych — porównanie napisów sprawdza każdą literę, a nie tylko początek.
Pary, trójki, słowa — do końca danych
string imie, najlepszy;
int punkty, rekord = -1;
while (cin >> imie >> punkty) {
if (punkty > rekord) {
rekord = punkty;
najlepszy = imie;
}
}
cout << najlepszy << " " << rekord << "\n";
W warunku może stać kilka wczytań naraz: cin >> imie >> punkty. Warunek jest prawdziwy tylko wtedy, gdy udały się wszystkie — czyli gdy przeczytaliśmy cały rekord. Tak czyta się dane „wiersz za wierszem, do końca”, gdy każdy wiersz ma stałą liczbę kawałków.
Pętla nie wie nic o wierszach — po prostu czyta imię, potem liczbę, potem imię… Gdyby dane były porozrzucane inaczej (kilka rekordów w jednym wierszu), program działałby tak samo.
Gdy na taśmie stoi coś innego niż liczba
int a = 7, b = 7, c = 7;
cin >> a;
cin >> b; // na taśmie stoi litera
cin >> c;
cout << a << " " << b << " " << c << "\n";
if (cin.fail()) cout << "strumien zepsuty\n";
Pierwsze wczytanie się udaje: a = 12. Drugie trafia na literę a ze słowa „abc”. To nie cyfra, więc wczytanie się nie udaje — i dzieją się trzy rzeczy:
1. b dostaje wartość 0 (tak działa C++ od wersji z 2011 roku).
2. Strumień przechodzi w stan fail — sprawdzisz to przez cin.fail().
3. Litera zostaje na taśmie. A ponieważ strumień jest „zepsuty”, każde następne cin >> nic nie robi — dlatego c zostało równe 7, choć na taśmie czeka liczba 5.
long long x, suma = 0;
while (cin >> x) suma += x;
cin.clear(); // naprawiamy strumień
string slowo;
cin >> slowo; // litera wciąż czeka na taśmie
cout << suma << " " << slowo << "\n";
Strumień da się „naprawić”: cin.clear() kasuje flagi błędu. Taśma się przy tym nie zmienia — słowo, o które potknęła się pętla, wciąż czeka i możemy je wczytać do string.
To się przydaje, gdy dane składają się z liczb, a po nich stoi słowo — i nie wiemy, ile jest liczb. Pętla while (cin >> x) zatrzyma się dokładnie na pierwszym kawałku, który nie jest liczbą.
Prześledź to w ramce: najpierw cin >> a, potem nieudane cin >> b, potem cin.clear(), słowo i liczba. Spróbuj też własnych danych — na przykład liczby 3000000000, która nie mieści się w int: wczytanie też się nie uda, a zmienna dostanie największą wartość int, czyli 2147483647.
Wpisz własne dane
Pułapka: while (!cin.eof())
W internecie często można spotkać taki sposób czytania do końca danych: „dopóki nie koniec pliku — czytaj”. Wygląda rozsądnie, ale ma podstępny błąd.
int x, ile = 0;
long long suma = 0;
while (!cin.eof()) {
cin >> x;
ile++;
suma += x;
}
cout << ile << " " << suma << "\n";
Flaga eof zapala się dopiero wtedy, gdy program spróbuje czytać za końcem danych. Po wczytaniu trójki z wejścia 1 na taśmie zostaje jeszcze enter:
Flaga eof jeszcze się nie zapaliła, więc pętla robi czwarty obrót. cin >> x przeskakuje enter, nie znajduje liczby i się nie udaje — ale x zostaje równe 3 i trójka zostaje policzona drugi raz. Na klawiaturze i w plikach dane prawie zawsze kończą się enterem, więc ten błąd wychodzi bardzo często.
Rada jest prosta: wczytanie zawsze w warunku pętli — while (cin >> x). Wtedy obrót wykonuje się tylko po udanym wczytaniu, niezależnie od enterów na końcu.
n na początku (for), wartość kończąca (while (cin >> x && x != 0)) i do końca danych (while (cin >> x)). cin >> x w warunku znaczy „czy się udało?”. Nie udaje się na końcu danych (eof i fail, zmienna bez zmian) i na znaku, który nie pasuje do typu (fail, liczba dostaje 0, znak zostaje na taśmie). Zepsuty strumień nic nie czyta, dopóki nie wywołasz cin.clear(). Wczytanie stawiaj w warunku, nie w środku pętli — i nigdy while (!cin.eof()).
Najpierw rozpisz taśmę na kartce i przejdź pętlę obrót po obrocie — a dopiero potem kliknij „Pokaż odpowiedź”.
int x, s = 0;
while (cin >> x) s += x;
cout << s;
1 2↵3Pokaż odpowiedź
int x, ile = 0;
while (cin >> x && x != 0) ile++;
cout << ile;
5 0 7 0Pokaż odpowiedź
int a, b, ile = 0;
while (cin >> a >> b && !(a == 0 && b == 0)) ile++;
cout << ile;
0 5↵5 0↵0 0↵1 1Pokaż odpowiedź
int x = 5;
cin >> x;
cout << x;
kotPokaż odpowiedź
int x = 5;
cin >> x;
cin >> x;
cout << x;
kot 8Pokaż odpowiedź
int a = 1, b = 2;
cin >> a >> b;
cout << a << " " << b;
7Pokaż odpowiedź
string s;
int ile = 0;
while (cin >> s && s != "KONIEC") ile++;
cout << ile;
ala KONIECZNIE KONIEC kotPokaż odpowiedź
int x;
long long s = 0;
while (cin >> x) s += x;
cin.clear();
string w;
cin >> w;
cout << s << w;
1 2 x 3Pokaż odpowiedź
8 ćwiczeń do tej części
Kliknij zadanie — otworzy się w sprawdzarce w nowej karcie. Napisz program u siebie, sprawdź go na przykładzie, wklej cały kod i kliknij Wyślij. Utknąłeś? Każde zadanie ma wskazówkę.
Wiele testów w jednym wejściu
Na wielu zawodach jedno uruchomienie programu sprawdza od razu wiele testów. Na początku wejścia stoi liczba testów t, a za nią kolejne testy — każdy w tym samym formacie. Program musi rozwiązać je wszystkie po kolei i dla każdego wypisać odpowiedź. Weźmy zadanie: „dla każdego testu podaj sumę jego liczb”. Wejście wygląda tak:
3
4 3 9 -2 7
2 -8 -3
1 5
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
long long suma = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
suma += x;
}
cout << suma << "\n";
}
To szkielet, który zobaczysz w tysiącach rozwiązań. Zewnętrzna pętla przechodzi po testach, a w jej środku stoi zwykły program „dla jednego testu” — dokładnie taki, jaki napisałbyś, gdyby test był tylko jeden.
Zapis while (t--) to skrót: najpierw sprawdza, czy t jest różne od zera, a dopiero potem zmniejsza t o jeden. Pętla obróci się więc dokładnie t razy. Jeśli wolisz, napisz zwykłe for (int k = 0; k < t; k++) — działa tak samo.
| sprawdzenie | t przed sprawdzeniem | warunek (t != 0) | t po sprawdzeniu |
|---|---|---|---|
| 1 | 3 | prawda — test 1 | 2 |
| 2 | 2 | prawda — test 2 | 1 |
| 3 | 1 | prawda — test 3 | 0 |
| 4 | 0 | fałsz — koniec | −1 |
Wszystko, co dotyczy testu, twórz w środku pętli
int t;
cin >> t;
long long suma = 0; // BŁĄD: przed pętlą po testach
while (t--) {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
suma += x;
}
cout << suma << "\n";
}
Ten program różni się od poprzedniego jedną linijką: suma powstaje przed pętlą po testach. Pierwszy test wychodzi dobrze (17), ale drugi zaczyna liczyć od 17 zamiast od zera: 17 − 8 − 3 = 6. Trzeci — od 6.
To najczęstszy błąd w zadaniach z wieloma testami, a do tego zdradliwy: przykład z treści często ma jeden test i wtedy wszystko wygląda dobrze. Zasada jest prosta: każda zmienna, która opisuje jeden test — suma, licznik, rekord, flaga, vector, zbiór — powstaje w środku pętli po testach. Wtedy w każdym teście zaczyna od nowa sama.
| rzecz w teście | gdzie ją utworzyć | czym zacząć |
|---|---|---|
| suma, licznik | w środku pętli po testach | 0 |
| największy, najmniejszy | w środku pętli po testach | pierwszą liczbą testu albo LLONG_MIN / LLONG_MAX |
| flaga „znaleziono” | w środku pętli po testach | false |
| vector, set, multiset | w środku pętli po testach | pusty (albo clear() na początku testu) |
| wielka tablica globalna | poza main — raz | po teście wyzeruj tylko to, czego test użył (o tym za chwilę) |
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
set<int> s; // nowy, pusty zbiór w każdym teście
for (int i = 0; i < n; i++) {
int x;
cin >> x;
s.insert(x);
}
cout << s.size() << "\n";
}
Z kontenerami jest tak samo. Zbiór utworzony w środku pętli jest pusty na początku każdego testu. Gdyby powstał przed pętlą, drugi test zobaczyłby jeszcze liczby 1, 2 i 3 z pierwszego i wypisałby 4 zamiast 1.
Jeśli z jakiegoś powodu kontener musi istnieć poza pętlą, wyczyść go na początku każdego testu: s.clear(); albo v.clear();.
Doczytaj cały test — nawet gdy znasz już odpowiedź
Zadanie: w każdym teście są liczby n i k, a pod nimi n liczb. Czy k jest wśród nich? Kusi, żeby po znalezieniu k przerwać pętlę przez break — przecież odpowiedź już znamy. Zobacz, co się wtedy stanie:
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
string wynik = "NIE";
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (x == k) {
wynik = "TAK";
break; // BŁĄD: reszta testu zostaje na taśmie
}
}
cout << wynik << "\n";
}
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
string wynik = "NIE";
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (x == k) wynik = "TAK"; // bez break
}
cout << wynik << "\n";
}
W lewym programie pierwszy test kończy się po liczbie 7 — a liczby 3 i 9 zostają na taśmie. Drugi test zaczyna więc czytać od nich: bierze n = 3 i k = 9, a potem trzy liczby 2, 5, 5. Dziewiątki wśród nich nie ma, więc wypisuje NIE. Od tego miejsca wszystko jest przesunięte, a przy większej liczbie testów program zwykle kończy się bałaganem albo czeka na dane, których nie ma.
Zasada: każdy test czytamy do końca. Odpowiedź zapamiętaj w zmiennej i wypisz po pętli wczytującej. Jeśli koniecznie chcesz przerwać liczenie, przerwij liczenie — ale nie czytanie.
Numer testu i format wyniku
int t;
cin >> t;
for (int k = 1; k <= t; k++) {
int a, b;
cin >> a >> b;
cout << "Case #" << k << ": " << a * b << "\n";
}
int t;
cin >> t;
for (int k = 1; k <= t; k++) {
int n;
cin >> n;
if (k > 1) cout << "\n"; // pusty wiersz PRZED testem 2, 3, …
for (int i = 1; i <= n; i++) cout << string(i, '*') << "\n";
}
Wiele zawodów wymaga, żeby wynik każdego testu zaczynał się od jego numeru, np. Case #1: . Numer daje pętla for liczona od 1. Pilnuj każdego znaku: wielka litera C, spacja przed krzyżykiem, dwukropek i spacja po nim.
Inne zadania każą oddzielać wyniki testów pustym wierszem — między testami, nie po każdym. Najprościej wypisać pusty wiersz przed każdym testem oprócz pierwszego (if (k > 1)). Pilnowanie, który test jest ostatni, jest trudniejsze i łatwiej się w nim pomylić.
Testy bez liczby t: do zera albo do końca danych
int n, nr = 0;
while (cin >> n && n != 0) {
nr++;
int mx = INT_MIN;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
mx = max(mx, x);
}
cout << "Test " << nr << ": " << mx << "\n";
}
Czasem liczby testów nie ma, a dane kończą się umówionym testem (tu: n = 0) albo po prostu końcem danych. To te same formaty co w części 1 — tylko że pętla czyta nie pojedyncze liczby, ale nagłówki testów: while (cin >> n && n != 0) albo while (cin >> n).
Numer testu liczymy wtedy sami — zmienną nr, zwiększaną na początku każdego obrotu.
Wielka tablica i tysiące testów
Pod treścią zadań z wieloma testami często stoi ograniczenie w rodzaju: t ≤ 10⁴, n ≤ 10⁵, suma n we wszystkich testach ≤ 10⁵. To ostatnie zdanie jest bardzo ważne: mówi, że testów może być dużo, ale wszystkie razem mają niewiele liczb. Program, który w każdym teście robi tyle pracy, ile test ma liczb, zdąży bez problemu. Program, który w każdym teście robi coś dużego „na zapas”, nie zdąży.
Typowy przykład: liczniki w globalnej tablicy int ile[1000001]. Wyzerowanie jej przed każdym testem to milion operacji razy 10⁴ testów — 10¹⁰ operacji, około stu sekund. Zamiast tego wyzeruj po teście tylko te pola, które test zmienił:
#include <bits/stdc++.h>
using namespace std;
int ile[1000001]; // globalna: na start same zera
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a(n);
bool powtorka = false;
for (int &x : a) {
cin >> x;
if (ile[x] > 0) powtorka = true;
ile[x]++;
}
cout << (powtorka ? "TAK" : "NIE") << "\n";
for (int x : a) ile[x] = 0; // sprzątamy tylko to, czego użyliśmy
}
return 0;
}
Program sprawdza, czy w teście jakaś liczba się powtarza. Liczby testu zapisuje w vectorze — dzięki temu po teście wie, które pola tablicy ile zmienił, i zeruje tylko je. Sprzątanie kosztuje tyle samo co wczytanie, więc cały program robi pracę proporcjonalną do sumy n, a nie do t · 1 000 000.
Bez sprzątania drugi test zobaczyłby jeszcze ile[1] = 1 z pierwszego testu i wypisałby TAK. Inny dobry sposób to kontener tworzony w teście (zbiór albo posortowany vector) — wtedy sprzątać nie trzeba wcale.
int t; cin >> t; while (t--) { … } albo for (int k = 1; k <= t; k++), gdy potrzebny jest numer testu. Wszystko, co dotyczy jednego testu, twórz w środku pętli. Każdy test czytaj do końca — break w pętli wczytującej przesuwa kolejne testy. Pusty wiersz między testami wypisuj przed każdym testem oprócz pierwszego. Wielkie globalne tablice zeruj tylko tam, gdzie test ich użył.
Rozpisz na kartce, które liczby z taśmy trafiają do którego testu — a dopiero potem kliknij „Pokaż odpowiedź”.
int t = 3;
while (t--) cout << t << " ";
Pokaż odpowiedź
int t = 3, ile = 0;
while (t--) ile++;
cout << ile << " " << t;
Pokaż odpowiedź
int t, s = 0;
cin >> t;
while (t--) {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
s += x;
}
cout << s << " ";
}
2↵1 5↵2 1 1Pokaż odpowiedź
int t;
cin >> t;
for (int k = 1; k <= t; k++) {
int x;
cin >> x;
cout << "Case #" << k << ": " << x * x << "\n";
}
2↵4↵9Pokaż odpowiedź
int t;
cin >> t;
while (t--) {
int n, x;
cin >> n >> x;
cout << x << " ";
}
2↵3 7 8 9↵1 5Pokaż odpowiedź
int n;
while (cin >> n && n != 0) cout << n * n << " ";
2 3 0 4Pokaż odpowiedź
int t;
cin >> t;
vector<int> v;
while (t--) {
int x;
cin >> x;
v.push_back(x);
cout << v.size() << " ";
}
3 5 6 7Pokaż odpowiedź
int t = 3;
for (int k = 1; k <= t; k++) {
if (k > 1) cout << "\n";
cout << "test " << k << "\n";
}
Pokaż odpowiedź
8 ćwiczeń do tej części
Kliknij zadanie — otworzy się w sprawdzarce w nowej karcie. Napisz program u siebie, sprawdź go na przykładzie, wklej cały kod i kliknij Wyślij. Utknąłeś? Każde zadanie ma wskazówkę.
Wypisywanie z głową — separatory, kolumny i tabele
Wynik programu to też dane — tylko że czyta je sprawdzarka, a ona jest bardzo dokładna. Przypomnijmy z wprowadzenia: na końcu każdego wiersza spacje są wybaczane, puste wiersze na końcu wyniku też. Cała reszta musi się zgadzać co do znaku. Spójrz na dwa wyniki, w których spacje zaznaczyliśmy kropkami:
Dlatego przy spacjach można sobie pozwolić na trochę niedbałości, ale przy każdym innym separatorze — nie. W tej części nauczysz się wypisywać listy, wiersze po k elementów, równe kolumny i tabele tak, żeby zgadzał się każdy znak.
Separator między elementami — trzy sposoby
vector<int> v = {3, 1, 4, 1, 5};
int n = v.size();
// sposób 1: separator przed każdym oprócz pierwszego
for (int i = 0; i < n; i++) {
if (i > 0) cout << ", ";
cout << v[i];
}
cout << "\n";
// sposób 2: pierwszy osobno, reszta z separatorem
cout << v[0];
for (int i = 1; i < n; i++) cout << ", " << v[i];
cout << "\n";
// sposób 3: po elemencie separator albo koniec wiersza
for (int i = 0; i < n; i++) cout << v[i] << (i + 1 < n ? ", " : "\n");
Separator stoi między elementami, więc jest go o jeden mniej niż elementów. Trzeba więc jakoś „pominąć” jedno miejsce — pierwsze albo ostatnie.
Sposób 1 (separator przed elementem, oprócz pierwszego) jest najbezpieczniejszy: działa też dla pustej listy i nie wymaga znajomości długości. Polecamy go jako domyślny.
Sposób 2 jest krótki, ale wysypie się na pustym vectorze — v[0] nie istnieje.
Sposób 3 używa operatora ?: z lekcji o if: po każdym elemencie wypisuje albo separator, albo koniec wiersza. Wymaga znajomości długości.
set<string> s = {"pies", "kot", "chomik"};
bool pierwszy = true;
for (string w : s) {
if (!pierwszy) cout << ", ";
cout << w;
pierwszy = false;
}
cout << "\n";
Zbiór nie ma indeksów, więc warunek i > 0 odpada. Zamiast niego flaga pierwszy: na starcie true, po wypisaniu pierwszego elementu — false. To ten sam sposób 1, tylko bez numerów.
Listy w nawiasach i pusta lista
int n;
cin >> n;
vector<int> v(n);
for (int &x : v) cin >> x;
cout << "[";
for (int i = 0; i < n; i++) {
if (i > 0) cout << ", ";
cout << v[i];
}
cout << "]\n";
Nawias otwierający przed pętlą, zamykający po niej, a w środku — sposób 1. Dla pustej listy pętla nie wykona się ani razu i zostanie dokładnie [], bez żadnego przypadku specjalnego.
Ten sam schemat da zbiory w klamrach {1, 2, 3}, pary w nawiasach (3, 4) albo listy po średniku.
k elementów w wierszu
int n = 7, k = 3;
for (int i = 0; i < n; i++) {
cout << i + 1;
if ((i + 1) % k == 0) cout << "\n"; // pełny wiersz
else cout << " ";
}
if (n % k != 0) cout << "\n"; // ostatni, niepełny wiersz
Po każdym elemencie pytamy: czy to już k-ty element w tym wierszu? Element o indeksie i jest (i + 1)-ty od początku, więc wiersz kończy się, gdy (i + 1) % k == 0. W pozostałych przypadkach stawiamy spację.
Uwaga na ostatni wiersz. Gdy n nie dzieli się przez k, ostatni wiersz jest niepełny i nikt nie postawił po nim końca wiersza — robimy to po pętli. (Spacja po siódemce nie przeszkadza: sprawdzarka usuwa spacje z końca wiersza.)
Równe kolumny: szerokość wzięta z danych
Z lekcji Input / Output znasz setw(k) — pole o szerokości k znaków, w którym liczba jest dosunięta do prawej (albo do lewej po left). Tam szerokość była znana z góry. W prawdziwych tabelach zależy od danych: kolumna musi być tak szeroka jak najdłuższy wpis. Najpierw więc wczytujemy wszystko i liczymy szerokość, a dopiero potem wypisujemy.
vector<string> imie = {"Ola", "Bartek", "Zuzanna"};
vector<int> pkt = {100, 7, 85};
int w = 0;
for (string s : imie) w = max(w, (int)s.size());
for (int i = 0; i < 3; i++) {
cout << left << setw(w) << imie[i] << " | ";
cout << right << setw(3) << pkt[i] << "\n";
}
Szerokość liczymy w pętli: (int)s.size() dla napisów, a dla liczb — to_string(x).size(). Rzutowanie na int jest potrzebne, bo max chce dwóch liczb tego samego typu, a size() zwraca typ bez znaku.
Pamiętaj z lekcji Input / Output: left i right działają do odwołania, a setw — tylko na najbliższą wypisywaną rzecz.
Linie, nagłówki i tabela
vector<string> miasto = {"Krakow", "Hel", "Nowy Sacz"};
vector<int> mieszk = {804000, 3400, 83000};
int w1 = 6, w2 = 10; // szerokości nagłówków
for (int i = 0; i < 3; i++) {
w1 = max(w1, (int)miasto[i].size());
w2 = max(w2, (int)to_string(mieszk[i]).size());
}
cout << left << setw(w1) << "Miasto" << " | " << right << setw(w2) << "Mieszkancy" << "\n";
cout << string(w1, '-') << "-+-" << string(w2, '-') << "\n";
for (int i = 0; i < 3; i++) {
cout << left << setw(w1) << miasto[i] << " | " << right << setw(w2) << mieszk[i] << "\n";
}
Do szerokości kolumny wlicza się też nagłówek — dlatego zaczynamy od długości napisów „Miasto” (6) i „Mieszkancy” (10), a potem sprawdzamy wpisy.
Linię pod nagłówkiem budujemy z kawałków: string(w1, '-') to w1 myślników. Na skrzyżowaniu z kreską pionową stawiamy -+-, żeby linia miała dokładnie tę samą długość co wiersze z napisem | .
Ta sama sztuczka zrobi ramkę z gwiazdek, linię z równości pod rachunkiem albo podkreślenie tytułu.
setfill: kropki zamiast spacji — i pułapka trwałości
int W = 20;
cout << left << setfill('.') << setw(W - 2) << "Wstep" << right << setw(2) << 1 << "\n";
cout << left << setw(W - 2) << "Petle" << right << setw(2) << 15 << "\n";
cout << setfill(' '); // przywracamy spacje!
cout << setw(5) << 42 << "\n";
setfill('.') mówi, czym wypełniać puste miejsca w polu setw. Tytuł dostaje pole szerokości 18 dosunięte do lewej — kropki dopełniają je z prawej. Numer strony dostaje pole szerokości 2 dosunięte do prawej. Razem dokładnie 20 znaków. Zauważ, że przed jedynką też stoi kropka: pole numeru ma 2 znaki, a jedynka zajmuje jeden.
Pułapka: setfill jest trwały, tak jak left i fixed. Gdyby nie przedostatnia linijka, liczba 42 wyszłaby jako ...42. Po skończonej tabelce przywróć spacje: setfill(' '). Prostszy sposób na kropki to string(k, '.') — on niczego nie przestawia na stałe.
Liczby z przecinkiem w kolumnie
vector<double> ceny = {3.5, 12.99, 120, 0.4};
cout << fixed << setprecision(2);
for (double c : ceny) cout << setw(8) << c << " zl\n";
fixed i setprecision(2) ustawiamy raz, przed pętlą — są trwałe. setw(8) stoi przed każdą liczbą, bo działa tylko na najbliższą. Kropki dziesiętne ustawiają się w jednej kolumnie, bo wszystkie liczby mają tyle samo cyfr po kropce.
Szerokość pola obejmuje wszystkie znaki liczby: cyfry, kropkę i ewentualny minus.
Wiersz budowany w napisie — na przykład wyśrodkowany
vector<string> w = {"Zaproszenie", "na", "urodziny Oli"};
int d = 0;
for (string s : w) d = max(d, (int)s.size());
cout << string(d + 4, '*') << "\n";
for (string s : w) {
int k = d - s.size(); // wolne miejsca
string linia = "* " + string(k / 2, ' ') + s + string(k - k / 2, ' ') + " *";
cout << linia << "\n";
}
cout << string(d + 4, '*') << "\n";
Czasem łatwiej najpierw zbudować cały wiersz w napisie, a potem wypisać go jednym cout. Tu wyśrodkowujemy tekst w ramce: jeśli zostaje k wolnych miejsc, z lewej stawiamy k / 2 spacji, a z prawej resztę, k - k / 2. Przy nieparzystym k prawa strona dostaje o jedną spację więcej — tak jak przy „Zaproszenie”.
Zbudowany wiersz można też sprawdzić (linia.size()), odwrócić albo zapamiętać w vectorze — a w części 8 zobaczysz, że wypisywanie dużych kawałków naraz jest też szybsze.
if (i > 0) albo flaga pierwszy). k w wierszu: (i + 1) % k == 0 i osobno ostatni wiersz. Szerokość kolumny = najdłuższy wpis razem z nagłówkiem; najpierw licz, potem wypisuj. setw działa na jedną rzecz, a left, right, setfill, fixed i setprecision — do odwołania.
Najpierw zapisz wynik na kartce w kratkę — każda spacja w osobnej kratce — a dopiero potem kliknij „Pokaż odpowiedź”.
vector<int> v = {4, 5, 6};
for (int i = 0; i < 3; i++) {
if (i > 0) cout << "-";
cout << v[i];
}
Pokaż odpowiedź
cout << setw(4) << 7 << "|" << 12 << "|";
Pokaż odpowiedź
cout << setfill('*') << setw(5) << 42 << "\n";
cout << setw(3) << 7;
Pokaż odpowiedź
cout << left << setw(5) << "ab" << "|";
Pokaż odpowiedź
for (int i = 0; i < 5; i++) {
cout << i;
if ((i + 1) % 2 == 0) cout << "\n";
else cout << " ";
}
Pokaż odpowiedź
string s = "kot";
int w = 7;
int k = w - s.size();
cout << "[" << string(k / 2, ' ') << s << string(k - k / 2, ' ') << "]";
Pokaż odpowiedź
cout << fixed << setprecision(1) << setw(6) << 3.14159 << "|";
Pokaż odpowiedź
int x = -45;
cout << setw(to_string(x).size() + 2) << x << "|";
Pokaż odpowiedź
8 ćwiczeń do tej części
Kliknij zadanie — otworzy się w sprawdzarce w nowej karcie. Napisz program u siebie, sprawdź go na przykładzie, wklej cały kod i kliknij Wyślij. Utknąłeś? Każde zadanie ma wskazówkę.
Znak po znaku — cin.get, peek i plansze
Do tej pory czytaliśmy taśmę „kawałkami”: liczba, słowo, liczba. Czasem jednak trzeba zejść niżej i czytać ją znak po znaku — gdy liczy się każda spacja, gdy liczba jest sklejona z literą, gdy plansza nie ma odstępów albo gdy dopiero pierwszy znak mówi, co stoi dalej. Do tego służą trzy narzędzia: cin >> c, cin.get(c) i cin.peek().
cin >> c przeskakuje, cin.get(c) — nie
char a, b, c;
cin >> a >> b >> c;
cout << "[" << a << "][" << b << "][" << c << "]\n";
char a, b, c;
cin.get(a);
cin.get(b);
cin.get(c);
cout << "[" << a << "][" << b << "][" << c << "]\n";
Ten sam program, to samo wejście — a inny wynik. cin >> c najpierw przeskakuje białe znaki (spacje, entery, tabulatory), a potem bierze jeden znak. Dlatego dostaje x, y i z. cin.get(c) bierze dokładnie następny znak taśmy, cokolwiek to jest — także spację i enter. Dlatego drugi znak to spacja.
Przeklikaj to w ramce: najpierw cin >> a, a potem trzy razy cin.get. Ostatni z nich weźmie enter — w ramce zmienna pokaże go jako '\n'.
Wpisz własne dane
Cały tekst znak po znaku: while (cin.get(c))
char c;
int litery = 0, spacje = 0, entery = 0;
while (cin.get(c)) {
if (isalpha(c)) litery++;
else if (c == ' ') spacje++;
else if (c == '\n') entery++;
}
cout << litery << " " << spacje << " " << entery << "\n";
cin.get(c) też zwraca strumień, więc może stać w warunku pętli — tak jak cin >> x. Pętla przeczyta cały tekst, znak po znaku, aż do końca danych.
Uwaga na liczenie wierszy. Entery są między wierszami, a po ostatnim wierszu enter może być albo nie: w sprawdzarce go nie ma, na klawiaturze zwykle jest. Dlatego tekst „Ala ma↵kota” ma dwa wiersze, ale tylko jeden enter. Wiersze lepiej liczyć przez getline — w części 5.
Plansza bez spacji
int n, m;
cin >> n >> m;
vector<string> g(n);
for (auto &w : g) cin >> w;
int ile = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (g[i][j] == '#') ile++;
cout << ile << "\n";
int n, m;
cin >> n >> m;
char t[100][100];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> t[i][j];
for (int j = 0; j < m; j++) cout << t[n - 1][j];
cout << "\n";
Plansze w zadaniach to zwykle wiersze znaków bez spacji: #..#. Są dwa wygodne sposoby. Lewy: każdy wiersz to jedno „słowo”, więc cin >> w wczyta go w całości do napisu, a g[i][j] to znak w wierszu i, kolumnie j. Prawy: znak po znaku do tablicy char — cin >> t[i][j] sam przeskoczy entery na końcach wierszy.
Oba sposoby działają tylko dlatego, że na planszy nie ma spacji. Gdyby puste pole było spacją, cin >> by ją przeskoczył i plansza by się rozjechała — wtedy wiersze czyta się przez getline (część 5).
Cyfry olbrzyma
char c;
int suma = 0, ile = 0;
while (cin >> c) {
suma += c - '0';
ile++;
}
cout << ile << " cyfr, suma " << suma << "\n";
Liczba z 20 cyframi nie zmieści się w long long. Ale jeśli interesują nas tylko jej cyfry, nie trzeba jej w ogóle zamieniać na liczbę: czytamy ją znak po znaku do zmiennej char.
Znak cyfry to nie to samo co jej wartość: znak '7' ma kod 55. Ale kody cyfr stoją po kolei, więc c - '0' daje wartość: '7' - '0' to 55 − 48 = 7. Znasz to z lekcji o napisach.
Liczba sklejona z literą
int k;
char c;
while (cin >> k >> c) cout << string(k, c);
cout << "\n";
Na taśmie stoi 3a2b10c — bez żadnych spacji. A mimo to cin >> k >> c rozbiera to bezbłędnie. Dlaczego? cin >> k czyta cyfry i zatrzymuje się na pierwszym znaku, który nie pasuje do liczby — na literze a. Litera zostaje na taśmie, a cin >> c ją bierze. Potem znowu liczba, znowu litera…
Ta sama zasada rozbiera „12kg”, „5zl” albo „3x+7” — wystarczy wiedzieć, w jakiej kolejności stoją kawałki.
Zajrzyj, zanim weźmiesz: cin.peek()
long long suma = 0;
int slowa = 0;
while (cin >> ws && cin.peek() != EOF) {
if (isdigit(cin.peek())) {
long long x;
cin >> x;
suma += x;
} else {
string s;
cin >> s;
slowa++;
}
}
cout << suma << " " << slowa << "\n";
Czasem dopiero pierwszy znak mówi, do czego czytać: liczba czy słowo? cin.peek() podgląda następny znak taśmy, ale go nie zabiera — kursor zostaje w miejscu i zwykłe cin >> przeczyta potem cały kawałek.
Dwa szczegóły. Po pierwsze, peek nie przeskakuje białych znaków — dlatego najpierw cin >> ws, które przeskakuje spacje i entery (i nic więcej nie robi). Po drugie, na końcu danych peek zwraca specjalną wartość EOF (równą −1) — tak pętla wie, kiedy skończyć.
Wpisz własne dane
Znak po znaku z pamięcią: gdzie zaczyna się słowo?
char c;
bool wSlowie = false;
int slowa = 0;
while (cin.get(c)) {
if (c == ' ' || c == '\n') {
wSlowie = false;
} else {
if (!wSlowie) slowa++; // tu zaczyna się nowe słowo
wSlowie = true;
}
}
cout << slowa << "\n";
Czytając znak po znaku, często trzeba pamiętać, co było przed chwilą. Tu flaga wSlowie mówi, czy poprzedni znak należał do słowa. Słowo zaczyna się tam, gdzie po białym znaku (albo na samym początku) przychodzi zwykły znak — i tylko wtedy zwiększamy licznik. Dzięki temu kilka spacji pod rząd ani puste wiersze nie psują wyniku.
Na tej samej zasadzie działa ściskanie wielu spacji do jednej, szukanie najdłuższej serii czy składanie liczb ukrytych w tekście (zobaczysz je w części 6).
cin >> c przeskakuje białe znaki i bierze jeden znak. cin.get(c) bierze dokładnie następny znak — także spację i '\n'; while (cin.get(c)) czyta cały tekst. Plansze bez spacji: cin >> wiersz albo cin >> t[i][j]. Cyfra to c - '0'. cin >> liczba zatrzymuje się na pierwszym znaku, który do liczby nie pasuje. cin.peek() podgląda bez zabierania (na końcu danych: EOF), a cin >> ws przeskakuje białe znaki.
Rozpisz taśmę z widocznymi spacjami i enterami (␣, ↵) i przesuwaj kursor znak po znaku — a dopiero potem kliknij „Pokaż odpowiedź”.
char a, b;
cin >> a >> b;
cout << a << b;
x yPokaż odpowiedź
char a, b;
cin.get(a);
cin.get(b);
cout << "[" << a << b << "]";
x yPokaż odpowiedź
char c;
int ile = 0;
while (cin.get(c)) ile++;
cout << ile;
ab↵cdPokaż odpowiedź
char c;
int ile = 0;
while (cin >> c) ile++;
cout << ile;
ab↵cdPokaż odpowiedź
int k;
char c;
cin >> k >> c;
cout << k * 2 << c;
12kgPokaż odpowiedź
cin >> ws;
char z = cin.peek();
int x;
cin >> x;
cout << z << x;
45Pokaż odpowiedź
char c;
cin >> c;
cout << c - '0' + 1;
7Pokaż odpowiedź
vector<string> g(2);
for (auto &w : g) cin >> w;
cout << g[1][0] << g[0][1];
ab↵cdPokaż odpowiedź
8 ćwiczeń do tej części
Kliknij zadanie — otworzy się w sprawdzarce w nowej karcie. Napisz program u siebie, sprawdź go na przykładzie, wklej cały kod i kliknij Wyślij. Utknąłeś? Każde zadanie ma wskazówkę.
Całe wiersze — getline od środka
getline znasz z lekcji Input / Output: wczytuje cały wiersz razem ze spacjami. Teraz zajrzymy do środka — bo prawie wszystkie kłopoty z getline biorą się z jednego znaku: entera. Kto rozumie, co dzieje się z enterem, ten nie ma z getline żadnych kłopotów. (Tej części dotyczą też oba filmy z Olimpijskiego Koła Informatycznego na górze strony.)
getline zabiera enter — ale go nie oddaje
string a, b;
getline(cin, a);
getline(cin, b);
cout << a.size() << " " << b.size() << "\n";
cout << "[" << a << "]\n";
getline(cin, s) czyta znaki aż do entera. Sam enter zjada (zdejmuje z taśmy), ale nie wkłada do napisu. Dlatego pierwszy wiersz ma 11 znaków (razem ze spacjami), a nawiasy zamykają się tuż za „kota” — bez żadnego entera w środku.
Drugi getline zaczyna więc czytać od „O”, a nie od entera. Ostatni wiersz nie musi kończyć się enterem: getline weźmie wtedy wszystko do końca danych.
Wpisz własne dane
Trzeci getline w ramce nie ma już czego czytać — wczytanie się nie udaje, tak samo jak cin >> x na końcu danych. Właśnie dlatego getline może stać w warunku pętli.
Wszystkie wiersze do końca: while (getline(cin, s))
string s;
int nr = 0;
while (getline(cin, s)) {
nr++;
if (s.empty()) cout << nr << ": (pusty)\n";
else cout << nr << ": " << s << "\n";
}
Pusty wiersz to dla getline zwykły wiersz — z zerem znaków. getline zjada jego enter i zwraca pusty napis, a wczytanie się udaje. Pętla kończy się dopiero wtedy, gdy wierszy naprawdę zabraknie.
To ważna różnica w stosunku do cin >>, który puste wiersze po prostu przeskakuje. Jeśli w zadaniu pusty wiersz coś znaczy (koniec akapitu, uczeń bez ocen, przerwa między sekcjami), czytaj wiersze przez getline.
Największa pułapka: cin >> n, a potem getline
Znasz ją z lekcji Input / Output, ale wraca tak często, że warto ją zobaczyć jeszcze raz — tym razem w pętli. Zadanie: najpierw liczba n, a potem n zdań do ponumerowania.
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
string s;
getline(cin, s);
cout << i << ". " << s << "\n";
}
int n;
cin >> n;
cin.ignore(); // wyrzuć enter po liczbie
for (int i = 1; i <= n; i++) {
string s;
getline(cin, s);
cout << i << ". " << s << "\n";
}
cin >> n czyta cyfry i zatrzymuje się przed enterem — enter zostaje na taśmie. Pierwszy getline widzi go od razu, więc zwraca pusty wiersz i zjada enter. Drugi getline czyta „Ala ma kota”, a ostatnie zdanie w ogóle nie zostaje przeczytane. Przeklikaj to w ramce:
Wpisz własne dane
Są trzy sposoby, żeby się pozbyć tego entera — i każdy ma swoje „ale”:
| sposób | co wyrzuca | kiedy zawodzi |
|---|---|---|
cin.ignore(); | dokładnie jeden znak | gdy po liczbie stoją jeszcze spacje — wyrzuci spację, a enter zostanie |
cin.ignore(numeric_limits<streamsize>::max(), '\n'); | resztę wiersza razem z enterem | praktycznie nigdy — to najpewniejszy sposób |
getline(cin >> ws, s); | wszystkie białe znaki przed wierszem | gdy wiersz zaczyna się spacjami (zje je) albo gdy pusty wiersz coś znaczy (przeskoczy go) |
int n;
cin >> n;
cin.ignore();
string s;
getline(cin, s);
cout << "[" << s << "]\n";
int n;
cin >> n;
cin.ignore(numeric_limits<streamsize>::max(), '\n');
string s;
getline(cin, s);
cout << "[" << s << "]\n";
W lewym wejściu za piątką stoją dwie spacje (nie widać ich, ale są). cin.ignore() wyrzuca tylko pierwszą z nich, więc getline zwraca jedną spację. Prawy program wyrzuca wszystko aż do entera włącznie — numeric_limits<streamsize>::max() znaczy „ile się da”. Na zawodach dane są zwykle porządne i cin.ignore() wystarcza, ale ten długi zapis warto znać.
Przeplatanie: wiersz tekstu, wiersz liczb
int n;
cin >> n;
for (int i = 0; i < n; i++) {
string tytul;
int rok;
getline(cin >> ws, tytul);
cin >> rok;
cout << rok << ": " << tytul << "\n";
}
Gdy wiersze z tekstem i wiersze z liczbami idą na zmianę, enter zostaje na taśmie po każdej liczbie — nie tylko po pierwszej. Dlatego cin >> ws stoi przed każdym getline, w środku pętli.
Zapis getline(cin >> ws, tytul) to skrót: najpierw cin >> ws przeskakuje białe znaki, a potem getline czyta wiersz. Tytuły nie zaczynają się spacjami, więc to, że ws zjada spacje z początku wiersza, tu nie przeszkadza.
getline do wybranego znaku
string imie, miasto;
int pkt;
while (getline(cin >> ws, imie, ';')) {
getline(cin, miasto, ';');
cin >> pkt;
cout << imie << " z miasta " << miasto << ": " << pkt << "\n";
}
Trzeci argument getline to znak, na którym ma się zatrzymać — zamiast entera. getline(cin, s, ';') czyta do średnika i zjada średnik. Tak rozbierzesz dane, w których pola są oddzielone średnikami albo przecinkami, a same pola zawierają spacje („Nowy Sacz”).
Uwaga: ostatnie pole w wierszu nie kończy się średnikiem, tylko enterem. Dlatego punkty czytamy zwykłym cin >> pkt, a przed następnym imieniem przeskakujemy enter przez cin >> ws. Gdyby i ostatnie pole czytać do średnika, wpadłby do niego cały następny wiersz — zobacz w ramce:
Wpisz własne dane
Spacje na początku wiersza się liczą
string s;
while (getline(cin, s)) {
int k = 0;
while (k < (int)s.size() && s[k] == ' ') k++;
cout << k << " " << s.substr(k) << "\n";
}
getline oddaje wiersz dokładnie taki, jaki był — razem ze spacjami na początku. To jedyny sposób, żeby zobaczyć wcięcia: cin >> by je przeskoczył, a cin >> ws by je zjadł.
Pętla while liczy spacje od lewej, a s.substr(k) to reszta wiersza bez nich. Warunek k < (int)s.size() chroni przed wyjściem poza napis, gdy wiersz składa się z samych spacji.
Wiersze w vectorze
vector<string> w;
string s;
while (getline(cin, s)) w.push_back(s);
for (int i = (int)w.size() - 1; i >= 0; i--) cout << w[i] << "\n";
Gdy trzeba wrócić do wcześniejszych wierszy (wypisać od końca, znaleźć najdłuższy, policzyć szerokość ramki), zapisz je w vector<string>. Każdy wiersz to jeden element, a w[i][j] to j-ty znak i-tego wiersza — prawie jak plansza.
Rzutowanie (int)w.size() - 1 jest ważne: gdyby vector był pusty, w.size() - 1 bez rzutowania dałoby ogromną liczbę (to typ bez znaku — pamiętasz z lekcji o zbiorze).
getline(cin, s) czyta do entera, zjada go i nie wkłada do napisu. while (getline(cin, s)) czyta wszystkie wiersze — pusty wiersz to pusty napis, a nie koniec. Po cin >> n enter zostaje na taśmie: wyrzuć go przez cin.ignore() (jeden znak), cin.ignore(numeric_limits<streamsize>::max(), '\n') (do entera) albo czytaj getline(cin >> ws, s) (zjada też spacje na początku i puste wiersze). getline(cin, s, ';') czyta do średnika — ostatnie pole wiersza kończy się enterem.
Zaznacz na taśmie każdy enter (↵) i pilnuj, kto go zjada — a dopiero potem kliknij „Pokaż odpowiedź”.
string a, b;
getline(cin, a);
getline(cin, b);
cout << a.size() + b.size();
ab cd↵xPokaż odpowiedź
int n;
string s;
cin >> n;
getline(cin, s);
cout << "[" << s << "]";
5↵AlaPokaż odpowiedź
int n;
string s;
cin >> n;
getline(cin >> ws, s);
cout << "[" << s << "]";
5↵ AlaPokaż odpowiedź
string s;
int ile = 0;
while (getline(cin, s)) ile++;
cout << ile;
a↵↵bPokaż odpowiedź
string a, b;
getline(cin, a, ',');
getline(cin, b);
cout << b << a;
x,y zPokaż odpowiedź
string s;
getline(cin, s, ';');
getline(cin, s, ';');
cout << "[" << s << "]";
a;b↵c;dPokaż odpowiedź
int n;
cin >> n;
cin.ignore();
string s;
getline(cin, s);
cout << s.size();
3 ↵abcPokaż odpowiedź
string s;
while (getline(cin, s)) cout << s.size() << " ";
a↵↵bcPokaż odpowiedź
8 ćwiczeń do tej części
Kliknij zadanie — otworzy się w sprawdzarce w nowej karcie. Napisz program u siebie, sprawdź go na przykładzie, wklej cały kod i kliknij Wyślij. Utknąłeś? Każde zadanie ma wskazówkę.
Rozbieramy wiersz — stringstream i liczby w tekście
Zadanie: każdy wiersz to punkty jednego ucznia z kartkówek — ale każdy pisał inną liczbę kartkówek. Wypisz sumę dla każdego ucznia.
Samo cin >> x tu nie wystarczy: przeskakuje entery tak samo jak spacje, więc nie odróżni, gdzie kończą się liczby jednego ucznia, a zaczynają drugiego. Potrzebujemy dwóch kroków: najpierw wczytać cały wiersz przez getline, a potem rozebrać go na kawałki. Do rozbierania służy stringstream.
stringstream — strumień z napisu
string s;
while (getline(cin, s)) {
stringstream ss(s); // strumień, który czyta z napisu s
long long x, suma = 0;
while (ss >> x) suma += x;
cout << suma << "\n";
}
stringstream ss(s); tworzy strumień, który zamiast z wejścia czyta z napisu s. Mieszka w bibliotece <sstream> (a bits/stdc++.h już ją ma). Wszystko, co znasz o cin, działa tak samo: ss >> x przeskakuje spacje, czyta liczbę, w warunku odpowiada „czy się udało”. Jedyna różnica: taśmą jest teraz jeden wiersz, więc while (ss >> x) kończy się na końcu wiersza.
Pusty wiersz daje pusty strumień — pętla nie obróci się ani razu i suma zostanie 0. Bardzo ważne: stringstream tworzymy w środku pętli, nowy dla każdego wiersza. (To dokładnie ta sama zasada co przy wielu testach w części 2.)
Strumień z napisu dostanie osobną lekcję (Stringstream, numer 29), z zamianami typów i budowaniem napisów. Tu wystarczy nam czytanie.
Słowa w wierszu
string s;
int nr = 0;
while (getline(cin, s)) {
nr++;
stringstream ss(s);
string w, najdluzsze;
int ile = 0;
while (ss >> w) {
ile++;
if (w.size() > najdluzsze.size()) najdluzsze = w;
}
cout << nr << ": " << ile << " slow, najdluzsze: " << najdluzsze << "\n";
}
Ze słowami jest tak samo: ss >> w czyta kolejne słowa wiersza. Trzy spacje między „Ala” a „ma” nie tworzą pustych słów — strumień je przeskakuje, tak jak cin.
To najprostszy i najpewniejszy sposób na liczenie słów w wierszu. W części 4 liczyliśmy słowa znak po znaku z flagą — tu robi to za nas strumień.
Separatory w środku wiersza: char jako „zjadacz”
int h1, m1, h2, m2;
char c;
while (cin >> h1 >> c >> m1 >> c >> h2 >> c >> m2) {
int minuty = (h2 * 60 + m2) - (h1 * 60 + m1);
cout << minuty << " min\n";
}
char a, b, c;
int x, y;
while (cin >> a >> x >> b >> y >> c) {
cout << x + y << " ";
}
cout << "\n";
Gdy format każdego kawałka jest stały, nie trzeba getline ani stringstream. Wystarczy sztuczka z lekcji Input / Output: separator (dwukropek, minus, nawias, przecinek) wczytujemy do zmiennej char, której potem nie używamy — jej zadaniem jest tylko „zjeść” znak. Teraz robimy to w pętli while, do końca danych.
Minus przed liczbą nie przeszkadza: w (3,-4) zmienna b zjada przecinek, a cin >> y czyta całe −4 razem ze znakiem. Kłopot byłby tylko wtedy, gdyby separatorem był sam minus, a liczby mogły być ujemne — wtedy trzeba myśleć.
Rozcinanie po wybranym znaku: getline(ss, pole, ',')
string s;
getline(cin, s);
stringstream ss(s);
string pole;
int nr = 0;
while (getline(ss, pole, ',')) {
nr++;
cout << nr << ": [" << pole << "]\n";
}
getline działa na każdym strumieniu — także na stringstream. Z trzecim argumentem czyta do wybranego znaku i go zjada, więc while (getline(ss, pole, ',')) tnie wiersz na kawałki między przecinkami. Spacje zostają w polach („Nowy Sacz”), a dwa przecinki obok siebie dają puste pole.
Pole z liczbą zamienisz na liczbę przez stoi(pole) albo stoll(pole) — znasz je z lekcji o napisach.
Jedna pułapka: przecinek na samym końcu wiersza nie daje pustego ostatniego pola. Po nim nie ma już żadnego znaku, więc getline nic nie czyta i pętla się kończy. Jeśli puste ostatnie pole ma znaczenie, trzeba je doliczyć osobno.
Składanie liczby z cyfr
string s;
getline(cin, s);
long long x = 0, suma = 0;
bool wLiczbie = false;
for (char c : s) {
if (isdigit(c)) {
x = x * 10 + (c - '0');
wLiczbie = true;
} else if (wLiczbie) {
suma += x; // liczba się skończyła
x = 0;
wLiczbie = false;
}
}
if (wLiczbie) suma += x; // liczba na samym końcu
cout << suma << "\n";
Czasem liczby siedzą w tekście bez żadnych odstępów — „abc12de5f100”. Strumień tu nie pomoże (słowo „abc12de5f100” wczyta w całości), więc składamy liczby sami, cyfra po cyfrze: każda kolejna cyfra przesuwa dotychczasową liczbę o jedno miejsce w lewo (x * 10) i dopisuje się na końcu.
Każdy znak, który nie jest cyfrą, kończy liczbę — wtedy doliczamy ją i zaczynamy od zera. Liczbę, która stoi na samym końcu napisu, trzeba doliczyć po pętli, bo żadna litera jej już nie zakończy.
| znak | cyfra? | x po kroku | suma po kroku |
|---|---|---|---|
a, b, c | nie | 0 | 0 |
1 | tak | 0 · 10 + 1 = 1 | 0 |
2 | tak | 1 · 10 + 2 = 12 | 0 |
d | nie — koniec liczby | 0 | 12 |
e, 5, f | … | 0 | 17 |
1, 0, 0 | tak | 1 → 10 → 100 | 17 |
| (koniec napisu) | — | — | 117 |
Działanie w wierszu
string s;
while (getline(cin, s)) {
stringstream ss(s);
long long wynik, x;
char op;
ss >> wynik;
while (ss >> op >> x) {
if (op == '+') wynik += x;
else wynik -= x;
}
cout << wynik << "\n";
}
Wiersz „12+7-3+100” to liczba, a potem pary „znak, liczba”. Pierwsze ss >> wynik czyta 12 i zatrzymuje się na plusie (plus nie jest cyfrą). Potem pętla czyta pary: ss >> op bierze znak, ss >> x — liczbę.
A co z minusem? Przecież ss >> x umie czytać liczby ujemne… Ale minus zostaje zjedzony wcześniej, przez ss >> op, więc do x trafia już sama liczba. Kolejność wczytań robi tu całą robotę.
Liczba z nietypowym zapisem — rozbierz napis
string s;
long long grosze = 0;
while (cin >> s) {
size_t p = s.find(',');
if (p == string::npos) {
grosze += stoll(s) * 100;
} else {
string zl = s.substr(0, p), gr = s.substr(p + 1);
grosze += stoll(zl) * 100;
if (gr.size() == 1) grosze += (gr[0] - '0') * 10;
else grosze += stoll(gr);
}
}
cout << grosze / 100 << "," << setfill('0') << setw(2) << grosze % 100 << "\n";
Polskie kwoty pisze się z przecinkiem: 12,50. Dla C++ przecinek nie jest częścią liczby, więc cin >> double przeczytałby tylko 12. Do tego ktoś pisał niedbale: „12,5” to też dwanaście złotych i pięćdziesiąt groszy, a „3,05” — trzy złote i pięć groszy.
Gdy zapis liczby jest nietypowy, czytaj ją jako napis i rozbierz sam: find znajduje przecinek, substr wycina części, stoll zamienia je na liczby. Całość liczymy w groszach — liczby całkowite są dokładne, a double nie zawsze.
getline + stringstream ss(s) + while (ss >> x) — nowy strumień dla każdego wiersza. Stały format z separatorami: zjadaj je zmienną char. Pola oddzielone znakiem: getline(ss, pole, ',') (puste pole w środku tak, na końcu — nie). Liczby sklejone z tekstem: x = x * 10 + (c - '0') i doliczenie ostatniej po pętli. Nietypowy zapis liczby: czytaj jako napis, rozbieraj find i substr.
Rozpisz, co po kolei zabiera każde wczytanie ze strumienia — a dopiero potem kliknij „Pokaż odpowiedź”.
string s = "4 5 6";
stringstream ss(s);
int x, suma = 0;
while (ss >> x) suma += x;
cout << suma;
Pokaż odpowiedź
stringstream ss("10 kot 20");
int x, ile = 0;
while (ss >> x) ile++;
cout << ile;
Pokaż odpowiedź
stringstream ss("a,b,,c");
string p;
int ile = 0;
while (getline(ss, p, ',')) ile++;
cout << ile;
Pokaż odpowiedź
stringstream ss("a,b,");
string p;
int ile = 0;
while (getline(ss, p, ',')) ile++;
cout << ile;
Pokaż odpowiedź
stringstream ss("12:05");
int h, m;
char c;
ss >> h >> c >> m;
cout << h * 60 + m;
Pokaż odpowiedź
string s = "x7y42";
int x = 0;
for (char c : s)
if (isdigit(c)) x = x * 10 + (c - '0');
cout << x;
Pokaż odpowiedź
stringstream ss("5-2+10");
int w, x;
char op;
ss >> w;
while (ss >> op >> x) w += (op == '+' ? x : -x);
cout << w;
Pokaż odpowiedź
string s = "3,5";
size_t p = s.find(',');
cout << s.substr(0, p) << " " << s.substr(p + 1);
Pokaż odpowiedź
8 ćwiczeń do tej części
Kliknij zadanie — otworzy się w sprawdzarce w nowej karcie. Napisz program u siebie, sprawdź go na przykładzie, wklej cały kod i kliknij Wyślij. Utknąłeś? Każde zadanie ma wskazówkę.
Polecenia różnych typów — każde z innymi danymi
W wielu zadaniach wejście to lista poleceń: „dodaj”, „usuń”, „pokaż”, „ile”. Każde polecenie ma inne dane: jedno ma liczbę, drugie dwie, trzecie żadnej, czwarte — cały tekst do końca wiersza. Program czyta najpierw nazwę polecenia, a dopiero ona mówi mu, co wczytać dalej.
Najpierw nazwa polecenia, potem jego dane
int q;
cin >> q;
long long saldo = 0;
while (q--) {
string p;
cin >> p;
if (p == "WPLATA") {
long long x;
cin >> x;
saldo += x;
} else if (p == "WYPLATA") {
long long x;
cin >> x;
if (saldo >= x) saldo -= x;
else cout << "ODMOWA\n";
} else { // STAN
cout << saldo << "\n";
}
}
Schemat jest zawsze ten sam: wczytaj słowo polecenia, a potem w gałęzi if dla tego polecenia — dokładnie tyle danych, ile ono ma. WPLATA i WYPLATA mają po jednej liczbie, STAN nie ma żadnej.
Zanim zaczniesz pisać, zrób sobie na kartce tabelkę poleceń z treści:
| polecenie | dane po nim | co wypisuje |
|---|---|---|
| WPLATA | x | nic |
| WYPLATA | x | ODMOWA, gdy brakuje pieniędzy |
| STAN | — | saldo |
Polecenia jako znaki i jako numery
int q;
cin >> q;
vector<int> v;
while (q--) {
int typ;
cin >> typ;
if (typ == 1) { // 1 x — dopisz x na koniec
int x;
cin >> x;
v.push_back(x);
} else if (typ == 2) { // 2 — usuń ostatni
if (!v.empty()) v.pop_back();
} else { // 3 i — wypisz i-ty (od 1)
int i;
cin >> i;
if (i <= (int)v.size()) cout << v[i - 1] << "\n";
else cout << "BRAK\n";
}
}
Na olimpiadzie polecenia zapisuje się zwykle numerami: „1 x”, „2”, „3 i”. Czyta się je jeszcze prościej — do zmiennej int. Czasem polecenie to jeden znak, np. + 5, - 3, ? — wtedy czytamy je do char.
Tu typ 2 nie ma żadnych danych, a typy 1 i 3 mają po jednej liczbie — ale znaczą one coś zupełnie innego. Zwróć też uwagę na ochronę przed złymi danymi: pop_back tylko na niepustym vectorze i sprawdzenie, czy element numer i w ogóle istnieje.
Nie czytaj za dużo — i nie czytaj za mało
int q;
cin >> q;
long long licznik = 0, x = 0;
char op = ' ';
while (q--) {
cin >> op >> x; // BŁĄD: polecenie ? nie ma liczby
if (op == '+') licznik += x;
else if (op == '-') licznik -= x;
else cout << licznik << "\n";
}
int q;
cin >> q;
long long licznik = 0;
while (q--) {
char op;
cin >> op;
if (op == '?') {
cout << licznik << "\n";
} else {
long long x;
cin >> x;
if (op == '+') licznik += x;
else licznik -= x;
}
}
Lewy program przy każdym poleceniu czyta znak i liczbę. Przy pytajniku liczby nie ma, więc cin >> x sięga do następnego wiersza i trafia na plus z polecenia „+ 3”. Plus mógłby być początkiem liczby, ale zaraz za nim stoi spacja — wczytanie się nie udaje i strumień się psuje. Od tej chwili nic już nie jest czytane, op zostaje pytajnikiem, a program w kółko wypisuje 5. Jedno polecenie bez liczby zepsuło całą resztę.
Prawy program czyta liczbę tylko w gałęzi, która jej potrzebuje. Odwrotny błąd — czytanie za mało (np. pominięcie drugiej liczby polecenia) — działa tak samo jak niedoczytany test z części 2: następne polecenie zaczyna się od śmieci.
Polecenie z tekstem do końca wiersza
vector<string> notatki;
string p;
while (cin >> p) {
if (p == "NOTUJ") {
string t;
getline(cin >> ws, t); // reszta wiersza
notatki.push_back(t);
} else if (p == "POKAZ") {
int k;
cin >> k;
if (k <= (int)notatki.size()) cout << notatki[k - 1] << "\n";
else cout << "BRAK\n";
}
}
Gdy po słowie polecenia stoi tekst ze spacjami, cin >> wczytałby z niego tylko pierwsze słowo. Bierzemy więc resztę wiersza przez getline.
Uwaga na spację: po cin >> p kursor stoi tuż za słowem NOTUJ, czyli przed spacją. Zwykły getline(cin, t) dałby więc „␣kupic mleko” — ze spacją na początku. Dlatego getline(cin >> ws, t): ws zjada tę spację. (Można też wczytać zwykłym getline i obciąć pierwszy znak: t = t.substr(1).)
Polecenia na zbiorze i multisecie
int q;
cin >> q;
multiset<int> m;
while (q--) {
int typ;
cin >> typ;
if (typ == 1) {
int x;
cin >> x;
m.insert(x);
} else if (typ == 2) {
int x;
cin >> x;
auto it = m.find(x);
if (it != m.end()) m.erase(it); // jedna kopia
} else {
if (m.empty()) cout << "PUSTO\n";
else cout << *m.begin() << " " << *m.rbegin() << "\n";
}
}
Polecenia to najczęstszy sposób, w jaki zadania sprawdzają struktury danych: zbiór, multiset, vector jako stos. Program jest zawsze taki sam — pętla po poleceniach, rozgałęzienie po typie — a zmienia się tylko to, co robimy w każdej gałęzi.
Typy 1 i 2 mają liczbę, typ 3 — nie. Wyjęcie jednej kopii z multisetu to erase(find(x)), ale tylko po sprawdzeniu, że find coś znalazł — znasz to z lekcji o zbiorze. Polecenie „2 9” dotyczy liczby, której nie ma, więc nic nie robi.
Ile jest poleceń? Te same trzy formaty
string p;
int x = 0, y = 0;
while (cin >> p && p != "KONIEC") {
if (p == "GDZIE") {
cout << "(" << x << ", " << y << ")\n";
} else {
int k;
cin >> k;
if (p == "N") y += k;
else if (p == "S") y -= k;
else if (p == "E") x += k;
else x -= k;
}
}
Liczbę poleceń zadanie podaje na jeden z trzech znanych już sposobów: liczba q na początku (while (q--)), słowo kończące (while (cin >> p && p != "KONIEC")) albo koniec danych (while (cin >> p)) — dokładnie jak w części 1.
Ostatnie else obsługuje wszystkie cztery kierunki naraz, bo wszystkie mają po jednej liczbie. Gdyby polecenia miały różne dane, każde dostałoby własną gałąź.
string, znak do char, numer do int), potem w gałęzi tego polecenia — dokładnie jego dane. Za dużo wczytanych danych psuje strumień, za mało — przesuwa następne polecenia. Tekst do końca wiersza: getline(cin >> ws, t). Liczba poleceń: q na początku, słowo kończące albo koniec danych.
Przejdź polecenia po kolei, trzymając na kartce stan programu — a dopiero potem kliknij „Pokaż odpowiedź”.
int q, s = 0;
cin >> q;
while (q--) {
char op;
cin >> op;
if (op == '?') cout << s << " ";
else {
int x;
cin >> x;
s += x;
}
}
3↵+ 4↵?↵+ 1Pokaż odpowiedź
int q;
cin >> q;
set<int> s;
while (q--) {
string p;
cin >> p;
if (p == "DODAJ") {
int x;
cin >> x;
s.insert(x);
} else cout << s.size() << " ";
}
4↵DODAJ 5↵DODAJ 5↵ILE↵DODAJ 7Pokaż odpowiedź
int q;
cin >> q;
vector<int> v;
while (q--) {
int t;
cin >> t;
if (t == 1) {
int x;
cin >> x;
v.push_back(x);
} else if (t == 2) v.pop_back();
else cout << v.size();
}
5↵1 7↵1 8↵2↵3↵1 9Pokaż odpowiedź
string p, t;
cin >> p;
getline(cin, t);
cout << "[" << t << "]";
NOTUJ ala maPokaż odpowiedź
string p;
int x = 0, y = 0;
while (cin >> p && p != "KONIEC") {
if (p == "GDZIE") cout << "(" << x << ", " << y << ")";
else {
int k;
cin >> k;
if (p == "N") y += k;
else if (p == "S") y -= k;
else if (p == "E") x += k;
else x -= k;
}
}
E 2↵N 1↵W 5↵GDZIE↵KONIECPokaż odpowiedź
string p;
int wynik = 0;
while (cin >> p) {
if (p == "X") {
int a, b;
cin >> a >> b;
wynik += a * b;
} else {
int a;
cin >> a;
wynik -= a;
}
}
cout << wynik;
X 2 3↵Y 4↵X 1 1Pokaż odpowiedź
int q;
cin >> q;
multiset<int> m;
while (q--) {
int typ;
cin >> typ;
if (typ == 1) {
int x;
cin >> x;
m.insert(x);
} else if (typ == 2) {
int x;
cin >> x;
auto it = m.find(x);
if (it != m.end()) m.erase(it);
} else {
if (m.empty()) cout << "PUSTO";
else cout << *m.begin() << " " << *m.rbegin();
}
}
4↵1 3↵1 3↵2 3↵3Pokaż odpowiedź
int q, ile = 0;
cin >> q;
string p;
while (q--) {
cin >> p;
if (p == "DODAJ") {
int x;
cin >> x;
}
ile++;
}
cout << ile;
3↵DODAJ 1↵POKAZ↵DODAJ 2Pokaż odpowiedź
8 ćwiczeń do tej części
Kliknij zadanie — otworzy się w sprawdzarce w nowej karcie. Napisz program u siebie, sprawdź go na przykładzie, wklej cały kod i kliknij Wyślij. Utknąłeś? Każde zadanie ma wskazówkę.
Duże dane — bufor, sync_with_stdio, generatory i pliki
Przy dziesięciu liczbach nie ma znaczenia, jak je czytasz. Przy milionie — ma ogromne. Na olimpiadzie dane mają często po kilka megabajtów i zdarza się, że program z dobrym algorytmem nie mieści się w limicie czasu tylko dlatego, że samo wczytywanie i wypisywanie trwa za długo. Zobaczmy, ile to kosztuje — zmierzyliśmy to na tym samym serwerze, na którym działa sprawdzarka:
| co robi program | czas |
|---|---|
wczytuje 10⁶ liczb przez cin (domyślne ustawienia) | ok. 255 ms |
wczytuje 10⁶ liczb przez cin po sync_with_stdio(false) | ok. 46 ms |
wczytuje 10⁶ liczb przez scanf | ok. 85 ms |
wypisuje 10⁶ wierszy przez cout z endl | ok. 480 ms |
wypisuje 10⁶ wierszy przez cout z "\n" | ok. 50 ms |
wypisuje 10⁶ wierszy przez printf | ok. 63 ms |
Różnice są pięcio- i dziesięciokrotne — a przy limicie jednej sekundy pół sekundy na samo wypisanie to bardzo dużo. Na Twoim komputerze liczby będą inne (w konsoli Windowsa endl bywa jeszcze dużo wolniejszy), ale proporcje zostaną podobne. Za chwilę zobaczysz, skąd te różnice się biorą i jak je usunąć dwiema linijkami.
Bufor — dlaczego endl jest wolny
cout nie wysyła na ekran każdego znaku osobno. Zbiera znaki w buforze — kawałku pamięci programu — i dopiero gdy bufor się zapełni (albo program się kończy), wysyła wszystko naraz. To jak ciężarówka, która odjeżdża, dopiero gdy jest pełna: jeden kurs z tysiącem paczek jest dużo tańszy niż tysiąc kursów z jedną paczką, bo każda wysyłka to rozmowa programu z systemem operacyjnym.
A endl? To enter i rozkaz „wyślij teraz” (opróżnij bufor). Program z endl po każdym wierszu wysyła ciężarówkę z jedną paczką — milion razy. Program z "\n" dokłada enter do bufora i jedzie dalej. Na ekranie widać dokładnie to samo; różnica jest tylko w czasie. Sprawdź to w ramce: najpierw z endl, potem przełącz na "\n" i porównaj liczbę wysyłek.
W ramce bufor mieści 16 znaków, żeby było go widać. Prawdziwy bufor ma kilka tysięcy znaków, więc milion krótkich wierszy z "\n" to zaledwie kilkaset wysyłek, a z endl — milion. Wniosek na zawody: kończ wiersze znakiem "\n". endl przydaje się tylko wtedy, gdy wynik musi pojawić się na ekranie natychmiast — na przykład w programie, który rozmawia z użytkownikiem.
Dwie linijki, które przyspieszają czytanie
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
long long suma = 0;
for (int i = 0; i < n; i++) {
long long x;
cin >> x;
suma += x;
}
cout << suma << "\n";
return 0;
}
Te dwie linijki znasz z lekcji Input / Output. Teraz wiesz dość, żeby zrozumieć, co robią.
ios_base::sync_with_stdio(false); — C++ odziedziczył po języku C funkcje scanf i printf. Domyślnie cin i cout są z nimi zsynchronizowane: czytają i piszą „przez nie”, znak po znaku, żeby można je było dowolnie mieszać. To kosztuje. Ta linijka wyłącza synchronizację — cin i cout dostają własne, duże bufory i przyspieszają kilka razy.
cin.tie(nullptr); — domyślnie cin jest „przywiązany” do cout: przed każdym wczytaniem opróżnia bufor cout, żeby pytanie „Podaj liczbę:” było widać, zanim program zacznie czekać. Na zawodach nikt nie czyta pytań, a gdy program na przemian czyta i pisze (pytanie — odpowiedź — pytanie…), każde wczytanie robiłoby wysyłkę. Ta linijka odwiązuje cin od cout.
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cout << "1 ";
printf("2 ");
cout << "3 ";
printf("4\n");
return 0;
}
Cena za szybkość: po sync_with_stdio(false) cout i printf mają osobne bufory, więc ich teksty mogą się wymieszać w dowolnej kolejności. Tutaj bufor cout („1 3 ”) został wysłany przed buforem printf („2 4”) — choć w programie stały na przemian. Na innym komputerze kolejność może być jeszcze inna.
Zasada: po tych dwóch linijkach używaj tylko cin i cout (albo tylko scanf i printf) — nigdy obu naraz.
Przetwarzaj w locie — nie zapisuj, czego nie trzeba
Duże dane to nie tylko czas, ale i pamięć. Liczba int zajmuje 4 bajty, long long — 8. Dziesięć milionów long long to 80 MB — przy limicie 256 MB to już spory kawałek, a przy 64 MB (zdarza się na olimpiadzie) — za dużo. Zanim więc zapiszesz dane do vectora, zapytaj: czy muszę do nich wracać?
| o co pyta zadanie | trzeba zapamiętać dane? |
|---|---|
| suma, średnia, najmniejsza, największa, ile spełnia warunek | nie — licz w locie |
| porównanie z poprzednią liczbą, seria, zmiany kierunku | nie — pamiętaj tylko poprzednią |
| wypisanie od końca, sortowanie, mediana | tak |
| pytania o fragmenty (sumy od a do b) | tak — np. sumy prefiksowe |
Dane z generatora
long long n, s, a, b, m;
cin >> n >> s >> a >> b >> m;
long long x = s, suma = 0, mx = -1;
for (long long i = 1; i <= n; i++) {
if (i > 1) x = (x * a + b) % m;
suma += x;
mx = max(mx, x);
}
cout << suma << " " << mx << "\n";
Gdy danych jest naprawdę dużo — dziesiątki milionów liczb — nie da się ich nawet przesłać. Wtedy zadanie podaje przepis: generator z lekcji o złożoności, x₁ = s, xᵢ = (xᵢ₋₁ · a + b) mod m. Na wejściu jest tylko pięć liczb, a program sam wylicza kolejne wyrazy.
Tu ciąg to 3, 26, 87, 14, 3. Każdy wyraz od razu doliczamy i porównujemy — bez tablicy. Iloczyn x * a może mieć prawie 10¹⁸, więc wszystko w long long, a modulo bierzemy po każdym kroku.
Suma kontrolna — gdy wyników jest za dużo
int n;
cin >> n;
const long long MOD = 1000000007;
long long pref = 0, kontrolna = 0;
for (int i = 1; i <= n; i++) {
long long x;
cin >> x;
pref += x; // i-ty wynik: suma pierwszych i liczb
kontrolna = (kontrolna + i * (pref % MOD)) % MOD;
}
cout << kontrolna << "\n";
Bywa i odwrotnie: wyników jest tyle, że nikt nie chce ich wypisywać ani porównywać. Wtedy zadanie każe wypisać sumę kontrolną — jedną liczbę, która zależy od wszystkich wyników, np. 1 · w₁ + 2 · w₂ + … + n · wₙ modulo 10⁹ + 7. Mnożenie przez numer sprawia, że zamiana kolejności dwóch wyników też zmienia sumę.
Tu wynikami są sumy prefiksów: 5, 6, 8, 11. Suma kontrolna: 1 · 5 + 2 · 6 + 3 · 8 + 4 · 11 = 85. Modulo bierzemy po każdym dodaniu — tak jak w lekcji o modulo.
Pliki: ofstream i ifstream
ofstream wy("liczby.txt"); // plik do pisania
for (int i = 1; i <= 5; i++) wy << i * i << "\n";
wy.close(); // zamknij — teraz wszystko jest zapisane
ifstream we("liczby.txt"); // ten sam plik, do czytania
int x, suma = 0;
while (we >> x) suma += x;
cout << "Suma z pliku: " << suma << "\n";
ifstream brak("nie_ma_takiego.txt");
if (!brak) cout << "Nie udalo sie otworzyc pliku\n";
Strumień nie musi być połączony z klawiaturą i ekranem. ofstream (z biblioteki <fstream>) to strumień, który pisze do pliku — używasz go dokładnie jak cout. ifstream czyta z pliku — dokładnie jak cin, łącznie z while (we >> x) i getline(we, s).
Plik, którego nie ma, nie wywołuje błędu programu — strumień po prostu jest od razu „zepsuty”, a każde wczytanie się nie udaje. Dlatego warto sprawdzić if (!we) zaraz po otwarciu.
Na olimpiadzie pliki zdarzają się rzadko — prawie zawsze dane przychodzą na standardowe wejście. Ale niektóre konkursy (i wiele starszych zadań) każą czytać z pliku o podanej nazwie i do niego pisać.
freopen — testowanie bez przepisywania danych
#include <bits/stdc++.h>
using namespace std;
int main() {
{ ofstream f("dane.txt"); f << "3\n10 20 30\n"; } // u siebie: plik z Notatnika
freopen("dane.txt", "r", stdin); // od teraz cin czyta z pliku
int n;
cin >> n;
long long suma = 0;
for (int i = 0; i < n; i++) {
long long x;
cin >> x;
suma += x;
}
cout << suma << "\n";
return 0;
}
Przy dużych przykładach przepisywanie danych na klawiaturze za każdym uruchomieniem jest męczące. Zapisz je raz do pliku (np. w Notatniku, obok programu) i dodaj na początku main jedną linijkę: freopen("dane.txt", "r", stdin);. Od tej chwili cin czyta z pliku, a reszta programu się nie zmienia. Tak samo freopen("wynik.txt", "w", stdout) przekieruje cout do pliku.
Pierwsza linijka w main tylko przygotowuje plik, żeby przykład dał się uruchomić tutaj — u siebie tworzysz plik ręcznie.
dane.txt u niej nie ma. Jeśli zostawisz freopen, program przeczyta pustkę i dostaniesz złą odpowiedź. Przed wysłaniem usuń tę linijkę albo zakomentuj ją: // freopen("dane.txt", "r", stdin);.
ios_base::sync_with_stdio(false); cin.tie(nullptr); na początku main, wiersze kończone "\n", a nie endl (endl = enter + wysyłka bufora). Po wyłączeniu synchronizacji nie mieszaj cin/cout z scanf/printf. Nie zapamiętuj danych, do których nie wracasz. Dane z generatora licz w locie, a gdy wyników jest za dużo — sumę kontrolną. Pliki: ofstream pisze, ifstream czyta, freopen przekierowuje cin — tylko u siebie.
Policz na kartce kolejne wartości — a dopiero potem kliknij „Pokaż odpowiedź”.
cout << "a" << endl << "b" << "\n";
Pokaż odpowiedź
long long x = 2;
for (int i = 1; i <= 3; i++) x = (x * 3 + 1) % 10;
cout << x;
Pokaż odpowiedź
long long s = 0;
for (int i = 1; i <= 4; i++) s = (s + i * i) % 7;
cout << s;
Pokaż odpowiedź
int n, x, mx = INT_MIN, ile = 0;
cin >> n;
while (n--) {
cin >> x;
if (x > mx) {
mx = x;
ile = 1;
} else if (x == mx) ile++;
}
cout << mx << " " << ile;
4↵3 9 2 9Pokaż odpowiedź
ofstream wy("t.txt");
wy << "7 8";
wy.close();
ifstream we("t.txt");
int a, b;
we >> a >> b;
cout << a + b;
Pokaż odpowiedź
ifstream we("nie_ma_takiego.txt");
int x = 5;
we >> x;
cout << x << " " << (we ? 1 : 0);
Pokaż odpowiedź
cout << sizeof(long long) * 10000000 / 1000000;
Pokaż odpowiedź
string w;
for (int i = 1; i <= 3; i++) w += to_string(i) + "\n";
cout << w.size();
Pokaż odpowiedź
8 ćwiczeń do tej części
Kliknij zadanie — otworzy się w sprawdzarce w nowej karcie. Napisz program u siebie, sprawdź go na przykładzie, wklej cały kod i kliknij Wyślij. Utknąłeś? Każde zadanie ma wskazówkę.
Baza zadań: wejście i wyjście w praktyce
Znasz już cały warsztat: trzy formaty danych i stan strumienia, wiele testów w jednym wejściu, separatory, kolumny i tabele, czytanie znak po znaku z cin.get i peek, getline od środka, rozbieranie wiersza strumieniem stringstream, polecenia z różną liczbą danych, a do tego bufor, sync_with_stdio, generatory i sumy kontrolne. Czas na zadania, które łączą kilka z tych rzeczy naraz — wiele z nich to formaty wzięte prosto z życia: rachunki, kalendarze, tabele ligowe, dzienniki serwera, pliki CSV i Markdown. Zadania są ułożone od najłatwiejszego do najtrudniejszego: najpierw rozgrzewka, potem zadania średnie, a na końcu trudne — z wielkim finałem.
Przy każdym zadaniu widać, jakich zagadnień używa — jeśli coś brzmi obco, wróć do odpowiedniej części, mapa lekcji jest na górze strony. A tu masz najważniejsze schematy w jednym miejscu:
Ściąga: gotowe schematy
Ile jest danych?
cin >> n; for (… n razy) cin >> x; while (cin >> x && x != 0) while (cin >> a >> b && !(a == 0 && b == 0)) while (cin >> s && s != "KONIEC") while (cin >> x) // do końca
Wczytanie zawsze w warunku. Nigdy while (!cin.eof()).
Stan strumienia
if (cin >> x) // udało się? cin.fail() // nieudane wczytanie cin.eof() // czytał za końcem cin.clear(); // napraw i czytaj dalej
Litera zamiast liczby: liczba = 0, znak zostaje na taśmie, strumień zepsuty.
Wiele testów
int t; cin >> t;
for (int k = 1; k <= t; k++) {
// zmienne i kontenery TUTAJ
// wczytaj CAŁY test
cout << "Case #" << k << ": " …
}
Globalne liczniki czyść tylko tam, gdzie test ich użył.
Separatory i kolumny
if (i > 0) cout << ", "; if ((i + 1) % k == 0) cout << "\n"; w = to_string(x).size(); cout << setw(w) << x; // prawo cout << left << setw(w); // lewo string(k, '-')
Najpierw policz szerokości, potem wypisuj.
Znak po znaku
cin >> c; // przeskakuje białe cin.get(c); // bierze wszystko while (cin.get(c)) // cały tekst cin >> ws; cin.peek() // zajrzyj c - '0' // cyfra na liczbę
Plansza bez spacji: cin >> wiersz albo cin >> t[i][j].
Całe wiersze
while (getline(cin, s)) cin >> n; cin.ignore(); getline(cin >> ws, s); getline(cin, s, ';');
ws zjada też spacje na początku wiersza i puste wiersze — czasem to źle.
Rozbieranie wiersza
stringstream ss(s); while (ss >> x) // liczby while (getline(ss, p, ',')) // pola ss >> a >> op >> b x = x * 10 + (c - '0');
Nowy stringstream dla każdego wiersza.
Duże dane
ios_base::sync_with_stdio(false); cin.tie(nullptr); cout << x << "\n"; // nie endl // nie mieszaj z printf/scanf
Przetwarzaj w locie. Za dużo wyniku? Suma kontrolna.
cin >> do kawałków bez spacji, getline do wierszy, stringstream do wnętrza wiersza, cin.get do pojedynczych znaków. 4) Najpierw napisz samo wczytywanie i wypisz to, co wczytałeś — dopiero gdy się zgadza, dopisz obliczenia. 5) Sprawdź przykład z treści znak po znaku: spacje, przecinki, puste wiersze. 6) Pomyśl o największym teście: long long, szybkie wejście, wynik bez endl.
Rozgrzewka · zadania 1–10
Jeden albo dwa pomysły naraz: lista obecności, rachunek z kropkami, tekst w lustrze, wc, histogram, pogoda dzień po dniu, kody pocztowe, obrót planszy, szachownica w ramce i średnie ocen.
Średnie · zadania 11–20
Kilka sztuczek naraz: kółko i krzyżyk, kartka z kalendarza, tabela ligi, kalkulator z kolejnością działań, dziennik serwera, tekst w ramce, słownik zamian, rozkład jazdy, kalendarz wydarzeń i biblioteka.
Trudne · zadania 21–28
Prawdziwe formaty z życia: macierz i lista w nawiasach, tabela w Markdownie, własna sprawdzarka, arkusz kalkulacyjny, formatowanie kodu, CSV z cudzysłowami — a na końcu wielki finał: tabela wyników zawodów.