C++ · Podstawy · Lekcja 04

Pętla while w C++

Do tej pory każda instrukcja w Twoim programie wykonywała się co najwyżej raz. Teraz nauczysz program powtarzać: wypisać sto liczb trzema linijkami kodu, zsumować dane, których jest nie wiadomo ile, rozebrać liczbę na cyfry albo kręcić się tak długo, aż coś się stanie. Poznasz pętlę while krok po kroku — od pierwszego licznika, przez sumy, rekordy i algorytm Euklidesa, aż po break, continue, do … while i pętlę w pętli. Po każdej części czekają ćwiczenia ze sprawdzarką.

59 ćwiczeń w trakcie lekcji28 zadań w bazie na koniec87 ze sprawdzarką C++
Filmy z OKI

Wolisz obejrzeć?

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

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ś lekcje Typy zmiennych, Input / Output i If / Else. Umiesz więc tworzyć zmienne i zmieniać ich wartość (także skrótami i++, i--, suma += x), wczytywać dane przez cin, wypisywać wyniki przez cout i podejmować decyzje instrukcją if. Najważniejsze z tego wszystkiego będą warunki: pętla while używa dokładnie takich samych warunków jak if — porównań <, <=, ==, != i operatorów &&, ||, !.

Różnica jest jedna, ale ogromna: if sprawdza warunek raz i wykonuje swoje klamry co najwyżej jeden raz. while sprawdza warunek wiele razy i wykonuje klamry tak długo, jak warunek jest prawdziwy — może to być 5 razy, milion razy albo ani razu.

Uczymy się tak samo jak poprzednio: przepisuj przykłady do swojego edytora i uruchamiaj je, przy pytaniach „Co wypisze program?” najpierw śledź program w głowie (albo na kartce), a dopiero potem sprawdzaj odpowiedź, i po każdej części rób ćwiczenia w sprawdzarce. Lekcja jest długa — nie przerabiaj jej za jednym razem. Pętle to najważniejszy temat całego początku nauki programowania, więc warto poświęcić mu kilka dni.

CZĘŚĆ 01–02

Pierwsza pętla

Jak działa while, jak śledzić pętlę obrót po obrocie i z jakich trzech elementów składa się każda pętla.

CZĘŚĆ 03–04

Zbieranie wyników i danych

Licznik, suma i iloczyn, wczytywanie wielu liczb, największa i najmniejsza liczba, dane do zera i do końca wejścia.

CZĘŚĆ 05–06

Pętle, które same wiedzą, kiedy skończyć

Cyfry liczby, litery napisu, symulacje, problem Collatza i algorytm Euklidesa.

CZĘŚĆ 07–08

Sterowanie pętlą

break, continue, while (true), do … while i pętla w pętli — prostokąty, trójkąty i tabliczka mnożenia.

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 liczbę:” i bez dodatkowych słów. Jedna dobra wiadomość na tę lekcję: spacje na końcu wiersza są ignorowane. Gdy wypisujesz liczby w pętli przez cout << i << " ", spacja po ostatniej liczbie niczego nie psuje.

Mapa lekcji

while — powtarzaj, dopóki…

Wyobraź sobie zadanie: wypisz liczby od 1 do 5. Z tym, co już umiesz, napiszesz pięć instrukcji cout. Działa. A gdyby trzeba było wypisać liczby od 1 do 1000? Albo od 1 do n, gdzie n wczytujesz z klawiatury i nie wiesz z góry, ile wyniesie? Tu kończą się możliwości programu, który czyta się od góry do dołu i każdą linijkę wykonuje raz.

Potrzebujemy instrukcji, która mówi: „wykonuj ten kawałek kodu tak długo, jak warunek jest prawdziwy”. To właśnie pętla while (po angielsku „dopóki”, czytaj: „łajl”). W zwykłym języku mówisz tak często: „dopóki talerz nie jest pusty, jedz”, „dopóki nie dojdziesz do końca strony, czytaj”.

bez_petli.cpp
cout << 1 << "\n";
cout << 2 << "\n";
cout << 3 << "\n";
cout << 4 << "\n";
cout << 5 << "\n";
// ...a dla 1000 liczb? 1000 linijek?
▶ Wyjście
1 2 3 4 5
z_petla.cpp
int i = 1;
while (i <= 5) {
    cout << i << "\n";
    i++;
}
// dla 1000 liczb zmieniasz tylko 5 na 1000
▶ Wyjście
1 2 3 4 5

Oba programy wypisują to samo. Ale ten z prawej ma zawsze 5 linijek — niezależnie od tego, czy liczb jest 5, 1000 czy miliard. Zanim zobaczysz, jak dokładnie działa, przyjrzyj się jego budowie.

Jak wygląda pętla while

schemat_while.cpp
while (warunek) {
    // ciało pętli: te instrukcje wykonują się
    // raz za razem, dopóki warunek jest prawdziwy
}
❓

warunek w nawiasie

Dokładnie taki sam jak w if: porównanie, które daje true albo false, np. i <= 5. Program sprawdza go przed każdym obrotem pętli.

🔁

ciało pętli w klamrach

Instrukcje między { a }. Jedno wykonanie ciała nazywamy obrotem pętli (albo iteracją). Po każdym obrocie program wraca na górę, do warunku.

🔢

licznik

Zmienna i liczy obroty. Tworzymy ją przed pętlą, a w ciele zmieniamy (i++), żeby warunek kiedyś przestał być prawdziwy.

🚪

wyjście z pętli

Gdy warunek okaże się fałszywy, program nie wchodzi do klamer, tylko przeskakuje za nie i idzie dalej — tak jak przy fałszywym if.

liczenie.cpp
#include <iostream>
using namespace std;

int main() {
    int i = 1;
    while (i <= 5) {
        cout << i << "\n";
        i++;
    }
    cout << "Koniec!\n";
    return 0;
}
▶ Wyjście
1 2 3 4 5 Koniec!
int i = 1 i <= 5 ? TAK cout << i i++ wróć do warunku NIE cout << "Koniec!"
Najważniejsza jest przerywana strzałka: po wykonaniu ciała program nie idzie dalej, tylko wraca do warunku. Wyjść z pętli może jedynie drogą „NIE”.

Prześledźmy pętlę obrót po obrocie

Pętlę rozumie się dopiero wtedy, gdy raz albo dwa razy „wykonasz” ją w głowie — dokładnie tak, jak robi to komputer. Weź kartkę i zapisuj, jaką wartość ma i w chwili sprawdzania warunku, co wychodzi z warunku i co program robi dalej. Dla programu liczenie.cpp wygląda to tak:

Kroki przed sprawdzeniemwarunek i <= 5co się dzieje
start——int i = 1; — tworzymy licznik
obrót 111 <= 5 → truewypisuje 1, i zmienia się na 2
obrót 222 <= 5 → truewypisuje 2, i zmienia się na 3
obrót 333 <= 5 → truewypisuje 3, i zmienia się na 4
obrót 444 <= 5 → truewypisuje 4, i zmienia się na 5
obrót 555 <= 5 → truewypisuje 5, i zmienia się na 6
koniec66 <= 5 → falsepętla się kończy, program wypisuje Koniec!

Zauważ trzy rzeczy. Po pierwsze, warunek sprawdzany jest sześć razy, a ciało wykonuje się pięć razy — ostatnie sprawdzenie to właśnie to, które kończy pętlę. Po drugie, po pętli zmienna i ma wartość 6, a nie 5: zwiększyliśmy ją jeszcze w ostatnim obrocie. Po trzecie, Koniec! wypisuje się tylko raz, bo stoi za klamrami pętli.

Zapamiętaj Pętla while działa w kółko według jednego przepisu: sprawdź warunek → jeśli prawdziwy, wykonaj ciało i wróć do sprawdzania → jeśli fałszywy, wyjdź za klamry. To, co jest w klamrach, może wykonać się wiele razy. To, co jest za klamrami, wykonuje się raz — dopiero po zakończeniu pętli.

Od 1 do n

Największa siła pętli: liczba obrotów może zależeć od danych. Zamiast 5 wpisujemy w warunku zmienną n, którą wczytujemy z klawiatury. Ten sam program wypisze wtedy 3 liczby, 10 liczb albo milion — zależnie od tego, co dostanie:

od_1_do_n.cpp
int n;
cin >> n;
int i = 1;
while (i <= n) {
    cout << i << " ";
    i++;
}
cout << "\n";
▶ Wejście
3
▶ Wyjście
1 2 3
▶ Wejście
10
▶ Wyjście
1 2 3 4 5 6 7 8 9 10
▶ Wejście
1
▶ Wyjście
1

Tym razem liczby wypisujemy w jednym wierszu, oddzielone spacjami: cout << i << " ". Za ostatnią liczbą też stoi spacja, ale tego nie widać — a sprawdzarka spacje na końcu wiersza ignoruje. Po pętli wypisujemy "\n", żeby zakończyć wiersz.

Od tej pory, tak jak w lekcji o if, przykłady często będą fragmentami programu — bez #include i main. Chcąc je uruchomić, wklej je do środka main, tak jak w liczenie.cpp.

Odliczanie w dół

Licznik nie musi rosnąć. Gdy zaczniemy od n i będziemy go zmniejszać przez i--, dostaniemy odliczanie. Warunek też się zmienia: kręcimy się, dopóki licznik jest większy od zera:

odliczanie.cpp
int n;
cin >> n;
int i = n;
while (i > 0) {
    cout << i << "... ";
    i--;
}
cout << "Start!\n";
▶ Wejście
5
▶ Wyjście
5... 4... 3... 2... 1... Start!
▶ Wejście
2
▶ Wyjście
2... 1... Start!

Prześledź to sam dla n = 2: i = 2, warunek 2 > 0 prawdziwy → wypisz „2... ”, i = 1; warunek 1 > 0 prawdziwy → wypisz „1... ”, i = 0; warunek 0 > 0 fałszywy → koniec pętli, wypisz „Start!”.

Zamiast tworzyć osobną zmienną i, można też zmniejszać samo n — while (n > 0) { cout << n << " "; n--; }. Działa tak samo, tylko po pętli w n zostaje 0 i pierwotnej wartości już nie mamy. Jeśli będzie potrzebna później, pracuj na kopii.

Powtórz coś n razy

Czasem licznik w ogóle nie jest wypisywany — służy tylko do tego, żeby pętla wykonała się określoną liczbę razy. Taki schemat wygląda zwykle tak: licznik od 0, warunek i < n:

n_razy.cpp
int n;
cin >> n;
int i = 0;
while (i < n) {
    cout << "Hip hip hura!\n";
    i++;
}
▶ Wejście
3
▶ Wyjście
Hip hip hura! Hip hip hura! Hip hip hura!

Dlaczego to daje dokładnie n obrotów? Licznik przyjmuje po kolei wartości 0, 1, 2, …, n − 1 — to jest właśnie n różnych liczb. Gdy dojdzie do n, warunek i < n przestaje być prawdziwy.

Ten sam efekt da start od 1 i warunek i <= n (wartości 1, 2, …, n). Obie wersje są dobre — ważne, żeby start i warunek do siebie pasowały. Start od 0 z warunkiem i <= n dałby o jeden obrót za dużo. Do tego jeszcze wrócimy.

Licznik w obliczeniach

Licznik pętli to zwykła zmienna int, więc możesz go używać w działaniach: mnożyć, dzielić, liczyć resztę. Dzięki temu w każdym obrocie dostajesz inną wartość. Tabelka kwadratów i tabliczka mnożenia to jedna pętla:

kwadraty.cpp
int i = 1;
while (i <= 5) {
    cout << i << " do kwadratu = " << i * i << "\n";
    i++;
}
▶ Wyjście
1 do kwadratu = 1 2 do kwadratu = 4 3 do kwadratu = 9 4 do kwadratu = 16 5 do kwadratu = 25
tabliczka.cpp
int k;
cin >> k;
int i = 1;
while (i <= 10) {
    cout << k << " x " << i << " = " << k * i << "\n";
    i++;
}
▶ Wejście
7
▶ Wyjście
7 x 1 = 7 7 x 2 = 14 7 x 3 = 21 7 x 4 = 28 7 x 5 = 35 7 x 6 = 42 7 x 7 = 49 7 x 8 = 56 7 x 9 = 63 7 x 10 = 70

Pętla i if razem

W klamrach pętli może stać każda instrukcja, którą znasz — także if. Wtedy w każdym obrocie program podejmuje decyzję od nowa. Na przykład: wypisz liczby od 1 do 10, ale przy liczbach parzystych dopisz gwiazdkę:

gwiazdki.cpp
int i = 1;
while (i <= 10) {
    cout << i;
    if (i % 2 == 0) {
        cout << "*";
    }
    cout << " ";
    i++;
}
cout << "\n";
▶ Wyjście
1 2* 3 4* 5 6* 7 8* 9 10*

