C++ · Etap 2 · Lekcja 08

String — napisy w C++

Imię, słowo, całe zdanie, tekst czytany wiersz po wierszu, a nawet liczba tak wielka, że nie mieści się w żadnym typie — wszystko to zapiszesz w napisie. Podstawy już znasz: sklejanie plusem, length() i s[i]. Teraz poznasz napisy naprawdę. Nauczysz się wczytywać tekst na każdy sposób, rozpoznawać rodzaje znaków, budować i zmieniać napisy, porównywać je słownikowo, wycinać i szukać fragmentów, liczyć na olbrzymich liczbach zapisanych cyfra po cyfrze, a na koniec rozwiązywać olimpijskie zadania z tekstem. Po każdej części czekają ćwiczenia ze sprawdzarką.

66 ćwiczeń w trakcie lekcji29 zadań w bazie na koniec95 ze sprawdzarką C++
Filmy z OKI

Wolisz obejrzeć?

Olimpijskie Koło Informatyczne nagrywa swoje zajęcia i udostępnia je za darmo. Poniżej 4 odcinki o tym temacie — dobre uzupełnienie, jeśli wolisz obejrzeć niż przeczytać.

Materiały Olimpijskiego Koła Informatycznego — kanał zewnętrzny. Kliknięcie odtwarza film tutaj, bez opuszczania strony.

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 i Tablice. Z napisami spotkałeś się już wiele razy, tylko zawsze trochę przy okazji. W lekcji o typach poznałeś string, sklejanie plusem, length(), pojedyncze litery s[0] oraz znaki char i ich kody ASCII. W Input / Output — getline. W lekcjach o pętlach przechodziłeś napis znak po znaku i budowałeś nowe napisy, a w tablicach liczyłeś litery w tablicy liczników.

Teraz zbierzemy to wszystko w jednym miejscu i pójdziemy dużo dalej. Zobaczysz, jak napis wygląda od środka i dlaczego s.length() - 1 potrafi dać liczbę z dwudziestu cyfr. Poznasz gotowe funkcje do rozpoznawania znaków i metody, które wycinają, znajdują, usuwają i wstawiają fragmenty tekstu. Dowiesz się, w jakiej kolejności C++ ustawia słowa i dlaczego „Zebra” jest przed „antylopą”. Nauczysz się liczyć na liczbach, które mają sto cyfr, i rozwiązywać zadania olimpijskie z tekstem.

Uczymy się tak samo jak poprzednio. Przepisuj przykłady do swojego edytora i uruchamiaj je. Przy pytaniach „Co wypisze program?” najpierw rozpisz sobie znaki napisu w pudełkach z numerami i odpowiedz w głowie, a dopiero potem sprawdzaj. Po każdej części rób ćwiczenia w sprawdzarce. Części jest osiem, a ćwiczeń dużo — nie spiesz się i rób przerwy.

CZĘŚĆ 01–02

Napis i wczytywanie

Znaki w pudełkach, długość i pusty napis, a potem słowa, wiersze i cały tekst aż do końca danych.

CZĘŚĆ 03–04

Znaki i budowanie

Rodzaje znaków i toupper, liczniki i serie, a potem zmienianie i budowanie nowych napisów.

CZĘŚĆ 05–06

Porównywanie i fragmenty

Kolejność słownikowa, a potem substr, find, erase, insert i replace.

CZĘŚĆ 07–08

Liczby i olimpiada

Cyfry i olbrzymy zapisane jako napisy, liczniki liter, szyfry, okna i sumy prefiksowe.

Przypomnienie: złota zasada sprawdzarki Sprawdzarka porównuje Twoje wyjście z oczekiwanym znak po znaku, więc wypisujesz dokładnie to, o co prosi zadanie — bez „Podaj słowo:” i bez dodatkowych słów. Spacje na końcu wiersza są ignorowane. Uważaj natomiast na spacje w środku wiersza, na wielkość liter i na znaki przestankowe — w zadaniach z napisami to one najczęściej decydują o wyniku. Teksty we wszystkich zadaniach tej lekcji składają się z liter bez polskich ogonków, cyfr, spacji i znaków przestankowych. Dlaczego bez ogonków — dowiesz się w części 1.

Mapa lekcji

Napis to rząd pudełek ze znakami

W lekcji o tablicach poznałeś rząd pudełek z numerami. Napis — zmienna typu string — w środku wygląda bardzo podobnie. To też rząd pudełek, tylko w każdym leży jeden znak, czyli wartość typu char. Pudełka są ponumerowane od zera, a do każdego dobierasz się zapisem s[numer]. Są dwie ważne różnice: napis sam wie, ile ma pudełek, i potrafi dokładać nowe pudełka na końcu, kiedy dopisujesz tekst. Nie musisz więc z góry zgadywać rozmiaru, jak przy tablicy.

string s = „kotek”; — pięć znaków w pięciu pudełkach o numerach od 0 do 4. Napis wie, że ma 5 pudełek: tyle zwraca s.length().
kotek.cpp
string s = "kotek";
cout << s << "\n";            // cały napis
cout << s.length() << "\n";   // ile ma znaków
cout << s[0] << "\n";         // pierwszy znak
cout << s[4] << "\n";         // ostatni znak
cout << s[1] << s[2] << "\n"; // drugi i trzeci, jeden za drugim
▶ Wyjście
kotek 5 k k ot

Prześledź wyjście linijka po linijce. cout << s wypisuje cały napis naraz — tego tablica nie potrafiła. s.length() mówi, ile jest pudełek: 5.

s[0] to pierwsze pudełko, a s[4] — ostatnie. W słowie „kotek” oba zawierają literę k, dlatego w wyjściu są dwa k pod rząd.

Ostatnia linijka wypisuje dwa znaki jeden za drugim: s[1] to o, a s[2] to t. Między nimi nie ma spacji, bo żadnej nie wypisaliśmy.

Numery pudełek: od 0 do długość − 1 Napis o długości n ma pudełka s[0], s[1], …, s[n - 1]. Pierwszy znak to zawsze s[0], a ostatni — s[n - 1], czyli s[s.length() - 1]. Pudełka s[n] już nie ma. To dokładnie ta sama zasada co w tablicach.

Długość: length() i size()

Długość napisu to liczba jego znaków. Liczą się wszystkie znaki: litery, cyfry, kropki, wykrzykniki — i spacje. Spacja to pełnoprawny znak, który zajmuje swoje pudełko. Na rysunkach będziemy ją pokazywać jako ␣, żeby było ją widać.

„Ala ma kota” ma 11 znaków. Spacje (niebieskie) stoją w pudełkach 3 i 6 — tak samo jak litery.
dlugosci.cpp
string a = "Ala ma kota";
string b = "";       // pusty napis — zero znaków
string c = " ";      // jedna spacja
string d = "?!";
cout << a.length() << "\n";
cout << b.length() << "\n";
cout << c.length() << "\n";
cout << d.size() << "\n";   // size() to to samo co length()
▶ Wyjście
11 0 1 2

length() i size() robią dokładnie to samo — możesz używać, którego chcesz. W wielu programach olimpijskich zobaczysz size(), bo tak samo nazywa się długość w innych strukturach, które poznasz później.

Zwróć uwagę na napis b. Dwa cudzysłowy bez niczego w środku to napis pusty — prawdziwy napis, który ma zero znaków. A c to nie pusty napis, tylko napis z jedną spacją. Na ekranie wyglądają tak samo, ale mają różne długości.

Nawiasy po length są obowiązkowe. Bez nich kompilator zgłosi błąd.

Pusty napis i empty()

Gdy tworzysz napis bez wartości — string s; — dostajesz napis pusty. To ważna różnica względem int: zmienna liczbowa utworzona w main bez wartości zawiera śmieci, a napis zawsze zaczyna jako pusty. Czy napis jest pusty, sprawdzisz metodą empty(). Zwraca prawdę albo fałsz, więc nadaje się prosto do if.

pusty.cpp
string s;                      // bez wartości — pusty
cout << s.length() << "\n";
cout << s.empty() << "\n";     // 1, czyli prawda
s = "a";
cout << s.empty() << "\n";     // 0, czyli fałsz
if (s.empty()) {
    cout << "pusto\n";
} else {
    cout << "jest tekst\n";
}
▶ Wyjście
0 1 0 jest tekst

Zapis s.empty() czytaj: „czy napis s jest pusty?”. Pamiętasz z lekcji o typach, że cout wypisuje prawdę jako 1, a fałsz jako 0.

Zamiast s.empty() możesz napisać s.length() == 0 albo s == "" — znaczą to samo. empty() jest po prostu najkrótsze i najczytelniejsze.

Pusty napis przyda się bardzo często jako punkt startowy: zaczynasz od "" i dokładasz kolejne znaki. Tak będziemy budować napisy w części 4.

Pierwszy, ostatni i środkowy znak

Te trzy pozycje pojawiają się w zadaniach bez przerwy, więc warto mieć je w małym palcu. Najwygodniej najpierw zapisać długość w zmiennej n — za chwilę zobaczysz, że to nie tylko wygoda.

Napis ma 13 znaków. Pierwszy to s[0], ostatni — s[12], czyli s[n - 1]. Środkowy (pomarańczowy) leży w pudełku 13 / 2 = 6.
pozycje.cpp
string s = "programowanie";
int n = s.length();        // 13
cout << s[0] << "\n";      // pierwszy
cout << s[n - 1] << "\n";  // ostatni
cout << s[n / 2] << "\n";  // środkowy: s[6]
cout << s.front() << s.back() << "\n";
▶ Wyjście
p e m pe

Dla nieparzystej długości środek jest jeden: przed nim i za nim stoi tyle samo znaków. W słowie o 13 znakach to pudełko 6 — przed nim pudełka 0–5, za nim 7–12, po sześć z każdej strony. Dzielenie całkowite n / 2 daje właśnie 6.

Dla parzystej długości środkowe są dwa: s[n / 2 - 1] i s[n / 2]. Sprawdź na kartce: w słowie „domek” (5 liter) środkiem jest m, a w słowie „okno” (4 litery) środkowe są k i n.

s.front() i s.back() to skróty: pierwszy i ostatni znak. Działają tylko dla napisu, który nie jest pusty.

Zmiana jednego znaku

Pudełko napisu zachowuje się jak zwykła zmienna typu char. Możesz do niego wpisać nowy znak przez =. Napis zmienia się w tym jednym miejscu, a długość zostaje taka sama. Prześledź program w tabelce obok — w każdej linijce zmienia się dokładnie jedno pudełko.

zmiana.cpp
string s = "kot";
s[0] = 'p';      // k zamienia się w p
cout << s << "\n";
s[2] = 'r';      // t zamienia się w r
cout << s << "\n";
s[1] = s[0];     // drugie pudełko dostaje kopię pierwszego
cout << s << "\n";
▶ Wyjście
pot por ppr
po linijces[0]s[1]s[2]s
string s = "kot";kotkot
s[0] = 'p';potpot
s[2] = 'r';porpor
s[1] = s[0];pprppr

Znak wpisujesz w apostrofach: 'p'. Zapis s[0] = "p"; się nie skompiluje — w cudzysłowie jest napis, a do pudełka mieści się tylko jeden znak.

Przez s[i] = … możesz tylko podmienić istniejący znak. Nowego pudełka na końcu tak nie dodasz: w trzyznakowym napisie s[3] = 'y'; to błąd. Dokładanie znaków poznasz w części 4.

Napis tworzony na różne sposoby

Napis możesz utworzyć na kilka sposobów. Pięć z nich znasz już z lekcji o typach, szósty jest nowy. W programie obok każdy napis wypisujemy w nawiasach kwadratowych — to prosty trik, dzięki któremu widać, gdzie napis się zaczyna i kończy, nawet gdy jest pusty albo kończy się spacją.

tworzenie.cpp
string a;                 // pusty
string b = "tekst";       // z gotowym tekstem
string c(4, '*');         // 4 razy ten sam znak
string d = b;             // kopia napisu b
string e = b + "!";       // sklejony z dwóch kawałków
string f(1, 'x');         // napis z jednego znaku
cout << "[" << a << "]\n";
cout << "[" << b << "]\n";
cout << "[" << c << "]\n";
cout << "[" << d << "]\n";
cout << "[" << e << "]\n";
cout << "[" << f << "]\n";
▶ Wyjście
[] [tekst] [****] [tekst] [tekst!] [x]

string c(4, '*'); to ten sam przepis co string(4, '*') z lekcji o typach: „zrób napis z czterech gwiazdek”. Najpierw liczba, potem znak w apostrofach.

string f(1, 'x'); wygląda dziwnie, ale bywa potrzebny: robi napis z jednego znaku. Znak 'x' i napis "x" to w C++ różne rzeczy — w części 4 zobaczysz, kiedy ta różnica gryzie.

Nawiasy kwadratowe w cout nie są częścią napisów — to zwykły tekst, który wypisujemy dookoła. Używaj tego triku zawsze, gdy nie masz pewności, co naprawdę jest w napisie.

Kopiowanie i porównywanie — tu napis wygrywa z tablicą

Z lekcji o tablicach pamiętasz, że tablicy nie da się skopiować znakiem =, a a == b nie porównuje jej zawartości. Z napisami jest dużo wygodniej: = robi pełną kopię, a == porównuje tekst znak po znaku. Kopia jest osobnym napisem — zmiana kopii nie rusza oryginału.

kopia.cpp
string a = "kot";
string b = a;          // b to osobna kopia
b[0] = 'p';            // zmieniamy tylko b
cout << a << " " << b << "\n";
cout << (a == b) << "\n";   // czy takie same?
b[0] = 'k';
cout << (a == b) << "\n";
▶ Wyjście
kot pot 0 1

Po b = a oba napisy zawierają „kot”, ale leżą w osobnych pudełkach. Zmiana b[0] zmienia tylko b, więc a zostaje „kot”, a b staje się „pot”.

Porównanie a == b sprawdza, czy oba napisy mają tę samą długość i te same znaki na tych samych miejscach. Po przywróceniu b[0] = 'k' znowu są równe. Nawias wokół porównania w cout jest obowiązkowy — pamiętasz to z lekcji o typach.

Porównywaniem napisów — także tym, który jest „mniejszy” — zajmiemy się dokładnie w części 5.

Poza napisem — ten sam błąd co w tablicy

Co się stanie, gdy sięgniesz po pudełko, którego nie ma, na przykład s[5] w trzyznakowym napisie? Dokładnie to samo co w tablicy: C++ nie sprawdza numeru. Nie zobaczysz komunikatu. Dostaniesz przypadkowy znak z pamięci obok albo program się wysypie — czasem dopiero w sprawdzarce.

Napis ma jednak bezpieczniejszą wersję nawiasów: metodę at. Zapis s.at(i) działa jak s[i], ale najpierw sprawdza, czy pudełko i istnieje. Jeśli nie — zatrzymuje program z komunikatem o błędzie zamiast udawać, że wszystko gra.

Prawdziwe pudełka mają numery 0, 1 i 2. Czerwone s[3], s[4] i s[5] nie należą do napisu.
poza.cpp
string s = "kot";
cout << s[5] << "\n";      // BŁĄD: nie ma pudełka 5 — wynik przypadkowy
cout << s.at(5) << "\n";   // at() sprawdza numer i zatrzymuje program
▶ Przykładowe wyjście — u Ciebie może być inne
terminate called after throwing an instance of 'std::out_of_range' what(): basic_string::at: __n (which is 5) >= this->size() (which is 3)
Program dziwnie się zachowuje? Użyj at Pierwsza linijka wypisała jakiś przypadkowy znak (albo nic) i program poszedł dalej, jakby nic się nie stało. Dopiero at zatrzymał program i powiedział wprost: pytasz o pudełko 5, a napis ma rozmiar 3. Gdy Twój program daje dziwne wyniki, zamień na chwilę s[i] na s.at(i) — jeśli gdzieś wychodzisz poza napis, od razu się dowiesz. W gotowym rozwiązaniu możesz wrócić do zwykłych nawiasów.

Pułapka: długość nie zna liczb ujemnych

Teraz rzecz, która zaskakuje prawie każdego. Liczba zwracana przez s.length() ma specjalny typ, który nie ma liczb ujemnych — taki typ nazywa się „bez znaku” (po angielsku unsigned). Co się dzieje, gdy od zera w takim typie odejmiesz jeden? Wynik „przekręca się” jak licznik kilometrów w starym samochodzie: po 0000 cofnięciu wychodzi 9999. Tu wychodzi największa liczba, jaką ten typ mieści.

bez_znaku.cpp
string s = "";                    // pusty, długość 0
cout << s.length() - 1 << "\n";   // 0 - 1 w typie bez znaku
int n = s.length();               // długość w zwykłym int
cout << n - 1 << "\n";            // teraz -1, tak jak trzeba
▶ Wyjście
18446744073709551615 -1

Pierwsza linijka wyniku to nie żart: 18 446 744 073 709 551 615, czyli 264 − 1. Tyle wychodzi z 0 − 1, gdy liczba nie może być ujemna.

Czym to grozi? Pętla for (int i = 0; i < s.length() - 1; i++) dla pustego napisu wykonałaby się miliardy razy i wyszła daleko poza napis. To bardzo częsty powód błędu wykonania w sprawdzarce.

Najprostsza ochrona: na początku zapisz długość w zmiennej int n = s.length(); i dalej używaj n. W zwykłym int zero minus jeden to po prostu −1. Przy okazji znikną ostrzeżenia kompilatora o porównywaniu liczb „ze znakiem i bez znaku”.

Polskie litery to dwa znaki

Na koniec obiecane wyjaśnienie, dlaczego w zadaniach nie ma polskich liter. Komputer zapisuje znaki z ogonkami — ą, ć, ę, ł, ń, ó, ś, ź, ż — za pomocą dwóch bajtów, a string liczy bajty, nie litery. Słowo „żółw” ma dla nas cztery litery, ale dla C++ siedem znaków: ż, ó i ł zajmują po dwa pudełka, a w — jedno.

