Wolisz obejrzeć?
Olimpijskie Koło Informatyczne nagrywa swoje zajęcia i udostępnia je za darmo. Poniżej 2 odcinki o tym temacie — dobre uzupełnienie, jeśli wolisz obejrzeć niż przeczytać.
Co już umiesz i czego się nauczysz
Ta lekcja zakłada, że przerobiłeś 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.
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.
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.
Pętle, które same wiedzą, kiedy skończyć
Cyfry liczby, litery napisu, symulacje, problem Collatza i algorytm Euklidesa.
Sterowanie pętlą
break, continue, while (true), do … while i pętla w pętli — prostokąty, trójkąty i tabliczka mnożenia.
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”.
cout << 1 << "\n";
cout << 2 << "\n";
cout << 3 << "\n";
cout << 4 << "\n";
cout << 5 << "\n";
// ...a dla 1000 liczb? 1000 linijek?
int i = 1;
while (i <= 5) {
cout << i << "\n";
i++;
}
// dla 1000 liczb zmieniasz tylko 5 na 1000
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
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.
#include <iostream>
using namespace std;
int main() {
int i = 1;
while (i <= 5) {
cout << i << "\n";
i++;
}
cout << "Koniec!\n";
return 0;
}
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:
| Krok | i przed sprawdzeniem | warunek i <= 5 | co się dzieje |
|---|---|---|---|
| start | — | — | int i = 1; — tworzymy licznik |
| obrót 1 | 1 | 1 <= 5 → true | wypisuje 1, i zmienia się na 2 |
| obrót 2 | 2 | 2 <= 5 → true | wypisuje 2, i zmienia się na 3 |
| obrót 3 | 3 | 3 <= 5 → true | wypisuje 3, i zmienia się na 4 |
| obrót 4 | 4 | 4 <= 5 → true | wypisuje 4, i zmienia się na 5 |
| obrót 5 | 5 | 5 <= 5 → true | wypisuje 5, i zmienia się na 6 |
| koniec | 6 | 6 <= 5 → false | pę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.
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:
int n;
cin >> n;
int i = 1;
while (i <= n) {
cout << i << " ";
i++;
}
cout << "\n";
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:
int n;
cin >> n;
int i = n;
while (i > 0) {
cout << i << "... ";
i--;
}
cout << "Start!\n";
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:
int n;
cin >> n;
int i = 0;
while (i < n) {
cout << "Hip hip hura!\n";
i++;
}
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:
int i = 1;
while (i <= 5) {
cout << i << " do kwadratu = " << i * i << "\n";
i++;
}
int k;
cin >> k;
int i = 1;
while (i <= 10) {
cout << k << " x " << i << " = " << k * i << "\n";
i++;
}
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ę:
int i = 1;
while (i <= 10) {
cout << i;
if (i % 2 == 0) {
cout << "*";
}
cout << " ";
i++;
}
cout << "\n";
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ę:
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--;
}
}
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.
Najpierw odpowiedz w myślach — prześledź program obrót po obrocie — a dopiero potem kliknij „Pokaż odpowiedź”.
int i = 1;
while (i <= 3) {
cout << i;
i++;
}
Pokaż odpowiedź
raz?int i = 0;
while (i < 4) {
cout << "raz ";
i++;
}
Pokaż odpowiedź
i na końcu?int i = 10;
while (i > 7) {
cout << i << " ";
i--;
}
cout << "| " << i;
Pokaż odpowiedź
int i = 1;
while (i <= 4) {
cout << i * 10 << " ";
i++;
}
Pokaż odpowiedź
int i = 1;
while (i <= 3) {
cout << "A";
i++;
}
cout << "B";
Pokaż odpowiedź
int i = 1;
while (i <= 6) {
if (i % 3 == 0) {
cout << i << " ";
}
i++;
}
Pokaż odpowiedź
7 ćwiczeń do tej części
Kliknij zadanie — otworzy się w sprawdzarce w nowej karcie. Napisz program u siebie, sprawdź go na przykładzie, wklej cały kod i kliknij Wyślij. Utknąłeś? Każde zadanie ma wskazówkę.
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ć.
Start — przed pętlą
Zmienna z warunku musi istnieć i mieć wartość, zanim program pierwszy raz sprawdzi warunek: int i = 1;.
Warunek — w nawiasie
Mówi, kiedy pętla ma się jeszcze kręcić: i <= n. Gdy przestaje być prawdziwy, pętla się kończy.
Zmiana — w ciele
Coś w klamrach musi zmieniać zmienną z warunku tak, żeby warunek kiedyś stał się fałszywy: i++.
int n = 4;
int i = 1; // 1. start
while (i <= n) { // 2. warunek
cout << i << " ";
i++; // 3. zmiana
}
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ą:
int i = 2;
while (i <= 12) {
cout << i << " ";
i += 2; // co dwa
}
int i = 0;
while (i <= 30) {
cout << i << " ";
i += 5; // co pięć
}
int i = 20;
while (i > 0) {
cout << i << " ";
i -= 3; // w dół co trzy
}
int p = 1;
while (p <= 100) {
cout << p << " ";
p *= 2; // dwa razy więcej
}
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 warunek | wartości licznika w kolejnych obrotach | ile obrotów |
|---|---|---|
i = 1; while (i <= 5) | 1, 2, 3, 4, 5 | 5 |
i = 1; while (i < 5) | 1, 2, 3, 4 | 4 |
i = 0; while (i < 5) | 0, 1, 2, 3, 4 | 5 |
i = 0; while (i <= 5) | 0, 1, 2, 3, 4, 5 | 6 |
i = 5; while (i > 0), i-- | 5, 4, 3, 2, 1 | 5 |
i = 5; while (i >= 0), i-- | 5, 4, 3, 2, 1, 0 | 6 |
i = 0; while (i < 10), i += 3 | 0, 3, 6, 9 | 4 |
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.
int n;
cin >> n;
int i = 1;
while (i <= n) {
cout << "*";
i++;
}
cout << "|koniec\n";
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:
int i = 1;
while (i <= 5) {
cout << i << " ";
// brak i++ — i zawsze wynosi 1
}
int i = 1;
while (i <= 5) {
cout << i << " ";
i--; // licznik oddala się od 5
}
int i = 1;
while (i <= 5); {
cout << i << " ";
i++;
}
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.
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ć:
int i = 1;
while (i <= 3) {
int i = 1; // nowa zmienna i w każdym obrocie!
cout << i << " ";
i++;
}
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:
int x = 100; // wartość do wypisania
int ile = 0; // licznik obrotów
while (ile < 5) {
cout << x << " ";
x -= 7;
ile++;
}
| obrót | ile | x | wypisuje |
|---|---|---|---|
| 1 | 0 | 100 | 100 |
| 2 | 1 | 93 | 93 |
| 3 | 2 | 86 | 86 |
| 4 | 3 | 79 | 79 |
| 5 | 4 | 72 | 72 |
| — | 5 | 65 | koniec |
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:
#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;
}
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ą.
Najpierw odpowiedz w myślach — prześledź program obrót po obrocie — a dopiero potem kliknij „Pokaż odpowiedź”.
int i = 3;
int ile = 0;
while (i <= 12) {
ile++;
i += 3;
}
cout << ile;
Pokaż odpowiedź
int i = 1;
while (i < 50) {
cout << i << " ";
i *= 3;
}
Pokaż odpowiedź
int i = 10;
while (i < 5) {
cout << "X";
i++;
}
cout << "koniec";
Pokaż odpowiedź
i po pętli?int i = 0;
while (i < 10) {
i += 4;
}
cout << i;
Pokaż odpowiedź
int i = 5;
while (i != 0) {
cout << i << " ";
i -= 2;
}
Pokaż odpowiedź
int a = 1, b = 10;
while (a < b) {
a += 2;
b -= 1;
}
cout << a << " " << b;
Pokaż odpowiedź
7 ćwiczeń do tej części
Kliknij zadanie — otworzy się w sprawdzarce w nowej karcie. Napisz program u siebie, sprawdź go na przykładzie, wklej cały kod i kliknij Wyślij. Utknąłeś? Każde zadanie ma wskazówkę.
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.
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
| obrót | i | suma przed | suma po |
|---|---|---|---|
| 1 | 1 | 0 | 0 + 1 = 1 |
| 2 | 2 | 1 | 1 + 2 = 3 |
| 3 | 3 | 3 | 3 + 3 = 6 |
| 4 | 4 | 6 | 6 + 4 = 10 |
| 5 | 5 | 10 | 10 + 5 = 15 |
| — | 6 | 6 <= 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.
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:
int n;
cin >> n;
int suma = 0;
int i = 1;
while (i <= n) {
if (i % 2 == 0) {
suma += i;
}
i++;
}
cout << suma << "\n";
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?
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";
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.
int n;
cin >> n;
long long wynik = 1; // iloczyn od 1!
int i = 1;
while (i <= n) {
wynik *= i;
i++;
}
cout << wynik << "\n";
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:
long long a;
int b;
cin >> a >> b;
long long wynik = 1;
int i = 0;
while (i < b) {
wynik *= a;
i++;
}
cout << wynik << "\n";
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ć:
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";
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:
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";
}
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:
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";
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.
Najpierw odpowiedz w myślach — prześledź program obrót po obrocie — a dopiero potem kliknij „Pokaż odpowiedź”.
int suma = 0;
int i = 1;
while (i <= 4) {
suma += i * i;
i++;
}
cout << suma;
Pokaż odpowiedź
int iloczyn = 0;
int i = 1;
while (i <= 5) {
iloczyn *= i;
i++;
}
cout << iloczyn;
Pokaż odpowiedź
int ile = 0;
int i = 1;
while (i <= 20) {
if (i % 4 == 0) {
ile++;
}
i++;
}
cout << ile;
Pokaż odpowiedź
int suma = 0;
int i = 1;
while (i <= 4) {
suma += i;
cout << suma << " ";
i++;
}
Pokaż odpowiedź
int n = 6;
int s = 0;
int d = 1;
while (d < n) {
if (n % d == 0) {
s += d;
}
d++;
}
cout << s;
Pokaż odpowiedź
int a = 0, b = 1;
int i = 1;
while (i <= 3) {
a += i;
b *= i + 1;
i++;
}
cout << a << " " << b;
Pokaż odpowiedź
7 ćwiczeń do tej części
Kliknij zadanie — otworzy się w sprawdzarce w nowej karcie. Napisz program u siebie, sprawdź go na przykładzie, wklej cały kod i kliknij Wyślij. Utknąłeś? Każde zadanie ma wskazówkę.
Wiele 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
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";
| obrót | wczytane x | suma |
|---|---|---|
| 1 | 3 | 3 |
| 2 | 8 | 11 |
| 3 | −2 | 9 |
| 4 | 10 | 19 |
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:
#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;
}
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:
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";
| x | x > maks? | maks |
|---|---|---|
| 3 (przed pętlą) | — | 3 |
| 9 | tak | 9 |
| −4 | nie | 9 |
| 9 | nie (9 > 9 to fałsz) | 9 |
| 2 | nie | 9 |
-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:
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";
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:
int x = -1; // cokolwiek różnego od 0
int ile = 0;
while (x != 0) {
cin >> x;
ile++; // liczy też zero!
}
cout << ile << "\n";
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";
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.
int x;
int ile = 0;
long long suma = 0;
while (cin >> x) {
ile++;
suma += x;
}
cout << ile << " liczb, suma " << suma << "\n";
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).
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:
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";
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ą.
Najpierw odpowiedz w myślach — prześledź program obrót po obrocie — a dopiero potem kliknij „Pokaż odpowiedź”.
int n;
cin >> n;
int s = 0, i = 0;
while (i < n) {
int x;
cin >> x;
s += x * 2;
i++;
}
cout << s;
3 4 1 7Pokaż odpowiedź
int n;
cin >> n;
int maks = 0, i = 0;
while (i < n) {
int x;
cin >> x;
if (x > maks) maks = x;
i++;
}
cout << maks;
4 -5 -3 -9 -4Pokaż odpowiedź
int x;
cin >> x;
int s = 0;
while (x != 0) {
s += x;
cin >> x;
}
cout << s;
7 2 9 0 5Pokaż odpowiedź
int x, ile = 0;
while (cin >> x) {
if (x > 2) ile++;
}
cout << ile;
3 8 1 6Pokaż odpowiedź
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;
5 2 4 4 1 3Pokaż odpowiedź
int n;
cin >> n;
int s = 0, i = 0;
while (i < n) {
int x;
cin >> x;
s += x;
i++;
cout << s / i << " ";
}
4 10 20 30 40Pokaż odpowiedź
8 ćwiczeń do tej części
Kliknij zadanie — otworzy się w sprawdzarce w nowej karcie. Napisz program u siebie, sprawdź go na przykładzie, wklej cały kod i kliknij Wyślij. Utknąłeś? Każde zadanie ma wskazówkę.
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
| n | n % 10 | n / 10 |
|---|---|---|
| 4821 | 1 | 482 |
| 482 | 2 | 48 |
| 48 | 8 | 4 |
| 4 | 4 | 0 |
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).
long long n;
cin >> n;
while (n > 0) {
cout << n % 10 << " "; // ostatnia cyfra
n /= 10; // obcinamy ją
}
cout << "\n";
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";
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.
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.
long long n;
cin >> n;
long long wynik = 0;
while (n > 0) {
wynik = wynik * 10 + n % 10;
n /= 10;
}
cout << wynik << "\n";
| n | cyfra | wynik |
|---|---|---|
| 1234 | 4 | 0 · 10 + 4 = 4 |
| 123 | 3 | 4 · 10 + 3 = 43 |
| 12 | 2 | 43 · 10 + 2 = 432 |
| 1 | 1 | 432 · 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:
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";
}
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:
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";
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():
string s;
cin >> s;
int i = 0;
while (i < s.length()) {
cout << i << ": " << s[i] << "\n";
i++;
}
string s;
cin >> s;
int ile = 0;
int i = 0;
while (i < s.length()) {
if (s[i] == 'a') {
ile++;
}
i++;
}
cout << ile << "\n";
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:
string s;
cin >> s;
int i = s.length() - 1; // ostatni znak
while (i >= 0) {
cout << s[i];
i--;
}
cout << "\n";
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ą.
Najpierw odpowiedz w myślach — prześledź program obrót po obrocie — a dopiero potem kliknij „Pokaż odpowiedź”.
int n = 507;
int s = 0;
while (n > 0) {
s += n % 10;
n /= 10;
}
cout << s;
Pokaż odpowiedź
int n = 100000;
int ile = 0;
while (n > 0) {
n /= 10;
ile++;
}
cout << ile;
Pokaż odpowiedź
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ź
int n = 9876;
while (n >= 10) {
n /= 10;
}
cout << n;
Pokaż odpowiedź
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ź
string s = "abcde";
int i = 0;
while (i < s.length()) {
cout << s[i];
i += 2;
}
Pokaż odpowiedź
8 ćwiczeń do tej części
Kliknij zadanie — otworzy się w sprawdzarce w nowej karcie. Napisz program u siebie, sprawdź go na przykładzie, wklej cały kod i kliknij Wyślij. Utknąłeś? Każde zadanie ma wskazówkę.
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?
long long n;
cin >> n;
int ile = 0;
while (n > 1) {
n /= 2;
ile++;
}
cout << ile << "\n";
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.
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";
| tydzień | wpłata | suma | suma < 100? |
|---|---|---|---|
| 1 | 10 | 10 | tak |
| 2 | 15 | 25 | tak |
| 3 | 20 | 45 | tak |
| 4 | 25 | 70 | tak |
| 5 | 30 | 100 | nie — 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.
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";
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.
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";
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.
int a, b;
cin >> a >> b;
while (b != 0) {
int r = a % b;
a = b;
b = r;
}
cout << a << "\n";
| a | b | a % b |
|---|---|---|
| 48 | 18 | 12 |
| 18 | 12 | 6 |
| 12 | 6 | 0 |
| 6 | 0 | b = 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:
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";
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.
Najpierw odpowiedz w myślach — prześledź program obrót po obrocie — a dopiero potem kliknij „Pokaż odpowiedź”.
int n = 1;
int k = 0;
while (n < 1000) {
n *= 10;
k++;
}
cout << k;
Pokaż odpowiedź
int n = 5, kroki = 0;
while (n != 1) {
if (n % 2 == 0) n /= 2;
else n = 3 * n + 1;
kroki++;
}
cout << kroki;
Pokaż odpowiedź
int a = 35, b = 21;
while (b != 0) {
int r = a % b;
a = b;
b = r;
}
cout << a;
Pokaż odpowiedź
int s = 0, k = 0;
while (s <= 10) {
k++;
s += k;
}
cout << k;
Pokaż odpowiedź
int a = 47, b = 9, ile = 0;
while (a >= b) {
a -= b;
ile++;
}
cout << ile << " " << a;
Pokaż odpowiedź
int x = 100, lata = 0;
while (x < 200) {
x += x / 10;
lata++;
}
cout << lata << " " << x;
Pokaż odpowiedź
7 ćwiczeń do tej części
Kliknij zadanie — otworzy się w sprawdzarce w nowej karcie. Napisz program u siebie, sprawdź go na przykładzie, wklej cały kod i kliknij Wyślij. Utknąłeś? Każde zadanie ma wskazówkę.
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.
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";
}
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:
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";
}
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ąć:
int i = 0;
while (i < 12) {
i++; // najpierw zwiększ!
if (i % 3 == 0) {
continue; // wielokrotności 3 pomijamy
}
cout << i << " ";
}
cout << "\n";
int i = 1;
while (i <= 12) {
if (i % 3 == 0) {
continue; // przeskakuje też i++!
}
cout << i << " ";
i++;
}
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.
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";
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.
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";
}
}
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ń.
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!):
do {
// ciało — wykona się co najmniej raz
} while (warunek);
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";
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:
long long n;
cin >> n;
int ile = 0;
do {
ile++;
n /= 10;
} while (n > 0);
cout << ile << "\n";
| Pętla | kiedy sprawdza warunek | najmniej obrotów | kiedy jej użyć |
|---|---|---|---|
while (w) { … } | przed każdym obrotem | 0 | prawie zawsze — to podstawowa pętla |
do { … } while (w); | po każdym obrocie | 1 | gdy o kolejnym obrocie decyduje wynik obrotu (rzut, odpowiedź, cyfra) |
while (true) { … break; } | tam, gdzie stoi break | zależy od break | gdy warunek wyjścia najwygodniej sprawdzić w środku |
Najpierw odpowiedz w myślach — prześledź program obrót po obrocie — a dopiero potem kliknij „Pokaż odpowiedź”.
int i = 1;
while (i <= 10) {
if (i == 4) {
break;
}
cout << i << " ";
i++;
}
cout << "| " << i;
Pokaż odpowiedź
int i = 0;
while (i < 6) {
i++;
if (i % 2 == 0) {
continue;
}
cout << i << " ";
}
Pokaż odpowiedź
int n = 10, ile = 0;
do {
ile++;
n++;
} while (n < 5);
cout << ile;
Pokaż odpowiedź
int x = 1;
while (true) {
x *= 3;
if (x > 50) {
break;
}
}
cout << x;
Pokaż odpowiedź
int n = 221;
int d = 2;
while (d * d <= n) {
if (n % d == 0) break;
d++;
}
cout << d;
Pokaż odpowiedź
int x, s = 0;
while (cin >> x) {
if (x == 0) break;
if (x < 0) continue;
s += x;
}
cout << s;
5 -1 3 0 7Pokaż odpowiedź
7 ćwiczeń do tej części
Kliknij zadanie — otworzy się w sprawdzarce w nowej karcie. Napisz program u siebie, sprawdź go na przykładzie, wklej cały kod i kliknij Wyślij. Utknąłeś? Każde zadanie ma wskazówkę.
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
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++;
}
| w | wartości k | co wypisuje |
|---|---|---|
| 0 | 0, 1, 2, 3, 4 | ***** i enter |
| 1 | 0, 1, 2, 3, 4 | ***** i enter |
| 2 | 0, 1, 2, 3, 4 | ***** i enter |
| 3 | 3 < 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ą
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++;
}
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:
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++;
}
int n = 4;
int w = 1;
while (w <= n) {
int k = 1;
while (k <= w) {
cout << k << " ";
k++;
}
cout << "\n";
w++;
}
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).
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++;
}
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:
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++;
}
#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;
}
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:
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";
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.
Najpierw odpowiedz w myślach — prześledź program obrót po obrocie — a dopiero potem kliknij „Pokaż odpowiedź”.
int w = 0, ile = 0;
while (w < 4) {
int k = 0;
while (k < 3) {
ile++;
k++;
}
w++;
}
cout << ile;
Pokaż odpowiedź
int w = 1;
while (w <= 3) {
int k = 1;
while (k <= 3) {
cout << w;
k++;
}
cout << " ";
w++;
}
Pokaż odpowiedź
int w = 0, k = 0;
while (w < 3) {
while (k < 2) {
cout << "x";
k++;
}
cout << "|";
w++;
}
Pokaż odpowiedź
int w = 3;
while (w >= 1) {
int k = 0;
while (k < w) {
cout << "#";
k++;
}
cout << "\n";
w--;
}
Pokaż odpowiedź
ile++?int ile = 0, w = 1;
while (w <= 4) {
int k = w;
while (k <= 4) {
ile++;
k++;
}
w++;
}
cout << ile;
Pokaż odpowiedź
int w = 1;
while (w <= 3) {
int k = 1;
while (k <= 5) {
if (k > w) break;
cout << k;
k++;
}
cout << " ";
w++;
}
Pokaż odpowiedź
8 ćwiczeń do tej części
Kliknij zadanie — otworzy się w sprawdzarce w nowej karcie. Napisz program u siebie, sprawdź go na przykładzie, wklej cały kod i kliknij Wyślij. Utknąłeś? Każde zadanie ma wskazówkę.
Baza zadań: 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.
Rozgrzewka · zadania 1–8
Jedna pętla i jeden pomysł naraz — FizzBuzz, sumy, cyfry i ramka z gwiazdek.
Średnie · zadania 9–20
Symulacje, rekordy i serie, liczby pierwsze, system dwójkowy i szyfr Cezara.
Trudne · zadania 21–28
Rozkład na czynniki, NWW, Collatz, trójkąt Pascala — a na końcu wielki finał: dziennik pogody.