I odwrotnie — pętla może stać w środku if. Gdy chcesz iść od a do b rosnąco albo malejąco, zależnie od tego, która liczba jest większa, piszesz if … else, a w każdej gałęzi osobną pętlę:

w_obie_strony.cpp
int a, b;
cin >> a >> b;
int i = a;
if (a <= b) {
    while (i <= b) {
        cout << i << " ";
        i++;
    }
} else {
    while (i >= b) {
        cout << i << " ";
        i--;
    }
}
▶ Wejście
2 5
▶ Wyjście
2 3 4 5
▶ Wejście
5 2
▶ Wyjście
5 4 3 2

Zwróć uwagę na wcięcia: ciało pętli wewnątrz if jest przesunięte o kolejne 4 spacje. Kompilatorowi to obojętne, ale Ty od razu widzisz, co jest w środku czego. Każda klamra otwierająca ma swoją zamykającą dokładnie pod początkiem swojej linijki.

Sprawdź się w głowie

Najpierw odpowiedz w myślach — prześledź program obrót po obrocie — a dopiero potem kliknij „Pokaż odpowiedź”.

Co wypisze ten fragment?
int i = 1;
while (i <= 3) {
    cout << i;
    i++;
}
Pokaż odpowiedź
123Licznik przyjmuje wartości 1, 2, 3. Gdy dojdzie do 4, warunek 4 <= 3 jest fałszywy. Między liczbami nie ma spacji, bo jej nie wypisujemy.
Ile razy wypisze się słowo raz?
int i = 0;
while (i < 4) {
    cout << "raz ";
    i++;
}
Pokaż odpowiedź
raz raz raz razCztery razy: dla i = 0, 1, 2 i 3. Start od 0 z warunkiem i < 4 daje dokładnie 4 obroty.
Co wypisze program — i jaka będzie wartość i na końcu?
int i = 10;
while (i > 7) {
    cout << i << " ";
    i--;
}
cout << "| " << i;
Pokaż odpowiedź
10 9 8 | 7Obroty dla i = 10, 9 i 8. Po trzecim obrocie i = 7 i warunek 7 > 7 jest fałszywy. Za pętlą i wynosi 7.
Co się wypisze w każdym obrocie?
int i = 1;
while (i <= 4) {
    cout << i * 10 << " ";
    i++;
}
Pokaż odpowiedź
10 20 30 40Licznik jest zwykłą zmienną — w każdym obrocie wypisujemy jego dziesięciokrotność.
Gdzie jest koniec pętli? Co wypisze program?
int i = 1;
while (i <= 3) {
    cout << "A";
    i++;
}
cout << "B";
Pokaż odpowiedź
AAABA jest w klamrach pętli, więc wypisuje się trzy razy. B stoi za klamrami — wypisuje się raz, po zakończeniu pętli.
Pętla z if w środku. Co wypisze?
int i = 1;
while (i <= 6) {
    if (i % 3 == 0) {
        cout << i << " ";
    }
    i++;
}
Pokaż odpowiedź
3 6Pętla przechodzi przez wszystkie liczby od 1 do 6, ale wypisuje tylko te, które dzielą się przez 3. Pozostałe obroty niczego nie wypisują — tylko zwiększają i.

Start, warunek i zmiana

Przyjrzyj się jeszcze raz pętlom z poprzedniej części. Każda z nich miała te same trzy elementy, i to nie przypadek — bez któregokolwiek z nich pętla się psuje. Zanim przejdziemy dalej, nauczmy się je rozpoznawać i dobierać.

1️⃣

Start — przed pętlą

Zmienna z warunku musi istnieć i mieć wartość, zanim program pierwszy raz sprawdzi warunek: int i = 1;.

2️⃣

Warunek — w nawiasie

Mówi, kiedy pętla ma się jeszcze kręcić: i <= n. Gdy przestaje być prawdziwy, pętla się kończy.

3️⃣

Zmiana — w ciele

Coś w klamrach musi zmieniać zmienną z warunku tak, żeby warunek kiedyś stał się fałszywy: i++.

trzy_elementy.cpp
int n = 4;
int i = 1;            // 1. start
while (i <= n) {      // 2. warunek
    cout << i << " ";
    i++;              // 3. zmiana
}
▶ Wyjście
1 2 3 4

Krok nie musi wynosić 1

Zmiana w ciele pętli to dowolna instrukcja zmieniająca licznik. Najczęściej jest to i++, ale równie dobrze może to być i += 2, i -= 5 albo i *= 2. Wtedy licznik „skacze” o więcej niż jeden. Popatrz na cztery pętle, które różnią się tylko startem, warunkiem i zmianą:

parzyste.cpp
int i = 2;
while (i <= 12) {
    cout << i << " ";
    i += 2;      // co dwa
}
▶ Wyjście
2 4 6 8 10 12
co_piec.cpp
int i = 0;
while (i <= 30) {
    cout << i << " ";
    i += 5;      // co pięć
}
▶ Wyjście
0 5 10 15 20 25 30
w_dol_co_trzy.cpp
int i = 20;
while (i > 0) {
    cout << i << " ";
    i -= 3;      // w dół co trzy
}
▶ Wyjście
20 17 14 11 8 5 2
potegi_dwojki.cpp
int p = 1;
while (p <= 100) {
    cout << p << " ";
    p *= 2;      // dwa razy więcej
}
▶ Wyjście
1 2 4 8 16 32 64

Ciekawy jest przykład z odliczaniem co trzy. Po liczbie 2 licznik zmienia się na −1 i warunek i > 0 jest fałszywy. Pętla nie trafiła w zero, ale to nie problem: warunek „większe od zera” zatrzymuje ją w dobrym miejscu. Gdyby warunek brzmiał i != 0, licznik przeskoczyłby zero i pętla nigdy by się nie zatrzymała! Dlatego w warunkach pętli wolimy <, <=, >, >= niż !=.

A potęgi dwójki pokazują, że licznik nie musi rosnąć równo: 1, 2, 4, 8, … Po 64 jest 128, a 128 <= 100 to już fałsz.

Ile razy wykona się pętla?

To pytanie zadawaj sobie przy każdej pętli, którą piszesz. Najczęstszy błąd początkujących (i nie tylko) to pętla, która wykonuje się o jeden raz za dużo albo za mało. Ma nawet swoją nazwę: błąd o jeden (po angielsku off-by-one). Popatrz, jak drobna zmiana startu albo warunku zmienia liczbę obrotów:

Start i warunekwartości licznika w kolejnych obrotachile obrotów
i = 1; while (i <= 5)1, 2, 3, 4, 55
i = 1; while (i < 5)1, 2, 3, 44
i = 0; while (i < 5)0, 1, 2, 3, 45
i = 0; while (i <= 5)0, 1, 2, 3, 4, 56
i = 5; while (i > 0), i--5, 4, 3, 2, 15
i = 5; while (i >= 0), i--5, 4, 3, 2, 1, 06
i = 0; while (i < 10), i += 30, 3, 6, 94
Jak nie pomylić się o jeden Zanim uruchomisz program, wypisz sobie na kartce pierwszą i ostatnią wartość licznika, dla której pętla się wykona. Pierwsza wynika ze startu, ostatnia — z warunku. Dla i = 1; while (i <= n) to 1 i n, a dla i = 0; while (i < n) to 0 i n − 1. Potem sprawdź program dla najmniejszych danych, np. n = 1 — tam błąd o jeden widać od razu.

Pętla, która nie wykona się ani razu

Warunek jest sprawdzany przed pierwszym obrotem. Jeśli już wtedy jest fałszywy, ciało nie wykona się ani razu — program od razu przeskoczy za pętlę. To nie jest błąd, tylko bardzo przydatna cecha: pętla sama „radzi sobie” z przypadkiem, gdy nie ma nic do zrobienia.

zero_obrotow.cpp
int n;
cin >> n;
int i = 1;
while (i <= n) {
    cout << "*";
    i++;
}
cout << "|koniec\n";
▶ Wejście
4
▶ Wyjście
****|koniec
▶ Wejście
0
▶ Wyjście
|koniec

Dla n = 0 warunek 1 <= 0 jest fałszywy od razu, więc nie wypisuje się żadna gwiazdka. Program nie potrzebuje osobnego if (n > 0) — pętla zrobiła to za nas.

Pętla nieskończona — gdy program „wisi”

Najgroźniejszy błąd przy pętlach: warunek nigdy nie staje się fałszywy. Program kręci się wtedy w kółko bez końca — nic nie wypisuje albo wypisuje w nieskończoność, i nie kończy się sam. Na swoim komputerze przerwiesz go klawiszami Ctrl + C, a sprawdzarka zgłosi przekroczenie limitu czasu. Trzy najczęstsze przyczyny:

zapomniane_i.cpp
int i = 1;
while (i <= 5) {
    cout << i << " ";
    // brak i++ — i zawsze wynosi 1
}
▶ Wyjście — bez końca
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 …
zly_kierunek.cpp
int i = 1;
while (i <= 5) {
    cout << i << " ";
    i--;     // licznik oddala się od 5
}
▶ Wyjście — bez końca
1 0 -1 -2 -3 -4 -5 -6 -7 …
srednik.cpp
int i = 1;
while (i <= 5); {
    cout << i << " ";
    i++;
}
▶ Wyjście — nic, program wisi
(pusto — program się nie kończy)

Trzeci przypadek jest najbardziej podstępny. Średnik po nawiasie kończy instrukcję while, więc ciałem pętli jest… nic. Pętla sprawdza 1 <= 5, nie robi nic, sprawdza znowu — i tak bez końca. Klamry, które stoją dalej, w ogóle nie należą do pętli. Znasz już tę pułapkę z if, ale przy while skutek jest gorszy: zamiast złego wyniku masz zawieszony program.

Program wisi? Sprawdź po kolei 1) Czy w ciele pętli jest zmiana zmiennej z warunku? 2) Czy zmiana idzie w dobrą stronę — przybliża warunek do fałszu? 3) Czy po while (…) nie stoi przypadkiem średnik? 4) Czy licznik nie przeskakuje wartości z warunku !=? W 9 przypadkach na 10 winowajca jest wśród tych czterech.

Start musi być przed pętlą

Dwa błędy z pierwszym elementem. Pierwszy: zmienna bez wartości. int i; bez = 1 zawiera przypadkowe „śmieci” z pamięci — może to być 0, może 32 767, może −1 000 000. Pętla zachowa się za każdym razem inaczej. Drugi: start postawiony w środku pętli. Wtedy w każdym obrocie licznik wraca do wartości początkowej i pętla nie ma szans się skończyć:

start_w_srodku.cpp
int i = 1;
while (i <= 3) {
    int i = 1;    // nowa zmienna i w każdym obrocie!
    cout << i << " ";
    i++;
}
▶ Wyjście — bez końca
1 1 1 1 1 1 1 1 …

Tu jest jeszcze gorzej, niż się wydaje: int i = 1; w klamrach tworzy nową zmienną o tej samej nazwie, która przesłania tę zewnętrzną. i++ zwiększa tę wewnętrzną, a ona znika na końcu obrotu. Warunek pętli patrzy na zewnętrzne i, które wciąż wynosi 1.

Zasada: zmienne, które mają przetrwać między obrotami (liczniki, sumy, rekordy), tworzysz przed pętlą. W klamrach tworzysz tylko to, co jest potrzebne w jednym obrocie i potem może zniknąć.

Dwie zmienne w jednej pętli

Czasem pętla musi pilnować dwóch rzeczy naraz: ile obrotów już było i jaką wartość wypisać. Weźmy zadanie: wypisz 5 pierwszych liczb ciągu, który zaczyna się od 100 i co krok maleje o 7. Warunek nie może zależeć od wypisywanej liczby (bo nie wiemy z góry, na której się zatrzymać), ale może zależeć od licznika obrotów:

dwie_zmienne.cpp
int x = 100;     // wartość do wypisania
int ile = 0;     // licznik obrotów
while (ile < 5) {
    cout << x << " ";
    x -= 7;
    ile++;
}
▶ Wyjście
100 93 86 79 72
obrótilexwypisuje
10100100
219393
328686
437979
547272
—565koniec

Ten sam pomysł działa przy godzinach. Autobus odjeżdża o 7:40, potem co 25 minut, aż do 9:00. Najprościej liczyć wszystko w minutach od północy (7:40 to 7 · 60 + 40 = 460 minut), a dopiero przy wypisywaniu zamieniać z powrotem na godziny i minuty — z zerami z przodu, które znasz z lekcji Input / Output:

odjazdy.cpp
#include <iostream>
#include <iomanip>
using namespace std;