zolw.cpp
string s = "żółw";
cout << s.length() << "\n";
▶ Wyjście
7

Z tego samego powodu s[0] to tylko połowa litery ż — wypisany osobno pokaże się jako dziwny znaczek, a toupper w ogóle go nie zmieni. Dlatego w zadaniach olimpijskich (także na OI i OIJ) teksty składają się ze zwykłych liter od a do z — i tak samo jest we wszystkich zadaniach tej lekcji.

Jeśli testujesz program u siebie, wpisuj dane bez polskich liter: „zolw”, a nie „żółw”.

Sprawdź się w głowie

Najpierw odpowiedz w myślach — rozpisz sobie znaki napisu w pudełkach z numerami i śledź program linijka po linijce — a dopiero potem kliknij „Pokaż odpowiedź”.

Co wypisze ten fragment?
string s = "olimpiada";
cout << s.length() << " " << s[3];
Pokaż odpowiedź
9 m„olimpiada” ma 9 liter. Numerujemy od zera: s[0] = o, s[1] = l, s[2] = i, s[3] = m.
Ile znaków ma ten napis?
string s = "Ala ma kota.";
cout << s.length();
Pokaż odpowiedź
129 liter, 2 spacje i kropka: 9 + 2 + 1 = 12. Spacje i znaki przestankowe też zajmują pudełka.
Co wypisze ten fragment?
string s = "mama";
s[0] = 'l';
s[2] = 'l';
cout << s;
Pokaż odpowiedź
lalaZmieniamy pudełka 0 i 2 — oba zawierały m. Pudełka 1 i 3 (litery a) zostają bez zmian.
Kopia i oryginał. Co wypisze ten fragment?
string s = "abc";
string t = s;
t[1] = 'X';
cout << s << t;
Pokaż odpowiedź
abcaXct to osobna kopia, więc zmiana t[1] nie rusza s. Wypisujemy „abc”, a zaraz za nim „aXc”.
Co wypisze ten fragment?
string s(3, 'o');
cout << s + "k" << " " << s.length();
Pokaż odpowiedź
oook 3s to „ooo”. s + "k" tworzy nowy napis „oook” do wypisania, ale samego s nie zmienia — jego długość to nadal 3.
Co wypisze ten fragment?
string s = "programista";
int n = s.length();
cout << s[n - 2] << s[n / 2];
Pokaż odpowiedź
tan = 11. s[9] to t (przedostatnia litera), a s[11 / 2] = s[5] to a: p-r-o-g-r-a.
Co wypisze ten fragment?
string s;
cout << s.empty() << s.length();
Pokaż odpowiedź
10Napis bez wartości jest pusty: empty() daje prawdę (1), a długość to 0. Wypisane bez spacji dają „10”.
Wielkość liter. Co wypisze ten fragment?
string a = "Kot";
string b = "kot";
cout << (a == b);
Pokaż odpowiedź
0Wielka K i mała k to dla komputera różne znaki (inne kody ASCII), więc napisy nie są równe.
Ćwiczenia · teraz Ty

8 ćwiczeń do tej części

0 / 8 zaliczonych

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ę.

Wszystkie ćwiczenia z tej części w sprawdzarce →

Wczytywanie tekstu na każdy sposób

W zadaniach napis prawie nigdy nie jest wpisany w program — przychodzi z wejścia. Czasem to jedno słowo, czasem całe zdanie ze spacjami, a czasem cały tekst z wieloma wierszami, o którym nie wiesz nawet, ile ma słów. W tej części poukładamy wszystkie sposoby wczytywania tekstu. Część z nich znasz z lekcji Input / Output — teraz zobaczysz je razem i dowiesz się, kiedy który wybrać.

Słowo czy cały wiersz?

Podstawowe pytanie brzmi: czy spacja ma kończyć napis, czy nie? Spójrz na dwa programy, które dostają to samo wejście.

slowo.cpp
string s;
cin >> s;                       // jedno słowo
cout << "[" << s << "]\n";
▶ Wejście
Jan Maria Kowalski
▶ Wyjście
[Jan]
wiersz.cpp
string s;
getline(cin, s);                // cały wiersz
cout << "[" << s << "]\n";
▶ Wejście
Jan Maria Kowalski
▶ Wyjście
[Jan Maria Kowalski]
zapisco wczytujespacje i Entery
cin >> s;jedno słowo — ciąg znaków bez odstępówna początku je pomija, a na pierwszym odstępie po słowie się zatrzymuje
getline(cin, s);cały wiersz — wszystko aż do Enteraspacje trafiają do napisu; Enter jest zabierany z wejścia, ale do napisu nie trafia

Odstęp to spacja, tabulator albo Enter. Dla cin >> wszystkie trzy znaczą to samo: „tu kończy się słowo”. Dlatego cin >> nie przejmuje się tym, ile spacji jest między słowami ani czy słowa leżą w jednym wierszu, czy w kilku:

odstepy.cpp
string a, b, c;
cin >> a >> b >> c;
cout << a << "|" << b << "|" << c << "\n";
▶ Wejście
Ala ma kota
▶ Wyjście
Ala|ma|kota

Pięć spacji po „Ala”, a potem pusty wiersz — cin >> po prostu je przeskakuje i bierze kolejne słowa. W napisach nie ma żadnych spacji ani Enterów.

To bardzo wygodne, gdy dane to słowa. Ale gdy spacje są ważne — imię i nazwisko, zdanie, adres — potrzebujesz getline.

Słowa aż do końca danych

Często zadanie nie mówi, ile będzie słów: „wczytaj tekst i policz w nim słowa”. Znasz już na to sposób z lekcji o pętli while — while (cin >> x). Działa tak samo dla napisów: dopóki udaje się wczytać kolejne słowo, warunek jest prawdziwy, a gdy dane się skończą — fałszywy i pętla się kończy.

ile_slow.cpp
string s;
int ile = 0;
while (cin >> s) {     // wczytaj kolejne słowo, dopóki się da
    ile++;
}
cout << ile << "\n";
▶ Wejście
Litwo, ojczyzno moja! ty jestes jak zdrowie
▶ Wyjście
7
najdluzsze.cpp
string s, najdluzsze = "";
while (cin >> s) {
    if (s.length() > najdluzsze.length()) {
        najdluzsze = s;
    }
}
cout << najdluzsze << "\n";
▶ Wejście
Litwo, ojczyzno moja! ty jestes jak zdrowie
▶ Wyjście
ojczyzno

Zauważ dwie rzeczy. Po pierwsze, „słowo” dla cin >> to wszystko między odstępami — razem z przecinkami i wykrzyknikami. „Litwo,” ma 6 znaków, a „moja!” — 5. Po drugie, w prawym programie zaczynamy od pustego napisu, więc pierwsze słowo zawsze okaże się dłuższe. Przy remisie zostaje słowo wcześniejsze, bo warunek to >, a nie >= — to ten sam schemat co rekord z lekcji o tablicach.

Jak zakończyć dane, gdy wpisujesz je z klawiatury Sprawdzarka sama mówi programowi, że dane się skończyły. Gdy testujesz u siebie i wpisujesz tekst ręcznie, pętla czeka na kolejne słowa w nieskończoność. Koniec danych zgłaszasz kombinacją klawiszy: na Windowsie Ctrl+Z, a potem Enter, na Linuksie i Macu Ctrl+D.

Wiersz po wierszu

getline też można zapętlić. while (getline(cin, linia)) wczytuje kolejne wiersze aż do końca danych. W odróżnieniu od cin >> nie pomija pustych wierszy — pusty wiersz to po prostu napis o długości 0.

wiersze.cpp
string linia;
int nr = 0;
while (getline(cin, linia)) {
    nr++;
    cout << nr << ": " << linia << " (" << linia.length() << ")\n";
}
▶ Wejście
Ala ma kota a kot ma Ale koniec
▶ Wyjście
1: Ala ma kota (11) 2: a kot ma Ale (12) 3: (0) 4: koniec (6)

Każdy obrót pętli to jeden wiersz wejścia, razem ze spacjami. Trzeci wiersz jest pusty, więc program wypisuje numer, pusty napis i długość 0.

Gdybyś chciał pomijać puste wiersze, wystarczy na początku obrotu dopisać:

pomin_puste.cpp
if (linia.empty()) {
    continue;
}

Liczba, a potem wiersz — pułapka z Enterem

Ta pułapka pojawiła się już w lekcji Input / Output, ale jest tak częsta, że musimy ją powtórzyć. Wejście wygląda tak: w pierwszym wierszu liczba, w drugim zdanie. Po cin >> n na taśmie wejścia zostaje Enter, który kończył pierwszy wiersz. getline czyta „do Entera” — a Enter leży od razu na początku. Wczytuje więc pusty napis i kończy pracę.

pulapka.cpp
int n;
string zdanie;
cin >> n;
getline(cin, zdanie);      // wczyta pusty kawałek po liczbie!
cout << n << " [" << zdanie << "]\n";
▶ Wejście
3 Ala ma kota
▶ Wyjście — źle
3 []
naprawione.cpp
int n;
string zdanie;
cin >> n;
cin.ignore();              // zjedz Enter po liczbie
getline(cin, zdanie);
cout << n << " [" << zdanie << "]\n";
▶ Wejście
3 Ala ma kota
▶ Wyjście
3 [Ala ma kota]

cin.ignore() zabiera z wejścia jeden znak — właśnie ten Enter. Jest też drugi sposób, odporny nawet na spacje zostawione za liczbą: getline(cin >> ws, zdanie);. ws pomija wszystkie odstępy (spacje i Entery), a getline zaczyna czytać od pierwszego prawdziwego znaku. Uwaga: ws zje też spacje na początku zdania, więc używaj go tylko wtedy, gdy wiersz nie zaczyna się od ważnych spacji.

Najczęstszy układ w zadaniach to liczba n, a potem n wierszy tekstu. cin.ignore() wystarczy wtedy raz, zaraz po liczbie — kolejne getline same zabierają swoje Entery:

n_wierszy.cpp
int n;
cin >> n;
cin.ignore();
for (int i = 1; i <= n; i++) {
    string linia;
    getline(cin, linia);
    cout << i << ". " << linia << "\n";
}
▶ Wejście
3 mleko 2 litry chleb jajka 10 sztuk
▶ Wyjście
1. mleko 2 litry 2. chleb 3. jajka 10 sztuk
Kiedy cin, kiedy getline Dane to słowa albo liczby — cin >>. Dane to wiersze, w których spacje są ważne — getline. Mieszasz oba sposoby i po cin >> przychodzi getline — między nimi cin.ignore() (albo cin >> ws). Odwrotna kolejność jest bezpieczna: cin >> po getline sam pominie odstępy.

Tablica napisów

Gdy słowa trzeba zapamiętać — żeby wypisać je od końca albo porównać z czymś wczytanym później — wkładasz je do tablicy napisów, tak jak w lekcji o tablicach. Każde pudełko t[i] zawiera cały napis.

od_konca.cpp
string t[100];
int n;
cin >> n;
for (int i = 0; i < n; i++) {
    cin >> t[i];
}
for (int i = n - 1; i >= 0; i--) {
    cout << t[i] << " ";
}
cout << "\n";
▶ Wejście
4 raz dwa trzy cztery
▶ Wyjście
cztery trzy dwa raz
pierwsze_litery.cpp
string t[3] = {"Polski", "Zwiazek", "Wedkarski"};
for (int i = 0; i < 3; i++) {
    cout << t[i][0];       // pierwsza litera i-tego słowa
}
cout << "\n";
cout << t[1][2] << "\n";   // trzecia litera drugiego słowa
▶ Wyjście
PZW i

Prawy program pokazuje nowy zapis z dwoma nawiasami kwadratowymi. t[i] to cały napis numer i, a skoro to napis, to jego znak numer j to t[i][j]. Czytaj od lewej: „z tablicy t weź słowo i, a z tego słowa — znak j”. t[1] to „Zwiazek”, więc t[1][2] to jego trzecia litera, i.

Wiersz pocięty przecinkami

Czasem kawałki tekstu nie są oddzielone spacjami, tylko innym znakiem, na przykład przecinkiem: Ola,Jan,Ewa. cin >> wczytałby to jako jedno słowo. Są na to dwa sposoby. Pierwszy znasz z lekcji Input / Output: getline z trzecim argumentem czyta do wskazanego znaku zamiast do Entera.

przecinki_getline.cpp
string imie;
while (getline(cin, imie, ',')) {
    cout << "- " << imie << "\n";
}
▶ Wejście
Ola,Jan,Ewa
▶ Wyjście
- Ola - Jan - Ewa
przecinki_petla.cpp
string linia, kawalek = "";
getline(cin, linia);
for (char c : linia) {
    if (c == ',') {
        cout << "- " << kawalek << "\n";
        kawalek = "";          // zaczynamy nowy kawałek
    } else {
        kawalek += c;          // dokładamy znak do kawałka
    }
}
cout << "- " << kawalek << "\n";   // ostatni kawałek
▶ Wejście
Ola,Jan,Ewa
▶ Wyjście
- Ola - Jan - Ewa

Lewy sposób jest krótszy, ale ma haczyk: ostatni kawałek kończy się nie przecinkiem, tylko Enterem — i ten Enter trafia do napisu, jeśli w danych jest. Prawy sposób jest odporny: najpierw wczytujemy cały wiersz, a potem sami idziemy po nim znak po znaku. Gdy trafiamy na przecinek, kawałek jest gotowy; każdy inny znak doklejamy do kawałka. Po pętli zostaje ostatni kawałek — po nim nie było przecinka, więc trzeba go wypisać osobno. Ten schemat cięcia wiersza przyda się jeszcze wiele razy, a w części 6 poznasz trzeci sposób, z find i substr.

Sprawdź się w głowie

Najpierw odpowiedz w myślach — przy każdym pytaniu wyobraź sobie taśmę wejścia i to, co zabiera z niej każda instrukcja — a dopiero potem kliknij „Pokaż odpowiedź”.

Co wypisze program dla podanego wejścia?
string a, b;
cin >> a >> b;
cout << b << a;
Wejście: Ala ma kota
Pokaż odpowiedź
maAlacin >> czyta po jednym słowie: a to „Ala”, b to „ma”. „kota” zostaje na wejściu nieprzeczytane. Wypisujemy b, a zaraz za nim a — bez spacji.
A ten program?
string s;
getline(cin, s);
cout << s.length();
Wejście: Ala ma kota
Pokaż odpowiedź
11getline wczytuje cały wiersz razem ze spacjami: 9 liter i 2 spacje.
Wejście ma dwa wiersze. Co wypisze program?
int n;
string s;
cin >> n;
getline(cin, s);
cout << s.length();
Wejście: 5 Ala ma kota
Pokaż odpowiedź
0Klasyczna pułapka: po liczbie został Enter, więc getline wczytuje pusty napis. Brakuje cin.ignore().
Ile razy wykona się pętla?
string s;
int k = 0;
while (cin >> s) {
    k++;
}
cout << k;
Wejście: raz dwa trzy cztery
Pokaż odpowiedź
4cin >> czyta słowa i nie przejmuje się Enterami: raz, dwa, trzy, cztery.
A ile razy ta pętla?
string s;
int k = 0;
while (getline(cin, s)) {
    k++;
}
cout << k;
Wejście: raz dwa trzy cztery
Pokaż odpowiedź
2getline czyta całe wiersze, a wiersze są dwa: „raz dwa trzy” i „cztery”.
Dwa nawiasy. Co wypisze ten fragment?
string t[3] = {"kot", "pies", "mysz"};
cout << t[1][0] << t[2][3];
Pokaż odpowiedź
pzt[1] to „pies”, a jego pierwsza litera to p. t[2] to „mysz”, a jej znak numer 3 (czwarty) to z.
Ile kawałków wczyta ta pętla?
string s;
int k = 0;
while (getline(cin, s, ',')) {
    k++;
}
cout << k;
Wejście: a,bb,,ccc
Pokaż odpowiedź
4Kawałki to „a”, „bb”, pusty napis (między dwoma przecinkami nic nie ma) i „ccc”. Pusty kawałek też się liczy.
Co wypisze program?
string imie, reszta;
cin >> imie;
getline(cin, reszta);
cout << "[" << reszta << "]";
Wejście: Jan Kowalski
Pokaż odpowiedź
[ Kowalski]cin >> zatrzymuje się przed spacją po „Jan”. getline czyta resztę wiersza od tego miejsca — razem ze spacją na początku.
Ćwiczenia · teraz Ty

8 ćwiczeń do tej części

0 / 8 zaliczonych

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ę.

Wszystkie ćwiczenia z tej części w sprawdzarce →

Znak po znaku: rodzaje znaków i liczniki

Większość zadań z napisami sprowadza się do tego samego: przejdź po napisie znak po znaku i przy każdym znaku zadaj pytanie. Czy to litera? Cyfra? Wielka czy mała? Taka sama jak poprzednia? W tej części nauczysz się zadawać takie pytania szybko i bez pomyłek — warunkami na przedziałach i gotowymi funkcjami z biblioteki <cctype>.

Dwie pętle po napisie — przypomnienie

Z lekcji o pętli for znasz dwa sposoby przejścia po napisie. Oba w programach poniżej liczą, ile razy w tekście występuje litera a.

petla_indeks.cpp
string s = "ala ma kota";
int n = s.length();
int ile = 0;
for (int i = 0; i < n; i++) {
    if (s[i] == 'a') {
        ile++;
    }
}
cout << ile << "\n";
▶ Wyjście
4
petla_kazdy.cpp
string s = "ala ma kota";
int ile = 0;
for (char c : s) {      // dla każdego znaku c z napisu s
    if (c == 'a') {
        ile++;
    }
}
cout << ile << "\n";
▶ Wyjście
4