int main() {
    int x = 7 * 60 + 40;      // 7:40
    int koniec = 9 * 60;      // 9:00
    cout << setfill('0');
    while (x <= koniec) {
        cout << setw(2) << x / 60 << ":" << setw(2) << x % 60 << "\n";
        x += 25;
    }
    return 0;
}
▶ Wyjście
07:40 08:05 08:30 08:55

Kolejna wartość, 9:20, jest już po 9:00, więc pętla się kończy. setfill('0') wystarczy ustawić raz, przed pętlą, a setw(2) trzeba powtarzać przy każdej liczbie — działa tylko na najbliższą.

Sprawdź się w głowie

Najpierw odpowiedz w myślach — prześledź program obrót po obrocie — a dopiero potem kliknij „Pokaż odpowiedź”.

Ile razy wykona się ciało tej pętli?
int i = 3;
int ile = 0;
while (i <= 12) {
    ile++;
    i += 3;
}
cout << ile;
Pokaż odpowiedź
4Licznik przyjmuje wartości 3, 6, 9 i 12. Następna wartość to 15, a 15 <= 12 jest fałszem.
Co wypisze ten fragment?
int i = 1;
while (i < 50) {
    cout << i << " ";
    i *= 3;
}
Pokaż odpowiedź
1 3 9 27Po 27 licznik zmienia się na 81, a 81 < 50 jest fałszem.
Co wypisze program?
int i = 10;
while (i < 5) {
    cout << "X";
    i++;
}
cout << "koniec";
Pokaż odpowiedź
koniecJuż przy pierwszym sprawdzeniu 10 < 5 jest fałszem, więc ciało nie wykona się ani razu.
Jaką wartość ma i po pętli?
int i = 0;
while (i < 10) {
    i += 4;
}
cout << i;
Pokaż odpowiedź
12Wartości: 0 → 4 → 8 → 12. Dla 12 warunek 12 < 10 jest fałszem. Pętla zatrzymuje się na pierwszej wartości, która nie spełnia warunku — tu na 12, a nie na 10.
Ta pętla ma wypisać 5 4 3 2 1 0. Czy się zatrzyma?
int i = 5;
while (i != 0) {
    cout << i << " ";
    i -= 2;
}
Pokaż odpowiedź
5 3 1 -1 -3 -5 … (bez końca)Nie! Licznik idzie 5, 3, 1, −1 — przeskakuje zero i warunek i != 0 jest prawdziwy już zawsze. Bezpieczniej pisać i > 0 albo i >= 0.
Dwie zmienne. Co wypisze program?
int a = 1, b = 10;
while (a < b) {
    a += 2;
    b -= 1;
}
cout << a << " " << b;
Pokaż odpowiedź
7 7Kolejne pary (a, b): (1, 10) → (3, 9) → (5, 8) → (7, 7). Przy (7, 7) warunek 7 < 7 jest fałszem.

Zmienna, która zbiera wynik

Do tej pory pętle głównie wypisywały. Bardzo często chcemy jednak, żeby pętla coś policzyła i dała jeden wynik na końcu: sumę, liczbę pasujących elementów, iloczyn. Do tego służy zmienna, którą nazwiemy akumulatorem (od „akumulować” — gromadzić). Działa jak skarbonka: przed pętlą jest pusta, w każdym obrocie coś do niej wrzucamy, a po pętli zaglądamy, ile się uzbierało.

Suma od 1 do n

Policzmy 1 + 2 + 3 + … + n. Potrzebujemy dwóch zmiennych: licznika i, który przechodzi po kolejnych liczbach, i sumy suma, do której te liczby dokładamy.

suma_do_n.cpp
int n;
cin >> n;
int suma = 0;         // pusta skarbonka
int i = 1;
while (i <= n) {
    suma += i;        // wrzucamy i
    i++;
}
cout << suma << "\n"; // zaglądamy po pętli
▶ Wejście
5
▶ Wyjście
15
▶ Wejście
100
▶ Wyjście
5050
obrótisuma przedsuma po
1100 + 1 = 1
2211 + 2 = 3
3333 + 3 = 6
4466 + 4 = 10
551010 + 5 = 15
—66 <= 5 fałsz, koniec

Trzy miejsca, w których łatwo się pomylić — i każde daje inny zły wynik:

❌ brak = 0

int suma;
while (…) { suma += i; … }

Zmienna bez wartości ma w środku śmieci. Dokładasz do przypadkowej liczby — wynik może być dowolny.

❌ zerowanie w pętli

while (…) {
    int suma = 0;
    suma += i; …
}

Skarbonka opróżniana w każdym obrocie. Do tego znika za klamrami — po pętli nie da się jej nawet wypisać.

❌ wypisywanie w pętli

while (…) {
    suma += i;
    cout << suma; …
}

Wypisujesz wszystkie sumy pośrednie (1, 3, 6, 10, 15), a zadanie chce tylko ostatniej. Wypisuj po pętli.

Schemat akumulatora Przed pętlą — utwórz zmienną i nadaj jej wartość startową. W pętli — dorzucaj do niej kolejne wartości. Po pętli — wypisz wynik. Ten schemat zobaczysz w setkach zadań.

Suma tylko niektórych liczb

Gdy w ciele pętli postawisz if, możesz dokładać do sumy tylko liczby, które spełniają jakiś warunek. Pętla przechodzi po wszystkich, ale skarbonka dostaje tylko wybrane:

suma_parzystych.cpp
int n;
cin >> n;
int suma = 0;
int i = 1;
while (i <= n) {
    if (i % 2 == 0) {
        suma += i;
    }
    i++;
}
cout << suma << "\n";
▶ Wejście
10
▶ Wyjście
30

Dla n = 10 do sumy trafiają 2, 4, 6, 8 i 10 — razem 30. Pozostałe obroty tylko zwiększają i.

Uwaga na miejsce i++: stoi poza klamrami if, więc wykonuje się w każdym obrocie. Gdyby wpadło do środka if, licznik zatrzymałby się na pierwszej nieparzystej liczbie i pętla kręciłaby się bez końca.

Tu akurat da się prościej — licznik od 2 i i += 2 — ale schemat „pętla po wszystkich + if” działa dla każdego warunku, także takiego, którego nie da się zastąpić sprytnym krokiem.

Licznik warunkowy: ile jest takich liczb?

Licznik to też akumulator, tylko zamiast dokładać liczbę, dokładasz jedynkę — za każdym razem, gdy warunek jest spełniony. Ile liczb od 1 do n dzieli się przez 7 albo kończy się cyfrą 7?

siodemki.cpp
int n;
cin >> n;
int ile = 0;
int i = 1;
while (i <= n) {
    if (i % 7 == 0 || i % 10 == 7) {
        ile++;
    }
    i++;
}
cout << ile << "\n";
▶ Wejście
30
▶ Wyjście
6

Dla n = 30 pasują: 7, 14, 17, 21, 27 i 28 — sześć liczb. Liczba 7 spełnia oba warunki naraz (dzieli się przez 7 i kończy się na 7), ale licznik zwiększa się dla niej tylko raz, bo cały warunek z || sprawdzany jest raz i daje jedno true.

Gdybyś napisał dwa osobne if-y, każdy z własnym ile++, siódemka zostałaby policzona dwa razy i wyszłoby 7. Przy licznikach zawsze zastanów się, czy jeden element może pasować do kilku warunków.

Dobry nawyk przy sprawdzaniu takiego programu: na chwilę dopisz w if instrukcję cout << i << " ";. Zobaczysz, które liczby zostały policzone, i od razu wyłapiesz pomyłkę.

Iloczyn startuje od jedynki

Akumulator dla mnożenia działa tak samo, z jedną różnicą: wartość startowa to 1, a nie 0. Zero pomnożone przez cokolwiek daje zero, więc iloczyn startujący od zera zostałby zerem na zawsze. Klasyczny przykład to silnia: n! = 1 · 2 · 3 · … · n, np. 5! = 120.

silnia.cpp
int n;
cin >> n;
long long wynik = 1;    // iloczyn od 1!
int i = 1;
while (i <= n) {
    wynik *= i;
    i++;
}
cout << wynik << "\n";
▶ Wejście
5
▶ Wyjście
120
▶ Wejście
20
▶ Wyjście
2432902008176640000

Silnia rośnie zawrotnie szybko: 10! to już 3 628 800, a 13! = 6 227 020 800 nie mieści się w int (którego zakres kończy się na ok. 2,1 miliarda). Z int wynik program dla n = 13 wypisałby bzdurę — przepełnienie, które znasz z lekcji o typach. Dlatego wynik trzymamy w long long, który mieści silnie aż do 20!.

Przy pętlach sumujących i mnożących zawsze zadawaj sobie pytanie: jak duży może być wynik? Suma tysiąca liczb po milion to miliard — jeszcze się mieści. Suma miliona takich liczb — już nie.

Potęga bez funkcji pow

Ten sam schemat liczy potęgę: aᵇ to iloczyn b liczb równych a. Licznik obrotów jest tu osobną zmienną, bo samo a się nie zmienia:

potega.cpp
long long a;
int b;
cin >> a >> b;
long long wynik = 1;
int i = 0;
while (i < b) {
    wynik *= a;
    i++;
}
cout << wynik << "\n";
▶ Wejście
2 10
▶ Wyjście
1024
▶ Wejście
3 0
▶ Wyjście
1
▶ Wejście
10 18
▶ Wyjście
1000000000000000000

Dla b = 0 pętla nie wykona się ani razu i zostanie 1 — a z matematyki wiadomo, że a⁰ = 1. Znowu pętla sama dobrze obsłużyła przypadek brzegowy. Funkcja pow z biblioteki cmath liczy na liczbach z przecinkiem i dla dużych wyników potrafi się pomylić w ostatnich cyfrach, więc w zadaniach na liczbach całkowitych lepiej liczyć potęgę pętlą.

Dzielniki i liczby pierwsze

Liczba d jest dzielnikiem n, gdy n % d == 0. Żeby znaleźć wszystkie dzielniki, wystarczy sprawdzić po kolei każde d od 1 do n. Przy okazji możemy je policzyć:

dzielniki.cpp
int n;
cin >> n;
int ile = 0;
int d = 1;
while (d <= n) {
    if (n % d == 0) {
        cout << d << " ";
        ile++;
    }
    d++;
}
cout << "\nDzielnikow: " << ile << "\n";
▶ Wejście
12
▶ Wyjście
1 2 3 4 6 12 Dzielnikow: 6
▶ Wejście
13
▶ Wyjście
1 13 Dzielnikow: 2

Liczba 13 ma tylko dwa dzielniki: 1 i samą siebie. Takie liczby nazywamy pierwszymi (2, 3, 5, 7, 11, 13, 17, …). Liczba 1 nie jest pierwsza — ma tylko jeden dzielnik.

Mamy więc gotowy test pierwszości: policz dzielniki i po pętli sprawdź, czy jest ich dokładnie dwa. Decyzję podejmujemy dopiero po pętli, bo w trakcie nie wiemy jeszcze, ile dzielników się uzbiera:

pierwsza.cpp
int n;
cin >> n;
int ile = 0;
int d = 1;
while (d <= n) {
    if (n % d == 0) {
        ile++;
    }
    d++;
}
if (ile == 2) {
    cout << "pierwsza\n";
} else {
    cout << "nie jest pierwsza\n";
}
▶ Wejście
97
▶ Wyjście
pierwsza

Ten program jest poprawny, ale dla dużych n — powiedzmy miliarda — wykona miliard obrotów i będzie liczył kilka sekund. W części o break zobaczysz, jak go przyspieszyć tysiące razy.

Kilka akumulatorów naraz

W jednej pętli możesz zbierać kilka wyników jednocześnie — każdy w swojej zmiennej. Policzmy dla liczb od 1 do n: sumę parzystych, sumę nieparzystych i ile jest liczb podzielnych przez 3:

trzy_wyniki.cpp
int n;
cin >> n;
int parzyste = 0, nieparzyste = 0, przez3 = 0;
int i = 1;
while (i <= n) {
    if (i % 2 == 0) {
        parzyste += i;
    } else {
        nieparzyste += i;
    }
    if (i % 3 == 0) {
        przez3++;
    }
    i++;
}
cout << parzyste << " " << nieparzyste << " " << przez3 << "\n";
▶ Wejście
10
▶ Wyjście
30 25 3

Pierwszy if … else wybiera, do której sumy dorzucić liczbę — zawsze do dokładnie jednej. Drugi if jest niezależny: dla 6 wykonają się oba (6 jest parzyste i dzieli się przez 3), dla 7 — tylko część else pierwszego.

Sprawdź się w głowie

Najpierw odpowiedz w myślach — prześledź program obrót po obrocie — a dopiero potem kliknij „Pokaż odpowiedź”.