Lewa pętla zna numer znaku (i), prawa — tylko sam znak (c). Zasada wyboru jest prosta: gdy potrzebujesz pozycji (wypisać, gdzie coś jest), sąsiadów (s[i - 1], s[i + 1]) albo chcesz zmieniać napis — bierz pętlę z indeksem. Gdy tylko oglądasz każdy znak po kolei — pętla „dla każdego” jest krótsza i nie da się w niej wyjść poza napis.

Jaki to znak? Warunki na przedziałach

W tabeli ASCII małe litery stoją jedna za drugą (od 97 do 122), wielkie też (od 65 do 90), cyfry też (od 48 do 57). Dlatego pytanie „czy to mała litera?” to pytanie „czy kod znaku leży między kodem a i kodem z?”. Nie musisz znać kodów — porównujesz ze znakami w apostrofach, a C++ sam podstawi liczby.

warunekprawdziwy, gdy c to…przykłady
c >= 'a' && c <= 'z'mała literaa, k, z
c >= 'A' && c <= 'Z'wielka literaA, K, Z
c >= '0' && c <= '9'cyfra0, 5, 9
c == ' 'spacja␣
c == 'a' || c == 'e' || …jeden z wymienionych znakówsamogłoski: a, e, i, o, u, y

Ten sposób znasz z lekcji o if. Działa zawsze i jest całkowicie przewidywalny. Ma jedną wadę: warunki są długie i łatwo w nich o literówkę — na przykład c >= 'a' && c <= 'Z' z jedną wielką literą przez pomyłkę. Dlatego C++ ma gotowe funkcje.

Gotowe funkcje: isdigit, isalpha i spółka

Biblioteka <cctype> (jest też w <bits/stdc++.h>) zawiera funkcje, które odpowiadają na pytania o rodzaj znaku. Ich nazwy zaczynają się od is — po angielsku „czy jest”. isdigit(c) czytaj: „czy c jest cyfrą?”.

funkcjaprawda, gdy c to…to samo co
isdigit(c)cyfra od 0 do 9c >= '0' && c <= '9'
islower(c)mała literac >= 'a' && c <= 'z'
isupper(c)wielka literac >= 'A' && c <= 'Z'
isalpha(c)litera, mała albo wielkaislower(c) || isupper(c)
isalnum(c)litera albo cyfraisalpha(c) || isdigit(c)
isspace(c)odstęp: spacja, tabulator, Enterc == ' ' || c == '\t' || c == '\n' …
ispunct(c)znak przestankowy: . , ! ? : ; - ( ) itd.—
rodzaje.cpp
string s;
getline(cin, s);
int litery = 0, cyfry = 0, spacje = 0, inne = 0;
for (char c : s) {
    if (isalpha(c)) {
        litery++;
    } else if (isdigit(c)) {
        cyfry++;
    } else if (isspace(c)) {
        spacje++;
    } else {
        inne++;
    }
}
cout << litery << " " << cyfry << " " << spacje << " " << inne << "\n";
▶ Wejście
Ala ma 2 koty!
▶ Wyjście
9 1 3 1

Cztery liczniki i łańcuch else if: każdy znak trafia do dokładnie jednej grupy. Litery: A, l, a, m, a, k, o, t, y — dziewięć. Cyfra jedna (2), spacje trzy, a „inne” to wykrzyknik.

Kolejność warunków ma znaczenie tylko wtedy, gdy grupy się nakładają. Tu się nie nakładają, więc mogłyby stać w dowolnej kolejności — ale else na końcu musi zostać ostatni, bo łapie wszystko, czego nie złapały warunki przed nim.

Prawda to nie zawsze 1 Funkcje is… zwracają int: zero, gdy odpowiedź brzmi „nie”, i jakąś liczbę różną od zera, gdy „tak” — niekoniecznie 1! Na serwerze sprawdzarki isalpha('k') to 1024, na Twoim komputerze może wyjść na przykład 258 albo 2. W warunkach if i while to bez znaczenia, bo każda liczba różna od zera liczy się jako prawda. Ale nie porównuj ich wyniku z 1 ani z true i nie wypisuj go — pisz po prostu if (isalpha(c)) albo if (!isalpha(c)).
nie_jeden.cpp
cout << isalpha('k') << "\n";      // liczba różna od zera
cout << isalpha('7') << "\n";      // 0
if (isalpha('k')) {
    cout << "to litera\n";
}
if (isalpha('k') == true) {        // ŹLE: 1024 to nie 1
    cout << "tego nie zobaczysz\n";
}
▶ Wyjście — pierwsza liczba u Ciebie może być inna
1024 0 to litera

Pierwszy if działa: 1024 to „nie zero”, więc prawda. Drugi nie działa, choć wygląda niewinnie: true w porównaniu z liczbą zamienia się na 1, a 1024 to nie 1.

Jeśli naprawdę potrzebujesz zera albo jedynki — na przykład żeby dodać wynik do licznika — zamień go na bool: ile += (isalpha(c) != 0);. Ale prościej i czytelniej jest napisać zwykły if z ile++.

toupper i tolower — zmiana wielkości litery

W lekcji o typach zamieniałeś małą literę na wielką rachunkiem c - 'a' + 'A'. Gotowe funkcje robią to samo prościej: toupper(c) daje wielką wersję litery („to upper” — na wielką), a tolower(c) — małą. Znaki, które nie są literami, zwracają bez zmian. Jest tylko jedna pułapka — ta sama co przy is…: wynik to int.

toupper.cpp
char c = 'k';
cout << toupper(c) << "\n";          // liczba!
cout << (char)toupper(c) << "\n";    // teraz znak
char d = toupper(c);                 // zapis do char też daje znak
cout << d << "\n";
cout << (char)tolower('Q') << "\n";
cout << (char)toupper('7') << "\n";  // nie litera — bez zmian
▶ Wyjście
75 K K q 7

cout << toupper(c) wypisuje 75 — kod litery K — bo cout widzi liczbę typu int. Żeby zobaczyć literę, zamień wynik na char: rzutowaniem (char) albo przypisaniem do zmiennej typu char.

Najczęściej i tak zapisujesz wynik z powrotem do napisu: s[i] = toupper(s[i]);. Pudełko napisu jest typu char, więc zamiana dzieje się sama i nic nie trzeba rzutować.

wielkie.cpp
string s;
getline(cin, s);
int n = s.length();
for (int i = 0; i < n; i++) {
    s[i] = toupper(s[i]);
}
cout << s << "\n";
▶ Wejście
Ala ma 2 koty!
▶ Wyjście
ALA MA 2 KOTY!
bez_wielkosci.cpp
char a, b;
cin >> a >> b;
if (tolower(a) == tolower(b)) {
    cout << "ta sama litera\n";
} else {
    cout << "rozne litery\n";
}
▶ Wejście
K k
▶ Wyjście
ta sama litera

Prawy program pokazuje bardzo częsty trik: gdy wielkość liter ma nie mieć znaczenia, sprowadź oba znaki do małych liter i dopiero wtedy porównaj. Tutaj porównujemy dwa wyniki tolower ze sobą — oba są liczbami, więc porównanie działa bez rzutowania.

Gdzie jest pierwszy, a gdzie ostatni?

Szukanie w napisie wygląda tak samo jak szukanie w tablicy. Zaczynasz od pozycji „nie znaleziono”, czyli -1, i idziesz pętlą z indeksem. Pierwsze wystąpienie: zapisz pozycję i przerwij pętlę przez break. Ostatnie: zapisuj pozycję za każdym razem i nie przerywaj — na końcu zostanie ostatnia.

pierwsza_ostatnia.cpp
string s;
cin >> s;
int n = s.length();
int pierwsza = -1, ostatnia = -1;
for (int i = 0; i < n; i++) {
    if (isdigit(s[i])) {
        pierwsza = i;
        break;            // pierwsza znaleziona — koniec
    }
}
for (int i = 0; i < n; i++) {
    if (isdigit(s[i])) {
        ostatnia = i;     // nadpisujemy aż do końca
    }
}
cout << pierwsza << " " << ostatnia << "\n";
▶ Wejście
abc7de9f
▶ Wyjście
3 6
▶ Inne wejście
tekst
▶ Wyjście
-1 -1
Cyfry stoją w pudełkach 3 i 6. Pierwsza pętla zatrzymuje się na 3, druga przechodzi cały napis i zapamiętuje 6.

Ostatnie wystąpienie można też znaleźć szybciej: idąc pętlą od końca, od i = n - 1 w dół, i przerywając na pierwszej cyfrze. Oba sposoby są dobre.

Wartość -1 to umówiony znak „nie ma” — żaden prawdziwy indeks nie jest ujemny, więc nie da się go pomylić z pozycją.

Sąsiednie znaki: s[i] i s[i + 1]

Wiele pytań dotyczy par sąsiadów: ile jest podwójnych liter, czy po samogłosce stoi spółgłoska, czy litery rosną. Tak samo jak w tablicy pętla musi wtedy kończyć się wcześniej: i < n - 1, bo przy ostatnim znaku nie ma już s[i + 1]. Tu przydaje się n typu int — dla pustego napisu n - 1 to −1 i pętla się po prostu nie wykona.

W słowie „mississippi” podwójne litery stoją na pozycjach 2–3 (ss), 5–6 (ss) i 8–9 (pp). Par sąsiadów jest n − 1 = 10, a takich samych — 3.
podwojne.cpp
string s;
cin >> s;
int n = s.length();
int ile = 0;
for (int i = 0; i < n - 1; i++) {
    if (s[i] == s[i + 1]) {
        ile++;
    }
}
cout << ile << "\n";
▶ Wejście
mississippi
▶ Wyjście
3
zmiany.cpp
string s;
cin >> s;
int n = s.length();
int zmiany = 0;      // ile razy wielkość litery się zmienia
for (int i = 1; i < n; i++) {
    if (isupper(s[i]) && islower(s[i - 1])) zmiany++;
    if (islower(s[i]) && isupper(s[i - 1])) zmiany++;
}
cout << zmiany << "\n";
▶ Wejście
aaBBcD
▶ Wyjście
3

Prawy program patrzy w drugą stronę: na znak i jego poprzednika. Wtedy pętla startuje od i = 1, bo pierwszy znak poprzednika nie ma. Dwie wersje — s[i] z s[i + 1] do n - 1 albo s[i] z s[i - 1] od 1 — sprawdzają dokładnie te same pary. Wybierz tę, która lepiej pasuje do zadania.

Serie: ten sam znak pod rząd

Seria to kilka takich samych znaków stojących obok siebie, na przykład bbbb w „aaabbbbcc”. Jak znaleźć najdłuższą serię? Idziemy po napisie i pamiętamy długość bieżącej serii. Jeśli znak jest taki sam jak poprzedni — seria rośnie. Jeśli inny — zaczyna się nowa seria o długości 1. Po każdym kroku sprawdzamy, czy pobiliśmy rekord.

seria.cpp
string s;
cin >> s;
int n = s.length();
int dlugosc = 1, rekord = 1;
char znak = s[0];
for (int i = 1; i < n; i++) {
    if (s[i] == s[i - 1]) {
        dlugosc++;          // seria trwa
    } else {
        dlugosc = 1;        // nowa seria
    }
    if (dlugosc > rekord) {
        rekord = dlugosc;
        znak = s[i];
    }
}
cout << znak << " " << rekord << "\n";
▶ Wejście
aaabbbbcc
▶ Wyjście
b 4
is[i]s[i − 1]dlugoscrekord
start——11 (a)
1aa22 (a)
2aa33 (a)
3ba13 (a)
4bb23 (a)
5bb33 (a)
6bb44 (b)
7cb14 (b)
8cc24 (b)

Ten program zakłada, że napis nie jest pusty — czyta s[0] na samym początku. W zadaniu zawsze sprawdź, czy ograniczenia to gwarantują.

Flagi: czy jest choć jeden? czy wszystkie?

Dwa pytania pojawiają się bez przerwy: „czy w napisie jest choć jeden znak taki-a-taki?” i „czy wszystkie znaki są takie-a-takie?”. Oba rozwiązuje flaga, czyli zmienna bool z lekcji o if. Dla „choć jeden” startujesz od false i zmieniasz na true, gdy znajdziesz pasujący znak. Dla „wszystkie” — odwrotnie: startujesz od true i zmieniasz na false przy pierwszym znaku, który nie pasuje.

flagi.cpp
string s;
cin >> s;
bool jestCyfra = false;     // czy choć jeden znak to cyfra
bool sameLitery = true;     // czy wszystkie znaki to litery
for (char c : s) {
    if (isdigit(c)) {
        jestCyfra = true;
    }
    if (!isalpha(c)) {
        sameLitery = false;
    }
}
cout << jestCyfra << " " << sameLitery << "\n";
▶ Wejście
haslo123
▶ Wyjście
1 0
▶ Inne wejście
Kot
▶ Wyjście
0 1
Choć jeden — start od false. Wszystkie — start od true „Choć jeden” zmienia zdanie po pierwszym znaku, który pasuje. „Wszystkie” zmienia zdanie po pierwszym znaku, który nie pasuje. Zwróć uwagę na !isalpha(c) — wykrzyknik odwraca odpowiedź: „c nie jest literą”. Gdy flaga raz się zmieni, już nie wraca, więc możesz od razu wyjść z pętli przez break — chyba że w tej samej pętli liczysz jeszcze coś innego, jak tutaj.
Sprawdź się w głowie

Najpierw odpowiedz w myślach — rozpisz sobie znaki napisu w pudełkach z numerami i śledź program linijka po linijce — a dopiero potem kliknij „Pokaż odpowiedź”.

Co wypisze ten fragment?
string s = "a1b2c3";
int k = 0;
for (char c : s) {
    if (isdigit(c)) k += c - '0';
}
cout << k;
Pokaż odpowiedź
6Cyfry to 1, 2 i 3, a c - '0' zamienia znak cyfry na jej wartość: 1 + 2 + 3 = 6.
Liczba czy litera? Co wypisze ten fragment?
cout << (char)toupper('b') << toupper('b');
Pokaż odpowiedź
B66Z rzutowaniem na char widać literę B. Bez rzutowania toupper daje int — kod litery B, czyli 66.
Co wypisze ten fragment?
string s = "Hello World";
int k = 0;
for (char c : s) {
    if (isupper(c)) k++;
}
cout << k;
Pokaż odpowiedź
2Wielkie są tylko H i W.
Ile par takich samych sąsiadów?
string s = "aabbbab";
int n = s.length(), k = 0;
for (int i = 0; i < n - 1; i++) {
    if (s[i] == s[i + 1]) k++;
}
cout << k;
Pokaż odpowiedź
3Pary sąsiadów: aa ✓, ab, bb ✓, bb ✓, ba, ab. Seria bbb daje dwie pary, bo środkowe b należy do obu.
Co wypisze ten fragment?
string s = "Kot i PIES";
for (char &c : s) {
    c = tolower(c);
}
cout << s;
Pokaż odpowiedź
kot i piesDzięki & zmieniamy prawdziwe znaki napisu. Spacje i małe litery tolower zostawia bez zmian.
Pierwsze czy ostatnie? Co wypisze ten fragment?
string s = "abcabc";
int p = -1;
for (int i = 0; i < 6; i++) {
    if (s[i] == 'b') p = i;
}
cout << p;
Pokaż odpowiedź
4Nie ma break, więc p jest nadpisywane przy każdym b: najpierw 1, potem 4. Zostaje ostatnie.
Co wypisze ten fragment?
char c = 'z';
c = toupper(c) + 1;
cout << c;
Pokaż odpowiedź
[toupper('z') to kod litery Z, czyli 90. Plus 1 daje 91 — a pod numerem 91 w tabeli ASCII stoi nawias kwadratowy. Za Z nie ma już liter!
Flaga. Co wypisze ten fragment?
string s = "abc!";
bool ok = true;
for (char c : s) {
    if (!islower(c)) ok = false;
}
cout << ok;
Pokaż odpowiedź
0Wykrzyknik nie jest małą literą, więc flaga „wszystkie są małymi literami” zmienia się na false.
Ćwiczenia · teraz Ty

8 ćwiczeń do tej części

0 / 8 zaliczonych

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ę.

Wszystkie ćwiczenia z tej części w sprawdzarce →

Zmieniamy i budujemy napisy

Z napisem możesz pracować na dwa sposoby. Pierwszy: zmieniasz znaki w miejscu, pudełko po pudełku. Napis ma wtedy cały czas tę samą długość — każdy znak zamienia się na inny. Drugi: budujesz nowy napis od pustego, dokładając kawałek po kawałku. Wtedy możesz robić, co chcesz: pomijać znaki, podwajać je, wstawiać nowe. W tej części przećwiczymy oba sposoby i poznamy pułapki, które czyhają przy sklejaniu.

Zmiana w miejscu

Do zmiany w miejscu wystarczy pętla z indeksem i przypisanie s[i] = …. Albo pętla „dla każdego” z & — pamiętasz z lekcji o pętli for, że bez & zmienna c jest tylko kopią znaku i zmiany przepadają.

podkreslniki.cpp
string s;
getline(cin, s);
for (char &c : s) {     // & — pracujemy na prawdziwych znakach
    if (c == ' ') {
        c = '_';
    }
}
cout << s << "\n";
▶ Wejście
Ala ma kota
▶ Wyjście
Ala_ma_kota
tytul.cpp
string s;
getline(cin, s);
int n = s.length();
for (int i = 0; i < n; i++) {
    if (i == 0 || s[i - 1] == ' ') {
        s[i] = toupper(s[i]);    // pierwsza litera słowa
    }
}
cout << s << "\n";
▶ Wejście
ala ma kota
▶ Wyjście
Ala Ma Kota

W prawym programie litera zaczyna słowo, gdy stoi na samym początku albo zaraz po spacji. Kolejność w warunku i == 0 || s[i - 1] == ' ' jest bardzo ważna. Pamiętasz z lekcji o if skrócone obliczanie? Gdy i == 0 jest prawdą, C++ nie sprawdza już drugiej części — i dobrze, bo s[-1] nie istnieje. Odwrotna kolejność czytałaby poza napisem.

Budowanie od pustego napisu: += i push_back

Drugi sposób zaczyna się od pustego napisu "". Potem dokładasz kawałki na koniec. Doklejać możesz pojedynczy znak albo cały napis — operator += przyjmie jedno i drugie. Jest też metoda push_back(c) („wepchnij na koniec”), która dokłada tylko jeden znak.

budowa.cpp
string w = "";        // zaczynamy od pustego
w += 'k';             // jeden znak
w += "ot";            // cały napis
w.push_back('y');     // push_back — jeden znak
cout << w << " " << w.length() << "\n";
▶ Wyjście
koty 4
po linijcewdługość
string w = "";0
w += 'k';k1
w += "ot";kot3
w.push_back('y');koty4

Najczęściej budowanie odbywa się w pętli: idziesz po starym napisie i decydujesz, co z każdym znakiem zrobić w nowym. Zostawić? Pominąć? Dopisać dwa razy? Zamienić na coś innego? Ta jedna decyzja to cały program.

tylko_cyfry.cpp
string s, cyfry = "";
getline(cin, s);
for (char c : s) {
    if (isdigit(c)) {
        cyfry += c;        // cyfrę zostawiamy, resztę pomijamy
    }
}
cout << cyfry << "\n";
▶ Wejście
tel. 600-100-200
▶ Wyjście
600100200
podwajanie.cpp
string s, w = "";
cin >> s;
for (char c : s) {
    w += c;                // każdy znak
    w += c;                // ... dwa razy
}
cout << w << "\n";
▶ Wejście
kot
▶ Wyjście
kkoott
gwiazdki.cpp
string s, w = "";
getline(cin, s);
for (char c : s) {
    if (isdigit(c)) {
        w += "**";         // cyfrę zamieniamy na dwie gwiazdki
    } else {
        w += c;
    }
}
cout << w << "\n";
▶ Wejście
PIN 1234
▶ Wyjście
PIN ********

Zwróć uwagę, że nowy napis może być krótszy od starego (tylko cyfry), dłuższy (podwajanie, gwiazdki) albo zupełnie inny. Przy zmianie w miejscu tak się nie da — tam długość zawsze zostaje ta sama.

Dlatego zasada jest prosta: jeśli każdy znak zamienia się na dokładnie jeden znak — zmieniaj w miejscu. Jeśli coś znika albo przybywa — buduj nowy napis.

Doklejanie z przodu

Kawałek możesz dokleić także na początek: w = c + w;. Czytaj: „nowe w to znak c, a za nim całe stare w”. Doklejanie każdego kolejnego znaku z przodu odwraca napis.

z_przodu.cpp
string s, w = "";
cin >> s;
for (char c : s) {
    w = c + w;        // nowy znak na początek
}
cout << w << "\n";
▶ Wejście
abc
▶ Wyjście
cba
obrótcw po obrocie
start—
1.aa
2.bba
3.ccba

Zapis c + w działa, bo w jest napisem: znak plus napis daje napis. Ale uwaga — doklejanie z przodu jest wolne: za każdym razem komputer przepisuje cały napis o jedno miejsce. Dla kilku tysięcy znaków to nic, dla miliona — za dużo. Wrócimy do tego w części 8.

Usuwanie z końca: pop_back i clear

pop_back() to odwrotność push_back: usuwa ostatni znak napisu. clear() usuwa wszystkie znaki naraz — napis staje się pusty. Typowe zastosowanie pop_back: dopisujesz separator po każdym elemencie, a na koniec usuwasz ten ostatni, niepotrzebny.

pop_back.cpp
string s = "1, 2, 3, ";
s.pop_back();       // usuwa spację
s.pop_back();       // usuwa przecinek
cout << "[" << s << "]\n";
s.clear();
cout << "[" << s << "] " << s.empty() << "\n";
▶ Wyjście
[1, 2, 3] [] 1
schodki.cpp
string s = "kot", w = "";
for (char c : s) {
    w += c;
    cout << w << "\n";      // rośnie: k, ko, kot
}
while (w.length() > 1) {
    w.pop_back();
    cout << w << "\n";      // maleje: ko, k
}
▶ Wyjście
k ko kot ko k
pop_back na pustym napisie to błąd Z pustego napisu nie da się usunąć ostatniego znaku, bo go nie ma. pop_back() na pustym napisie to błąd — taki sam jak wyjście poza tablicę: program może się wysypać albo zacząć robić dziwne rzeczy. Zanim zawołasz pop_back(), upewnij się, że napis nie jest pusty: if (!s.empty()) s.pop_back();.

Pułapki sklejania

Sklejanie plusem wydaje się proste, ale kryje cztery pułapki. Wszystkie biorą się z tego samego: w C++ tylko string umie się sklejać. Znak w apostrofach to tak naprawdę liczba (kod ASCII), a tekst w cudzysłowie, który nie trafił jeszcze do zmiennej string, to „surowy” tekst, który sklejać się nie umie. Plus działa jak sklejanie tylko wtedy, gdy co najmniej jedna strona jest prawdziwym napisem string.

dwa_cudzyslowy.cpp
string s = "Ala" + " ma";      // BŁĄD: żadna strona nie jest stringiem
▶ Kompilator
error: invalid operands of types 'const char [4]' and 'const char [4]' to binary 'operator+'
dwa_cudzyslowy_dobrze.cpp
string s = "Ala";
s += " ma";                     // s jest stringiem — działa
string t = s + " kota";         // lewa strona to string — działa
cout << t << "\n";
▶ Wyjście
Ala ma kota

Pułapka 1: dwa teksty w cudzysłowach. "Ala" + " ma" się nie skompiluje — po obu stronach jest surowy tekst. Wystarczy, że jedna strona będzie zmienną typu string.

znak_plus_znak.cpp
string s = "ab";
cout << s[0] + s[1] << "\n";    // dwa znaki to dwie liczby: 97 + 98
string w = "";
w += s[0];
w += s[1];                      // tak sklejasz znaki
cout << w << "\n";
▶ Wyjście
195 ab

Pułapka 2: znak plus znak to liczba. s[0] + s[1] nie skleja liter, tylko dodaje ich kody: 97 + 98 = 195. Zapis string w = s[0] + s[1]; w ogóle się nie skompiluje — z liczby nie da się zrobić napisu.

Znaki sklejasz, dokładając je po kolei do napisu (+=), albo zaczynając od napisu z jednego znaku: string(1, s[0]) + s[1].

napis_plus_liczba.cpp
string s = "kot";
string a = s + to_string(5);    // dobrze: "kot5"
string b = s;
b += 5;                         // kompiluje się, ale…
cout << a << " " << a.length() << "\n";
cout << b.length() << "\n";     // też 4 znaki — ale jakie?
▶ Wyjście
kot5 4 4

Pułapka 3: napis i liczba. Zapis s + 5 w ogóle się nie skompiluje — i dobrze. Gorzej z s += 5: kompiluje się bez ostrzeżenia, ale nie dokleja cyfry 5! Liczba 5 zostaje potraktowana jak kod znaku numer 5 — to niewidzialny znak sterujący. Napis ma 4 znaki, ale czwarty to nie „5”.

Liczbę doklejasz po zamianie na napis: s + to_string(5) albo s += to_string(5). Funkcję to_string znasz z lekcji o typach — a w części 7 poznasz ją dokładniej.

tekst_plus_liczba.cpp
int x = 3;
cout << "Wynik: " + x << "\n";      // ŹLE
cout << "Wynik: " << x << "\n";     // dobrze
▶ Wyjście
ik: Wynik: 3

Pułapka 4: surowy tekst plus liczba. To najdziwniejsza z nich. "Wynik: " + 3 to nie sklejanie, tylko przesunięcie początku tekstu o 3 znaki: „Wyn” znika i wychodzi „ik: ”. Program się kompiluje i działa, tylko wypisuje bzdury.

W cout nie sklejaj niczego plusem — wypisuj kawałki po kolei przez <<. To najprostszy sposób, żeby ominąć wszystkie cztery pułapki naraz.

zapisco się dziejewynik
s + "ma", s + 'x', 'x' + ssklejanie — jedna strona to stringnapis
"Ala" + " ma"dwa surowe tekstybłąd kompilacji
'a' + 'b', s[0] + s[1]dodawanie kodów ASCIIliczba (195)
s + 5napis plus liczbabłąd kompilacji
s += 5doklejenie znaku o kodzie 5niewidzialny znak
"Wynik: " + 3przesunięcie początku tekstu„ik: ”
s + to_string(5)sklejanie z napisem „5”napis „kot5”

Odwracanie i palindromy — dwa sposoby

Napis od tyłu możesz zbudować jako nowy napis albo odwrócić w miejscu. Nowy napis przydaje się wtedy, gdy oryginał jest jeszcze potrzebny — na przykład żeby porównać go z odwróconym i sprawdzić, czy to palindrom. Odwracanie w miejscu wygląda dokładnie tak jak w tablicy: zamieniasz parami pierwszy z ostatnim, drugi z przedostatnim i tak dalej, aż do połowy.

palindrom_kopia.cpp
string s, w = "";
cin >> s;
int n = s.length();
for (int i = n - 1; i >= 0; i--) {
    w += s[i];            // od ostatniego do pierwszego
}
if (w == s) {
    cout << "palindrom\n";
} else {
    cout << w << "\n";
}
▶ Wejście
kajak
▶ Wyjście
palindrom
▶ Inne wejście
kotlet
▶ Wyjście
teltok
odwroc_w_miejscu.cpp
string s;
cin >> s;
int n = s.length();
for (int i = 0; i < n / 2; i++) {
    swap(s[i], s[n - 1 - i]);
}
cout << s << "\n";
▶ Wejście
kotlet
▶ Wyjście
teltok

Lewa pętla idzie od n - 1 w dół, więc licznik musi być zwykłym int — po zerze zejdzie do −1 i pętla się skończy. Prawa pętla zatrzymuje się w połowie: gdyby szła do końca, każdą parę zamieniłaby dwa razy i napis wróciłby do początku.

Powtarzanie: ten sam napis k razy

string(k, c) powtarza jeden znak. Żeby powtórzyć cały napis, doklejasz go w pętli. Często trzeba też coś wstawić między powtórzenia — wtedy przydaje się trik z separatorem: przed każdym powtórzeniem oprócz pierwszego.

powtorz.cpp
string s, w = "";
int k;
cin >> s >> k;
for (int i = 0; i < k; i++) {
    if (i > 0) {
        w += "-";        // separator przed każdym oprócz pierwszego
    }
    w += s;
}
cout << w << "\n";
cout << string(w.length(), '=') << "\n";   // kreska tej samej długości
▶ Wejście
ha 3
▶ Wyjście
ha-ha-ha ========
Zmieniaj w miejscu albo buduj nowy Każdy znak zamienia się na jeden znak (wielkość liter, szyfr, podmiana) — zmiana w miejscu przez s[i] = … albo for (char &c : s). Znaki znikają, przybywają albo zmienia się ich kolejność — budowanie nowego napisu od "" przez +=. Znaki sklejasz zawsze z prawdziwym napisem, a liczby — po zamianie to_string.
Sprawdź się w głowie

Najpierw odpowiedz w myślach — rozpisz sobie znaki napisu w pudełkach z numerami i śledź program linijka po linijce — a dopiero potem kliknij „Pokaż odpowiedź”.

Co wypisze ten fragment?
string w = "";
w += 'a';
w += "bc";
w.push_back('d');
w.pop_back();
cout << w;
Pokaż odpowiedź
abcPo kolei: „a”, „abc”, „abcd”, a pop_back usuwa ostatnie d.
Z przodu i z tyłu. Co wypisze ten fragment?
string w = "x";
w = 'y' + w;
w = w + 'z';
cout << w;
Pokaż odpowiedź
yxz'y' + w dokleja y przed x, a w + 'z' — z na końcu. W obu przypadkach jedna strona to napis, więc plus skleja.
Co wypisze ten fragment?
cout << 'a' + 1;
Pokaż odpowiedź
98Znak plus liczba to liczba: kod litery a (97) plus 1. Żeby zobaczyć literę b, trzeba napisać (char)('a' + 1).
Co wypisze ten fragment?
string s = "ab";
string w = "";
w += s[1];
w += s[0];
w += s;
cout << w;
Pokaż odpowiedź
baabNajpierw b, potem a, a na końcu cały napis „ab”.
Odwracanie przez doklejanie z przodu. Co wypisze ten fragment?
string s = "kajak", w = "";
for (char c : s) {
    w = c + w;
}
cout << (w == s);
Pokaż odpowiedź
1Doklejanie z przodu odwraca napis. „kajak” od tyłu to też „kajak”, więc napisy są równe.
Co wypisze ten fragment?
string s = "ala";
for (char &c : s) {
    c++;
}
cout << s;
Pokaż odpowiedź
bmbKażdy znak przesuwa się o jedno miejsce w tabeli ASCII: a → b, l → m. Dzięki & zmiany trafiają do napisu.
Bez &. Co wypisze ten fragment?
string s = "abc";
for (char c : s) {
    c = 'x';
}
cout << s;
Pokaż odpowiedź
abcBez & zmienna c jest kopią znaku. Zmieniamy kopie, a napis zostaje nietknięty.
Surowy tekst plus liczba. Co wypisze ten fragment?
cout << "Ala ma kota" + 4;
Pokaż odpowiedź
ma kotaTo nie sklejanie, tylko przesunięcie początku tekstu o 4 znaki: „Ala ” zostaje pominięte.
Ćwiczenia · teraz Ty

8 ćwiczeń do tej części

0 / 8 zaliczonych

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ę.

Wszystkie ćwiczenia z tej części w sprawdzarce →

Porównywanie napisów: równe, mniejsze, większe

Liczby porównujesz od pierwszej lekcji: 3 < 7, 10 == 10. Napisy też można porównywać tymi samymi operatorami: ==, !=, <, >, <=, >=. Równość jest prosta. Ciekawsze jest pytanie, kiedy jeden napis jest mniejszy od drugiego. Odpowiedź: wtedy, gdy w słowniku stałby wcześniej. Zobaczysz jednak, że „słownik” komputera ma kilka niespodzianek.

== i != — czy to dokładnie ten sam tekst?

Dwa napisy są równe, gdy mają tę samą długość i na każdej pozycji ten sam znak. Wielkość liter ma znaczenie, spacje też — nawet niewidoczna spacja na końcu.

rownosc.cpp
string a = "kot", b = "Kot", c = "kot ", d = "kot";
cout << (a == b) << "\n";   // K i k to różne znaki
cout << (a == c) << "\n";   // c ma spację na końcu
cout << (a == d) << "\n";   // dokładnie ten sam tekst
cout << (a != b) << "\n";   // != to „różne”
▶ Wyjście
0 0 1 1
haslo.cpp
string haslo;
cin >> haslo;
if (haslo == "sezam") {
    cout << "Witaj!\n";
} else {
    cout << "Zle haslo\n";
}
▶ Wejście
Sezam
▶ Wyjście
Zle haslo

Napis możesz porównywać ze zmienną albo z tekstem w cudzysłowie, jak w prawym programie. Hasło „Sezam” z wielkiej litery nie pasuje do „sezam” — i dobrze, tak działają prawdziwe hasła.

Kolejność słownikowa: < i >

Jak komputer decyduje, który napis jest mniejszy? Robi dokładnie to, co Ty, gdy szukasz słowa w słowniku. Porównuje pierwsze znaki. Jeśli są różne — ten napis, którego znak jest wcześniej w alfabecie, jest mniejszy, i koniec. Jeśli są takie same — przechodzi do drugich znaków, potem do trzecich i tak dalej, aż do pierwszej różnicy. Taka kolejność nazywa się leksykograficzną — od greckiego słowa lexikon, słownik.

Pierwsze trzy znaki są takie same (zielone). Pierwsza różnica jest na pozycji 3: e kontra l. e jest wcześniej w alfabecie, więc „kotek” < „kotlet”. Dalszych znaków już nikt nie ogląda.
slownikowo.cpp
string a = "kotek", b = "kotlet", c = "kot";
cout << (a < b) << "\n";   // e < l na pozycji 3
cout << (c < a) << "\n";   // kot to początek słowa kotek
cout << (b > c) << "\n";
cout << (a < a) << "\n";   // nic nie jest mniejsze od siebie
▶ Wyjście
1 1 1 0
pozycjaa = kotekb = kotletwerdykt
0kkrówne — dalej
1oorówne — dalej
2ttrówne — dalej
3ele < l, więc a < b

A co, jeśli jeden napis skończy się, zanim znajdziemy różnicę — jak „kot” i „kotek”? Wtedy krótszy jest mniejszy. W słowniku też „kot” stoi przed „kotek”. Pusty napis jest więc mniejszy od każdego innego.

Zwróć uwagę: długość ma znaczenie tylko wtedy, gdy krótszy napis jest początkiem dłuższego. „b” jest większe od „aaa”, choć jest krótsze — bo już pierwsze znaki się różnią, a b jest dalej w alfabecie niż a.

Wielkie litery przed małymi

Pierwsza niespodzianka. Komputer nie zna alfabetu, zna tylko kody ASCII. Wielkie litery mają kody od 65 do 90, a małe od 97 do 122. Każda wielka litera jest więc „mniejsza” od każdej małej. Dla komputera „Zebra” stoi w słowniku przed „antylopą”, bo Z (90) < a (97). Podobnie cyfry (48–57) są przed wszystkimi literami, a spacja (32) — przed cyframi.

zebra.cpp
string a = "Zebra", b = "antylopa";
cout << (a < b) << "\n";       // Z (90) < a (97)
string x = a, y = b;           // kopie do porównania
for (char &c : x) c = tolower(c);
for (char &c : y) c = tolower(c);
cout << (x < y) << "\n";       // zebra > antylopa
cout << a << " " << b << "\n"; // oryginały bez zmian
▶ Wyjście
1 0 Zebra antylopa

Gdy w zadaniu kolejność ma być „prawdziwie alfabetyczna”, bez względu na wielkość liter, porównuj kopie zamienione na małe litery. Oryginały zostają nietknięte, więc możesz je potem wypisać tak, jak je wczytałeś.

W większości zadań olimpijskich ten problem nie występuje, bo słowa składają się z samych małych liter. Ale gdy dane mieszają wielkość liter — na przykład nazwiska z wielkiej litery — pamiętaj o tej pułapce.

Liczby zapisane jako napisy

Druga niespodzianka. Jako napisy "10" < "9" — bo porównanie zaczyna się od pierwszych znaków, a 1 jest przed 9. Napis nie wie, że zawiera liczbę! Kiedy to ważne? Gdy liczby są tak wielkie, że nie mieszczą się w żadnym typie i muszą zostać napisami — zajmiemy się nimi w części 7. Na szczęście naprawa jest prosta. Dla liczb nieujemnych bez zer na początku: dłuższa liczba jest większa, a gdy długości są równe — porównanie napisów daje właściwy wynik, bo cyfry stoją w tabeli ASCII po kolei.

wieksza_liczba.cpp
string a, b;
cin >> a >> b;
cout << (a < b) << "\n";   // porównanie napisów — uwaga!
bool aMniejsza;
if (a.length() != b.length()) {
    aMniejsza = a.length() < b.length();
} else {
    aMniejsza = a < b;
}
cout << aMniejsza << "\n";  // porównanie liczb
▶ Wejście
99 100
▶ Wyjście
0 1

Jako napisy „99” jest większe od „100”, bo 9 > 1 na pierwszej pozycji — stąd 0 w pierwszym wierszu. Jako liczby 99 < 100: krótsza liczba jest mniejsza.

Przy równych długościach zwykłe porównanie napisów działa: „123” < „129”, bo pierwsza różnica (3 i 9) rozstrzyga tak samo jak przy liczbach.

Najmniejszy i największy napis

Skoro napisy umieją się porównywać, możesz szukać wśród nich minimum i maksimum — dokładnie tym samym schematem co w tablicach. Startujesz od pierwszego napisu, a nie od pustego: pusty byłby mniejszy od wszystkich i nigdy by nie przegrał w szukaniu minimum.

min_max.cpp
int n;
cin >> n;
string s, najm, najw;
cin >> s;
najm = s;
najw = s;
for (int i = 1; i < n; i++) {
    cin >> s;
    if (s < najm) najm = s;
    if (s > najw) najw = s;
}
cout << najm << " " << najw << "\n";
▶ Wejście
5 gruszka jablko sliwka banan wisnia
▶ Wyjście
banan wisnia

Pierwsze słowo — „gruszka” — od razu zostaje i minimum, i maksimum. Potem każde kolejne słowo porównujemy z rekordami: „jablko” jest dalej niż „gruszka” (j > g), więc zostaje maksimum; „banan” jest wcześniej niż wszystko dotąd, więc zostaje minimum; i tak dalej.

Pętla zaczyna się od i = 1, bo jedno słowo wczytaliśmy przed nią. Słów jest n, więc w pętli wczytujemy n − 1 pozostałych.

Zamiana i porządkowanie: swap

swap(a, b) działa także na napisach — zamienia całą ich zawartość. Dzięki temu możesz uporządkować kilka słów alfabetycznie dokładnie tym sposobem, którym w lekcji o if porządkowałeś trzy liczby: trzy porównania i trzy ewentualne zamiany.

trzy_slowa.cpp
string a, b, c;
cin >> a >> b >> c;
if (a > b) swap(a, b);   // teraz a <= b
if (b > c) swap(b, c);   // największe trafia do c
if (a > b) swap(a, b);   // porządek w pierwszej parze
cout << a << " " << b << " " << c << "\n";
▶ Wejście
ola ania ewa
▶ Wyjście
ania ewa ola
krokabc
startolaaniaewa
a > b — zamianaaniaolaewa
b > c — zamianaaniaewaola
a > b — bez zmiananiaewaola

Dla wielu słów takie ręczne zamiany przestają wystarczać. Sortowanie dowolnie wielu napisów jednym poleceniem poznasz w lekcji o sortowaniu — a działa ono na napisach dokładnie według kolejności słownikowej z tej części.

Porównanie ręczne: wspólny początek

Czasem nie wystarczy wiedzieć, który napis jest mniejszy — trzeba wiedzieć, gdzie się różnią. Wtedy piszesz porównanie sam: idziesz od początku, dopóki znaki są takie same i żaden napis się nie skończył. Pozycja, na której się zatrzymasz, to długość wspólnego początku.

wspolny_poczatek.cpp
string a, b;
cin >> a >> b;
int na = a.length(), nb = b.length();
int i = 0;
while (i < na && i < nb && a[i] == b[i]) {
    i++;
}
cout << "wspolny poczatek: " << i << " znaki\n";
if (i < na && i < nb) {
    cout << "roznica: " << a[i] << " i " << b[i] << "\n";
}
▶ Wejście
kotek kotlet
▶ Wyjście
wspolny poczatek: 3 znaki roznica: e i l

Kolejność warunków w while znów ma znaczenie: najpierw sprawdzamy, czy i mieści się w obu napisach, a dopiero potem porównujemy a[i] z b[i]. Skrócone obliczanie chroni przed zajrzeniem poza krótszy napis.

Po pętli są trzy możliwości: znaleźliśmy różnicę (wtedy oba warunki i < … są prawdziwe), skończył się krótszy napis albo napisy są identyczne. To dokładnie te trzy przypadki, które rozważa operator <.

Porównanie też kosztuje Porównanie dwóch liczb to jedna operacja. Porównanie dwóch napisów to tyle operacji, ile znaków mają wspólnego początku — dla dwóch prawie identycznych napisów o milionie znaków to milion operacji. Zwykle nie ma to znaczenia, ale gdy porównujesz każde słowo z każdym, pamiętaj, że jedno porównanie może być długie.
Sprawdź się w głowie

Najpierw odpowiedz w myślach — rozpisz sobie znaki napisu w pudełkach z numerami i śledź program linijka po linijce — a dopiero potem kliknij „Pokaż odpowiedź”.

Co wypisze ten fragment?
string a = "abc";
cout << (a < "abd") << (a < "ab");
Pokaż odpowiedź
10„abc” < „abd”, bo pierwsza różnica to c < d. „abc” nie jest mniejsze od „ab” — „ab” to początek „abc”, więc to „ab” jest mniejsze.
Co wypisze ten fragment?
string a = "Ala", b = "ala";
cout << (a < b);
Pokaż odpowiedź
1Wielka A (65) ma mniejszy kod niż mała a (97), więc „Ala” jest mniejsze.
Liczby jako napisy. Co wypisze ten fragment?
string a = "9", b = "10";
cout << (a < b);
Pokaż odpowiedź
0Porównanie napisów zaczyna się od pierwszych znaków: 9 kontra 1. 9 jest dalej, więc „9” > „10”.
Co wypisze ten fragment?
string a = "kot", b = "kotek";
cout << (a < b) << (a > b) << (a == b);
Pokaż odpowiedź
100„kot” to początek słowa „kotek” — krótszy napis jest mniejszy.
Krótsze nie znaczy mniejsze. Co wypisze ten fragment?
string a = "b", b = "aaa";
cout << (a > b);
Pokaż odpowiedź
1Już pierwsze znaki się różnią: b > a. Długość nie ma tu nic do rzeczy.
Co wypisze ten fragment?
string a = "zebra", b = "Zebra";
cout << (a == b) << (a > b);
Pokaż odpowiedź
01Napisy nie są równe (z i Z to różne znaki), a mała z ma większy kod niż wielka Z.
Minimum w tablicy napisów. Co wypisze ten fragment?
string t[3] = {"ma", "ala", "kota"};
string m = t[0];
for (int i = 1; i < 3; i++) {
    if (t[i] < m) m = t[i];
}
cout << m;
Pokaż odpowiedź
alaPierwsze litery to m, a i k — a jest najwcześniej w alfabecie.
Spacja też jest znakiem. Co wypisze ten fragment?
string a = " a", b = "a";
cout << (a < b);
Pokaż odpowiedź
1Pierwsze znaki: spacja (32) kontra a (97). Spacja ma mniejszy kod, więc „ a” jest mniejsze.
Ćwiczenia · teraz Ty

8 ćwiczeń do tej części

0 / 8 zaliczonych

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ę.

Wszystkie ćwiczenia z tej części w sprawdzarce →

Fragmenty i szukanie: substr, find, erase, insert, replace

Do tej pory wszystko robiłeś pętlą, znak po znaku. To dobra szkoła, ale napis ma też gotowe metody — polecenia pisane po kropce, jak s.length() — które załatwiają typowe zadania jedną linijką. W tej części poznasz pięć najważniejszych: substr wycina kawałek, find szuka fragmentu, a erase, insert i replace usuwają, wstawiają i podmieniają. Każdą pokażemy na rysunku pudełek, żeby było widać, które dokładnie znaki biorą udział.

substr — kawałek napisu

s.substr(od, ile) tworzy nowy napis z ile znaków napisu s, zaczynając od pozycji od. Nazwa to skrót od „substring” — podnapis, kawałek napisu. Sam napis s się nie zmienia.

s.substr(3, 4) to „gram”: zaczynamy od pudełka 3 i bierzemy 4 znaki — pudełka 3, 4, 5 i 6.
substr.cpp
string s = "programowanie";
cout << s.substr(3, 4) << "\n";    // od 3, cztery znaki
cout << s.substr(0, 7) << "\n";    // od początku, siedem znaków
cout << s.substr(7) << "\n";       // bez drugiej liczby: do końca
cout << s.substr(10, 100) << "\n"; // za dużo? bierze do końca
cout << s << "\n";                 // s bez zmian
▶ Wyjście
gram program owanie nie programowanie
Druga liczba to długość, nie koniec Najczęstszy błąd z substr: traktowanie drugiej liczby jak pozycji końca. s.substr(3, 6) to sześć znaków od pozycji 3, a nie znaki od 3 do 6. Gdy chcesz fragment od pozycji a do pozycji b włącznie, policz jego długość: s.substr(a, b - a + 1).

Jeśli poprosisz o więcej znaków, niż zostało do końca, substr się nie obrazi — po prostu weźmie wszystko do końca. Tak było z s.substr(10, 100).

Gdy początek wypada za napisem

Pierwsza liczba musi wskazywać miejsce w napisie albo tuż za nim. s.substr(s.length()) jest jeszcze w porządku — daje pusty napis, bo za ostatnim znakiem nic już nie ma. Ale s.substr(s.length() + 1) i dalsze to błąd: program zatrzyma się z komunikatem out_of_range, tak jak przy at.

substr_koniec.cpp
string s = "kot";
cout << "[" << s.substr(3) << "]\n";      // od pozycji 3 = tuż za napisem
cout << "[" << s.substr(1, 0) << "]\n";   // zero znaków — też pusty
▶ Wyjście
[] []
substr_blad.cpp
string s = "kot";
cout << s.substr(4) << "\n";   // BŁĄD: 4 > długość 3
▶ Wyjście
terminate called after throwing an instance of 'std::out_of_range' what(): basic_string::substr: __pos (which is 4) > this->size() (which is 3)

Początek i koniec napisu

Dwa najczęstsze kawałki to początek (przedrostek) i koniec (przyrostek). Początek z k znaków to s.substr(0, k). Koniec z k znaków zaczyna się na pozycji n - k, więc to s.substr(n - k). Dzięki nim łatwo sprawdzisz, czy słowo zaczyna się albo kończy na coś.

poczatek_koniec.cpp
string s = "kotlet";
int n = s.length();
cout << s.substr(0, 3) << "\n";     // pierwsze 3 znaki
cout << s.substr(n - 3) << "\n";    // ostatnie 3 znaki
if (s.substr(0, 3) == "kot") {
    cout << "zaczyna sie od kot\n";
}
if (n >= 3 && s.substr(n - 3) == "let") {
    cout << "konczy sie na let\n";
}
▶ Wyjście
kot let zaczyna sie od kot konczy sie na let
Niebieskie: s.substr(0, 3). Zielone: s.substr(n - 3) — od pozycji 6 − 3 = 3 do końca.

Po co warunek n >= 3? Dla słowa krótszego niż 3 znaki n - 3 jest ujemne. Liczba ujemna przekazana do substr zamienia się w ogromną liczbę bez znaku (pamiętasz pułapkę z części 1?) i program się wysypie. Skrócone obliczanie sprawia, że dla krótkich słów substr w ogóle się nie wykona.

s.substr(0, 3) jest bezpieczne nawet dla krótszych słów — weźmie tyle, ile jest.

find — gdzie jest fragment?

s.find(x) szuka w napisie s fragmentu x i zwraca pozycję jego pierwszego znaku przy pierwszym wystąpieniu. Szukać możesz całego napisu albo jednego znaku. To dokładnie ta pętla, którą pisałeś w części 3, tylko gotowa.

s.find(„kot”) to 7 — tam zaczyna się pierwsze wystąpienie (niebieskie). s.find(„ma”) to 4 (zielone). Drugie „kot” na pozycji 14 i drugie „ma” na pozycji 18 są później, więc find ich nie zwraca.
find.cpp
string s = "ala ma kota a kot ma ale";
cout << s.find("kot") << "\n";    // pierwsze wystąpienie
cout << s.find('m') << "\n";      // można szukać znaku
cout << s.find("ma") << "\n";
cout << s.find("kot", 8) << "\n"; // szukaj od pozycji 8
cout << s.rfind("ma") << "\n";    // szukaj od końca
▶ Wyjście
7 4 4 14 18

Druga liczba w find mówi, od której pozycji zacząć szukanie. s.find("kot", 8) pomija wszystko przed pozycją 8, więc pierwsze „kot” (od 7) już się nie liczy i wychodzi 14.

rfind („reverse find”) szuka od końca, czyli zwraca ostatnie wystąpienie. Uwaga: pozycja nadal liczy się od początku napisu — rfind zmienia tylko kierunek szukania.

Gdy nie ma: string::npos

Co zwraca find, gdy niczego nie znajdzie? Specjalną wartość string::npos — „no position”, brak pozycji. To największa liczba typu długości, czyli ta sama ogromna liczba, którą widziałeś w części 1 jako 0 − 1. Bezpiecznie jest zawsze porównywać wynik find właśnie z string::npos.

npos.cpp
string s = "programowanie";
if (s.find("gram") != string::npos) {
    cout << "jest gram na pozycji " << s.find("gram") << "\n";
}
if (s.find("kot") == string::npos) {
    cout << "nie ma kota\n";
}
cout << s.find("kot") << "\n";    // npos wypisany wprost
int p = s.find("kot");
cout << p << "\n";                // npos włożony do int
▶ Wyjście
jest gram na pozycji 3 nie ma kota 18446744073709551615 -1

Dwie ostatnie linijki pokazują ciekawostkę, z której korzysta wielu zawodników. Gdy wynik find zapiszesz w zwykłej zmiennej int, wartość npos zamienia się w −1. Dzięki temu możesz pisać tak samo jak przy szukaniu w tablicy: int p = s.find(x); i potem if (p == -1).

Oba sposoby są dobre — wybierz jeden i trzymaj się go. W tej lekcji przy pętlach będziemy używać int i −1, bo są krótsze i znajome z tablic.

find_jako_warunek.cpp
string s = "kotlet";
if (s.find("kot")) {               // ŹLE!
    cout << "jest\n";
} else {
    cout << "nie ma\n";
}
▶ Wyjście — źle
nie ma
Nigdy nie pisz if (s.find(x)) „kot” stoi na samym początku słowa, więc find zwraca 0 — a 0 w warunku to fałsz. Program mówi „nie ma”, choć jest. Z kolei gdy fragmentu naprawdę nie ma, npos to liczba różna od zera, czyli prawda. Taki warunek działa dokładnie na odwrót, niż chcesz. Zawsze pisz pełne porównanie: s.find(x) != string::npos albo p != -1.

Wszystkie wystąpienia

Żeby znaleźć wszystkie wystąpienia, wołasz find w pętli. Każde kolejne szukanie zaczynasz za poprzednim znaleziskiem. Tylko: jak daleko za? Są dwie możliwości i dają różne wyniki.

wszystkie.cpp
string s = "abrakadabra";
int p = s.find("abra");
while (p != -1) {
    cout << p << " ";
    p = s.find("abra", p + 1);   // szukaj dalej, od następnej pozycji
}
cout << "\n";
▶ Wyjście
0 7
nakladanie.cpp
string s = "aaaa", x = "aa";
int k1 = 0, k2 = 0;
int p = s.find(x);
while (p != -1) {
    k1++;
    p = s.find(x, p + 1);          // mogą na siebie nachodzić
}
p = s.find(x);
while (p != -1) {
    k2++;
    p = s.find(x, p + x.length()); // bez nachodzenia
}
cout << k1 << " " << k2 << "\n";
▶ Wyjście
3 2

W napisie „aaaa” fragment „aa” zaczyna się na pozycjach 0, 1 i 2 — trzy wystąpienia, które na siebie nachodzą. Jeśli każde kolejne szukanie zaczynasz od p + 1, znajdziesz wszystkie trzy. Jeśli od p + x.length() — przeskakujesz całe znalezisko i znajdziesz tylko te, które się nie nakładają: 0 i 2. Które liczenie jest właściwe, zależy od zadania — zawsze przeczytaj dokładnie, o co pyta.

Rozcinanie napisu w miejscu znaku

find i substr razem pozwalają rozciąć napis w wybranym miejscu: find mówi, gdzie stoi znak podziału, a substr wycina kawałki przed nim i za nim. To trzeci — po getline z przecinkiem i pętli z części 2 — sposób na dzielenie tekstu.

email.cpp
string email = "jan.kowalski@szkola.edu.pl";
int p = email.find('@');
string uzytkownik = email.substr(0, p);   // p znaków przed @
string domena = email.substr(p + 1);      // wszystko za @
cout << uzytkownik << "\n" << domena << "\n";
▶ Wyjście
jan.kowalski szkola.edu.pl
plik.cpp
string plik = "zdjecie.wakacje.jpg";
int p = plik.rfind('.');              // ostatnia kropka
cout << plik.substr(p + 1) << "\n";   // rozszerzenie
cout << plik.substr(0, p) << "\n";    // nazwa bez rozszerzenia
▶ Wyjście
jpg zdjecie.wakacje

Zwróć uwagę na email.substr(0, p). Znak @ stoi na pozycji p, a przed nim jest dokładnie p znaków (pozycje od 0 do p − 1) — dlatego długość kawałka to p. A w nazwie pliku szukamy kropki od końca, bo kropek może być kilka, a rozszerzenie to tylko to, co za ostatnią.

Gdy kawałki mają stałe miejsca — jak godzina w postaci 07:45 — nie trzeba nawet szukać. Wystarczy substr i znana z lekcji o typach funkcja stoi, która zamienia napis na liczbę:

godzina.cpp
string czas;
cin >> czas;                       // np. 07:45
int g = stoi(czas.substr(0, 2));   // "07" → 7
int m = stoi(czas.substr(3, 2));   // "45" → 45
cout << g * 60 + m << "\n";        // minuty od północy
▶ Wejście
07:45
▶ Wyjście
465
Godziny: pudełka 0–1, czyli substr(0, 2). Minuty: pudełka 3–4, czyli substr(3, 2). Dwukropek na pozycji 2 pomijamy.

erase i insert — usuwanie i wstawianie

Teraz metody, które zmieniają napis. s.erase(od, ile) usuwa ile znaków od pozycji od — znaki za nimi przesuwają się w lewo i zajmują wolne miejsce. s.insert(od, t) wstawia napis t tak, że jego pierwszy znak stanie na pozycji od — znaki od tej pozycji przesuwają się w prawo.

s.erase(7, 3) usuwa pomarańczowe pudełka 7, 8 i 9 („owa”). Litery „nie” przesuwają się w lewo i powstaje „programnie”.
erase_insert.cpp
string s = "programowanie";
s.erase(7, 3);              // usuń 3 znaki od pozycji 7
cout << s << "\n";
s.insert(0, "super");       // wstaw na początek
cout << s << "\n";
s.insert(s.length(), "!");  // wstaw na sam koniec
cout << s << "\n";
s.erase(0, 5);              // usuń 5 pierwszych znaków
cout << s << "\n";
s.erase(7);                 // bez drugiej liczby: do końca
cout << s << "\n";
▶ Wyjście
programnie superprogramnie superprogramnie! programnie! program
po linijces
s.erase(7, 3);programnie
s.insert(0, "super");superprogramnie
s.insert(s.length(), "!");superprogramnie!
s.erase(0, 5);programnie!
s.erase(7);program

W odróżnieniu od substr te metody zmieniają s na stałe — nie trzeba niczego przypisywać. Wstawianie na pozycję s.length() to to samo co s += ….

replace — podmiana fragmentu

s.replace(od, ile, t) to erase i insert w jednym: usuwa ile znaków od pozycji od i w ich miejsce wstawia napis t. Nowy kawałek może być krótszy albo dłuższy od usuniętego — reszta napisu sama się przesunie.

replace.cpp
string s = "Ala ma kota";
s.replace(7, 4, "psa");     // od pozycji 7 zamień 4 znaki na "psa"
cout << s << "\n";
s.replace(0, 3, "Ola i Ela");
cout << s << "\n";
▶ Wyjście
Ala ma psa Ola i Ela ma psa
zamien_wszystkie.cpp
string s = "kot i kot i kotek";
string co = "kot", na = "pies";
int p = s.find(co);
while (p != -1) {
    s.replace(p, co.length(), na);
    p = s.find(co, p + na.length());   // szukaj ZA wstawionym tekstem
}
cout << s << "\n";
▶ Wyjście
pies i pies i piesek

Prawy program zamienia wszystkie wystąpienia. Najważniejszy jest ostatni wiersz pętli: kolejne szukanie zaczyna się za właśnie wstawionym tekstem, czyli od p + na.length(). Gdyby zaczynało się od p, a nowy tekst zawierał stary (na przykład zamieniasz „a” na „aa”), program znajdowałby w kółko to, co sam przed chwilą wstawił — i nigdy by się nie skończył.

metodaco robizmienia s?
s.substr(od, ile)zwraca kawałek: ile znaków od pozycji od (bez ile — do końca)nie
s.find(x), s.find(x, od)pozycja pierwszego wystąpienia x (szukając od pozycji od) albo nposnie
s.rfind(x)pozycja ostatniego wystąpienia x albo nposnie
s.erase(od, ile)usuwa ile znaków od pozycji od (bez ile — do końca)tak
s.insert(od, t)wstawia napis t przed pozycję odtak
s.replace(od, ile, t)zamienia ile znaków od pozycji od na napis ttak
Sprawdź się w głowie

Najpierw odpowiedz w myślach — rozpisz sobie znaki napisu w pudełkach z numerami i śledź program linijka po linijce — a dopiero potem kliknij „Pokaż odpowiedź”.

Co wypisze ten fragment?
string s = "informatyka";
cout << s.substr(2, 5);
Pokaż odpowiedź
formaOd pozycji 2 (litera f) bierzemy pięć znaków: f, o, r, m, a.
Co wypisze ten fragment?
string s = "informatyka";
cout << s.substr(7);
Pokaż odpowiedź
tykaBez drugiej liczby substr bierze wszystko od pozycji 7 do końca.
Co wypisze ten fragment?
string s = "banan";
cout << s.find("an") << " " << s.rfind("an");
Pokaż odpowiedź
1 3„an” stoi na pozycjach 1 i 3. find daje pierwsze wystąpienie, rfind — ostatnie.
Szukanie od pozycji. Co wypisze ten fragment?
string s = "banan";
cout << s.find("an", 2);
Pokaż odpowiedź
3Szukamy od pozycji 2, więc wystąpienie na pozycji 1 się nie liczy. Następne zaczyna się na 3.
Co wypisze ten fragment?
string s = "kot";
int p = s.find("pies");
cout << p;
Pokaż odpowiedź
-1„pies” nie występuje, więc find zwraca npos, a npos zapisany w int to −1.
Co wypisze ten fragment?
string s = "abcdef";
s.erase(1, 2);
cout << s;
Pokaż odpowiedź
adefUsuwamy 2 znaki od pozycji 1, czyli b i c.
Co wypisze ten fragment?
string s = "abc";
s.insert(1, "XY");
cout << s << s.length();
Pokaż odpowiedź
aXYbc5„XY” trafia przed pozycję 1 — między a i b. Napis ma teraz 5 znaków.
Ile wystąpień znajdzie ta pętla?
string s = "mama";
int k = 0, p = s.find("ma");
while (p != -1) {
    k++;
    p = s.find("ma", p + 1);
}
cout << k;
Pokaż odpowiedź
2„ma” zaczyna się na pozycjach 0 i 2. Szukanie od pozycji 3 już nic nie znajduje.
Co wypisze ten fragment?
string s = "12:30";
cout << stoi(s.substr(0, 2)) + stoi(s.substr(3));
Pokaż odpowiedź
42stoi("12") to liczba 12, a stoi("30") — 30. Teraz plus to dodawanie liczb: 42.
Ćwiczenia · teraz Ty

9 ćwiczeń do tej części

0 / 9 zaliczonych

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ę.

Wszystkie ćwiczenia z tej części w sprawdzarce →

Napisy i liczby: cyfry, zamiany i olbrzymy

Liczba i napis z cyframi to dla komputera dwie zupełnie różne rzeczy. 123 to liczba — można ją dodawać i mnożyć. "123" to trzy znaki w pudełkach — można je wycinać, odwracać i liczyć. W tej części nauczysz się przechodzić między tymi światami i korzystać z obu. A na koniec zobaczysz, jak liczyć na liczbach, które mają sto albo tysiąc cyfr — za dużych dla każdego typu, ale nie dla napisu.

Cyfra jako znak, cyfra jako liczba

Przypomnienie z lekcji o typach: znaki cyfr stoją w tabeli ASCII po kolei, od '0' (kod 48) do '9' (kod 57). Dlatego c - '0' zamienia znak cyfry na jej wartość, a '0' + d zamienia wartość od 0 do 9 na znak. Te dwa zapisy będą Ci towarzyszyć przez całą tę część.

cyfra_znak.cpp
char c = '7';
int d = c - '0';           // znak '7' → liczba 7
char e = '0' + 3;          // liczba 3 → znak '3'
cout << d * 2 << " " << e << "\n";
string s = "2026";
int suma = 0;
for (char z : s) {
    suma += z - '0';       // dodajemy wartości cyfr
}
cout << suma << "\n";
▶ Wyjście
14 3 10
zapiswyniktyp
'7'znak 7 (kod 55)char
'7' - '0'7int
'0' + 351int
(char)('0' + 3)znak 3char

'0' + 3 to liczba 51 — kod znaku 3. Żeby była znakiem, trzeba ją zapisać do zmiennej char (jak e w programie) albo zrzutować przez (char).

to_string i stoi — w obie strony

Całą liczbę zamienisz na napis funkcją to_string(x), a napis z cyframi na liczbę — funkcją stoi(s) („string to int”). Dla dużych liczb jest stoll („string to long long”). Obie znasz z lekcji o typach. Teraz zobacz, ile dają w połączeniu z tym, co wiesz o napisach: liczba cyfr to po prostu długość napisu, a pierwsza i ostatnia cyfra to pierwszy i ostatni znak.

to_string.cpp
int x = 4096;
string s = to_string(x);                     // "4096"
cout << s.length() << "\n";                  // liczba cyfr
cout << s[0] << s[s.length() - 1] << "\n";   // pierwsza i ostatnia cyfra
string t = "123";
cout << stoi(t) + 1 << "\n";                 // liczba: dodawanie
cout << t + "1" << "\n";                     // napis: sklejanie
long long duza = stoll("9000000000");
cout << duza * 2 << "\n";
▶ Wyjście
4 46 124 1231 18000000000
palindrom_liczbowy.cpp
long long n;
cin >> n;
string s = to_string(n), w = "";
int k = s.length();
for (int i = k - 1; i >= 0; i--) {
    w += s[i];
}
if (s == w) {
    cout << "TAK\n";
} else {
    cout << "NIE\n";
}
▶ Wejście
1234321
▶ Wyjście
TAK
▶ Inne wejście
1230
▶ Wyjście
NIE

W lekcji o pętli while sprawdzałeś, czy liczba jest palindromem, rozbierając ją na cyfry przez % 10 i / 10. Z napisem jest krócej: zamieniasz liczbę na napis i porównujesz go z odwróconym. Oba sposoby są dobre — wybierz ten, który w danym zadaniu jest prostszy.

Na co uważać przy stoi stoi czyta cyfry od początku napisu i zatrzymuje się na pierwszym znaku, który do liczby nie pasuje: stoi("12abc") to 12, a stoi(" 7") to 7 (spacje na początku pomija). Ale gdy napis nie zaczyna się od liczby — stoi("abc") — program zatrzyma się z błędem invalid_argument. A gdy liczba nie mieści się w int — z błędem out_of_range; wtedy użyj stoll.

Olbrzymy: liczby za duże dla każdego typu

Największy typ, który znasz, long long, mieści liczby do około 9 · 1018 — to 19 cyfr. Co zrobić z liczbą, która ma 100 cyfr? W zadaniach olimpijskich takie liczby się zdarzają, a jedyne miejsce, gdzie się zmieszczą, to napis. Wczytujesz je przez cin >> s jak zwykłe słowo i liczysz na nich cyfra po cyfrze — tak jak w szkole liczysz pisemnie.

Sporo pytań o olbrzyma da się rozstrzygnąć bez żadnych obliczeń, samym oglądaniem cyfr. Ostatnia cyfra mówi o parzystości i o podzielności przez 5 i 10. Suma cyfr — o podzielności przez 3 i 9. Dwie ostatnie cyfry — o podzielności przez 4.

olbrzym.cpp
string s;
cin >> s;
int n = s.length();
int ostatnia = s[n - 1] - '0';
int suma = 0;
for (char c : s) {
    suma += c - '0';
}
cout << "cyfr: " << n << "\n";
cout << "parzysta: " << (ostatnia % 2 == 0) << "\n";
cout << "podzielna przez 3: " << (suma % 3 == 0) << "\n";
▶ Wejście
12345678901234567890123456789
▶ Wyjście
cyfr: 29 parzysta: 0 podzielna przez 3: 1

Ta liczba ma 29 cyfr — o dziesięć za dużo dla long long. Ostatnia cyfra to 9, więc liczba jest nieparzysta. Suma cyfr to 135, a 135 dzieli się przez 3 — więc cała liczba też.

Zwróć uwagę, że suma cyfr jest mała nawet dla gigantycznej liczby: tysiąc cyfr daje sumę najwyżej 9000. Spokojnie zmieści się w int.

Reszta z dzielenia olbrzyma

A co z podzielnością przez 7 albo przez 1000? Tu przydaje się sztuczka z lekcji o modulo. Liczbę budujemy cyfra po cyfrze: przy każdej nowej cyfrze stara wartość mnoży się przez 10 i dochodzi cyfra. Ale nie musimy pamiętać całej wartości — wystarczy jej reszta. Po każdym kroku bierzemy % k, więc liczby nigdy nie urosną.

reszta.cpp
string s;
long long k;
cin >> s >> k;
long long r = 0;
for (char c : s) {
    r = (r * 10 + (c - '0')) % k;
}
cout << r << "\n";
▶ Wejście
12345678901234567890 7
▶ Wyjście
1
cyfrar · 10 + cyfrar = … % 7
10 · 10 + 1 = 11
21 · 10 + 2 = 125
35 · 10 + 3 = 534
44 · 10 + 4 = 442
………

Po pierwszych czterech cyfrach r = 2 — i rzeczywiście 1234 = 7 · 176 + 2. Na końcu zostaje reszta z całej liczby. r nigdy nie przekracza k, a r * 10 + 9 mieści się w long long nawet dla k rzędu miliarda.

Dodawanie pisemne na napisach

Dwóch olbrzymów można dodać dokładnie tak, jak uczyli Cię w podstawówce: od ostatnich cyfr, z przeniesieniem. Idziemy dwoma indeksami od końca obu liczb. W każdym kroku dodajemy dwie cyfry (albo jedną, gdy krótsza liczba już się skończyła) i przeniesienie z poprzedniego kroku. Ostatnia cyfra sumy trafia do wyniku, a dziesiątki idą dalej jako przeniesienie.

dodawanie.cpp
string a, b;
cin >> a >> b;
string wynik = "";
int i = a.length() - 1, j = b.length() - 1;
int przeniesienie = 0;
while (i >= 0 || j >= 0 || przeniesienie > 0) {
    int suma = przeniesienie;
    if (i >= 0) {
        suma += a[i] - '0';
        i--;
    }
    if (j >= 0) {
        suma += b[j] - '0';
        j--;
    }
    wynik = (char)('0' + suma % 10) + wynik;  // cyfra na początek
    przeniesienie = suma / 10;
}
cout << wynik << "\n";
▶ Wejście
999 1234
▶ Wyjście
2233
krokcyfrysumado wynikudalejwynik
1.9 + 413313
2.9 + 3 + 1133133
3.9 + 2 + 11221233
4.— + 1 + 12202233

Warunek pętli ma trzy części: działamy, dopóki zostały cyfry w a, albo w b, albo jest jeszcze przeniesienie. Bez trzeciej części przy 999 + 1 zgubilibyśmy jedynkę na początku wyniku.

Nowe cyfry wyniku dochodzą od końca, więc doklejamy je z przodu. Przy tysiącach cyfr to w zupełności wystarczy.

System dwójkowy na napisach

W lekcji o modulo zamieniałeś liczby na inne systemy. Napisy bardzo to ułatwiają, bo liczba w systemie dwójkowym to po prostu napis z zer i jedynek. W stronę „napis → liczba” działa ten sam trik co przy reszcie z olbrzyma, tylko mnożymy przez 2 zamiast przez 10. W stronę „liczba → napis” zbieramy reszty z dzielenia przez 2 i doklejamy je z przodu, bo wychodzą od końca.

z_dwojkowego.cpp
string b;
cin >> b;
long long w = 0;
for (char c : b) {
    w = w * 2 + (c - '0');
}
cout << w << "\n";
▶ Wejście
101101
▶ Wyjście
45
na_dwojkowy.cpp
long long n;
cin >> n;
string b = "";
if (n == 0) {
    b = "0";
}
while (n > 0) {
    b = (char)('0' + n % 2) + b;
    n /= 2;
}
cout << b << "\n";
▶ Wejście
45
▶ Wyjście
101101

Prześledź lewy program dla 101101: w = 1, potem 1 · 2 + 0 = 2, 2 · 2 + 1 = 5, 5 · 2 + 1 = 11, 11 · 2 + 0 = 22, 22 · 2 + 1 = 45. Każda kolejna cyfra przesuwa dotychczasową wartość o jedno miejsce w lewo (mnożenie przez 2) i dokłada się na końcu. Zero obsługujemy osobno w prawym programie, bo dla n = 0 pętla nie wykona się ani razu i napis zostałby pusty.

Liczby ukryte w tekście

Ostatni schemat tej części: tekst, w którym między literami stoją liczby, na przykład „W koszyku 12 jablek i 125 sliwek”. Jak wyciągnąć z niego liczby? Idziemy znak po znaku i budujemy bieżącą liczbę: każda cyfra to liczba = liczba * 10 + cyfra. Gdy trafimy na znak, który nie jest cyfrą, bieżąca liczba się skończyła — zapisujemy ją i zaczynamy od zera.

liczby_w_tekscie.cpp
string s;
getline(cin, s);
long long suma = 0, liczba = 0;
for (char c : s) {
    if (isdigit(c)) {
        liczba = liczba * 10 + (c - '0');
    } else {
        suma += liczba;    // liczba się skończyła
        liczba = 0;
    }
}
suma += liczba;            // liczba na samym końcu tekstu
cout << suma << "\n";
▶ Wejście
W koszyku 12 jablek, 3 gruszki i 125 sliwek
▶ Wyjście
140

Dodawanie przy każdym znaku, który nie jest cyfrą, wygląda podejrzanie — przecież liter jest dużo. Ale gdy przed literą nie było cyfr, liczba wynosi 0, więc dodanie jej niczego nie zmienia. Prosto i bez dodatkowych warunków.

Najczęstszy błąd: brak linijki po pętli. Gdy tekst kończy się cyfrą, ostatnia liczba nie ma za sobą litery, która by ją „zamknęła” — trzeba ją dodać osobno.

Sprawdź się w głowie

Najpierw odpowiedz w myślach — rozpisz sobie znaki napisu w pudełkach z numerami i śledź program linijka po linijce — a dopiero potem kliknij „Pokaż odpowiedź”.

Co wypisze ten fragment?
cout << '8' - '0' + 1;
Pokaż odpowiedź
9'8' - '0' to wartość cyfry, 8. Plus 1 daje 9.
Co wypisze ten fragment?
cout << (char)('0' + 5) << 5;
Pokaż odpowiedź
55Najpierw znak 5 (kod 53 zamieniony na znak), a zaraz za nim liczba 5. Na ekranie wyglądają tak samo.
Co wypisze ten fragment?
string s = to_string(305);
cout << s.length() << s[1];
Pokaż odpowiedź
30„305” ma 3 znaki, a znak na pozycji 1 to 0.
Liczba czy napis? Co wypisze ten fragment?
string a = "40", b = "2";
cout << stoi(a) + stoi(b) << " " << a + b;
Pokaż odpowiedź
42 402Po zamianie na liczby plus dodaje: 42. Na napisach plus skleja: „402”.
Co wypisze ten fragment?
string b = "1101";
int w = 0;
for (char c : b) {
    w = w * 2 + (c - '0');
}
cout << w;
Pokaż odpowiedź
131 → 1 · 2 + 1 = 3 → 3 · 2 + 0 = 6 → 6 · 2 + 1 = 13.
Co wypisze ten fragment?
int n = 6;
string b = "";
while (n > 0) {
    b = (char)('0' + n % 2) + b;
    n /= 2;
}
cout << b;
Pokaż odpowiedź
110Reszty z dzielenia przez 2: 6 → 0, 3 → 1, 1 → 1. Doklejane z przodu dają 110.
Co wypisze ten fragment?
cout << stoi("12abc") + 1;
Pokaż odpowiedź
13stoi czyta cyfry od początku i zatrzymuje się na literze a: wychodzi 12. Plus 1 daje 13.
Reszta z dzielenia. Co wypisze ten fragment?
string s = "987";
int r = 0;
for (char c : s) {
    r = (r * 10 + (c - '0')) % 4;
}
cout << r;
Pokaż odpowiedź
39 % 4 = 1, potem 18 % 4 = 2, potem 27 % 4 = 3. I rzeczywiście 987 = 4 · 246 + 3.
Ćwiczenia · teraz Ty

9 ćwiczeń do tej części

0 / 9 zaliczonych

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ę.

7.1 Cyfry słowniełatwe✓ zaliczone 305 → trzy zero piec. Tablica-ściąga z nazwami cyfr i c - '0' jako indeks. c - '0'tablica napisówolbrzym Rozwiąż 7.2 Cyfry iloczynułatwe✓ zaliczone Pomnóż dwie liczby i powiedz, ile cyfr ma wynik i jaka jest suma jego cyfr — przez to_string. to_stringlong longsuma cyfr Rozwiąż 7.3 Test podzielności olbrzymaśrednie✓ zaliczone Przez które liczby od 2 do 12 dzieli się liczba z tysiąca cyfr? reszta z olbrzyma(r * 10 + d) % kpętla po k Rozwiąż 7.4 Przestaw cyfryśrednie✓ zaliczone Z tych samych cyfr ułóż największą i najmniejszą liczbę. Uwaga na zera na początku! liczniki cyfrile[c - '0']zero na początku Rozwiąż 7.5 Z dwójkowego na dziesiętnyłatwe✓ zaliczone Napis z zer i jedynek zamień na liczbę: w = w * 2 + cyfra. w * 2 + (c - '0')long longsystem dwójkowy Rozwiąż 7.6 Na dwójkowyłatwe✓ zaliczone Zapisz liczbę w systemie dwójkowym: reszty z dzielenia przez 2, doklejane z przodu. n % 2doklejanie z przoduzero osobno Rozwiąż 7.7 Największa liczba w tekścieśrednie✓ zaliczone W tekście ukryte są liczby, niektóre po 50 cyfr. Znajdź największą — porównując napisy. budowanie liczbyolbrzymynajpierw długość Rozwiąż 7.8 Olbrzym razy cyfraśrednie✓ zaliczone Pomnóż liczbę z tysiąca cyfr przez jedną cyfrę — pisemnie, od końca, z przeniesieniem. mnożenie pisemneprzeniesienieod końca Rozwiąż 7.9 Dodawanie dwójkoweśrednie✓ zaliczone Dodaj dwie liczby zapisane w systemie dwójkowym — tysiąc cyfr, pisemnie. dodawanie pisemne% 2 i / 2dwa indeksy od końca Rozwiąż
Wszystkie ćwiczenia z tej części w sprawdzarce →

Napisy na olimpiadzie: liczniki, szyfry, okna

Na olimpiadzie napisy są długie — sto tysięcy, a nawet milion znaków — a pytań o nie jest dużo. Pętla w pętli, która dla zwykłych danych działa w mgnieniu oka, nagle potrzebuje godzin. W tej części poznasz sztuczki, które pozwalają odpowiadać szybko: tablicę liczników liter, szyfry z modulo, przesuwane okno i sumy prefiksowe na napisie. Większość z nich znasz już z tablic — teraz zobaczysz je w świecie tekstu. Na koniec sprawdzimy, które operacje na napisach są tanie, a które drogie.

Tablica liczników liter

W lekcji o tablicach liczyłeś litery w tablicy int ile[26], gdzie literze c odpowiada pudełko c - 'a'. To jedna z najważniejszych sztuczek w zadaniach tekstowych, bo wiele pytań dotyczy nie kolejności liter, tylko tego, ile ich jest. Na przykład: dwa słowa są anagramami (jedno powstaje z drugiego przez przestawienie liter), gdy każda litera występuje w nich tyle samo razy.

anagramy.cpp
string a, b;
cin >> a >> b;
int ile[26] = {};
for (char c : a) ile[c - 'a']++;    // litery a dodajemy
for (char c : b) ile[c - 'a']--;    // litery b odejmujemy
bool anagram = true;
for (int k = 0; k < 26; k++) {
    if (ile[k] != 0) anagram = false;
}
cout << (anagram ? "TAK" : "NIE") << "\n";
▶ Wejście
ramka marka
▶ Wyjście
TAK
▶ Inne wejście
kotek kotlet
▶ Wyjście
NIE

Zamiast dwóch tablic liczników wystarczy jedna: litery pierwszego słowa zwiększają liczniki, a drugiego — zmniejszają. Jeśli słowa mają te same litery w tych samych ilościach, wszystko się zeruje.

Ile to kosztuje? Jedno przejście po każdym słowie i 26 obrotów na koniec. Porównywanie „każda litera z każdą” byłoby dużo wolniejsze — dla słów o stu tysiącach liter różnica to ułamek sekundy kontra wiele minut.

Gdy w tekście mogą być nie tylko małe litery, możesz liczyć wszystkie znaki naraz. Kody ASCII zwykłych znaków mieszczą się między 0 a 127, więc wystarczy tablica int ile[128], a znak sam w sobie jest numerem pudełka: ile[c]++.

wszystkie_znaki.cpp
string s = "programowanie";
int ile[128] = {};
for (char c : s) {
    ile[c]++;                  // znak to numer pudełka
}
for (int c = 0; c < 128; c++) {
    if (ile[c] > 1) {
        cout << (char)c << " ";  // znaki, które się powtarzają
    }
}
cout << "\n";
▶ Wyjście
a o r

Druga pętla przechodzi po wszystkich kodach od 0 do 127 i wypisuje znaki, które wystąpiły więcej niż raz. Dzięki temu wynik jest od razu uporządkowany według tabeli ASCII — w przypadku małych liter to po prostu kolejność alfabetyczna.

W „programowanie” litery a, o i r występują po dwa razy, a wszystkie pozostałe — po razie.

Szyfry i modulo

Szyfr Cezara znasz z wcześniejszych lekcji: każdą literę przesuwamy o k miejsc w alfabecie, a gdy wyjdziemy za z — wracamy na początek. To „wracanie w kółko” to dokładnie modulo: numer litery to c - 'a', po przesunięciu (c - 'a' + k) % 26, a z powrotem na znak — 'a' + …. Wielkie litery obsługujemy osobno, z 'A' zamiast 'a', a pozostałe znaki zostawiamy.

cezar.cpp
int k;
string s;
cin >> k;
cin.ignore();
getline(cin, s);
for (char &c : s) {
    if (islower(c)) {
        c = 'a' + (c - 'a' + k) % 26;
    } else if (isupper(c)) {
        c = 'A' + (c - 'A' + k) % 26;
    }
}
cout << s << "\n";
▶ Wejście
3 Zyzio i Ala
▶ Wyjście
Cbclr l Dod

Z przesuwa się o 3 na C: numer 25, plus 3 to 28, a 28 % 26 = 2, czyli C. Spacje zostają na miejscu, bo nie są literami.

Jak odszyfrować? Przesunąć o k wstecz. Odejmowanie przy modulo bywa zdradliwe (pamiętasz ujemne reszty z lekcji o modulo?), więc zamiast odejmować k, dodaj 26 - k — przesunięcie o 26 to pełne okrążenie, które niczego nie zmienia.

W ćwiczeniach poznasz silniejszy szyfr Vigenère’a, w którym każda litera przesuwa się o inną wartość — i tam modulo przyda się dwa razy.

Okno o stałej długości

Typowe pytanie: który fragment długości k zawiera najwięcej samogłosek? Fragmentów jest n − k + 1, a każdy ma k znaków. Liczenie każdego od nowa to około n · k operacji — dla n = 100 000 i k = 50 000 to miliardy. A przecież sąsiednie fragmenty różnią się tylko dwoma znakami! Wyobraź sobie okno o szerokości k, które przesuwamy po napisie o jedno miejsce: z lewej jeden znak wypada, z prawej jeden wchodzi. Wystarczy poprawić licznik o te dwa znaki.

Okno długości 4 przesunęło się z pozycji 4–7 na 5–8: pomarańczowe s[4] wypadło z okna, zielone s[8] weszło. Pozostałe trzy znaki są wspólne i nie trzeba ich liczyć od nowa.
okno.cpp
string s, sam = "aeiouy";
int k;
cin >> s >> k;
int n = s.length();
int ile = 0;
for (int i = 0; i < k; i++) {               // pierwsze okno: 0..k-1
    if (sam.find(s[i]) != string::npos) ile++;
}
int najlepiej = ile;
for (int i = k; i < n; i++) {               // okno przesuwa się o 1
    if (sam.find(s[i]) != string::npos) ile++;      // wchodzi s[i]
    if (sam.find(s[i - k]) != string::npos) ile--;  // wypada s[i - k]
    if (ile > najlepiej) najlepiej = ile;
}
cout << najlepiej << "\n";
▶ Wejście
programowanie 4
▶ Wyjście
3

Zwróć uwagę na trik z sam.find(s[i]). Zamiast długiego warunku c == 'a' || c == 'e' || … szukamy znaku w napisie z samogłoskami — jeśli find go znajdzie, to samogłoska. Krótko i bez literówek.

Pierwsza pętla liczy pierwsze okno. Druga przesuwa okno: gdy jego prawy koniec jest na pozycji i, lewy jest na i - k + 1, więc znak, który właśnie wypadł, stał na i - k. Całość to około n kroków zamiast n · k. Najlepsze okno to „anie” na końcu — trzy samogłoski.

Sumy prefiksowe na napisie

A gdy pytań jest dużo i każde dotyczy innego fragmentu — „ile liter a jest między pozycją l a r?” — pomagają sumy prefiksowe z lekcji o tablicach. p[i] to liczba liter a wśród pierwszych i znaków napisu. Fragment od l-tego do r-tego znaku (licząc od 1) zawiera wtedy p[r] - p[l - 1] liter a — jedno odejmowanie zamiast pętli.

prefiksy.cpp
string s;
cin >> s;
int n = s.length();
int p[1001];
p[0] = 0;
for (int i = 1; i <= n; i++) {
    p[i] = p[i - 1] + (s[i - 1] == 'a');   // i-ty znak to s[i - 1]
}
int q;
cin >> q;
for (int k = 0; k < q; k++) {
    int l, r;
    cin >> l >> r;
    cout << p[r] - p[l - 1] << "\n";
}
▶ Wejście
abracadabra 3 1 11 2 5 4 8
▶ Wyjście
5 1 3
i01234567891011
znak—abracadabra
p[i]011122334445

Zapis (s[i - 1] == 'a') to porównanie, które daje true albo false — a w rachunkach true liczy się jako 1, a false jako 0. Dzięki temu dodajemy jedynkę dokładnie wtedy, gdy znak to a.

Pytanie „4 8”: p[8] - p[3] = 4 − 1 = 3. Znaki od 4. do 8. to a, c, a, d, a — trzy litery a.

Które operacje są szybkie, a które wolne?

Na olimpiadzie program ma limit czasu, zwykle około sekundy — w tym czasie komputer wykona kilkaset milionów prostych operacji. Dlatego warto wiedzieć, ile kosztują operacje na napisach. Niektóre zajmują chwilę bez względu na długość napisu. Inne muszą przejść po wszystkich znakach — i jeśli robisz je w pętli, koszt mnoży się przez liczbę obrotów.

operacjakosztuwagi
s[i], s.length(), s.empty()stałyzawsze błyskawicznie
s += c, s.push_back(c), s.pop_back()stałydokładanie i zabieranie na końcu
s + t, s.substr(od, ile), string t = sdługość wynikupowstaje nowy napis — każdy znak trzeba skopiować
s == t, s < tdo pierwszej różnicydla prawie równych napisów — cała długość
c + s, s.insert(0, …), s.erase(0, 1)długość swszystkie znaki przesuwają się o miejsce
s.find(t)nawet n · mdla każdej pozycji porównuje kawałek z t
wolno_szybko.cpp
string s = "";
for (int i = 0; i < 100000; i++) {
    s = s + 'x';      // WOLNO: za każdym razem kopia całego s
}
string t = "";
for (int i = 0; i < 100000; i++) {
    t += 'x';         // SZYBKO: dokłada jeden znak
}

Oba fragmenty budują napis ze stu tysięcy liter x, ale pierwszy jest wielokrotnie wolniejszy. s = s + 'x' najpierw tworzy nowy napis — kopię całego s z dodanym znakiem — a potem przepisuje go z powrotem do s. Przy ostatnich obrotach to kopiowanie stu tysięcy znaków naraz, a w sumie — około pięciu miliardów kopiowań. t += 'x' dokłada jeden znak na końcu.

Ta sama pułapka dotyczy doklejania z przodu (w = c + w) — dla długich napisów lepiej zbudować wynik od końca przez +=, a potem odwrócić go raz pętlą ze swap.

Duże wejście? Przyspiesz cin Gdy na wejściu jest kilkaset tysięcy słów albo wierszy, samo wczytywanie może zająć dużo czasu. Pamiętasz z lekcji Input / Output dwie linijki na początku main: ios_base::sync_with_stdio(false); i cin.tie(nullptr);? Działają też z getline i wczytywaniem napisów. Po ich dopisaniu nie mieszaj już cin i cout z scanf i printf.

Tablica napisów i liczenie słów

Ostatni schemat: ile razy występuje każde słowo? Liter jest 26, więc wystarczyła tablica liczników. Różnych słów może być bardzo dużo, więc tak się nie da. Na razie — zanim poznasz struktury, które zrobią to szybciej — możesz wczytać słowa do tablicy i dla każdego policzyć, ile razy występuje, porównując je ze wszystkimi. Dla tysiąca słów to milion porównań: w sam raz.

najczestsze.cpp
int n;
cin >> n;
string t[1000];
for (int i = 0; i < n; i++) {
    cin >> t[i];
}
string najczestsze = "";
int rekord = 0;
for (int i = 0; i < n; i++) {
    int ile = 0;
    for (int j = 0; j < n; j++) {
        if (t[j] == t[i]) ile++;
    }
    if (ile > rekord || (ile == rekord && t[i] < najczestsze)) {
        rekord = ile;
        najczestsze = t[i];
    }
}
cout << najczestsze << " " << rekord << "\n";
▶ Wejście
8 kot pies kot mysz pies kot ala ala
▶ Wyjście
kot 3

Dla każdego słowa t[i] wewnętrzna pętla liczy, ile słów jest mu równych. Rekord zmienia się, gdy słowo występuje częściej — albo tyle samo razy, ale jest wcześniej w alfabecie. Dzięki temu przy remisie wygrywa słowo alfabetycznie pierwsze.

To rozwiązanie liczy każde słowo tyle razy, ile razy występuje — „kot” trzy razy. To marnotrawstwo, ale nieszkodliwe. W lekcji o mapach poznasz strukturę, która policzy słowa w jednym przejściu, nawet dla miliona słów.

Sprawdź się w głowie

Najpierw odpowiedz w myślach — rozpisz sobie znaki napisu w pudełkach z numerami i śledź program linijka po linijce — a dopiero potem kliknij „Pokaż odpowiedź”.

Co wypisze ten fragment?
int ile[26] = {};
string s = "banana";
for (char c : s) ile[c - 'a']++;
cout << ile[0] << ile[1] << ile['n' - 'a'];
Pokaż odpowiedź
312Pudełko 0 to a (3 razy), pudełko 1 to b (raz), a pudełko 'n' - 'a' to n (2 razy).
Szyfr Cezara. Co wypisze ten fragment?
string s = "xyz";
for (char &c : s) {
    c = 'a' + (c - 'a' + 2) % 26;
}
cout << s;
Pokaż odpowiedź
zabx (23) + 2 = 25 → z. y (24) + 2 = 26 % 26 = 0 → a. z (25) + 2 = 27 % 26 = 1 → b.
Odszyfrowanie. Co wypisze ten fragment?
char c = 'b';
int k = 3;
cout << (char)('a' + (c - 'a' + 26 - k) % 26);
Pokaż odpowiedź
yPrzesuwamy b o 3 wstecz: b → a → z → y. Rachunek: 1 + 26 − 3 = 24, a 24 % 26 = 24, czyli y.
Co wypisze ten fragment?
string sam = "aeiouy";
cout << (sam.find('o') != string::npos) << (sam.find('k') != string::npos);
Pokaż odpowiedź
10o jest samogłoską — find ją znajduje. k nie — find zwraca npos.
Sumy prefiksowe. Co wypisze ten fragment?
string s = "abcab";
int p[6];
p[0] = 0;
for (int i = 1; i <= 5; i++) {
    p[i] = p[i - 1] + (s[i - 1] == 'a');
}
cout << p[5] - p[1];
Pokaż odpowiedź
1p = 0, 1, 1, 1, 2, 2. p[5] - p[1] to liczba liter a wśród znaków od 2. do 5. (b, c, a, b) — jedna.
Okno długości 3. Co wypisze ten fragment?
string s = "abaaa";
int k = 3, ile = 0;
for (int i = 0; i < k; i++) ile += (s[i] == 'a');
int best = ile;
for (int i = k; i < 5; i++) {
    ile += (s[i] == 'a');
    ile -= (s[i - k] == 'a');
    if (ile > best) best = ile;
}
cout << best;
Pokaż odpowiedź
3Okna: „aba” (2), „baa” (2), „aaa” (3). Najlepsze ma trzy litery a.
Co wypisze ten fragment?
string s = "ala";
s = s + 'x';
s += 'y';
cout << s.length();
Pokaż odpowiedź
5Oba sposoby dokładają po jednym znaku — różnią się tylko szybkością, nie wynikiem.
Liczniki wszystkich znaków. Co wypisze ten fragment?
int ile[128] = {};
string s = "A a!";
for (char c : s) ile[c]++;
cout << ile['a'] + ile['A'] << ile[' '];
Pokaż odpowiedź
21a i A to różne pudełka, każde z licznikiem 1 — razem 2. Spacja wystąpiła raz.
Ćwiczenia · teraz Ty

8 ćwiczeń do tej części

0 / 8 zaliczonych

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ę.

Wszystkie ćwiczenia z tej części w sprawdzarce →

Baza zadań: napisy w praktyce

Znasz już wszystko, co potrzebne: napis jako rząd znaków, wczytywanie słów, wierszy i całego tekstu, rodzaje znaków i toupper, budowanie i zmienianie napisów, kolejność słownikową, metody substr, find, erase, insert i replace, liczby zapisane jako napisy, a do tego liczniki liter, szyfry, okna i sumy prefiksowe. Czas na zadania, które łączą kilka z tych rzeczy naraz. Są ułożone od najłatwiejszego do najtrudniejszego: najpierw rozgrzewka z jednym pomysłem, potem zadania średnie — szyfr harcerski, PESEL, alfabet Morse’a, krzyżówka, numer konta — a na końcu trudne, z olbrzymimi liczbami, palindromami, zawijaniem tekstu i wielkim finałem.

Przy każdym zadaniu widać, jakich zagadnień używa — także tych z poprzednich lekcji, jak modulo czy tablice. Jeśli coś brzmi obco, wróć do odpowiedniej części — mapa lekcji jest na górze strony. A tu masz najważniejsze schematy z lekcji w jednym miejscu:

Ściąga: gotowe schematy z napisami

Podstawy

int n = s.length();   // zawsze int!
s[0]  s[n - 1]  s[n / 2]
s.empty()  string(k, '*')
string t = s;  // osobna kopia

Indeksy od 0 do n - 1. Polskie litery zajmują po dwa znaki.

Wczytywanie

cin >> s;               // słowo
getline(cin, s);        // wiersz
while (cin >> s) …      // do końca
cin >> n; cin.ignore(); // przed getline

Po cin >>, a przed getline — cin.ignore() albo getline(cin >> ws, s).

Rodzaje znaków

isdigit(c) isalpha(c) isalnum(c)
isupper(c) islower(c) isspace(c)
s[i] = toupper(s[i]);
c - '0'   c - 'a'   '0' + d

is… zwracają „nie zero”, a nie 1. toupper daje int — w cout rzutuj na char.

Budowanie

string w = "";
w += c;  w += "abc";
w = c + w;      // z przodu
w.pop_back();   // gdy !w.empty()

Plus skleja tylko z prawdziwym string. Liczby: to_string(x).

Porównywanie

a == b   a < b   swap(a, b)
// olbrzymy bez zer na początku:
a.length() != b.length()
  ? a.length() < b.length() : a < b

Kolejność słownikowa do pierwszej różnicy. Wielkie litery przed małymi.

Fragmenty

s.substr(od, ile)  s.substr(od)
int p = s.find(x);   // -1: brak
s.find(x, p + 1)   s.rfind(x)
s.erase(od, ile)  s.insert(od, t)
s.replace(od, ile, t)

Nigdy if (s.find(x)). Od a do b włącznie: substr(a, b - a + 1).

Liczby i olbrzymy

to_string(x)  stoi(s)  stoll(s)
r = (r * 10 + (c - '0')) % k;
w = w * 2 + (c - '0');   // z dwójkowego
wynik = (char)('0' + d) + wynik;

Dodawanie i mnożenie pisemne — od końca, z przeniesieniem.

Olimpijskie sztuczki

int ile[26] = {};  ile[c - 'a']++;
c = 'a' + (c - 'a' + k) % 26;
p[i] = p[i - 1] + (s[i - 1] == 'a');
// okno: +wchodzący, -wypadający

Długie napisy: s += c, nie s = s + c.

Jak rozwiązywać zadania z napisami 1) Zdecyduj, jak wczytać dane: słowa (cin >>), wiersze ze spacjami (getline) czy całość do końca danych — i czy po liczbie trzeba zjeść Enter. 2) Zapisz długość w int n. 3) Zmieniasz znak na znak — pracuj w miejscu. Coś znika albo przybywa — buduj nowy napis. 4) Zanim napiszesz pętlę, sprawdź, czy nie ma gotowej metody: find, substr, replace. 5) Przy każdym s[i + 1], s[i - 1] i substr sprawdź brzegi — pusty napis, jeden znak, fragment na samym końcu. 6) Pytanie o to, ile jakich liter? Tablica liczników. Dużo pytań o fragmenty? Sumy prefiksowe albo okno. 7) Przetestuj skrajności: jeden znak, same spacje, wielkie i małe litery, liczba na samym końcu tekstu.
łatwe