Co wypisze ten fragment?
int suma = 0;
int i = 1;
while (i <= 4) {
    suma += i * i;
    i++;
}
cout << suma;
Pokaż odpowiedź
301 + 4 + 9 + 16 = 30 — dokładamy kwadraty kolejnych liczb.
Ktoś zapomniał o jednej rzeczy. Co wypisze program?
int iloczyn = 0;
int i = 1;
while (i <= 5) {
    iloczyn *= i;
    i++;
}
cout << iloczyn;
Pokaż odpowiedź
0Iloczyn startował od zera, więc każde mnożenie daje zero. Dla mnożenia start musi być 1.
Ile wypisze licznik?
int ile = 0;
int i = 1;
while (i <= 20) {
    if (i % 4 == 0) {
        ile++;
    }
    i++;
}
cout << ile;
Pokaż odpowiedź
5Przez 4 dzielą się 4, 8, 12, 16 i 20.
Gdzie jest cout? Co wypisze program?
int suma = 0;
int i = 1;
while (i <= 4) {
    suma += i;
    cout << suma << " ";
    i++;
}
Pokaż odpowiedź
1 3 6 10cout stoi w pętli, więc wypisuje sumę po każdym obrocie — sumy częściowe. Gdyby stał za pętlą, zobaczylibyśmy tylko 10.
Co policzy ta pętla dla n = 6?
int n = 6;
int s = 0;
int d = 1;
while (d < n) {
    if (n % d == 0) {
        s += d;
    }
    d++;
}
cout << s;
Pokaż odpowiedź
6Dzielniki 6 mniejsze od 6 to 1, 2 i 3 — ich suma to znowu 6. Liczby z taką własnością nazywamy doskonałymi (następna to 28).
Dwa akumulatory. Co wypisze program?
int a = 0, b = 1;
int i = 1;
while (i <= 3) {
    a += i;
    b *= i + 1;
    i++;
}
cout << a << " " << b;
Pokaż odpowiedź
6 24a = 1 + 2 + 3 = 6, a b = 2 · 3 · 4 = 24 (mnożymy przez i + 1, czyli przez 2, 3 i 4).

Wiele danych, jedna zmienna

Do tej pory wiedziałeś z góry, ile liczb wczyta program: jedną, dwie, trzy — i dla każdej tworzyłeś osobną zmienną. Ale zadania olimpijskie wyglądają zwykle tak: „w pierwszym wierszu jest liczba n, a w drugim n liczb”. Gdy n może wynosić milion, nie utworzysz miliona zmiennych. Rozwiązanie: wczytuj liczby w pętli, po jednej w każdym obrocie, i od razu rób z nimi to, co trzeba.

n liczb po kolei

suma_n_liczb.cpp
int n;
cin >> n;            // ile będzie liczb
int suma = 0;
int i = 0;
while (i < n) {
    int x;
    cin >> x;        // kolejna liczba
    suma += x;
    i++;
}
cout << suma << "\n";
▶ Wejście
4 3 8 -2 10
▶ Wyjście
19
obrótwczytane xsuma
133
2811
3−29
41019

Każde cin >> x zabiera z wejścia następną liczbę — pamiętasz z lekcji Input / Output, że wejście to taśma, którą cin czyta po kolei. Zmienna x w każdym obrocie dostaje nową wartość, a poprzednia przepada. Nie szkodzi — zdążyliśmy ją już dodać do sumy.

Zmienna x jest tu utworzona w klamrach pętli i to jest w porządku: potrzebujemy jej tylko w jednym obrocie. Suma natomiast musi przetrwać między obrotami, więc stoi przed pętlą. Nie ma też znaczenia, czy liczby są w jednym wierszu, czy każda w osobnym — cin >> przeskakuje spacje i entery.

Średnia

Średnia to suma podzielona przez liczbę elementów. Uwaga na pułapkę z lekcji o typach: suma i n są typu int, więc suma / n to dzielenie całkowite. Trzeba zamienić jedną z liczb na double:

srednia.cpp
#include <iostream>
#include <iomanip>
using namespace std;

int main() {
    int n;
    cin >> n;
    int suma = 0;
    int i = 0;
    while (i < n) {
        int ocena;
        cin >> ocena;
        suma += ocena;
        i++;
    }
    cout << fixed << setprecision(2);
    cout << (double)suma / n << "\n";
    return 0;
}
▶ Wejście
3 5 4 4
▶ Wyjście
4.33
▶ Wejście
4 6 5 6 6
▶ Wyjście
5.75

Największa liczba — rekord

Jak znaleźć największą z n liczb, nie pamiętając ich wszystkich? Tak samo jak sędzia na zawodach w skoku w dal: trzyma w głowie dotychczasowy rekord. Po każdym skoku porównuje: jeśli nowy skok jest dłuższy, rekord się zmienia. Po ostatnim skoku rekord jest wynikiem całych zawodów.

Jedno pytanie: od czego zacząć rekord? Najbezpieczniej od pierwszej wczytanej liczby — ona na pewno jest w danych. Wczytujemy ją przed pętlą, a pętla przechodzi po pozostałych n − 1 liczbach:

maksimum.cpp
int n;
cin >> n;
int maks;
cin >> maks;           // pierwsza liczba = rekord
int i = 1;             // jedną już mamy
while (i < n) {
    int x;
    cin >> x;
    if (x > maks) {
        maks = x;      // nowy rekord
    }
    i++;
}
cout << maks << "\n";
▶ Wejście
5 3 9 -4 9 2
▶ Wyjście
9
▶ Wejście
3 -7 -2 -15
▶ Wyjście
-2
xx > maks?maks
3 (przed pętlą)—3
9tak9
−4nie9
9nie (9 > 9 to fałsz)9
2nie9
Dlaczego nie maks = 0? Gdyby rekord startował od 0, dla danych -7 -2 -15 żadna liczba nie byłaby większa od zera i program wypisałby 0 — liczbę, której w ogóle nie ma w danych. Start od pierwszej liczby działa zawsze.

Minimum i maksimum naraz — i gdzie był rekord

Najmniejszą liczbę znajdujesz tak samo, tylko z < zamiast >. Obie da się szukać w jednej pętli. A jeśli zadanie pyta, na której pozycji stoi rekord, zapamiętujesz przy nim jeszcze numer obrotu:

min_max.cpp
int n;
cin >> n;
int t;
cin >> t;
int mini = t, maks = t;
int gdzieMaks = 1;
int i = 2;                 // numer kolejnej liczby
while (i <= n) {
    cin >> t;
    if (t < mini) {
        mini = t;
    }
    if (t > maks) {
        maks = t;
        gdzieMaks = i;
    }
    i++;
}
cout << "min " << mini << ", max " << maks;
cout << " (pomiar nr " << gdzieMaks << ")\n";
▶ Wejście
6 3 -2 5 8 -4 8
▶ Wyjście
min -4, max 8 (pomiar nr 4)

Liczba 8 występuje dwa razy — na pozycjach 4 i 6. Program podaje 4, bo przy drugiej ósemce warunek 8 > 8 jest fałszywy i rekord się nie zmienia. Gdyby zadanie chciało ostatniej pozycji rekordu, wystarczy zamienić > na >=.

Tu licznik i startuje od 2 i idzie do n włącznie, bo jest jednocześnie numerem wczytywanej liczby. Pierwszą liczbę (numer 1) wczytaliśmy przed pętlą.

Dane aż do zera

Czasem nikt nie podaje n. Zamiast tego umawiamy się, że dane kończą się umówioną wartością — na przykład zerem. Zero nie jest wtedy daną, tylko sygnałem „koniec”. Pętla kręci się, dopóki wczytana liczba nie jest zerem. Jest tu jedna subtelność — popatrz na dwie wersje:

do_zera_zle.cpp
int x = -1;        // cokolwiek różnego od 0
int ile = 0;
while (x != 0) {
    cin >> x;
    ile++;         // liczy też zero!
}
cout << ile << "\n";
▶ Wejście
5 -3 12 0
▶ Wyjście
4
do_zera_dobrze.cpp
int x;
cin >> x;          // pierwsza liczba przed pętlą
int ile = 0;
while (x != 0) {
    ile++;         // x na pewno nie jest zerem
    cin >> x;      // następna — na końcu obrotu
}
cout << ile << "\n";
▶ Wejście
5 -3 12 0
▶ Wyjście
3

W lewej wersji kolejność jest zła: najpierw wczytujemy, potem od razu liczymy, a sprawdzenie warunku przychodzi dopiero na następnym obrocie. Zero zdąży zostać policzone. W prawej wersji wczytujemy przed pętlą i na końcu każdego obrotu. Dzięki temu każda liczba jest najpierw sprawdzana warunkiem x != 0, a dopiero potem liczona. Zapamiętaj ten układ — przyda się wiele razy.

Prawa wersja ma jeszcze jedną zaletę: jeśli pierwsza liczba to od razu 0, pętla nie wykona się ani razu i wynik to 0 — tak jak trzeba.

Dane aż do końca: while (cin >> x)

Najwygodniejszy przypadek: nie ma n, nie ma zera na końcu — liczby po prostu się kończą. Wtedy używamy specjalnego warunku while (cin >> x). Działa tak: cin >> x próbuje wczytać kolejną liczbę i jednocześnie odpowiada, czy się udało. Udało się — warunek jest prawdziwy i wykonuje się ciało. Danych już nie ma — warunek jest fałszywy i pętla się kończy.

do_konca.cpp
int x;
int ile = 0;
long long suma = 0;
while (cin >> x) {
    ile++;
    suma += x;
}
cout << ile << " liczb, suma " << suma << "\n";
▶ Wejście
4 8 15 16 23 42
▶ Wyjście
6 liczb, suma 108

Wczytywanie i sprawdzanie dzieje się w jednym miejscu — w warunku — więc nie trzeba osobnego cin przed pętlą ani na jej końcu.

W sprawdzarce dane są zapisane w pliku i naprawdę się kończą. Gdy uruchamiasz taki program u siebie i wpisujesz liczby z klawiatury, program czeka na kolejne bez końca. Koniec danych zgłaszasz kombinacją Ctrl + Z, a potem Enter (Windows) albo Ctrl + D (Linux, macOS).

Trzy sposoby wczytywania w pętli — który kiedy? Jest n na początku → licznik od 0 do n i cin >> x w ciele. Dane kończą się umówioną wartością → wczytaj przed pętlą i na końcu obrotu, warunek x != 0. Nic nie wiadomo, dane po prostu się kończą → while (cin >> x). O tym, który przypadek masz, mówi zawsze opis wejścia w treści zadania.

Pamiętaj poprzednią liczbę

Niektóre pytania dotyczą sąsiednich liczb: czy ciąg rośnie? Ile razy temperatura wzrosła w porównaniu z dniem poprzednim? Wtedy oprócz bieżącej liczby trzymasz w osobnej zmiennej poprzednią. Na końcu obrotu bieżąca staje się poprzednią dla następnego obrotu:

wzrosty.cpp
int n;
cin >> n;
int poprz;
cin >> poprz;
int wzrosty = 0;
int i = 1;
while (i < n) {
    int x;
    cin >> x;
    if (x > poprz) {
        wzrosty++;
    }
    poprz = x;      // teraz x jest „poprzednią”
    i++;
}
cout << wzrosty << "\n";
▶ Wejście
7 3 5 4 6 6 8 1
▶ Wyjście
3

Porównujemy pary sąsiadów: (3, 5) wzrost, (5, 4) nie, (4, 6) wzrost, (6, 6) nie — równa to nie większa, (6, 8) wzrost, (8, 1) nie. Razem 3.

Najczęstszy błąd to zapomniane poprz = x; — wtedy każda liczba jest porównywana z pierwszą, a nie z poprzednią.

Sprawdź się w głowie

Najpierw odpowiedz w myślach — prześledź program obrót po obrocie — a dopiero potem kliknij „Pokaż odpowiedź”.