Rozgrzewka · zadania 1–10

Jeden pomysł naraz: akronimy, hashtagi, język P, rymy, łańcuch słów, wisielec, litery po kolei i SMS na starym telefonie.

1 Akronimłatwe✓ zaliczone polski zwiazek wedkarski → PZW: pierwsze litery słów, wielkimi literami. while (cin >> s)s[0]toupper Rozwiąż 2 Hashtagłatwe✓ zaliczone wakacje nad MORZEM → #WakacjeNadMorzem: bez spacji, każde słowo z wielkiej litery. tolowertoupperbudowanie Rozwiąż 3 Usuń powtórzenia obok siebiełatwe✓ zaliczone aaabccddd → abcd: z każdej serii takich samych liter zostaw jedną. s[i] != s[i - 1]seriebudowanie Rozwiąż 4 Język Płatwe✓ zaliczone kot → kopot: po każdej samogłosce dopisz p i tę samą samogłoskę. Tajny język z podwórka. find w napisie samogłosekbudowaniegetline Rozwiąż 5 Czy to się rymuje?łatwe✓ zaliczone Dwa słowa rymują się, gdy kończą się tymi samymi dwiema literami. kot i plot — tak. substr(n - 2)==n par Rozwiąż 6 Łańcuch słówłatwe✓ zaliczone Gra w słowa: każde słowo zaczyna się na ostatnią literę poprzedniego. Kto pierwszy złamał zasadę? s[0]ostatnia literapoprzednie słowo Rozwiąż 7 Każde słowo wspakłatwe✓ zaliczone Ala ma kota → alA am atok: odwróć każde słowo, ale zostaw kolejność słów. odwracaniecin >> spętla od końca Rozwiąż 8 Litery po koleiłatwe✓ zaliczone programowanie → aaegimnooprrw: ułóż litery alfabetycznie, licząc je w tablicy. int ile[26]string(k, c)sortowanie przez zliczanie Rozwiąż 9 Wisielecłatwe✓ zaliczone Pokaż odgadnięte litery hasła, a w miejsce reszty podkreślniki. Ile było pudeł? bool odgadniete[26]budowanieróżne litery Rozwiąż 10 SMS na starym telefoniełatwe✓ zaliczone Na klawiszu 2 są litery abc: a to jedno naciśnięcie, c — trzy. Ile naciśnięć zajmie SMS? tablica-ściągac - 'a'suma Rozwiąż
średnie