Co wypisze program dla podanego wejścia?
int n;
cin >> n;
int s = 0, i = 0;
while (i < n) {
    int x;
    cin >> x;
    s += x * 2;
    i++;
}
cout << s;
Wejście: 3 4 1 7
Pokaż odpowiedź
24Wczytujemy 4, 1 i 7 — każdą liczbę podwajamy: 8 + 2 + 14 = 24.
Ktoś zaczął rekord od zera. Co wypisze program?
int n;
cin >> n;
int maks = 0, i = 0;
while (i < n) {
    int x;
    cin >> x;
    if (x > maks) maks = x;
    i++;
}
cout << maks;
Wejście: 4 -5 -3 -9 -4
Pokaż odpowiedź
0Żadna z liczb ujemnych nie jest większa od 0, więc rekord się nie zmienia. Poprawna odpowiedź to −3 — dlatego rekord startujemy od pierwszej liczby.
Dane do zera. Co wypisze program?
int x;
cin >> x;
int s = 0;
while (x != 0) {
    s += x;
    cin >> x;
}
cout << s;
Wejście: 7 2 9 0 5
Pokaż odpowiedź
187 + 2 + 9 = 18. Na zerze pętla się kończy, a 5 po zerze w ogóle nie zostaje wczytane.
Do końca danych. Co wypisze program?
int x, ile = 0;
while (cin >> x) {
    if (x > 2) ile++;
}
cout << ile;
Wejście: 3 8 1 6
Pokaż odpowiedź
3Większe od 2 są 3, 8 i 6. Pętla kończy się sama, gdy dane się skończą.
Co policzy ten program?
int n, poprz;
cin >> n >> poprz;
int ile = 0, i = 1;
while (i < n) {
    int x;
    cin >> x;
    if (x == poprz) ile++;
    poprz = x;
    i++;
}
cout << ile;
Wejście: 5 2 4 4 1 3
Pokaż odpowiedź
1Liczy pary sąsiadów o równych wartościach. Jedyna taka para to (4, 4).
Gdzie stoi cout? Co wypisze program?
int n;
cin >> n;
int s = 0, i = 0;
while (i < n) {
    int x;
    cin >> x;
    s += x;
    i++;
    cout << s / i << " ";
}
Wejście: 4 10 20 30 40
Pokaż odpowiedź
10 15 20 25Po każdej liczbie wypisujemy średnią dotychczas wczytanych (dzielenie całkowite): 10/1, 30/2, 60/3, 100/4.
Ć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 →

Rozbieranie na kawałki: cyfry liczby i znaki napisu

W lekcji o typach wyciągałeś cyfry z liczby trzycyfrowej: setki, dziesiątki i jedności, każdą osobnym wzorem. To działało, bo wiedziałeś, ile cyfr ma liczba. Pętla pozwala rozebrać na cyfry liczbę o dowolnej długości — i to dwoma działaniami, które już znasz.

Dwa ruchy: n % 10 i n / 10

nn % 10n / 10
48211482
482248
4884
440

n % 10 to reszta z dzielenia przez 10, czyli ostatnia cyfra liczby. n / 10 to dzielenie całkowite, które tę ostatnią cyfrę obcina.

Powtarzając te dwa ruchy, dostajemy cyfry od końca: 1, 2, 8, 4. Gdy liczba skurczy się do zera, cyfr już nie ma — to nasz warunek końca: while (n > 0).

cyfry_od_konca.cpp
long long n;
cin >> n;
while (n > 0) {
    cout << n % 10 << " ";   // ostatnia cyfra
    n /= 10;                 // obcinamy ją
}
cout << "\n";
▶ Wejście
4821
▶ Wyjście
1 2 8 4
▶ Wejście
1200
▶ Wyjście
0 0 2 1
suma_i_liczba_cyfr.cpp
long long n;
cin >> n;
int suma = 0, ile = 0;
while (n > 0) {
    suma += n % 10;
    ile++;
    n /= 10;
}
cout << ile << " cyfr, suma " << suma << "\n";
▶ Wejście
4821
▶ Wyjście
4 cyfr, suma 15
▶ Wejście
1000000000000000000
▶ Wyjście
19 cyfr, suma 1

Liczba 10¹⁸ ma 19 cyfr i nie mieści się w int, dlatego n jest typu long long. Pętla wykona wtedy tylko 19 obrotów — tyle, ile cyfr — więc nawet ogromne liczby rozbiera błyskawicznie.

Uwaga na zero Dla n = 0 warunek n > 0 jest fałszywy od razu, więc pętla licząca cyfry powie, że zero ma 0 cyfr. Zwykle zadanie i tak zaczyna się od n ≥ 1, ale gdy zero jest dozwolone, obsłuż je osobnym if — albo pętlą do … while, którą poznasz w części 7.

Odwracanie liczby

Cyfry wychodzą od końca, więc łatwo z nich zbudować liczbę zapisaną wspak. Trik: wynik zaczyna od 0, a każdą nową cyfrę „doklejamy” z prawej strony mnożąc dotychczasowy wynik przez 10 i dodając cyfrę. Mnożenie przez 10 przesuwa wszystkie cyfry w lewo i robi miejsce na nową — tak jak dopisanie zera na końcu.

odwroc.cpp
long long n;
cin >> n;
long long wynik = 0;
while (n > 0) {
    wynik = wynik * 10 + n % 10;
    n /= 10;
}
cout << wynik << "\n";
▶ Wejście
1234
▶ Wyjście
4321
▶ Wejście
1200
▶ Wyjście
21
ncyfrawynik
123440 · 10 + 4 = 4
12334 · 10 + 3 = 43
12243 · 10 + 2 = 432
11432 · 10 + 1 = 4321

Dla 1200 dwa pierwsze obroty dają 0 · 10 + 0 = 0 — zera z przodu wyniku po prostu znikają. Odwróceniem 1200 jest 21.

Palindrom — i dlaczego potrzebna jest kopia

Liczba jest palindromem, gdy czytana od tyłu jest taka sama: 1221, 12321, 7. Wystarczy ją odwrócić i porównać z oryginałem. Ale uwaga — pętla odwracająca niszczy zmienną: po pętli n wynosi 0. Gdy oryginał będzie jeszcze potrzebny, pracuj na kopii:

palindrom.cpp
long long n;
cin >> n;
long long kopia = n;        // n zostaje nietknięte
long long odwr = 0;
while (kopia > 0) {
    odwr = odwr * 10 + kopia % 10;
    kopia /= 10;
}
if (odwr == n) {
    cout << "palindrom\n";
} else {
    cout << "nie palindrom\n";
}
▶ Wejście
12321
▶ Wyjście
palindrom
▶ Wejście
1231
▶ Wyjście
nie palindrom
▶ Wejście
120
▶ Wyjście
nie palindrom

Szukanie wśród cyfr

Wszystko, co umiesz robić z liczbami wczytywanymi w pętli — sumować, liczyć, szukać rekordu — działa też na cyfrach. Cyfra z n % 10 to po prostu kolejna liczba do obejrzenia:

cyfry_statystyka.cpp
long long n;
cin >> n;
int parzyste = 0, maks = 0;
while (n > 0) {
    int c = n % 10;
    if (c % 2 == 0) {
        parzyste++;
    }
    if (c > maks) {
        maks = c;
    }
    n /= 10;
}
cout << parzyste << " parzystych, najwieksza " << maks << "\n";
▶ Wejście
3846251
▶ Wyjście
4 parzystych, najwieksza 8

Tym razem rekord maks może zacząć od 0, bo cyfry nie bywają ujemne — każda cyfra jest co najmniej zerem.

Zapisanie cyfry w zmiennej c na początku obrotu porządkuje kod: dalej używasz krótkiego c, a nie powtarzasz n % 10 w każdym if.

Napis znak po znaku

Z lekcji o typach pamiętasz, że s[0] to pierwszy znak napisu, s[1] — drugi, a s.length() mówi, ile znaków ma napis. Gdy w miejsce liczby w nawiasach kwadratowych wstawisz licznik pętli, możesz obejrzeć każdy znak po kolei. Indeksy zaczynają się od 0, więc ostatni znak ma numer s.length() - 1, a warunek pętli to i < s.length():

znaki.cpp
string s;
cin >> s;
int i = 0;
while (i < s.length()) {
    cout << i << ": " << s[i] << "\n";
    i++;
}
▶ Wejście
kot
▶ Wyjście
0: k 1: o 2: t
ile_a.cpp
string s;
cin >> s;
int ile = 0;
int i = 0;
while (i < s.length()) {
    if (s[i] == 'a') {
        ile++;
    }
    i++;
}
cout << ile << "\n";
▶ Wejście
abrakadabra
▶ Wyjście
5

Pojedynczy znak napisu, s[i], jest typu char, więc porównujesz go z literą w apostrofach: s[i] == 'a'. Możesz też liczyć na kodach znaków, tak jak w lekcji o if: s[i] >= 'a' && s[i] <= 'z' to mała litera, a s[i] - '0' zamienia znak cyfry na liczbę.

Jeszcze jedna rzecz: kompilator może przy i < s.length() wypisać ostrzeżenie o porównywaniu liczb „ze znakiem i bez znaku” (signedness). Długość napisu jest typu, który nie ma liczb ujemnych. Dopóki i nie jest ujemne, nic złego się nie dzieje i ostrzeżenie możesz zignorować.

Napis od końca

Żeby przejść po napisie wstecz, licznik zaczyna od ostatniego indeksu i maleje. Pętla kończy się, gdy licznik zejdzie poniżej zera:

wspak.cpp
string s;
cin >> s;
int i = s.length() - 1;    // ostatni znak
while (i >= 0) {
    cout << s[i];
    i--;
}
cout << "\n";
▶ Wejście
programowanie
▶ Wyjście
einawomargorp

Ważne, żeby i było typu int. Po zerze licznik schodzi do −1, warunek -1 >= 0 jest fałszywy i pętla się kończy.

Do napisu możesz też zapisywać: s[i] = '*'; zamienia i-ty znak na gwiazdkę. Tak działa szyfr Cezara z bazy zadań — pętla przechodzi po słowie i każdą literę zamienia na inną.

Sprawdź się w głowie

Najpierw odpowiedz w myślach — prześledź program obrót po obrocie — a dopiero potem kliknij „Pokaż odpowiedź”.

Co wypisze ten fragment?
int n = 507;
int s = 0;
while (n > 0) {
    s += n % 10;
    n /= 10;
}
cout << s;
Pokaż odpowiedź
12Cyfry 7, 0 i 5 dają razem 12. Zero w środku liczby jest zwykłą cyfrą — dodaje 0.
Ile obrotów wykona pętla?
int n = 100000;
int ile = 0;
while (n > 0) {
    n /= 10;
    ile++;
}
cout << ile;
Pokaż odpowiedź
6Liczba 100000 ma 6 cyfr: 100000 → 10000 → 1000 → 100 → 10 → 1 → 0.
Co zostaje w n po pętli?
int n = 4821;
int w = 0;
while (n > 0) {
    w = w * 10 + n % 10;
    n /= 10;
}
cout << w << " " << n;
Pokaż odpowiedź
1284 0w to odwrócona liczba, a n po pętli zawsze wynosi 0 — dlatego przy palindromie potrzebna jest kopia.
Co wypisze ten fragment?
int n = 9876;
while (n >= 10) {
    n /= 10;
}
cout << n;
Pokaż odpowiedź
9Obcinamy cyfry, dopóki liczba ma co najmniej dwie. Zostaje pierwsza cyfra liczby.
Napis znak po znaku. Co wypisze program?
string s = "Ala ma KOTA";
int ile = 0, i = 0;
while (i < s.length()) {
    if (s[i] >= 'A' && s[i] <= 'Z') {
        ile++;
    }
    i++;
}
cout << ile;
Pokaż odpowiedź
5Wielkie litery to A, K, O, T i A. Spacje też są znakami napisu, ale nie spełniają warunku.
Co wypisze program?
string s = "abcde";
int i = 0;
while (i < s.length()) {
    cout << s[i];
    i += 2;
}
Pokaż odpowiedź
aceLicznik przyjmuje wartości 0, 2 i 4 — co drugi znak. Następna wartość, 6, nie spełnia warunku 6 < 5.

Pętla, która sama wie, kiedy skończyć

W większości dotychczasowych pętli liczba obrotów była znana od początku: n razy, od a do b, tyle razy, ile cyfr. Ale prawdziwa siła while ujawnia się wtedy, gdy nie wiadomo, ile będzie obrotów — wiadomo tylko, kiedy przestać. „Dolewaj wody, dopóki wiadro nie jest pełne.” „Oszczędzaj, dopóki nie uzbierasz na rower.” Pętla po prostu powtarza krok, aż warunek przestanie być spełniony, a my na końcu sprawdzamy, ile to trwało albo do czego doszliśmy.

Ile razy można podzielić przez 2?

polowienie.cpp
long long n;
cin >> n;
int ile = 0;
while (n > 1) {
    n /= 2;
    ile++;
}
cout << ile << "\n";
▶ Wejście
13
▶ Wyjście
3
▶ Wejście
1000000000000
▶ Wyjście
39

Dzielimy liczbę na pół (całkowicie), aż zostanie 1: 13 → 6 → 3 → 1, czyli 3 dzielenia. Nikt nie mówi z góry, ile będzie obrotów — pętla po prostu dzieli, dopóki ma co dzielić, a licznik ile zapisuje, ile razy to zrobiła.

Zobacz, jak mało obrotów potrzeba nawet dla biliona: 39. Połowienie bardzo szybko zmniejsza liczbę — ten fakt wróci do Ciebie wiele razy, np. przy wyszukiwaniu binarnym.

Do celu: po ilu krokach?

Typowe zadanie „aż do skutku”: co tydzień odkładasz pieniądze — w pierwszym tygodniu 10 zł, w każdym następnym o 5 zł więcej. Po ilu tygodniach będziesz mieć co najmniej 100 zł? Warunek pętli opisuje sytuację „jeszcze nie”: dopóki suma jest mniejsza od celu, odkładaj dalej.