Średnie · zadania 11–20

Kilka sztuczek naraz: GA-DE-RY-PO-LU-KI, czas trwania filmu, nawiasy, liczby rzymskie, kalkulator, PESEL, alfabet Morse’a, krzyżówka, obroty napisu i numer konta IBAN.

11 GA-DE-RY-PO-LU-KIśrednie✓ zaliczone Harcerski szyfr: g↔a, d↔e, r↔y, p↔o, l↔u, k↔i. Wielkość liter zostaje. klucz w napisiefindpara p ^ 1 Rozwiąż 12 Ile trwał film?średnie✓ zaliczone Start 23:15:00, koniec 01:02:30 — film skończył się po północy. Policz czas trwania. substrstoizera z przodu Rozwiąż 13 Nawiasyśrednie✓ zaliczone Czy nawiasy są poprawnie sparowane? Jeśli tak — jak głęboko się zagnieżdżają? licznik otwartychnigdy poniżej zeramaksimum Rozwiąż 14 Z rzymskich na arabskieśrednie✓ zaliczone MCMXCIV → 1994. Mniejsza cyfra przed większą odejmuje się, w każdym innym przypadku dodaje. tablica-ściągafinds[i + 1] Rozwiąż 15 Kalkulatorśrednie✓ zaliczone 12+34-5+100 → 141. Wyłuskaj liczby z napisu i pamiętaj znak przed każdą. liczba z cyfrostatni znak działaniawartownik Rozwiąż 16 PESELśrednie✓ zaliczone Sprawdź cyfrę kontrolną numeru PESEL i odczytaj z niego datę urodzenia i płeć. wagi cyfrsubstrmiesiąc + 20 Rozwiąż 17 Alfabet Morse’aśrednie✓ zaliczone ... --- ... → SOS. Odszyfruj wiadomość, szukając kodów w tablicy-ściądze. tablica napisówporównanie napisów(char)('A' + k) Rozwiąż 18 Krzyżówkaśrednie✓ zaliczone Dwa słowa krzyżują się na pierwszej wspólnej literze. Narysuj tę krzyżówkę z kropkami. findsiatka znakówpętla w pętli Rozwiąż 19 Czy to obrót?średnie✓ zaliczone ekkot to obrócony kotek? Sprytna sztuczka: szukaj b w napisie a + a. a + afindobrót napisu Rozwiąż 20 Numer konta IBANśrednie✓ zaliczone Banki sprawdzają numery kont resztą z dzielenia przez 97 liczby z 30 cyfr. Zrób to samo. reszta z olbrzymalitery na liczbysubstr Rozwiąż
trudne