skarbonka.cpp
int cel = 100;
int suma = 0, wplata = 10, tygodnie = 0;
while (suma < cel) {
    suma += wplata;
    wplata += 5;
    tygodnie++;
}
cout << tygodnie << " tygodni, uzbierane " << suma << " zl\n";
▶ Wyjście
5 tygodni, uzbierane 100 zl
tydzieńwpłatasumasuma < 100?
11010tak
21525tak
32045tak
42570tak
530100nie — koniec

Tak samo znajdziesz najmniejszą potęgę dwójki, która dogoni liczbę n: p = 1; while (p < n) p *= 2;. Albo pierwszy kwadrat większy od n: i = 1; while (i * i <= n) i++; — po pętli i * i jest już większe od n.

Lokata w banku — licz w groszach

Bank co roku dopisuje 5% odsetek do kwoty na lokacie. Po ilu latach 1000 zł zamieni się w co najmniej 1500 zł? Kusi, żeby użyć double i mnożyć przez 1.05. Ale pieniądze najlepiej liczyć na liczbach całkowitych, w groszach — banki naprawdę zaokrąglają odsetki do grosza, a double potrafi zgubić ułamki grosza w nieprzewidywalny sposób.

lokata.cpp
long long kwota = 1000 * 100;   // w groszach
long long cel = 1500 * 100;
int p = 5;                      // procent rocznie
int lata = 0;
while (kwota < cel) {
    kwota += kwota * p / 100;   // odsetki w dół do grosza
    lata++;
}
cout << lata << " lat, na koncie " << kwota / 100 << " zl " << kwota % 100 << " gr\n";
▶ Wyjście
9 lat, na koncie 1551 zl 30 gr

kwota * p / 100 liczy odsetki: najpierw mnożenie, potem dzielenie całkowite — które samo zaokrągla w dół do pełnego grosza. Kolejność jest ważna: kwota * (p / 100) dałoby zawsze 0, bo 5 / 100 w liczbach całkowitych to 0.

Na koniec grosze zamieniamy z powrotem na złote i grosze przez / 100 i % 100. Iloczyn kwota * p szybko rośnie, więc całość trzymamy w long long.

Problem Collatza

Słynna zagadka matematyczna, którą zrozumie każdy, a której nikt nie umie rozwiązać. Weź dowolną liczbę naturalną. Jeśli jest parzysta — podziel ją przez 2. Jeśli nieparzysta — pomnóż przez 3 i dodaj 1. Powtarzaj. Wygląda na to, że zawsze dojdziesz w końcu do 1 — komputery sprawdziły to dla trylionów liczb — ale nikt nie potrafi tego udowodnić.

Dla nas to idealna pętla „aż do skutku”: nie da się przewidzieć, ile będzie kroków, więc liczymy je w trakcie.

collatz.cpp
int n;
cin >> n;
int kroki = 0;
cout << n;
while (n != 1) {
    if (n % 2 == 0) {
        n /= 2;
    } else {
        n = 3 * n + 1;
    }
    cout << " " << n;
    kroki++;
}
cout << "\nkroki: " << kroki << "\n";
▶ Wejście
6
▶ Wyjście
6 3 10 5 16 8 4 2 1 kroki: 8
▶ Wejście
7
▶ Wyjście
7 22 11 34 17 52 26 13 40 20 10 5 16 8 4 2 1 kroki: 16

Tutaj warunek n != 1 jest bezpieczny: liczby w ciągu Collatza nie przeskakują jedynki, tylko do niej dochodzą. Spróbuj u siebie n = 27 — zobaczysz 111 kroków i liczby dochodzące aż do 9232.

Największy wspólny dzielnik — algorytm Euklidesa

Największy wspólny dzielnik (NWD) liczb a i b to największa liczba, przez którą dzielą się obie. NWD(12, 18) = 6, NWD(17, 5) = 1. Przydaje się do skracania ułamków, w zadaniach o rytmach i okresach, i w wielu zadaniach olimpijskich.

Pierwszy pomysł: sprawdzaj kandydatów od mniejszej liczby w dół, aż trafisz na wspólny dzielnik. Działa, ale dla liczb rzędu miliarda może potrzebować miliarda obrotów. Ponad dwa tysiące lat temu grecki matematyk Euklides wymyślił sposób o wiele szybszy. Opiera się na spostrzeżeniu: NWD(a, b) jest takie samo jak NWD(b, a % b) — reszta z dzielenia ma te same wspólne dzielniki co para wyjściowa. Zamieniamy więc parę na coraz mniejszą, aż druga liczba będzie zerem. Wtedy NWD(a, 0) = a.

nwd.cpp
int a, b;
cin >> a >> b;
while (b != 0) {
    int r = a % b;
    a = b;
    b = r;
}
cout << a << "\n";
▶ Wejście
48 18
▶ Wyjście
6
▶ Wejście
1000000000 999999999
▶ Wyjście
1
aba % b
481812
18126
1260
60b = 0, koniec

Trzy obroty zamiast kilkunastu. Dla miliardowych liczb Euklides potrzebuje najwyżej kilkudziesięciu obrotów. Zauważ trzecią zmienną r: to ten sam trik, co przy zamianie miejscami z lekcji o if — bez niej stracilibyśmy wartość b, zanim zdążylibyśmy jej użyć.

Bonus: najmniejsza wspólna wielokrotność to NWW(a, b) = a / NWD(a, b) * b.

Odejmowanie do skutku

Ostatni schemat tej części: odejmuj, dopóki się da. Układasz piramidę z klocków — rzędy po 1, 2, 3, … klocki. Ile pełnych rzędów ułożysz z n klocków? Za każdym razem sprawdzasz, czy starczy na kolejny rząd, i jeśli tak — zabierasz klocki:

piramida.cpp
long long n;
cin >> n;
long long rzad = 1;
while (n >= rzad) {
    n -= rzad;       // układamy rząd
    rzad++;          // następny jest o 1 dłuższy
}
cout << rzad - 1 << " rzedow, zostaje " << n << "\n";
▶ Wejście
12
▶ Wyjście
4 rzedow, zostaje 2
▶ Wejście
15
▶ Wyjście
5 rzedow, zostaje 0

Po pętli rzad jest numerem rzędu, którego nie udało się ułożyć, więc pełnych rzędów jest o jeden mniej. To częsty motyw w pętlach „aż do skutku”: po wyjściu zmienna jest o krok za daleko — zawsze sprawdź na małym przykładzie, czy wypisujesz ją, czy wartość o jeden mniejszą.

Ciekawostka: odejmowanie tej samej liczby b od a, dopóki się da, to po prostu dzielenie. Liczba odejmowań to a / b, a to, co zostanie, to a % b.

Sprawdź się w głowie

Najpierw odpowiedz w myślach — prześledź program obrót po obrocie — a dopiero potem kliknij „Pokaż odpowiedź”.

Ile wypisze ten fragment?
int n = 1;
int k = 0;
while (n < 1000) {
    n *= 10;
    k++;
}
cout << k;
Pokaż odpowiedź
31 → 10 → 100 → 1000. Przy 1000 warunek 1000 < 1000 jest fałszem. Trzy mnożenia.
Collatz od 5. Ile kroków?
int n = 5, kroki = 0;
while (n != 1) {
    if (n % 2 == 0) n /= 2;
    else n = 3 * n + 1;
    kroki++;
}
cout << kroki;
Pokaż odpowiedź
55 → 16 → 8 → 4 → 2 → 1, czyli 5 kroków.
Euklides. Co wypisze program?
int a = 35, b = 21;
while (b != 0) {
    int r = a % b;
    a = b;
    b = r;
}
cout << a;
Pokaż odpowiedź
7(35, 21) → (21, 14) → (14, 7) → (7, 0). NWD(35, 21) = 7.
Co wypisze program — i dlaczego nie 3?
int s = 0, k = 0;
while (s <= 10) {
    k++;
    s += k;
}
cout << k;
Pokaż odpowiedź
5Sumy: 1, 3, 6, 10, 15. Przy s = 10 warunek s <= 10 jest wciąż prawdziwy, więc pętla robi jeszcze jeden obrót. Kończy się dopiero przy s = 15, gdy k = 5.
Odejmowanie do skutku. Co wypisze?
int a = 47, b = 9, ile = 0;
while (a >= b) {
    a -= b;
    ile++;
}
cout << ile << " " << a;
Pokaż odpowiedź
5 2To samo co 47 / 9 = 5 i 47 % 9 = 2 — odejmowanie do skutku jest dzieleniem z resztą.
Co wypisze program?
int x = 100, lata = 0;
while (x < 200) {
    x += x / 10;
    lata++;
}
cout << lata << " " << x;
Pokaż odpowiedź
8 212W każdym obrocie x rośnie o jedną dziesiątą (zaokrągloną w dół): 100 → 110 → 121 → 133 → 146 → 160 → 176 → 193 → 212. Osiem obrotów, a 212 to pierwsza wartość, która nie jest mniejsza od 200.

break, continue, while (true) i do … while

Zwykła pętla while sprawdza warunek tylko w jednym miejscu — na górze, przed każdym obrotem. Czasem to za mało: chcesz przerwać pętlę w połowie obrotu, bo znalazłeś to, czego szukałeś, albo pominąć resztę obrotu dla niektórych danych. Do tego służą dwie instrukcje: break i continue. Na końcu tej części poznasz jeszcze odmianę pętli, która sprawdza warunek na dole.

break — wyjdź z pętli natychmiast

break (po angielsku „przerwij”) kończy pętlę od razu, w miejscu, w którym stoi. Reszta ciała się nie wykona, warunek nie zostanie już sprawdzony — program przeskakuje za klamry pętli. Znasz to słowo ze switch, gdzie robiło coś podobnego. Typowe użycie: szukasz czegoś w danych i gdy to znajdziesz, dalsze szukanie nie ma sensu.

pierwsza_ujemna.cpp
int n;
cin >> n;
int gdzie = 0;            // 0 = nie znaleziono
int i = 1;
while (i <= n) {
    int x;
    cin >> x;
    if (x < 0) {
        gdzie = i;
        break;            // dalej nie szukamy
    }
    i++;
}
if (gdzie == 0) {
    cout << "brak ujemnych\n";
} else {
    cout << "pierwsza ujemna na miejscu " << gdzie << "\n";
}
▶ Wejście
6 4 0 7 -2 5 -9
▶ Wyjście
pierwsza ujemna na miejscu 4
▶ Wejście
3 1 2 3
▶ Wyjście
brak ujemnych

Dla pierwszego wejścia pętla wykona się 4 razy i przerwie na −2. Liczby 5 i −9 nie zostaną nawet wczytane — nie są potrzebne. Gdyby nie było break, program szukałby dalej i gdzie nadpisałoby się pozycją ostatniej ujemnej, czyli 6.

Zmienna gdzie z wartością 0 jako „nie znaleziono” to bardzo popularny trik — po pętli od razu wiadomo, czy break się wykonał.

Szukaj dzielnika do pierwiastka

Pamiętasz test pierwszości z części 3? Dla dużego n był bardzo wolny, bo sprawdzał wszystkie liczby aż do n. Dwa pomysły przyspieszają go tysiące razy. Pierwszy: gdy znajdziemy jakikolwiek dzielnik między 2 a n − 1, liczba na pewno nie jest pierwsza — break. Drugi: jeśli n = a · b i a ≤ b, to a · a ≤ a · b = n. Czyli jeśli n ma dzielnik (inny niż 1 i n), to ma też taki, którego kwadrat nie przekracza n. Wystarczy sprawdzać d, dopóki d * d <= n:

pierwsza_szybko.cpp
long long n;
cin >> n;
bool pierwsza = (n >= 2);
long long d = 2;
while (d * d <= n) {
    if (n % d == 0) {
        pierwsza = false;
        break;
    }
    d++;
}
if (pierwsza) {
    cout << "pierwsza\n";
} else {
    cout << "zlozona, dzieli sie przez " << d << "\n";
}
▶ Wejście
91
▶ Wyjście
zlozona, dzieli sie przez 7
▶ Wejście
1000000007
▶ Wyjście
pierwsza

Dla 1 000 000 007 stara wersja wykonałaby miliard obrotów, a ta — około 31 623 (bo 31 623² ≈ 10⁹). Różnica między sekundami a ułamkiem milisekundy.

d jest typu long long, bo d * d dla dużych n przekracza zakres int. Warunek n >= 2 na starcie dba o liczby 0 i 1, które nie są pierwsze.

continue — pomiń resztę tego obrotu

continue („kontynuuj”) przerywa tylko bieżący obrót: przeskakuje resztę ciała i wraca na górę, do sprawdzenia warunku. Pętla trwa dalej. Przydaje się, gdy niektóre dane chcesz po prostu pominąć:

pomin_trojki.cpp
int i = 0;
while (i < 12) {
    i++;                  // najpierw zwiększ!
    if (i % 3 == 0) {
        continue;         // wielokrotności 3 pomijamy
    }
    cout << i << " ";
}
cout << "\n";
▶ Wyjście
1 2 4 5 7 8 10 11
pomin_trojki_zle.cpp
int i = 1;
while (i <= 12) {
    if (i % 3 == 0) {
        continue;         // przeskakuje też i++!
    }
    cout << i << " ";
    i++;
}
▶ Wyjście — program wisi
1 2

Prawa wersja to klasyczna pułapka. Dla i = 3 continue przeskakuje resztę ciała — razem z i++ na końcu. Licznik zostaje równy 3, warunek dalej jest prawdziwy, znowu continue… i tak bez końca. Dlatego w pętli while z continue zwiększaj licznik na początku obrotu, jak w lewej wersji. (Zwróć uwagę, że wtedy start to 0, a warunek i < 12 — licznik i tak przyjmie w ciele wartości od 1 do 12.)

Szczerze mówiąc, continue zawsze da się zastąpić zwykłym if: if (i % 3 != 0) { cout << i; }. Używaj tego, co jest dla Ciebie czytelniejsze — ale rozpoznawaj continue w cudzym kodzie.

while (true) — wyjście w środku

Warunek true jest zawsze prawdziwy, więc while (true) to pętla, która z siebie nigdy się nie skończy. Ma sens tylko razem z break: używamy jej wtedy, gdy najwygodniej sprawdzić, czy kończyć, w środku obrotu, a nie na górze. Przykład: użytkownik wpisuje hasło, aż trafi.

haslo.cpp
string haslo = "olimp";
string proba;
int numer = 0;
while (true) {
    cin >> proba;
    numer++;
    if (proba == haslo) {
        break;
    }
    cout << "Zle haslo, sprobuj jeszcze raz\n";
}
cout << "Witaj! Udalo sie za " << numer << " razem\n";
▶ Wejście
olimpiada Olimp olimp
▶ Wyjście
Zle haslo, sprobuj jeszcze raz Zle haslo, sprobuj jeszcze raz Witaj! Udalo sie za 3 razem

Zwykłym while z warunkiem na górze trzeba by wczytać hasło przed pętlą i jeszcze raz na końcu obrotu (jak przy danych do zera). Z while (true) mamy jedno cin i jasny przepis na obrót: wczytaj, policz, sprawdź — jeśli dobrze, wyjdź; jeśli źle, napisz komunikat.

Tak samo pisze się menu poleceń: wczytuj polecenia, wykonuj je, a przy poleceniu „koniec” — break.

licznik_polecen.cpp
int stan = 0;
char p;
while (true) {
    cin >> p;
    if (p == 'K') {
        break;              // koniec
    } else if (p == '+') {
        stan++;
    } else if (p == '-') {
        stan--;
    } else if (p == '?') {
        cout << "stan: " << stan << "\n";
    }
}
▶ Wejście
+ + + ? - ? K + ?
▶ Wyjście
stan: 3 stan: 2

Po K pętla się kończy, więc ostatnie + ? w ogóle nie zostaje przeczytane. Zwróć uwagę, że char wczytywany przez cin >> przeskakuje spacje — dostajemy kolejne znaki poleceń.

Uwaga na pętlę bez wyjścia W while (true) całe bezpieczeństwo spoczywa na break. Upewnij się, że na pewno kiedyś się wykona — że dane na pewno zawierają poprawne hasło albo polecenie końca. Jeśli zadanie tego nie gwarantuje, lepiej zwykły warunek, np. while (cin >> p).

do … while — najpierw zrób, potem sprawdź

Ostatnia odmiana pętli sprawdza warunek na końcu obrotu, a nie na początku. Dzięki temu ciało wykona się co najmniej raz, nawet jeśli warunek od razu jest fałszywy. Zwróć uwagę na zapis — do na górze, while (warunek) na dole i średnik po nawiasie (tu jest obowiązkowy!):

schemat_do_while.cpp
do {
    // ciało — wykona się co najmniej raz
} while (warunek);
kostka.cpp
int k;
int suma = 0, rzuty = 0;
do {
    cin >> k;          // rzut kostką
    suma += k;
    rzuty++;
} while (k == 6);      // szóstka = rzucasz jeszcze raz
cout << "pionek idzie o " << suma << " pol, rzutow: " << rzuty << "\n";
▶ Wejście
6 6 3 5
▶ Wyjście
pionek idzie o 15 pol, rzutow: 3
▶ Wejście
2 6
▶ Wyjście
pionek idzie o 2 pol, rzutow: 1

W tej grze gracz rzuca kostką zawsze przynajmniej raz, a po szóstce — jeszcze raz. Decyzja „czy rzucać dalej” zależy od wyniku rzutu, którego przed pierwszym obrotem jeszcze nie ma. To idealne miejsce na do … while.

Drugi przykład naprawia problem z części 5 — liczenie cyfr zera. Zero ma jedną cyfrę, a pętla while (n > 0) mówiła, że zero. Z do … while pierwsza cyfra jest liczona zawsze:

cyfry_do_while.cpp
long long n;
cin >> n;
int ile = 0;
do {
    ile++;
    n /= 10;
} while (n > 0);
cout << ile << "\n";
▶ Wejście
0
▶ Wyjście
1
▶ Wejście
4821
▶ Wyjście
4
Pętlakiedy sprawdza waruneknajmniej obrotówkiedy jej użyć
while (w) { … }przed każdym obrotem0prawie zawsze — to podstawowa pętla
do { … } while (w);po każdym obrocie1gdy o kolejnym obrocie decyduje wynik obrotu (rzut, odpowiedź, cyfra)
while (true) { … break; }tam, gdzie stoi breakzależy od breakgdy warunek wyjścia najwygodniej sprawdzić w środku
Sprawdź się w głowie

Najpierw odpowiedz w myślach — prześledź program obrót po obrocie — a dopiero potem kliknij „Pokaż odpowiedź”.

Co wypisze ten fragment?
int i = 1;
while (i <= 10) {
    if (i == 4) {
        break;
    }
    cout << i << " ";
    i++;
}
cout << "| " << i;
Pokaż odpowiedź
1 2 3 | 4Przy i = 4 pętla kończy się natychmiast — 4 już się nie wypisuje. Po pętli i wciąż wynosi 4.
Co wypisze ten fragment?
int i = 0;
while (i < 6) {
    i++;
    if (i % 2 == 0) {
        continue;
    }
    cout << i << " ";
}
Pokaż odpowiedź
1 3 5Dla parzystych i continue pomija cout. i++ stoi na początku, więc licznik zwiększa się w każdym obrocie.
Ile razy wykona się ciało pętli?
int n = 10, ile = 0;
do {
    ile++;
    n++;
} while (n < 5);
cout << ile;
Pokaż odpowiedź
1Warunek 11 < 5 jest fałszywy, ale do … while sprawdza go dopiero po pierwszym obrocie. Zwykłe while nie wykonałoby się ani razu.
while (true). Co wypisze program?
int x = 1;
while (true) {
    x *= 3;
    if (x > 50) {
        break;
    }
}
cout << x;
Pokaż odpowiedź
81x przyjmuje wartości 3, 9, 27, 81. Dla 81 warunek x > 50 jest prawdziwy i pętla się kończy.
Najmniejszy dzielnik. Co wypisze program?
int n = 221;
int d = 2;
while (d * d <= n) {
    if (n % d == 0) break;
    d++;
}
cout << d;
Pokaż odpowiedź
13221 = 13 · 17. Pierwszy dzielnik, na który trafia pętla, to 13 — i tu break kończy szukanie.
Dla podanego wejścia: co wypisze program?
int x, s = 0;
while (cin >> x) {
    if (x == 0) break;
    if (x < 0) continue;
    s += x;
}
cout << s;
Wejście: 5 -1 3 0 7
Pokaż odpowiedź
85 dodajemy, −1 pomijamy (continue), 3 dodajemy, na 0 kończymy (break). Siódemka nie zostaje nawet wczytana. 5 + 3 = 8.

Pętla w pętli: wiersze i kolumny

W ciele pętli może stać dowolna instrukcja — także druga pętla. Mówimy wtedy o pętli zewnętrznej i wewnętrznej (albo o pętlach zagnieżdżonych). Działa to jak zegar: wskazówka minutowa robi pełne okrążenie, zanim godzinowa przesunie się o jedną kreskę. Tu: wewnętrzna pętla wykonuje wszystkie swoje obroty w każdym jednym obrocie zewnętrznej.

Najłatwiej zobaczyć to na rysunkach z gwiazdek. Zewnętrzna pętla liczy wiersze, a wewnętrzna — gwiazdki w wierszu, czyli kolumny.

Prostokąt

prostokat.cpp
int a = 3, b = 5;       // 3 wiersze, 5 kolumn
int w = 0;
while (w < a) {         // pętla wierszy
    int k = 0;          // od nowa w każdym wierszu!
    while (k < b) {     // pętla gwiazdek
        cout << "*";
        k++;
    }
    cout << "\n";       // koniec wiersza
    w++;
}
▶ Wyjście
***** ***** *****
wwartości kco wypisuje
00, 1, 2, 3, 4***** i enter
10, 1, 2, 3, 4***** i enter
20, 1, 2, 3, 4***** i enter
33 < 3 fałsz — koniec

Gwiazdka wypisuje się w sumie 3 · 5 = 15 razy. Ogólnie: wewnętrzne ciało wykonuje się (obroty zewnętrznej) · (obroty wewnętrznej) razy. Dla dwóch pętli po 1000 obrotów to już milion — warto o tym pamiętać, gdy dane są duże.

Najczęstszy błąd: licznik wewnętrzny przed pętlą

prostokat_zle.cpp
int a = 3, b = 5;
int w = 0;
int k = 0;              // ❌ utworzone raz, przed obiema pętlami
while (w < a) {
    while (k < b) {
        cout << "*";
        k++;
    }
    cout << "\n";
    w++;
}
▶ Wyjście
*****

Pierwszy wiersz wyszedł dobrze, a potem tylko puste wiersze. Dlaczego? Po pierwszym wierszu k wynosi 5. W drugim obrocie zewnętrznej pętli warunek 5 < 5 jest od razu fałszywy, więc wewnętrzna pętla nie wykonuje się ani razu. I tak samo w trzecim.

Zasada: licznik wewnętrznej pętli ustawiasz na start wewnątrz zewnętrznej, tuż przed wewnętrzną. Wtedy każdy wiersz zaczyna liczyć gwiazdki od zera.

Trójkąt — wewnętrzna zależy od zewnętrznej

Najciekawsze rysunki powstają, gdy liczba obrotów wewnętrznej pętli zależy od numeru wiersza. W wierszu numer 1 jedna gwiazdka, w wierszu 2 — dwie, i tak dalej. Wystarczy w warunku wewnętrznej pętli użyć w zamiast stałej liczby:

trojkat.cpp
int n = 4;
int w = 1;
while (w <= n) {
    int k = 0;
    while (k < w) {     // w gwiazdek w wierszu w
        cout << "*";
        k++;
    }
    cout << "\n";
    w++;
}
▶ Wyjście
* ** *** ****
trojkat_liczb.cpp
int n = 4;
int w = 1;
while (w <= n) {
    int k = 1;
    while (k <= w) {
        cout << k << " ";
        k++;
    }
    cout << "\n";
    w++;
}
▶ Wyjście
1 1 2 1 2 3 1 2 3 4

Choinka — dwie wewnętrzne pętle po kolei

W jednym obrocie zewnętrznej pętli możesz mieć kilka wewnętrznych, jedna po drugiej. Choinka o wysokości n: w wierszu w najpierw n − w spacji (żeby przesunąć gwiazdki na środek), a potem 2 · w − 1 gwiazdek. Rozpisz sobie wiersze dla n = 4: (3 spacje, 1 gwiazdka), (2, 3), (1, 5), (0, 7).

choinka.cpp
int n = 4;
int w = 1;
while (w <= n) {
    int k = 0;
    while (k < n - w) {
        cout << " ";
        k++;
    }
    k = 0;                // drugi licznik od zera
    while (k < 2 * w - 1) {
        cout << "*";
        k++;
    }
    cout << "\n";
    w++;
}
▶ Wyjście
* *** ***** *******

Ten sam licznik k służy obu wewnętrznym pętlom — wystarczy go wyzerować między nimi. Można też utworzyć dwie osobne zmienne; liczy się tylko to, żeby każda pętla zaczynała od właściwej wartości.

Rada przy wszystkich rysunkach: zanim zaczniesz pisać, zrób tabelkę — numer wiersza i ile jakich znaków w nim stoi. Wzór na liczbę znaków (np. 2 · w − 1) zwykle widać od razu.