Trudne · zadania 21–29

Okres napisu, zawijanie wierszy, wzorce z pytajnikami, najdłuższy palindrom, odejmowanie i mnożenie olbrzymów, najdłuższy fragment bez powtórzeń, kwota słownie — a na koniec wielki finał: edytor tekstu.

21 Powtarzający się kawałektrudne✓ zaliczone abcabcabc to trzy razy abc. Znajdź najkrótszy kawałek, z którego powtórzeń składa się słowo. dzielniki długościs[i] == s[i - p]substr Rozwiąż 22 Wyjustowany teksttrudne✓ zaliczone Ułóż słowa w wiersze o szerokości W i rozłóż spacje tak, by każdy wiersz kończył się równo. tablica napisówrozkład spacjiostatni wiersz Rozwiąż 23 Wzorzec z pytajnikamitrudne✓ zaliczone We wzorcu ? pasuje do każdej litery. Gdzie w tekście pasuje wzorzec k?t — a gdzie ??a? pętla w pętlip[j] == ?break Rozwiąż 24 Najdłuższy palindromtrudne✓ zaliczone Znajdź najdłuższy fragment słowa, który jest palindromem. Rozszerzaj od każdego środka. dwa wskaźnikiśrodek nieparzysty i parzystysubstr Rozwiąż 25 Odejmowanie olbrzymówtrudne✓ zaliczone a − b dla liczb z tysiąca cyfr: porównaj, odejmij pisemnie z pożyczką, usuń zera z przodu. porównanie olbrzymówpożyczkazera na początku Rozwiąż 26 Mnożenie olbrzymówtrudne✓ zaliczone Pomnóż dwie liczby po 500 cyfr — pisemnie, każda cyfra z każdą, z przeniesieniem na końcu. tablica cyfr wynikuw[i + j]przeniesienie Rozwiąż 27 Najdłuższy fragment bez powtórzeńtrudne✓ zaliczone abcabcbb → abc. Dwa wskaźniki: przesuwaj początek okna za ostatnie wystąpienie powtórzonej litery. dwa wskaźnikiostatnie wystąpienieokno o zmiennej długości Rozwiąż 28 Kwota słownietrudne✓ zaliczone 2026 → dwa tysiace dwadziescia szesc. Tablice-ściągi słów i polska gramatyka: tysiąc, tysiące czy tysięcy? tablice napisówseparatortysiace / tysiecy Rozwiąż 29 Wielki finał: edytor tekstutrudne✓ zaliczone Zbuduj mały edytor: wstawianie, usuwanie, zamiana, wielkie litery, odwracanie i zliczanie — polecenie po poleceniu. insert / erasefind + replacewszystko naraz Rozwiąż

Częste błędy i dobre praktyki

0️⃣
Od 0 do długość − 1
Pierwszy znak to s[0], ostatni — s[s.length() - 1]. C++ nie sprawdza indeksów: s[n] da śmieci albo wysypie program. Gdy coś nie gra, zamień na chwilę s[i] na s.at(i).
➖
int n = s.length();
Długość nie zna liczb ujemnych: dla pustego napisu s.length() - 1 to 18 446 744 073 709 551 615. Zapisz długość w int i używaj n - 1.
↵
Enter po liczbie
Po cin >> n na wejściu zostaje Enter i getline wczyta pusty napis. Między nimi dopisz cin.ignore(); albo użyj getline(cin >> ws, s).
🔤
'a', "a" i a
Znak w apostrofach, napis w cudzysłowie, zmienna bez niczego. s[0] = "p" się nie skompiluje, a 'a' + 'b' to liczba 195, nie napis „ab”.
➕
Plus tylko ze stringiem
"Ala" + " ma" to błąd, s += 5 dokleja niewidzialny znak, a "Wynik: " + x ucina tekst. Liczby zamieniaj przez to_string, a w cout używaj <<.
🔢
toupper daje liczbę
cout << toupper(c) wypisze kod, np. 75. Rzutuj: (char)toupper(c) albo zapisz wynik do char lub s[i]. A wyników isdigit i spółki nie porównuj z 1.
🔍
find i npos
Brak wyniku to string::npos (w int: −1), a znalezisko na początku to 0. Nigdy nie pisz if (s.find(x)) — porównuj z npos albo z −1.
✂️
substr(od, ile)
Druga liczba to długość, nie pozycja końca. Fragment od a do b włącznie: s.substr(a, b - a + 1). Początek większy od długości kończy program błędem.
🔠
Wielkie przed małymi
W porównaniu napisów „Zebra” < „antylopa”, a „10” < „9”. Bez względu na wielkość — porównuj kopie zamienione na małe. Olbrzymy — najpierw długość.
🧩
Ostatni kawałek
Tniesz tekst po przecinkach albo składasz liczby z cyfr? Po pętli zostaje ostatni kawałek, za którym nie było separatora — obsłuż go osobno.
🐢
s += c, nie s = s + c
Sklejanie plusem tworzy kopię całego napisu. W pętli po długim tekście to miliardy operacji. Dokładaj przez +=, a doklejanie z przodu zamień na budowanie od końca i jedno odwrócenie.
🇵🇱
Bez polskich liter
Ą, ę, ł, ó, ś, ż… zajmują po dwa znaki: „żółw” ma długość 7. Testuj programy na tekstach bez ogonków — takie są dane na olimpiadzie i w sprawdzarce.

Co dalej?

Napisy pojawią się w niemal każdym kolejnym temacie: imiona w tabelach wyników, słowa do posortowania, teksty do policzenia. Następna lekcja to pary — sposób, żeby trzymać razem dwie wartości, na przykład imię i liczbę punktów. Potem przyjdą vector, czyli tablica, która sama rośnie jak napis, i sortowanie, które ułoży słowa w kolejności słownikowej jednym poleceniem. A jeśli chcesz trenować z mentorami — dołącz do T-Olimpians.