Wiersz i kolumna razem: szachownica i tabliczka

W ciele wewnętrznej pętli znasz oba numery — wiersza w i kolumny k. To pozwala zdecydować, co wypisać w konkretnym polu. Na szachownicy pole jest ciemne, gdy w + k jest parzyste, a w tabliczce mnożenia w polu stoi po prostu w * k:

szachownica.cpp
int n = 5;
int w = 0;
while (w < n) {
    int k = 0;
    while (k < n) {
        if ((w + k) % 2 == 0) {
            cout << "#";
        } else {
            cout << ".";
        }
        k++;
    }
    cout << "\n";
    w++;
}
▶ Wyjście
#.#.# .#.#. #.#.# .#.#. #.#.#
tabliczka_mnozenia.cpp
#include <iostream>
#include <iomanip>
using namespace std;

int main() {
    int n = 5;
    int w = 1;
    while (w <= n) {
        int k = 1;
        while (k <= n) {
            cout << setw(4) << w * k;
            k++;
        }
        cout << "\n";
        w++;
    }
    return 0;
}
▶ Wyjście
1 2 3 4 5 2 4 6 8 10 3 6 9 12 15 4 8 12 16 20 5 10 15 20 25

setw(4) z lekcji Input / Output wyrównuje liczby do prawej w polach szerokości 4 — dzięki temu kolumny stoją równo.

Pętla w pętli w obliczeniach

Zagnieżdżanie przydaje się nie tylko do rysunków. Gdy chcesz coś sprawdzić dla każdej liczby od 1 do n, a samo sprawdzenie wymaga pętli, dostajesz pętlę w pętli. Przykład: wypisz wszystkie liczby pierwsze do n. Zewnętrzna pętla przechodzi po kandydatach, a wewnętrzna — to test pierwszości z poprzedniej części:

pierwsze_do_n.cpp
int n;
cin >> n;
int x = 2;
while (x <= n) {
    bool pierwsza = true;       // od nowa dla każdego x
    int d = 2;
    while (d * d <= x) {
        if (x % d == 0) {
            pierwsza = false;
            break;              // kończy tylko wewnętrzną!
        }
        d++;
    }
    if (pierwsza) {
        cout << x << " ";
    }
    x++;
}
cout << "\n";
▶ Wejście
50
▶ Wyjście
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47

Dwie ważne rzeczy. Pierwsza: break przerywa tylko tę pętlę, w której stoi — tu wewnętrzną. Zewnętrzna działa dalej i przechodzi do następnego kandydata. Gdyby break kończył obie pętle, program zatrzymałby się na pierwszej liczbie złożonej.

Druga: flaga pierwsza jest ustawiana na true na początku każdego obrotu zewnętrznej pętli — z tego samego powodu, dla którego zerujemy licznik wewnętrzny. Gdyby stała przed zewnętrzną pętlą, po pierwszej liczbie złożonej (4) zostałaby fałszywa na zawsze.

Sprawdź się w głowie

Najpierw odpowiedz w myślach — prześledź program obrót po obrocie — a dopiero potem kliknij „Pokaż odpowiedź”.

Ile gwiazdek wypisze ten fragment?
int w = 0, ile = 0;
while (w < 4) {
    int k = 0;
    while (k < 3) {
        ile++;
        k++;
    }
    w++;
}
cout << ile;
Pokaż odpowiedź
124 obroty zewnętrznej po 3 obroty wewnętrznej: 4 · 3 = 12.
Co wypisze program?
int w = 1;
while (w <= 3) {
    int k = 1;
    while (k <= 3) {
        cout << w;
        k++;
    }
    cout << " ";
    w++;
}
Pokaż odpowiedź
111 222 333W wewnętrznej pętli wypisujemy numer wiersza, a nie kolumny — trzy razy to samo w.
Licznik wewnętrzny przed pętlą. Co wypisze program?
int w = 0, k = 0;
while (w < 3) {
    while (k < 2) {
        cout << "x";
        k++;
    }
    cout << "|";
    w++;
}
Pokaż odpowiedź
xx|||k zeruje się tylko raz, na samym początku. W drugim i trzecim obrocie zewnętrznej pętli wewnętrzna nie wykonuje się ani razu.
Trójkąt w drugą stronę. Co wypisze program?
int w = 3;
while (w >= 1) {
    int k = 0;
    while (k < w) {
        cout << "#";
        k++;
    }
    cout << "\n";
    w--;
}
Pokaż odpowiedź
### ## #Zewnętrzny licznik maleje, więc w kolejnych wierszach jest 3, 2 i 1 znak.
Ile razy wykona się instrukcja ile++?
int ile = 0, w = 1;
while (w <= 4) {
    int k = w;
    while (k <= 4) {
        ile++;
        k++;
    }
    w++;
}
cout << ile;
Pokaż odpowiedź
10Dla w = 1 wewnętrzna robi 4 obroty, dla w = 2 — 3, dla w = 3 — 2, dla w = 4 — 1. Razem 4 + 3 + 2 + 1 = 10.
break w pętli wewnętrznej. Co wypisze program?
int w = 1;
while (w <= 3) {
    int k = 1;
    while (k <= 5) {
        if (k > w) break;
        cout << k;
        k++;
    }
    cout << " ";
    w++;
}
Pokaż odpowiedź
1 12 123break przerywa tylko wewnętrzną pętlę — gdy k przekroczy numer wiersza. Zewnętrzna pętla działa dalej i rysuje kolejne wiersze.
Ć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ń: pętle w praktyce

Znasz już wszystkie narzędzia: pętlę while, liczniki, sumy i rekordy, wczytywanie danych na trzy sposoby, rozbieranie liczby na cyfry, pętle „aż do skutku”, break, continue, do … while i pętlę w pętli. Czas sprawdzić je na zadaniach, które łączą kilka z nich naraz. Zadania są ułożone od najłatwiejszego do najtrudniejszego: najpierw rozgrzewka z jedną pętlą, potem zadania średnie — symulacje, rekordy, liczby pierwsze, system dwójkowy — a na końcu trudne, z rozkładem na czynniki, trójkątem Pascala i wielkim finałem, w którym przydaje się wszystko naraz.

Przy każdym zadaniu widać, jakich zagadnień używa — także tych z poprzednich lekcji, jak long long, setprecision, dane typu 12:30 czy else if. Jeśli coś brzmi obco, wróć do odpowiedniej części — mapa lekcji jest na górze strony.

Jak rozwiązywać zadania z pętlami 1) Przeczytaj opis wejścia: czy jest n, czy dane kończą się umówioną wartością, czy po prostu się kończą? To wybiera rodzaj pętli. 2) Ustal, co ma przetrwać między obrotami (licznik, suma, rekord, poprzednia liczba) — te zmienne tworzysz przed pętlą. 3) Opisz słowami jeden obrót: co wczytuję, co sprawdzam, co zmieniam. 4) Zastanów się, kiedy pętla ma się skończyć, i sprawdź pierwszy i ostatni obrót na małym przykładzie. 5) Przetestuj skrajności: najmniejsze dane, największe dane (zakres typów!), liczby ujemne. Wskazówka przy każdym zadaniu pomoże, gdy utkniesz.
średnie

Średnie · zadania 9–20

Symulacje, rekordy i serie, liczby pierwsze, system dwójkowy i szyfr Cezara.

9 Ślimak w studniśrednie✓ zaliczone W dzień w górę o a, w nocy w dół o b. Którego dnia ślimak wyjdzie ze studni? whilesymulacjabreak Rozwiąż 10 Najdłuższa seriaśrednie✓ zaliczone Ile najwięcej równych liczb stoi obok siebie? Licz bieżącą serię i pamiętaj rekord. whilepoprzednia liczbarekord Rozwiąż 11 Srebrny medalśrednie✓ zaliczone Znajdź drugą największą wartość — inną niż największa. Bez tablic, w jednym przejściu. whiledwa rekordyflaga Rozwiąż 12 Wypłata z bankomatuśrednie✓ zaliczone Wydaj kwotę jak najmniejszą liczbą banknotów: zawsze bierz największy, jaki się mieści. whilezachłanniekilka pętli Rozwiąż 13 Ciąg Fibonacciegośrednie✓ zaliczone Każdy wyraz to suma dwóch poprzednich. Wypisz wszystkie nie większe od n. whiletrzy zmiennelong long Rozwiąż 14 Suma cyfr aż do skutkuśrednie✓ zaliczone Sumuj cyfry, potem cyfry sumy… aż zostanie jedna cyfra. Pętla w pętli. pętla w pętlisuma cyfrlong long Rozwiąż 15 Szyfr Cezaraśrednie✓ zaliczone Przesuń każdą literę słowa o k miejsc w alfabecie, z zawijaniem z z do a. whiles[i]kody znaków% Rozwiąż 16 Zapis dwójkowyśrednie✓ zaliczone Zamień liczbę na system dwójkowy — najpierw znajdź największą potęgę dwójki. whilepotęgi dwójkilong long Rozwiąż 17 Z dwójkowego na dziesiętnyśrednie✓ zaliczone Odczytaj napis z zer i jedynek jako liczbę: wynik = wynik * 2 + cyfra. whiles[i]budowanie liczbylong long Rozwiąż 18 Najdłuższe słowośrednie✓ zaliczone Czytaj słowa do końca danych. Ile ich było i które jest najdłuższe? while (cin >> s)stringrekord Rozwiąż 19 Liczby pierwsze w przedzialeśrednie✓ zaliczone Policz liczby pierwsze między a i b — każdą sprawdzaj do pierwiastka. pętla w pętlibreakd * d <= x Rozwiąż 20 Liczby narcystyczneśrednie✓ zaliczone Liczba równa sumie swoich cyfr podniesionych do potęgi równej liczbie cyfr, np. 153. pętla w pętlicyfrypotęga pętlą Rozwiąż
trudne

Trudne · zadania 21–28

Rozkład na czynniki, NWW, Collatz, trójkąt Pascala — a na końcu wielki finał: dziennik pogody.

Częste błędy i dobre praktyki

♾️
Program „wisi”
Warunek nigdy nie staje się fałszywy: brak zmiany licznika, zmiana w złą stronę albo licznik przeskakujący wartość z !=. Ctrl + C przerywa program.
🚫
Bez średnika po while
while (i <= n); to pusta pętla, która kręci się w nieskończoność. Po nawiasie od razu otwierasz klamrę.
1️⃣
Błąd o jeden
Ustal pierwszą i ostatnią wartość licznika. i = 0; i < n i i = 1; i <= n dają n obrotów, ale i = 0; i <= n — już n + 1.
📦
Akumulator przed pętlą
Suma i licznik od 0, iloczyn od 1 — ustawione przed pętlą. Utworzone w klamrach znikają i zerują się w każdym obrocie.
🖨️
Wynik po pętli
Jeśli zadanie chce jednej liczby, cout stoi za klamrami pętli. W środku wypisałbyś wszystkie wyniki pośrednie.
🏆
Maksimum od pierwszej liczby
Rekord zaczynaj od pierwszej wczytanej liczby, a nie od 0 — dla samych liczb ujemnych 0 byłoby złą odpowiedzią.
📏
long long w pętlach
Sumy, iloczyny, silnie i potęgi szybko przekraczają 2 miliardy. Zastanów się, jak duży może być wynik, a także d * d w warunku.
🧬
Kopia przed rozbieraniem
Pętla n /= 10 zostawia w n zero. Jeśli oryginał będzie potrzebny później (palindrom!), pracuj na kopii.
⏭️
continue a licznik
W while instrukcja continue przeskakuje resztę ciała — także i++ na jego końcu. Zwiększaj licznik na początku obrotu.
🔁
Zeruj wewnętrzny licznik
W pętli w pętli licznik wewnętrznej ustawiasz na start wewnątrz zewnętrznej, tuż przed wewnętrzną — inaczej drugi wiersz będzie pusty.
📥
while (cin >> x)
Gdy nie wiesz, ile będzie danych, czytaj do końca wejścia. Na swoim komputerze zakończysz wpisywanie klawiszami Ctrl + Z i Enter (Windows) albo Ctrl + D.
🧪
Testuj skrajności
Sprawdź program dla n = 0, n = 1, dla największych danych z treści i dla liczb ujemnych. Tam wychodzą błędy o jeden, przepełnienia i pętle bez końca.

Co dalej?

Następna lekcja to For loop: zobaczysz, jak start, warunek i zmianę pętli zapisać w jednej linijce — i dlaczego pętla for jest wygodniejsza wszędzie tam, gdzie z góry wiadomo, ile będzie obrotów. Wszystko, czego nauczyłeś się tutaj, przyda się od pierwszego zadania. A jeśli chcesz trenować z mentorami — dołącz do T-Olimpians.