C++ · Etap 2 · Lekcja 14

Zaokrąglanie — w dół, w górę i do najbliższej

Ile autobusów trzeba zamówić dla 47 osób? Ile pełnych godzin to 200 minut? Ile to jest 4,567 zł „do grosza”? Każde z tych pytań to zaokrąglanie — tylko za każdym razem w inną stronę. W tej lekcji poznasz wszystkie sposoby zaokrąglania w C++: floor, ceil, round i ucinanie (int), zobaczysz, czym różnią się dla liczb ujemnych, nauczysz się dzielić w górę bez żadnych ułamków, zaokrąglać do dziesiątek, kwadransów i groszy, a na koniec poznasz pułapki liczb z przecinkiem — i sposoby, żeby w nie nie wpaść. Wszystko narysujemy na osi liczbowej, a po każdej części czekają ćwiczenia ze sprawdzarką.

64 ćwiczenia w trakcie lekcji28 zadań w bazie na koniec92 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ś wszystkie poprzednie: Typy zmiennych, Input / Output, If / Else, While loop, For loop, Modulo, Tablice, String, Pair, Vector, Sortowanie i Max / Min. Z zaokrąglaniem już się spotkałeś, choć może o tym nie wiesz: dzielenie dwóch liczb typu int ucina wynik (7 / 2 to 3), rzutowanie (int)2.9 daje 2, a fixed << setprecision(2) wypisuje liczbę z dwiema cyframi po kropce. W lekcji o if policzyłeś nawet autobusy na wycieczkę — to było zaokrąglanie w górę.

Teraz zbierzemy to wszystko w jedno miejsce i uporządkujemy. Zaokrąglanie wygląda na proste, ale to jeden z tematów, na których najczęściej traci się punkty w zadaniach: liczby ujemne zaokrąglają się „w drugą stronę”, wynik floor potrafi wypisać się jako 1.23457e+06, a (int)(0.29 * 100) daje… 28. Po tej lekcji będziesz dokładnie wiedzieć, dlaczego, i jak tego uniknąć.

Uczymy się tak samo jak poprzednio. Przepisuj przykłady do swojego edytora i uruchamiaj je. Przy pytaniach „Co wypisze program?” najpierw narysuj sobie na kartce kawałek osi liczbowej, zaznacz na niej liczbę i dopiero potem sprawdzaj odpowiedź. Po każdej części rób ćwiczenia w sprawdzarce i nie idź dalej, dopóki nie przestaną sprawiać Ci kłopotu — kolejne części budują na poprzednich.

CZĘŚĆ 01–03

W dół, w górę, do najbliższej

Oś liczbowa i sąsiedzi liczby, potem gotowe funkcje: floor, ceil i round.

CZĘŚĆ 04–05

Minusy i liczby całkowite

Ucinanie (int), wszystkie cztery sposoby dla liczb ujemnych i dzielenie w górę bez ułamków.

CZĘŚĆ 06–07

Do dziesiątek i do groszy

Wielokrotności, kwadranse i ceny, zaokrąglanie do miejsc po przecinku i wypisywanie z setprecision.

CZĘŚĆ 08

Pułapki liczb z przecinkiem

Dlaczego 0.1 + 0.2 to nie 0.3, grosze bez błędów, epsilon, wielkie liczby i pierwiastek całkowity.

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. Spacje na końcu wiersza są ignorowane. W tej lekcji uważaj szczególnie na dwie rzeczy: gdy zadanie każe wypisać liczbę całkowitą, wypisz ją bez kropki (czyli jako int albo long long — w części 2 zobaczysz, dlaczego to takie ważne), a gdy każe wypisać liczbę z k miejscami po przecinku — użyj fixed << setprecision(k).

Mapa lekcji

Co to znaczy zaokrąglić?

Zaokrąglić liczbę to zamienić ją na inną, „okrąglejszą” — najczęściej na liczbę całkowitą. Robisz to codziennie, nawet o tym nie myśląc. Cena 4,99 zł to „prawie 5 złotych”. Film trwający 2 godziny i 50 minut to „prawie 3 godziny”. Ale jeśli masz 12 lat i 10 miesięcy, mówisz „mam 12 lat”, a nie „mam 13”, chociaż do trzynastu jest bliżej.

Zauważ, że w pierwszych dwóch przykładach zaokrągliliśmy w górę, a w trzecim — w dół. Każde zaokrąglenie ma kierunek i właśnie o kierunkach jest ta lekcja. W tej części nie poznasz jeszcze żadnej nowej funkcji. Narysujemy liczby na osi, nazwiemy kierunki, a potem nauczymy się zaokrąglać tym, co już znasz: rzutowaniem (int) i instrukcją if.

Oś liczbowa

Narysuj poziomą linię i zaznacz na niej liczby całkowite w równych odstępach: …, −2, −1, 0, 1, 2, 3, … Na prawo liczby rosną, na lewo maleją. Liczby całkowite leżą dokładnie na kreskach, a każda liczba z przecinkiem leży pomiędzy dwiema sąsiednimi kreskami. Na przykład 2.7 leży między 2 a 3:

012345w dółw góręx = 2.7
2.7 leży między kreskami 2 i 3. Sąsiad z lewej to 2, sąsiad z prawej to 3.

Te dwie liczby całkowite — sąsiad z lewej i sąsiad z prawej — to najważniejsi bohaterowie tej lekcji. Każde zaokrąglenie do całości wybiera jednego z nich:

• zaokrąglenie w dół wybiera sąsiada z lewej, czyli mniejszego: dla 2.7 to 2,
• zaokrąglenie w górę wybiera sąsiada z prawej, czyli większego: dla 2.7 to 3,
• zaokrąglenie do najbliższej wybiera tego, który leży bliżej: od 2.7 do 3 jest tylko 0.3, a do 2 aż 0.7 — więc 3.

liczbasąsiedziw dółw górędo najbliższejdlaczego
2.32 i 3232do 2 jest 0.3, do 3 jest 0.7
2.72 i 3233do 3 jest 0.3, do 2 jest 0.7
0.40 i 1010do 0 jest 0.4, do 1 jest 0.6
9.999 i 1091010do 10 brakuje tylko 0.01
2.52 i 3233dokładnie pośrodku — umawiamy się: w górę
5—555leży na kresce, nie ma czego zaokrąglać

Zwróć uwagę na dwa ostatnie wiersze. Liczba 2.5 leży dokładnie w połowie między 2 a 3, więc obaj sąsiedzi są tak samo blisko. Trzeba się jakoś umówić — w szkole połówki zaokrągla się w górę i my też tak zrobimy (w części 3 zobaczysz, jak robi to C++). A liczba całkowita, taka jak 5, leży dokładnie na kresce: nie ma między czym wybierać, więc każde zaokrąglenie zostawia ją bez zmian. To ważny przypadek, o którym łatwo zapomnieć!

Część całkowita i część ułamkowa

Z lekcji o typach zmiennych pamiętasz, że rzutowanie (int)x wyrzuca wszystko, co stoi po kropce: (int)2.75 to 2. To, co zostało wyrzucone, łatwo odzyskać — wystarczy odjąć: 2.75 − 2 = 0.75. Te dwa kawałki mają swoje nazwy: 2 to część całkowita, a 0.75 to część ułamkowa.

czesci.cpp
double x;
cin >> x;
int calk = (int)x;          // część całkowita
double ulamek = x - calk;   // część ułamkowa
cout << calk << "\n";
cout << ulamek << "\n";
▶ Wejście 1
2.75
▶ Wyjście 1
2 0.75
▶ Wejście 2
13.5
▶ Wyjście 2
13 0.5
▶ Wejście 3
0.04
▶ Wyjście 3
0 0.04

Prześledź pierwsze uruchomienie: x = 2.75, (int)x ucina „.75” i zostaje 2, a x - calk to 2.75 − 2 = 0.75.

W trzecim uruchomieniu x = 0.04 — liczba mniejsza od jedynki. Jej część całkowita to 0, a cała liczba to część ułamkowa.

Dla liczby dodatniej część ułamkowa jest zawsze co najmniej 0 i mniejsza od 1. Część ułamkowa równa 0 oznacza, że liczba jest całkowita.

Ważne: tak liczymy tylko dla liczb dodatnich (i zera). Liczbami ujemnymi zajmiemy się na końcu tej części.

W dół i w górę — ręcznie

Dla liczby dodatniej zaokrąglenie w dół to dokładnie jej część całkowita, czyli (int)x. Sąsiad z prawej jest o jeden dalej, więc w górę to (int)x + 1… prawie. Pamiętasz liczbę 5 z tabelki? Ona leży na kresce i jej zaokrąglenie w górę to 5, a nie 6. Dlatego najpierw sprawdzamy, czy po kropce cokolwiek jest — czyli czy x jest większe od swojej części całkowitej.

w_gore_recznie.cpp
double x;
cin >> x;
int dol = (int)x;              // w dół (dla x >= 0)
int gora = dol;
if (x > dol) gora = dol + 1;   // coś zostało po kropce
cout << dol << " " << gora << "\n";
▶ Wejście 1
2.3
▶ Wyjście 1
2 3
▶ Wejście 2
5
▶ Wyjście 2
5 5
▶ Wejście 3
0.01
▶ Wyjście 3
0 1

Dla x = 2.3: dol = 2, a ponieważ 2.3 > 2, gora = 3.

Dla x = 5: dol = 5, ale 5 > 5 to fałsz, więc gora zostaje 5. Dokładnie tak, jak chcieliśmy.

Dla x = 0.01: nawet maleńka część ułamkowa wystarcza, żeby w górę wyszło 1. Zaokrąglenie w górę nie patrzy na to, ile jest po kropce — wystarczy, że cokolwiek jest.

Porównanie x > dol zestawia double z int — to w porządku, C++ zamieni dol na double na czas porównania.

Skąd znasz zaokrąglanie w górę W lekcji o if liczyłeś autobusy na wycieczkę: osoby / miejsca, a potem if (osoby % miejsca != 0) dodawałeś jeszcze jeden autobus. To był ten sam pomysł: najpierw w dół, a jeśli coś zostało — o jeden w górę. W części 5 poznasz krótszy zapis tego schematu.

Do najbliższej — ręcznie

Teraz trzecie zaokrąglenie: do najbliższej. Który sąsiad leży bliżej? Wystarczy spojrzeć na część ułamkową — to przecież odległość od sąsiada z lewej. Jeśli jest mniejsza niż 0.5, bliżej jest w lewo, a jeśli większa — w prawo. Zaznaczmy na osi połówki (różowe kreski): liczby na lewo od różowej kreski idą w dół, a na prawo — w górę.

012345x = 2.5
Różowe przerywane kreski to połówki: 0.5, 1.5, 2.5… Liczba 2.5 stoi dokładnie na takiej kresce — w połowie drogi między 2 a 3.
najblizsza_recznie.cpp
double x;
cin >> x;
int dol = (int)x;
double ulamek = x - dol;
int wynik;
if (ulamek < 0.5) wynik = dol;   // bliżej w lewo
else wynik = dol + 1;            // bliżej w prawo albo połowa
cout << wynik << "\n";
▶ Wejście 1
2.3
▶ Wyjście 1
2
▶ Wejście 2
2.5
▶ Wyjście 2
3
▶ Wejście 3
7
▶ Wyjście 3
7

Dla 2.3 część ułamkowa to 0.3 — mniej niż połowa, więc wynik to 2.

Dla 2.5 część ułamkowa to dokładnie 0.5. Warunek 0.5 < 0.5 jest fałszywy, więc idziemy do else i wychodzi 3 — połówka w górę, tak jak się umówiliśmy.

Dla 7 część ułamkowa to 0, więc wynik to 7. Liczba całkowita znowu zostaje sobą.

Sztuczka: dodaj połówkę i utnij

Jest też krótszy zapis tego samego: (int)(x + 0.5). Dodajemy do liczby połówkę i ucinamy. Jak to działa? Jeśli część ułamkowa była mniejsza niż 0.5, po dodaniu 0.5 dalej jest mniejsza niż 1 — liczba nie przeskakuje przez kreskę i (int) daje sąsiada z lewej. Jeśli była co najmniej 0.5, po dodaniu przekracza kreskę i (int) daje sąsiada z prawej.

plus_polowka.cpp
for (double x : {2.3, 2.5, 2.7, 0.49, 9.5}) {
    cout << x << " -> " << (int)(x + 0.5) << "\n";
}
▶ Wyjście
2.3 -> 2 2.5 -> 3 2.7 -> 3 0.49 -> 0 9.5 -> 10
xx + 0.5(int)(x + 0.5)
2.32.82
2.53.03
2.73.23
0.490.990
9.510.010

Fioletowe wyniki to te, w których dodana połówka „przepchnęła” liczbę przez kreskę — czyli zaokrąglenie w górę.

A liczby ujemne?

Liczby ujemne leżą na osi na lewo od zera. Liczba −1.4 leży między −2 a −1. Który sąsiad jest „w dół”? Ten z lewej, czyli mniejszy: −2. A „w górę” to −1. To bywa mylące, bo −2 wygląda na „więcej” (ma większą dwójkę), ale jest mniejsze — leży bardziej na lewo. Pomyśl o temperaturze: −2 °C to zimniej niż −1 °C.

−4−3−2−101w dółw górę(int)x = −1.4
−1.4 leży między −2 a −1. W dół (w lewo) to −2, w górę (w prawo) to −1. A (int) ucina część po kropce i daje −1 — czyli idzie w górę!

Spójrz na fioletowy łuk. (int)(-1.4) wyrzuca „.4” i zostaje −1. Dla liczby dodatniej ucinanie dawało zaokrąglenie w dół, a tu dało zaokrąglenie w górę! Wszystko się zgadza, kiedy pomyślisz o tym tak: (int) zawsze idzie w stronę zera. Dla liczb dodatnich zero leży po lewej, a dla ujemnych — po prawej.

ujemne.cpp
double x = -1.4;
cout << (int)x << "\n";           // -1: ucina, czyli w stronę zera
double y = -2.7;
cout << (int)(y + 0.5) << "\n";   // -2: a najbliższa to -3!
▶ Wyjście
-1 -2

Sztuczka z połówką też się psuje. Dla y = −2.7 najbliższa liczba całkowita to −3 (do niej jest 0.3, a do −2 jest 0.7). Tymczasem −2.7 + 0.5 = −2.2, a (int)(-2.2) to −2.

Wszystkie ręczne sposoby z tej części działają tylko dla liczb dodatnich. Dla ujemnych trzeba by dopisywać kolejne if-y. Właśnie dlatego C++ ma gotowe funkcje, które działają zawsze — poznasz je w następnej części.

Cztery kierunki zaokrąglania W dół — do sąsiada z lewej, czyli mniejszego. W górę — do sąsiada z prawej, czyli większego. Do najbliższej — do bliższego z sąsiadów (a gdy liczba jest dokładnie w połowie, trzeba się umówić). Ucięcie — wyrzucenie części po kropce, czyli zawsze w stronę zera: dla liczb dodatnich to to samo co w dół, a dla ujemnych — to samo co w górę. Liczba całkowita przy każdym zaokrągleniu zostaje sobą.
Sprawdź się w głowie

Najpierw odpowiedz w myślach — narysuj sobie na kartce kawałek osi liczbowej i zaznacz na niej liczbę — a dopiero potem kliknij „Pokaż odpowiedź”.

Co wypisze ten fragment?
cout << (int)7.9;
Pokaż odpowiedź
7Rzutowanie ucina wszystko po kropce, nawet gdy do ósemki brakuje tylko 0.1.
Co wypisze ten fragment?
double x = 3.25;
cout << x - (int)x;
Pokaż odpowiedź
0.25Część ułamkowa: 3.25 − 3 = 0.25.
Co wypisze ten fragment?
double x = 6;
int d = (int)x;
int g = d;
if (x > d) g = d + 1;
cout << d << " " << g;
Pokaż odpowiedź
6 66 leży na kresce. Warunek 6 > 6 jest fałszywy, więc w górę też zostaje 6.
Co wypisze ten fragment?
cout << (int)(4.5 + 0.5) << " " << (int)(4.49 + 0.5);
Pokaż odpowiedź
5 44.5 + 0.5 = 5.0, więc 5. Ale 4.49 + 0.5 = 4.99 — nie przekracza kreski, więc 4.
Co wypisze ten fragment?
cout << (int)(-3.8);
Pokaż odpowiedź
-3(int) ucina w stronę zera. Dla liczby ujemnej to w górę: −3, a nie −4.
Co wypisze ten fragment?
double x = 9.5;
int d = (int)x;
if (x - d < 0.5) cout << d;
else cout << d + 1;
Pokaż odpowiedź
10Część ułamkowa to dokładnie 0.5, a warunek 0.5 < 0.5 jest fałszywy — idziemy w górę, do 10.
Co wypisze ten fragment?
cout << (int)(-0.7);
Pokaż odpowiedź
0Po ucięciu „.7” zostaje zero. Liczba typu int nie ma znaku przy zerze, więc wypisuje się zwykłe 0.
Co wypisze ten fragment?
int a = 7, b = 2;
cout << a / b << " " << (double)a / b;
Pokaż odpowiedź
3 3.5Przypomnienie z lekcji o typach: dzielenie dwóch int-ów ucina wynik. Po zamianie a na double dostajemy pełne 3.5.
Co wypisze ten fragment?
double x = 2.999;
cout << (int)x << " " << (int)(x + 0.5);
Pokaż odpowiedź
2 3Ucięcie daje 2, a do najbliższej (2.999 + 0.5 = 3.499) — 3.
Ć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 →

floor i ceil — w dół i w górę

W części 1 zaokrąglaliśmy ręcznie, rzutowaniem (int) i if-ami — i działało to tylko dla liczb dodatnich. Teraz poznasz dwie gotowe funkcje, które działają zawsze, także dla liczb ujemnych: floor zaokrągla w dół, a ceil — w górę. Nazwy pochodzą z angielskiego: floor to podłoga, a ceiling to sufit. Wyobraź sobie, że liczba unosi się w pokoju: floor to podłoga pod nią, a ceil — sufit nad nią.

Obie funkcje mieszkają w bibliotece <cmath> (matematycznej). Nagłówek <bits/stdc++.h> ma ją w środku, więc niczego nie dopisujesz.

Pierwszy program

floor_ceil.cpp
#include <bits/stdc++.h>
using namespace std;

int main() {
    double x;
    cin >> x;
    cout << floor(x) << "\n";   // w dół
    cout << ceil(x) << "\n";    // w górę
    return 0;
}
▶ Wejście 1
2.7
▶ Wyjście 1
2 3
▶ Wejście 2
-2.7
▶ Wyjście 2
-3 -2
▶ Wejście 3
5
▶ Wyjście 3
5 5

Ten sam program uruchomiliśmy trzy razy.

Dla 2.7 wszystko wygląda jak w części 1: w dół to 2, w górę to 3.

Dla −2.7 w dół wychodzi −3, a w górę −2. To nie pomyłka — za chwilę obejrzymy to na osi.

Dla 5 obie funkcje dają 5. Liczba całkowita leży na kresce, więc podłoga i sufit są w tym samym miejscu.

012345floorceilx = 2.7
floor(2.7) = 2 — sąsiad z lewej, ceil(2.7) = 3 — sąsiad z prawej.
xfloor(x)ceil(x)uwagi
2.323zwykła liczba dodatnia
2.923floor nie patrzy, jak blisko jest trójka
2.0123ceil — wystarczy odrobina po kropce
0.501między 0 a 1
555liczba całkowita zostaje sobą
−1.2−2−1w dół to dalej od zera!
−2.7−3−2w dół to dalej od zera!
−5−5−5liczba całkowita zostaje sobą

Liczby ujemne — powoli

Narysujmy −2.7. Leży między −3 a −2, trochę bliżej −3. floor zawsze idzie w lewo, czyli w stronę mniejszych liczb — do −3. ceil zawsze idzie w prawo, w stronę większych — do −2.

−5−4−3−2−10floorceilx = −2.7
floor(−2.7) = −3, ceil(−2.7) = −2. Kierunki są te same co dla liczb dodatnich: floor w lewo, ceil w prawo.

Dla wielu osób to na początku dziwne, bo „−3 to więcej niż −2” — przecież trójka jest większa od dwójki. Ale na osi −3 leży na lewo od −2, więc jest mniejsze. Pomaga myślenie o temperaturze albo o piętrach w budynku: piętro −3 jest niżej niż piętro −2, a −3 °C to mocniejszy mróz niż −2 °C. „W dół” oznacza zawsze „niżej na osi”.

mroz.cpp
double t = -3.4;    // temperatura w nocy
cout << floor(t) << " " << ceil(t) << "\n";
double p = -0.5;    // pół metra pod ziemią
cout << floor(p) << " " << ceil(p) << "\n";
▶ Wyjście
-4 -3 -1 -0

−3.4 °C leży między −4 a −3: w dół to −4, w górę to −3.

A w drugim wierszu widzisz coś dziwnego: ceil(-0.5) wypisało się jako −0. Matematycznie to po prostu 0, ale komputer zapamiętał „zero, do którego doszliśmy od strony minusa”. Na ekranie wygląda to głupio, a w sprawdzarce oznacza błędną odpowiedź — przecież „-0” to inny napis niż „0”. Zaraz zobaczysz, jak się tego pozbyć.

floor i ceil oddają double

To bardzo ważne: wynik floor(2.7) to nie int 2, tylko double 2.0. Na ekranie wygląda tak samo, bo cout nie dopisuje „.0” do liczb bez części ułamkowej. Ale ma to trzy skutki, które potrafią zepsuć program.

Skutek 1 — dzielenie. Wynik floor dzieli się jak double, a nie jak int:

dzielenie_po_floor.cpp
cout << floor(10.7) / 4 << "\n";   // 10.0 / 4
int k = floor(10.7);               // zapisane do int: 10
cout << k / 4 << "\n";             // 10 / 4 na int-ach
▶ Wyjście
2.5 2

floor(10.7) to 10.0, a 10.0 / 4 = 2.5 — dzielenie z ułamkiem, bo jedna z liczb jest typu double.

Po zapisaniu do zmiennej int dostajemy zwykłe 10 i dzielenie całkowite daje 2.

Skutek 2 — duże liczby. Z lekcji o wejściu i wyjściu pamiętasz, że cout pokazuje liczby double z sześcioma cyframi, a większe przechodzą na zapis naukowy. Wynik floor to double, więc dotyczy go to samo: floor(1234567.8) wypisze się jako 1.23457e+06. W zadaniu taki wynik jest zawsze zły.

Skutek 3 — minus zero. Widziałeś go przed chwilą: ceil(-0.5) wypisuje się jako -0.

Lekarstwo na skutki 2 i 3 jest jedno: zamień wynik na liczbę całkowitą, zanim go wypiszesz. Najbezpieczniej na long long, bo zmieści nawet bardzo duże liczby:

na_long_long.cpp
double x = 1234567.8;
cout << floor(x) << "\n";              // 1.23457e+06 — źle
cout << (long long)floor(x) << "\n";   // 1234567 — dobrze
long long d = floor(x);                // też dobrze
cout << d << "\n";
cout << ceil(-0.5) << "\n";            // -0 — źle
cout << (long long)ceil(-0.5) << "\n"; // 0 — dobrze
▶ Wyjście
1.23457e+06 1234567 1234567 -0 0

Masz dwa zapisy do wyboru: rzutowanie (long long)floor(x) albo zapisanie wyniku do zmiennej long long d = floor(x);. Oba robią to samo.

Czy rzutowanie niczego nie popsuje? Nie: wynik floor i ceil nie ma już nic po kropce, więc rzutowanie nie ma czego uciąć — tylko zmienia typ. A liczba typu long long wypisuje się zawsze cała i bez minusa przy zerze.

Najpierw zaokrąglij, potem zamień na liczbę całkowitą Wynik floor i ceil (a także poznanego w następnej części round) to double. Gdy zadanie każe wypisać liczbę całkowitą, pisz (long long)floor(x) albo long long w = floor(x);. Wtedy nie zobaczysz ani 1.23457e+06, ani -0. Kolejność jest ważna: (long long)floor(x) to co innego niż floor((long long)x) — to drugie najpierw ucina, a dla liczb ujemnych ucinanie to nie to samo co w dół!

Pułapka: dzielenie liczb całkowitych przed ceil

Bardzo często zaokrąglamy wynik dzielenia. I tu czai się stara znajoma z lekcji o typach: dzielenie dwóch int-ów ucina wynik, zanim ceil cokolwiek zobaczy.

ceil_dzielenia.cpp
int a = 7, b = 2;
cout << ceil(a / b) << "\n";           // 3 — źle!
cout << ceil((double)a / b) << "\n";   // 4
cout << ceil(a / 2.0) << "\n";         // 4
▶ Wyjście
3 4 4

W pierwszym wierszu komputer najpierw liczy a / b — na dwóch int-ach, więc wychodzi 3, a nie 3.5. Funkcja ceil dostaje gotowe 3 i nie ma czego zaokrąglać.

W drugim wierszu (double)a zamienia a na 7.0, więc dzielenie daje 3.5 i ceil zaokrągla je do 4. W trzecim to samo robi liczba 2.0.

Rzutuj przed dzieleniem, nie po ceil(a / b), floor(a / b) i ceil((double)(a / b)) są złe — w każdym z nich dzielenie odbywa się na int-ach. Dobrze: ceil((double)a / b), czyli rzutowanie stoi przy samym a, przed kreską ułamkową.

floor i ceil w zadaniach

W treściach zadań rzadko pada słowo „floor” albo „ceil”. Zamiast tego pojawiają się pytania o pełne rzeczy (to zwykle floor) albo o to, ile czegoś potrzeba (to zwykle ceil). Oto dwa przykłady.

farba.cpp
// Ile puszek farby kupić na ścianę?
double sciana;    // powierzchnia w m²
int wydajnosc;    // ile m² maluje jedna puszka
cin >> sciana >> wydajnosc;
cout << (long long)ceil(sciana / wydajnosc) << "\n";
▶ Wejście 1
12.5 4
▶ Wyjście 1
4
▶ Wejście 2
12 4
▶ Wyjście 2
3
godziny.cpp
// Ile pełnych i ile rozpoczętych godzin?
int minuty;
cin >> minuty;
cout << (long long)floor(minuty / 60.0) << "\n";
cout << (long long)ceil(minuty / 60.0) << "\n";
▶ Wejście 1
200
▶ Wyjście 1
3 4
▶ Wejście 2
180
▶ Wyjście 2
3 3

Ściana ma 12.5 m², a puszka wystarcza na 4 m². 12.5 / 4 = 3.125 — trzy puszki to za mało (pomalują 12 m²), więc trzeba kupić czwartą. Dla ściany 12 m² wychodzi równo 3, a ceil(3.0) to 3 — nie kupujemy zbędnej puszki.

200 minut to 3.33… godziny: pełne godziny są trzy (floor), a rozpoczętych — cztery (ceil). Tak liczy się na przykład opłaty za parking: płacisz za każdą rozpoczętą godzinę.

Słownik: z treści zadania na kod „ile pełnych…”, „ile całych…”, „ile zmieści się…”, „najwyżej ile…” → zwykle floor · „ile potrzeba…”, „ile co najmniej…”, „ile rozpoczętych…”, „żeby wystarczyło dla wszystkich…” → zwykle ceil. Zanim napiszesz kod, sprawdź swój wybór na przykładzie, w którym dzielenie wychodzi równo (jak 12 m² i 4 m²) — tam oba zaokrąglenia muszą dać ten sam wynik.

Czy liczba jest całkowita?

Skoro liczba całkowita to jedyna, której floor nic nie zmienia, możemy w ten sposób sprawdzić, czy liczba jest całkowita: floor(x) == x. Działa to także dla liczb ujemnych — w przeciwieństwie do sposobów z części 1.

czy_calkowita.cpp
for (double x : {4.0, 4.5, -3.0, -3.2}) {
    if (floor(x) == x) cout << x << " jest calkowita\n";
    else cout << x << " nie jest calkowita\n";
}
▶ Wyjście
4 jest calkowita 4.5 nie jest calkowita -3 jest calkowita -3.2 nie jest calkowita

Zamiast floor(x) == x możesz też napisać floor(x) == ceil(x) — podłoga i sufit spotykają się tylko na kresce.

W części 8 zobaczysz, że porównywanie liczb double znakiem == bywa zdradliwe, gdy liczba jest wynikiem obliczeń. Ale gdy x wczytujesz prosto z wejścia, ten test działa bez zarzutu.

Ile liczb całkowitych leży w przedziale?

Ładne zastosowanie obu funkcji naraz. Ile liczb całkowitych leży między a = −1.5 a b = 2.3 (łącznie z końcami)? Pierwsza liczba całkowita, która jest ≥ a, to ceil(a) = −1. Ostatnia, która jest ≤ b, to floor(b) = 2. Liczby od −1 do 2 to −1, 0, 1, 2 — jest ich 2 − (−1) + 1 = 4.

−3−2−101234a = −1.5b = 2.3
Zielone kropki to liczby całkowite z przedziału: od ceil(a) = −1 do floor(b) = 2. Jest ich floor(b) − ceil(a) + 1 = 4.
ile_calkowitych.cpp
double a, b;      // zakładamy, że a <= b
cin >> a >> b;
long long ile = (long long)floor(b) - (long long)ceil(a) + 1;
cout << ile << "\n";
▶ Wejście 1
-1.5 2.3
▶ Wyjście 1
4
▶ Wejście 2
0.2 0.8
▶ Wyjście 2
0
▶ Wejście 3
3 7
▶ Wyjście 3
5

Przedział od 0.2 do 0.8 nie zawiera żadnej liczby całkowitej: ceil(0.2) = 1, floor(0.8) = 0, a 0 − 1 + 1 = 0. Wzór sam to obsłużył!

Gdy końce są całkowite (od 3 do 7), ceil i floor ich nie ruszają i wychodzi 7 − 3 + 1 = 5: liczby 3, 4, 5, 6, 7.

To „+ 1” znasz z liczenia liczb od a do b w lekcji o pętli for.

Sprawdź się w głowie

Najpierw odpowiedz w myślach — narysuj sobie na kartce kawałek osi liczbowej i zaznacz na niej liczbę — a dopiero potem kliknij „Pokaż odpowiedź”.

Co wypisze ten fragment?
cout << floor(3.9) << " " << ceil(3.1);
Pokaż odpowiedź
3 4floor zawsze w dół, ceil zawsze w górę — niezależnie od tego, jak blisko jest kreska.
Co wypisze ten fragment?
cout << floor(-3.9) << " " << ceil(-3.1);
Pokaż odpowiedź
-4 -3−3.9 leży między −4 a −3; w dół (w lewo) to −4. −3.1 też leży między −4 a −3; w górę (w prawo) to −3.
Co wypisze ten fragment?
cout << floor(8) << ceil(8);
Pokaż odpowiedź
88Liczba całkowita zostaje sobą. Wyniki stoją obok siebie, bo nie wypisaliśmy spacji.
Co wypisze ten fragment?
cout << ceil(9 / 4);
Pokaż odpowiedź
29 / 4 na int-ach to 2 — ceil dostaje gotowe 2 i nic nie zmienia.
Co wypisze ten fragment?
cout << ceil(9 / 4.0);
Pokaż odpowiedź
39 / 4.0 = 2.25, a w górę to 3.
Co wypisze ten fragment?
cout << floor(7.5) / 2;
Pokaż odpowiedź
3.5floor(7.5) to double 7.0, więc dzielenie przez 2 daje 3.5, a nie 3.
Co wypisze ten fragment?
cout << ceil(-0.2);
Pokaż odpowiedź
-0−0.2 leży między −1 a 0; w górę to 0 — ale „zero od strony minusa”, które wypisuje się jako -0.
Co wypisze ten fragment?
cout << (long long)ceil(-0.2);
Pokaż odpowiedź
0Po zamianie na long long zostaje zwykłe zero.
Co wypisze ten fragment?
cout << floor(2.5) + ceil(2.5);
Pokaż odpowiedź
52 + 3 = 5. Dla każdej liczby, która nie jest całkowita, ceil(x) = floor(x) + 1.
Ile liczb całkowitych leży w przedziale od −1.5 do 1.5? Co wypisze program?
double a = -1.5, b = 1.5;
cout << floor(b) - ceil(a) + 1;
Pokaż odpowiedź
3floor(1.5) = 1, ceil(−1.5) = −1, więc 1 − (−1) + 1 = 3: liczby −1, 0 i 1.
Ć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 →

round — do najbliższej całkowitej

floor i ceil zawsze idą w jedną, z góry ustaloną stronę. A co, jeśli chcesz zaokrąglić „normalnie”, jak w szkole — do najbliższej liczby całkowitej? Do tego służy trzecia funkcja z <cmath>: round (po angielsku round to właśnie „zaokrąglić”). W tej części zobaczysz, jak round radzi sobie z połówkami i liczbami ujemnymi, poznasz jej wygodną siostrę llround i nauczysz się zaokrąglać wynik dzielenia, na przykład średnią ocen.

Pierwszy program

round.cpp
double x;
cin >> x;
cout << round(x) << "\n";
▶ Wejście 1
2.3
▶ Wyjście 1
2
▶ Wejście 2
2.7
▶ Wyjście 2
3
▶ Wejście 3
2.5
▶ Wyjście 3
3

round wybiera tego z dwóch sąsiadów, który leży bliżej.

2.3 jest bliżej dwójki (0.3) niż trójki (0.7), więc wynik to 2.

2.7 jest bliżej trójki, więc 3.

2.5 leży dokładnie pośrodku — i round wybrał 3, tak jak w szkole.

012345roundx = 2.7
Różowe kreski to połówki. 2.7 leży na prawo od połówki 2.5, więc round idzie do 3. Liczba na lewo od połówki poszłaby do 2.

Połówki — w stronę dalszą od zera

Co robi round, gdy liczba leży dokładnie w połowie? Dla liczb dodatnich — idzie w górę: round(2.5) = 3. Dla ujemnych — symetrycznie, czyli w dół: round(-2.5) = −3. Najłatwiej zapamiętać to tak: połówki idą w stronę dalszą od zera. Możesz też myśleć, że round zaokrągla samą liczbę bez minusa (2.5 → 3), a minus dopisuje na końcu (−3).

polowki.cpp
for (double x : {0.5, 1.5, 2.5, -0.5, -1.5, -2.5}) {
    cout << x << " -> " << round(x) << "\n";
}
▶ Wyjście
0.5 -> 1 1.5 -> 2 2.5 -> 3 -0.5 -> -1 -1.5 -> -2 -2.5 -> -3
−5−4−3−2−10roundx = −2.5
round(−2.5) = −3: połówka idzie dalej od zera, czyli dla liczby ujemnej w lewo.
xround(x)dlaczego
2.42na lewo od połówki 2.5
2.53połówka — dalej od zera
2.63na prawo od połówki
−2.4−2bliżej −2 (o 0.4) niż −3 (o 0.6)
−2.5−3połówka — dalej od zera
−2.6−3bliżej −3
0.51połówka — dalej od zera
77liczba całkowita zostaje sobą

round też oddaje double — poznaj llround

Tak samo jak floor i ceil, round oddaje liczbę typu double. Grożą więc te same kłopoty: zapis naukowy dla dużych liczb i minus zero. Możesz je naprawić rzutowaniem (long long)round(x), ale jest wygodniej: funkcja llround zaokrągla do najbliższej dokładnie tak samo jak round, ale od razu oddaje long long (dwa „l” w nazwie to właśnie long long).

llround.cpp
double x = 1234567.5;
cout << round(x) << "\n";       // 1.23457e+06
cout << llround(x) << "\n";     // 1234568
cout << round(-0.3) << "\n";    // -0
cout << llround(-0.3) << "\n";  // 0
▶ Wyjście
1.23457e+06 1234568 -0 0

1234567.5 to połówka, więc idzie dalej od zera: 1234568. Z round widzimy zapis naukowy, z llround — całą liczbę.

−0.3 leży między −1 a 0, bliżej zera. round daje „zero z minusem”, a llround — zwykłe 0.

Jest też lround (z jednym „l”), które oddaje typ long. Na komputerach z Windowsem long mieści tyle samo co int, więc bezpieczniej trzymać się llround.

Do najbliższej całkowitej: llround Gdy chcesz zaokrąglić do najbliższej liczby całkowitej i dostać liczbę całkowitą — pisz llround(x). Działa dla liczb dodatnich i ujemnych, połówki zaokrągla w stronę dalszą od zera, a wynik wypisuje się bez kropki i bez minusa przy zerze.

Dlaczego nie (int)(x + 0.5)?

W części 1 poznałeś sztuczkę „dodaj połówkę i utnij”. Zobaczmy, jak wypada w porównaniu z llround:

porownanie.cpp
for (double x : {2.7, 2.5, -2.2, -2.5, -2.7}) {
    cout << x << ": " << (int)(x + 0.5) << " " << llround(x) << "\n";
}
▶ Wyjście
2.7: 3 3 2.5: 3 3 -2.2: -1 -2 -2.5: -2 -3 -2.7: -2 -3

Dla liczb dodatnich oba sposoby się zgadzają. Dla ujemnych sztuczka się sypie, bo (int) ucina w stronę zera, a nie w dół.

Weź −2.2: najbliższa całkowita to −2. Tymczasem −2.2 + 0.5 = −1.7, a (int)(-1.7) to −1 — zupełnie źle.

Wniosek: sztuczkę z połówką rozumiej (pomoże Ci zrozumieć inne wzory), ale do zaokrąglania używaj llround.

Zaokrąglanie wyniku dzielenia

Najczęściej zaokrąglamy wynik dzielenia — średnią ocen, wynik na osobę, procent. Pułapka jest ta sama co przy ceil: jeśli dzielisz dwa int-y, ułamek ginie, zanim round go zobaczy.

srednia_zle.cpp
int suma = 23, n = 5;     // oceny 5, 4, 5, 4, 5
cout << round(suma / n) << "\n";           // 4 — źle
cout << round((double)suma / n) << "\n";   // 5 — dobrze
▶ Wyjście
4 5

Średnia to 23 / 5 = 4.6, czyli po zaokrągleniu 5. Ale suma / n liczone na int-ach daje 4 — i round(4) to 4.

Poprawka jest taka sama jak przy ceil: (double) przy liczniku, przed dzieleniem.

A teraz pełny program: wczytujemy oceny, wypisujemy średnią z dwoma miejscami po przecinku i ocenę końcową. Uważaj na jedną rzecz — fixed i setprecision działają na każdą liczbę double, także na wynik round:

ocena_koncowa.cpp
int n;
cin >> n;
int suma = 0;
for (int i = 0; i < n; i++) {
    int ocena;
    cin >> ocena;
    suma += ocena;
}
double srednia = (double)suma / n;
cout << fixed << setprecision(2) << srednia << "\n";
cout << round(srednia) << "\n";     // to też double!
cout << llround(srednia) << "\n";   // a to long long
▶ Wejście
4 5 4 4 5
▶ Wyjście
4.50 5.00 5

Średnia to 18 / 4 = 4.5 — połówka, więc ocena końcowa to 5.

Drugi wiersz to round(srednia): wynik to double, a po fixed << setprecision(2) każda liczba double dostaje dwie cyfry po kropce — stąd „5.00”.

Trzeci wiersz to llround(srednia): liczba typu long long, na którą fixed nie działa — wypisuje się jako „5”. Kolejny powód, żeby lubić llround.

Jak daleko do najbliższej całkowitej?

Czasem pytanie brzmi nie „ile wynosi zaokrąglenie?”, ale „o ile się pomylimy, zaokrąglając?”. To odległość między liczbą a jej zaokrągleniem: abs(x - round(x)). Funkcję abs (wartość bez minusa) znasz z poprzednich lekcji — działa też dla liczb double.

odleglosc.cpp
for (double x : {3.8, 7.25, -1.9}) {
    cout << x << ": najblizsza " << llround(x);
    cout << ", odleglosc " << abs(x - round(x)) << "\n";
}
▶ Wyjście
3.8: najblizsza 4, odleglosc 0.2 7.25: najblizsza 7, odleglosc 0.25 -1.9: najblizsza -2, odleglosc 0.1

3.8 − 4 = −0.2, a bez minusa 0.2.

−1.9 − (−2) = 0.1. Odległość jest zawsze między 0 a 0.5 — dalej niż o połowę do najbliższej liczby całkowitej być nie może.

Ta odległość przyda się, gdy trzeba znaleźć liczbę „najbliższą całości” albo sprawdzić, czy wynik pomiaru jest „prawie całkowity”.

Sprawdź się w głowie

Najpierw odpowiedz w myślach — narysuj sobie na kartce kawałek osi liczbowej i zaznacz na niej liczbę — a dopiero potem kliknij „Pokaż odpowiedź”.

Co wypisze ten fragment?
cout << round(4.49) << " " << round(4.5);
Pokaż odpowiedź
4 54.49 leży tuż przed połówką, więc w dół. 4.5 to połówka — w górę.
Co wypisze ten fragment?
cout << round(-4.5);
Pokaż odpowiedź
-5Połówka idzie w stronę dalszą od zera: dla liczby ujemnej to w dół, do −5.
Co wypisze ten fragment?
cout << round(-4.49);
Pokaż odpowiedź
-4Do −4 jest 0.49, do −5 jest 0.51 — bliżej jest −4.
Co wypisze ten fragment?
cout << llround(0.5) << llround(1.5) << llround(2.5);
Pokaż odpowiedź
123Każda połówka idzie w górę (dalej od zera): 1, 2 i 3 — wypisane bez spacji.
Co wypisze ten fragment?
cout << (int)(-1.6 + 0.5) << " " << llround(-1.6);
Pokaż odpowiedź
-1 -2−1.6 + 0.5 = −1.1, a ucięcie daje −1. Tymczasem najbliższa całkowita to −2.
Co wypisze ten fragment?
cout << round(7 / 2) << " " << round(7 / 2.0);
Pokaż odpowiedź
3 47 / 2 na int-ach to 3. A 7 / 2.0 = 3.5 — połówka, więc 4.
Co wypisze ten fragment?
cout << fixed << setprecision(1) << round(2.45);
Pokaż odpowiedź
2.0round(2.45) = 2 (bliżej dwójki), ale to double, więc po fixed i setprecision(1) wypisuje się jako 2.0.
Co wypisze ten fragment?
cout << abs(3.8 - round(3.8));
Pokaż odpowiedź
0.2round(3.8) = 4, a odległość 3.8 od 4 to 0.2.
Co wypisze ten fragment?
cout << llround(-0.4) << " " << round(-0.4);
Pokaż odpowiedź
0 -0Najbliższa całkowita to 0. llround daje zwykłe zero, round — zero z minusem.
Ć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 →

Ucinanie (int) i trunc — i dzielenie liczb ujemnych

Znasz już floor, ceil i round. Czwarty sposób zaokrąglania znasz od pierwszej lekcji — to ucinanie, czyli rzutowanie (int). W tej części poznasz jego bliźniaka trunc, ustawimy wszystkie cztery sposoby obok siebie i zajmiemy się miejscem, w którym najczęściej się mylą: liczbami ujemnymi. Na koniec zobaczysz, że to samo ucinanie siedzi w zwykłym dzieleniu liczb całkowitych — i co z tego wynika dla liczb z minusem.

(int) i trunc — zawsze w stronę zera

(int)x wyrzuca wszystko, co stoi po kropce. Funkcja trunc(x) robi dokładnie to samo (od angielskiego truncate — uciąć), tylko — jak wszystkie funkcje z <cmath> — oddaje double. Obie idą zawsze w stronę zera: dla liczb dodatnich to w dół, a dla ujemnych — w górę.

trunc.cpp
for (double x : {2.7, -2.7, 0.9, -0.9}) {
    cout << x << ": " << (int)x << " " << trunc(x) << "\n";
}
▶ Wyjście
2.7: 2 2 -2.7: -2 -2 0.9: 0 0 -0.9: 0 -0

(int)x i trunc(x) dają te same liczby. Różnica jest tylko w typie — i znowu widać ją w ostatnim wierszu: trunc(-0.9) to double, więc wypisuje się jako „-0”, a (int)(-0.9) to zwykłe 0.

W praktyce trunc przydaje się rzadko — zwykle wystarcza rzutowanie.

przypisanie.cpp
int a = 2.9;     // przypisanie do int też ucina
int b = -2.9;
cout << a << " " << b << "\n";
▶ Wyjście
2 -2

Ucinanie zdarza się też „po cichu”: gdy liczbę double zapisujesz do zmiennej typu int, C++ sam wykonuje (int). Nie ma żadnego zaokrąglania — 2.9 staje się 2.

To częsta przyczyna błędów: ktoś liczy średnią w double, zapisuje ją do int-a i dziwi się, że 4.9 zamieniło się w 4.

Cztery sposoby obok siebie

Czas zebrać wszystko razem. Poniżej jest zaokrąglarka: wpisz dowolną liczbę albo przesuń suwak i obserwuj, dokąd prowadzą cztery łuki. Szczególnie przyjrzyj się liczbom ujemnym i połówkom — kliknij przyciski −2.3, −2.5 i −2.7.

Zaokrąglarka — wpisz dowolną liczbę
Zaokrąglarka działa po włączeniu JavaScriptu.
cztery.cpp
for (double x : {2.3, 2.5, 2.7, -2.3, -2.5, -2.7}) {
    cout << x << ": " << floor(x) << " " << ceil(x) << " "
         << round(x) << " " << (int)x << "\n";
}
▶ Wyjście
2.3: 2 3 2 2 2.5: 2 3 3 2 2.7: 2 3 3 2 -2.3: -3 -2 -2 -2 -2.5: -3 -2 -3 -2 -2.7: -3 -2 -3 -2
xfloorceilround(int)
2.32322
2.52332
2.72332
−2.3−3−2−2−2
−2.5−3−2−3−2
−2.7−3−2−3−2

Porównaj kolumny floor i (int). Dla liczb dodatnich są identyczne, dla ujemnych — (int) pokrywa się z ceil.

Kiedy (int) to to samo co floor? Tylko dla liczb nieujemnych (x ≥ 0). Dla liczb ujemnych, które nie są całkowite, (int)x to ceil(x), czyli o jeden więcej niż floor(x). Jeśli w danych mogą pojawić się liczby ujemne, a zadanie mówi „w dół” — używaj floor, nie (int).

Dzielenie liczb całkowitych też ucina

Z lekcji o typach pamiętasz, że 7 / 2 to 3. Teraz możesz to nazwać dokładniej: dzielenie dwóch liczb całkowitych w C++ liczy prawdziwy iloraz (3.5) i ucina go — w stronę zera. Dla liczb dodatnich ucinanie to to samo co w dół, więc nic złego się nie dzieje. Ale dla ujemnych…

dzielenie_ujemne.cpp
cout << 7 / 2 << " " << -7 / 2 << "\n";   // ucina
cout << 7 % 2 << " " << -7 % 2 << "\n";   // reszta ma znak dzielnej
cout << floor(-7 / 2.0) << "\n";          // prawdziwe „w dół”
▶ Wyjście
3 -3 1 -1 -4

−7 / 2 = −3.5. Ucięcie daje −3, a zaokrąglenie w dół dałoby −4.

Reszta też jest „ucięta”: −7 % 2 to −1, bo −7 = (−3) · 2 + (−1). Spotkałeś to już w lekcji o modulo — tam naprawialiśmy ujemną resztę wzorem ((a % b) + b) % b.

Dzielenie w dół dla liczb ujemnych

Kiedy to ma znaczenie? Na przykład w kalendarzu. Ponumerujmy dni: dzisiaj (poniedziałek) to dzień 0, jutro to dzień 1, a wczoraj — dzień −1. Tydzień 0 to dni od 0 do 6, tydzień 1 to dni od 7 do 13, a tydzień −1 to dni od −7 do −1. W którym tygodniu jest dzień d? To d / 7 zaokrąglone w dół. Wczoraj (d = −1) był w tygodniu −1 — ale -1 / 7 w C++ to 0!

Jak to naprawić bez liczb z przecinkiem? Zauważ, że ucinanie i „w dół” różnią się tylko wtedy, gdy liczba jest ujemna i dzielenie nie wychodzi równo. A to jest dokładnie ta sytuacja, w której reszta d % 7 wychodzi ujemna. Wystarczy więc jeden if:

tygodnie.cpp
for (int d : {-8, -7, -1, 0, 6, 7}) {
    int tydzien = d / 7;
    if (d % 7 < 0) tydzien--;       // poprawka dla ujemnych
    int dzien = d - tydzien * 7;    // zawsze od 0 do 6
    cout << d << ": " << d / 7 << " " << tydzien << " " << dzien << "\n";
}
▶ Wyjście
-8: -1 -2 6 -7: -1 -1 0 -1: 0 -1 6 0: 0 0 0 6: 0 0 6 7: 1 1 0

Każdy wiersz to: numer dnia, zwykłe d / 7, poprawiony tydzień i dzień tygodnia (0 = poniedziałek).

Dla d = −1: -1 / 7 = 0, ale reszta −1 jest ujemna, więc odejmujemy jeden — tydzień −1. Dzień tygodnia: −1 − (−1) · 7 = 6, czyli niedziela. Zgadza się — wczoraj była niedziela!

Dla d = −7 reszta wynosi 0 (dzielenie wychodzi równo), więc poprawki nie ma: tydzień −1, poniedziałek.

Ten sposób zakłada, że dzielimy przez liczbę dodatnią — w zadaniach prawie zawsze tak jest.

Dwa sposoby na dzielenie w dół Dla liczb, które mieszczą się w int, możesz napisać po prostu floor((double)a / b) — to też działa. Sposób z if (a % b < 0) q--; jest jednak lepszy, bo liczy wyłącznie na liczbach całkowitych, więc działa także dla ogromnych liczb long long, przy których double traci dokładność (zobaczysz to w części 5).

Kratki na kartce w kratkę

Drugi przykład, gdzie różnica między floor i (int) ma znaczenie: plansza podzielona na kwadratowe kratki o boku 1. Kratka numer (i, j) to kwadrat, w którym i ≤ x < i + 1 oraz j ≤ y < j + 1. W której kratce leży punkt (x, y)? To (floor(x), floor(y)). Rzutowanie (int) zepsułoby wszystko na lewo i poniżej osi — punkty (−0.5, 2.3) i (0.5, 2.3) wylądowałyby w tej samej kratce, choć leżą po dwóch stronach osi.

kratka.cpp
double x, y;
cin >> x >> y;
cout << (long long)floor(x) << " " << (long long)floor(y) << "\n";
cout << (int)x << " " << (int)y << "\n";   // dla porównania — źle
▶ Wejście 1
-0.5 2.3
▶ Wyjście 1
-1 2 0 2
▶ Wejście 2
3.7 -1.2
▶ Wyjście 2
3 -2 3 -1

Punkt (−0.5, 2.3) leży w kratce, która zaczyna się w x = −1, więc jej numer to (−1, 2). (int) twierdzi, że to kratka (0, 2) — ta sama, w której leży punkt (0.5, 2.3).

Z kratkami spotkasz się w zadaniach o mapach, planszach i grach — zawsze, gdy współrzędne mogą być ujemne, sięgaj po floor.

W stronę zera i od zera

Skoro ucinanie zaokrągla w stronę zera, to można też zaokrąglać od zera: dla liczb dodatnich w górę, a dla ujemnych w dół. Takiej funkcji w C++ nie ma, ale łatwo ją złożyć z ceil i floor — i z operatora ?: z lekcji o if.

od_zera.cpp
double x = -2.3;
long long doZera = trunc(x);                       // -2
long long odZera = (x >= 0 ? ceil(x) : floor(x));  // -3
cout << doZera << " " << odZera << "\n";
▶ Wyjście
-2 -3

Ciekawostka: round zaokrągla połówki właśnie „od zera” — dlatego round(-2.5) to −3.

Za duże liczby dla (int) (int) mieści tylko liczby do około 2.1 miliarda. Rzutowanie większej liczby double, np. (int)3e9, nie daje żadnego sensownego wyniku — to błąd, który program może „zgłosić” dowolną bzdurą. Gdy liczby mogą być duże, rzutuj na (long long).
Sprawdź się w głowie

Najpierw odpowiedz w myślach — narysuj sobie na kartce kawałek osi liczbowej i zaznacz na niej liczbę — a dopiero potem kliknij „Pokaż odpowiedź”.

Co wypisze ten fragment?
cout << (int)5.99 << " " << trunc(5.99);
Pokaż odpowiedź
5 5Oba sposoby ucinają część po kropce.
Co wypisze ten fragment?
cout << (int)(-5.99);
Pokaż odpowiedź
-5Ucinanie idzie w stronę zera — dla liczby ujemnej to w górę.
Co wypisze ten fragment?
cout << floor(-5.99) << " " << (int)(-5.99);
Pokaż odpowiedź
-6 -5floor w dół (do −6), (int) w stronę zera (do −5).
Co wypisze ten fragment?
cout << -9 / 4 << " " << -9 % 4;
Pokaż odpowiedź
-2 -1−9 / 4 = −2.25, ucięte do −2. Reszta: −9 − (−2) · 4 = −1.
Co wypisze ten fragment?
cout << floor(-9 / 4.0);
Pokaż odpowiedź
-3−2.25 zaokrąglone w dół to −3.
Co wypisze ten fragment?
int a = -9, b = 4;
int q = a / b;
if (a % b < 0) q--;
cout << q;
Pokaż odpowiedź
-3a / b = −2, reszta −1 jest ujemna, więc poprawka: −3 — tak samo jak floor.
Co wypisze ten fragment?
int k = 7.99;
cout << k;
Pokaż odpowiedź
7Zapisanie double do int ucina — bez żadnego zaokrąglania.
Co wypisze ten fragment?
cout << trunc(-0.3);
Pokaż odpowiedź
-0trunc oddaje double, a ucięcie −0.3 daje zero od strony minusa.
Co wypisze ten fragment?
cout << -1 / 7 << " " << floor(-1 / 7.0);
Pokaż odpowiedź
0 -1Ucięcie −0.14… daje 0, a zaokrąglenie w dół — −1.
Ć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 →

Dzielenie z zaokrągleniem — bez żadnych ułamków

Najczęstsze zaokrąglanie w zadaniach to wcale nie zaokrąglanie liczb z przecinkiem. To dzielenie dwóch liczb całkowitych z zaokrągleniem w górę: ile autobusów, ile pudełek, ile stron, ile tygodni, ile kursów windą. Znasz już dwa sposoby: z lekcji o if (dzielenie i sprawdzenie reszty) i z części 2 (ceil((double)a / b)). W tej części poznasz trzeci — krótki wzór, który liczy wyłącznie na liczbach całkowitych. Zrozumiesz, dlaczego działa, i zobaczysz, dlaczego jest lepszy od ceil.

Przypomnienie: autobusy z lekcji o if

autobusy_if.cpp
int osoby = 50, miejsca = 12;
int autobusy = osoby / miejsca;          // 4 pełne autobusy
if (osoby % miejsca != 0) autobusy++;    // ktoś się nie zmieścił
cout << autobusy << "\n";
▶ Wyjście
5

50 / 12 = 4 pełne autobusy, które zabiorą 48 osób. Reszta 50 % 12 = 2 osoby — nie można ich zostawić, więc dochodzi piąty autobus.

Pomysł jest zawsze ten sam: dzielenie całkowite to zaokrąglenie w dół, a jeśli reszta nie jest zerem, dokładamy jeden.

Pobaw się suwakami. Każde kółko to jedno miejsce w autobusie: niebieskie są zajęte. Zielone autobusy są pełne, pomarańczowy — niepełny. Sprawdź, co się dzieje, gdy liczba osób jest wielokrotnością liczby miejsc (na przykład 20 osób i 5 miejsc).

Ile autobusów? — przesuwaj suwaki
Animacja działa po włączeniu JavaScriptu.

Wzór (n + k − 1) / k

Zaokrąglenie w górę przy dzieleniu n przez k (oba dodatnie) można zapisać jednym wzorem: (n + k - 1) / k. Zobacz, jak działa dla k = 5 i kolejnych n:

wzor.cpp
int k = 5;
for (int n = 20; n <= 26; n++) {
    cout << n << ": " << n / k << " " << (n + k - 1) / k << "\n";
}
▶ Wyjście
20: 4 4 21: 4 5 22: 4 5 23: 4 5 24: 4 5 25: 5 5 26: 5 6
nn + 4(n + 4) / 5
20244
21255
24285
25295
26306

Dlaczego to działa? Pomyśl o wielokrotnościach piątki: 20, 25, 30… Dzielenie całkowite przez 5 mówi, ile pełnych piątek mieści się w liczbie. Dodanie 4 (czyli k − 1) przesuwa liczbę do przodu tak, że:

• jeśli n było dokładnie wielokrotnością (20, 25), to n + 4 nie dochodzi do następnej wielokrotności (24, 29) — wynik się nie zmienia,
• jeśli n było choć trochę za wielokrotnością (21, 26), to n + 4 przekracza następną (25, 30) — wynik rośnie o jeden.

Czyli dokładnie to, co robił if z resztą! Gdybyś dodał całe k (czyli 5), dla n = 20 wyszłoby 25 / 5 = 5 — o jeden za dużo. Dlatego dodajemy k − 1: tyle, ile wynosi największa możliwa reszta.

bool_jako_liczba.cpp
int n = 23, k = 5;
cout << n / k + (n % k != 0) << "\n";   // 4 + 1
n = 25;
cout << n / k + (n % k != 0) << "\n";   // 5 + 0
▶ Wyjście
5 5

Drugi zapis tego samego, bez if: n / k + (n % k != 0). Porównanie n % k != 0 to bool, a z lekcji o typach pamiętasz, że true liczy się jak 1, a false jak 0. Dodajemy więc jedynkę dokładnie wtedy, gdy reszta nie jest zerem.

Oba wzory są dobre — wybierz ten, który lepiej rozumiesz.

Dzielenie w górę na liczbach całkowitych Dla n ≥ 0 i k > 0: (n + k - 1) / k albo n / k + (n % k != 0). Dzielenie w dół to po prostu n / k. Uwaga na zakres: jeśli n i k mogą sięgać miliarda, to n + k - 1 nie mieści się już w int — użyj long long.

Dlaczego nie ceil((double)n / k)?

Dla małych liczb ceil((double)n / k) działa dobrze. Kłopot zaczyna się przy liczbach naprawdę dużych. Typ double pamięta tylko około 15–16 cyfr — resztę gubi. A long long mieści liczby z 18 cyframi i pamięta każdą z nich dokładnie.

wielkie.cpp
long long n = 999999999999999999LL;   // 18 dziewiątek
long long k = 1;
cout << (long long)ceil((double)n / k) << "\n";   // źle
cout << (n + k - 1) / k << "\n";                  // dobrze
k = 3;
cout << (long long)ceil((double)n / k) << "\n";   // źle
cout << (n + k - 1) / k << "\n";                  // dobrze
▶ Wyjście
1000000000000000000 999999999999999999 333333333333333312 333333333333333333

Dzielenie przez 1 nie powinno niczego zmieniać, a jednak wersja z double zamieniła 18 dziewiątek w jedynkę z 18 zerami. Stało się to już przy (double)n: najbliższa liczba, jaką double potrafi zapamiętać, to właśnie 10¹⁸.

Przy dzieleniu przez 3 jest jeszcze gorzej — ostatnie cyfry wyniku są zupełnie przypadkowe.

Wzór na liczbach całkowitych daje dokładny wynik zawsze. Zapamiętaj: gdy dzielisz liczby całkowite, zostań przy liczbach całkowitych.

Do najbliższej — też bez ułamków

A jak zaokrąglić iloraz n / k do najbliższej liczby całkowitej, z połówkami w górę? Przypomnij sobie sztuczkę z części 1: dodaj połówkę i utnij. Tu dodajemy połówkę do ilorazu: n / k + 1/2. Sprowadzamy do wspólnego mianownika: (2n + k) / (2k). I to już da się policzyć na liczbach całkowitych: (2 * n + k) / (2 * k).

najblizsza_int.cpp
int k = 4;
for (int n : {5, 6, 7}) {
    cout << n << " / " << k << " = " << (double)n / k
         << " -> " << (2 * n + k) / (2 * k) << "\n";
}
▶ Wyjście
5 / 4 = 1.25 -> 1 6 / 4 = 1.5 -> 2 7 / 4 = 1.75 -> 2
procent.cpp
int zdali = 17, wszyscy = 23;
cout << 100 * zdali / wszyscy << "%\n";                    // w dół
cout << (200 * zdali + wszyscy) / (2 * wszyscy) << "%\n";  // do najbliższej
▶ Wyjście
73% 74%

W lewym przykładzie 6 / 4 = 1.5 to połówka — wzór zaokrąglił ją w górę, do 2.

W prawym liczymy, jaki procent uczniów zdał egzamin: 17 z 23 to 73.9…%. Procent w dół to 100 * zdali / wszyscy — mnożymy przed dzieleniem, bo zdali / wszyscy na int-ach dałoby 0. Procent do najbliższej to nasz wzór z n = 100 · zdali i k = wszyscy: (2 · 100 · zdali + wszyscy) / (2 · wszyscy).

Dla liczb całkowitych ten sam wynik daje też krótszy zapis (n + k / 2) / k — dodajemy połowę dzielnika i dzielimy. Wrócimy do niego w następnej części.

Uwaga na liczby ujemne

ujemne_wzor.cpp
int n = -9, k = 3;
cout << (n + k - 1) / k << "\n";   // -2 — źle!
cout << n / k << "\n";             // -3 — dobrze
▶ Wyjście
-2 -3

Wszystkie wzory z tej części zakładają, że n ≥ 0 i k > 0. Dla ujemnego n wzór się psuje: −9 / 3 to równo −3, a wzór daje −2.

Dlaczego? Dla liczb ujemnych zwykłe dzielenie n / k ucina w stronę zera, czyli w górę — samo z siebie robi to, co dla dodatnich robił wzór. Gdy w zadaniu mogą pojawić się liczby ujemne, wróć do sposobu z części 4: dzielenie, a potem poprawka zależna od znaku reszty.

Przykłady z życia

Dzielenie z zaokrągleniem pojawia się w zadaniach w wielu przebraniach. Zwykle oprócz samej liczby (ile autobusów) pytają też o resztę: ile miejsc zostało wolnych, ile osób jedzie ostatnim autobusem, ile osób dostaje więcej.

jajka.cpp
int jajka;
cin >> jajka;
int pelne = jajka / 10;               // pełne wytłaczanki
int potrzebne = (jajka + 9) / 10;     // wszystkie wytłaczanki
int wolne = potrzebne * 10 - jajka;   // puste miejsca w ostatniej
cout << pelne << " " << potrzebne << " " << wolne << "\n";
▶ Wejście 1
47
▶ Wyjście 1
4 5 3
▶ Wejście 2
50
▶ Wyjście 2
5 5 0
cukierki.cpp
int c, n;                      // cukierki i dzieci
cin >> c >> n;
int malo = c / n;              // tyle dostaje każde dziecko
int duzo = (c + n - 1) / n;    // najwięcej u jednego dziecka
int ileDuzo = c % n;           // ile dzieci dostaje więcej
cout << ileDuzo << " dzieci dostaje " << duzo << ", a "
     << n - ileDuzo << " dostaje " << malo << "\n";
▶ Wejście
17 5
▶ Wyjście
2 dzieci dostaje 4, a 3 dostaje 3

47 jajek: 4 pełne wytłaczanki po 10 sztuk, a do wszystkich potrzeba 5. Piąta zawiera 7 jajek, więc 3 miejsca zostają puste. Dla 50 jajek wszystkie wytłaczanki są pełne.

17 cukierków dla 5 dzieci: każde dostaje co najmniej 17 / 5 = 3, a zostają 17 % 5 = 2 cukierki — dwoje dzieci dostanie po jednym więcej, czyli po 4. Podział „po równo, jak się da” to zawsze para: w dół dla wszystkich i w górę dla tylu osób, ile wynosi reszta.

Sprawdź się w głowie

Najpierw odpowiedz w myślach — narysuj sobie na kartce kawałek osi liczbowej i zaznacz na niej liczbę — a dopiero potem kliknij „Pokaż odpowiedź”.

Co wypisze ten fragment?
cout << (17 + 4) / 5;
Pokaż odpowiedź
417 / 5 = 3.4, w górę to 4. Wzór: 21 / 5 = 4.
Co wypisze ten fragment?
cout << (20 + 4) / 5;
Pokaż odpowiedź
420 dzieli się przez 5 równo, więc w górę to dalej 4. Wzór: 24 / 5 = 4.
Co wypisze ten fragment?
cout << (21 + 4) / 5;
Pokaż odpowiedź
5Jedna osoba ponad 20 wymaga piątego „autobusu”: 25 / 5 = 5.
Co wypisze ten fragment?
int n = 9, k = 3;
cout << n / k + (n % k != 0);
Pokaż odpowiedź
3Reszta 0, więc porównanie daje false, czyli 0: 3 + 0 = 3.
Co wypisze ten fragment?
int n = 10, k = 3;
cout << n / k + (n % k != 0);
Pokaż odpowiedź
4Reszta 1, więc dodajemy true, czyli 1: 3 + 1 = 4.
Co wypisze ten fragment?
cout << (2 * 7 + 4) / (2 * 4);
Pokaż odpowiedź
2To 7 / 4 = 1.75 zaokrąglone do najbliższej: 18 / 8 = 2.
Co wypisze ten fragment?
cout << (2 * 5 + 4) / (2 * 4);
Pokaż odpowiedź
15 / 4 = 1.25, do najbliższej to 1: 14 / 8 = 1.
Co wypisze ten fragment?
int c = 23, n = 4;
cout << c / n << " " << c % n;
Pokaż odpowiedź
5 3Każde z 4 dzieci dostaje po 5 cukierków, a 3 zostają — troje dzieci dostanie po 6.
Ile wytłaczanek trzeba na 0 jajek? Co wypisze fragment?
cout << (0 + 9) / 10;
Pokaż odpowiedź
09 / 10 = 0. Wzór dobrze obsługuje zero — nie zamawiamy pustej wytłaczanki.
Ć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 →

Do dziesiątek, setek i dowolnych wielokrotności

Zaokrąglać można nie tylko do całości. Mówisz „na wycieczkę jedzie około 40 osób” (do dziesiątek), „rower kosztuje około 1200 zł” (do setek), „spotkajmy się kwadrans po” (do 15 minut). Sklep sprzedaje wodę w zgrzewkach po 6 butelek, a autobus odjeżdża co 20 minut. Wszystko to jest zaokrąglanie do wielokrotności jakiejś liczby k: do dziesiątek to k = 10, do kwadransów to k = 15. Dobra wiadomość: znasz już wszystkie potrzebne sztuczki. Wystarczy podzielić przez k, zaokrąglić i pomnożyć z powrotem przez k.

Do dziesiątek: w dół, w górę i do najbliższej

Weźmy liczbę 47. Dzielenie całkowite przez 10 mówi, ile jest pełnych dziesiątek: 47 / 10 = 4. Pomnożenie przez 10 zamienia 4 dziesiątki z powrotem na liczbę: 40. To zaokrąglenie w dół: a / 10 * 10. Zaokrąglenie w górę to ten sam pomysł z wzorem z części 5: (a + 9) / 10 * 10. A do najbliższej dziesiątki — dodajemy połowę dziesiątki i zaokrąglamy w dół: (a + 5) / 10 * 10 (to sztuczka „dodaj połówkę i utnij” z części 1).

dziesiatki.cpp
for (int a : {40, 41, 44, 45, 47, 49}) {
    cout << a << ": " << a / 10 * 10 << " " << (a + 9) / 10 * 10
         << " " << (a + 5) / 10 * 10 << "\n";
}
▶ Wyjście
40: 40 40 40 41: 40 50 40 44: 40 50 40 45: 40 50 50 47: 40 50 50 49: 40 50 50

Kolumny to: liczba, w dół, w górę, do najbliższej.

40 jest wielokrotnością dziesiątki, więc wszystkie trzy sposoby zostawiają ją w spokoju — tak jak liczbę całkowitą przy zwykłym zaokrąglaniu.

45 leży dokładnie w połowie między 40 a 50. Wzór z „+ 5” zaokrągla połówkę w górę, do 50.

Kolejność działań jest ważna: a / 10 * 10 liczy się od lewej, czyli (a / 10) * 10. Gdybyś napisał a * 10 / 10, dostałbyś z powrotem a — mnożenie przed dzieleniem nic nie ucina.

Dowolne k

Dziesiątka nie jest wyjątkowa. Dla dowolnego k > 0 i a ≥ 0:

zaokrąglenie a do wielokrotności kwzórprzykład: a = 52, k = 15
w dóła / k * k52 / 15 = 3, 3 · 15 = 45
w górę(a + k - 1) / k * k66 / 15 = 4, 4 · 15 = 60
do najbliższej (połówki w górę)(a + k / 2) / k * k59 / 15 = 3, 3 · 15 = 45
kwadranse.cpp
int k = 15;     // kwadrans
int m = 52;     // minuty
cout << m / k * k << "\n";             // w dół
cout << (m + k - 1) / k * k << "\n";   // w górę
cout << (m + k / 2) / k * k << "\n";   // do najbliższej
m = 53;
cout << (m + k / 2) / k * k << "\n";   // do najbliższej
▶ Wyjście
45 60 45 60

52 minuty leżą między kwadransami 45 a 60. Do 45 jest 7 minut, do 60 — 8 minut, więc najbliższy kwadrans to 45. A 53 minuty to 8 minut po 45 i 7 przed 60 — więc 60.

Przy „do najbliższej” dodajemy połowę k i zaokrąglamy w dół — to znów „dodaj połówkę i utnij”. Dla k = 15 połowa to 7.5, a k / 2 na int-ach to 7. Czy to nie psuje wyniku? Nie: liczby całkowite nigdy nie trafiają w 7.5 minuty — 7 minut po kwadransie idzie w dół, a 8 w górę, dokładnie tak, jak trzeba. Dla parzystego k (np. 10) połówka istnieje i wzór zaokrągla ją w górę.

Ten wzór daje dla liczb całkowitych to samo co (2 * a + k) / (2 * k) * k z części 5 — możesz używać tego, który wolisz.

Podziel, zaokrąglij, pomnóż Każde zaokrąglenie do wielokrotności k to trzy kroki: podziel przez k (ile jest pełnych k?), zaokrąglij wynik w wybraną stronę i pomnóż z powrotem przez k. Na liczbach całkowitych dzielenie z zaokrągleniem robisz wzorami z części 5. Pamiętaj, że to działa dla a ≥ 0 — dla liczb ujemnych użyj sposobu z części 4 albo funkcji floor i ceil.

Te same kroki na liczbach z przecinkiem

Gdy liczba jest typu double, zamiast dzielenia całkowitego używasz funkcji z <cmath>: dzielisz przez k, zaokrąglasz llround, floor albo ceil i mnożysz przez k.

ceny.cpp
double cena = 1234.56;
cout << llround(cena / 10) * 10 << "\n";            // do dziesiątek
cout << llround(cena / 100) * 100 << "\n";          // do setek
cout << (long long)ceil(cena / 100) * 100 << "\n";  // w górę do setek
▶ Wyjście
1230 1200 1300

1234.56 / 10 = 123.456, najbliższa całkowita to 123, a razy 10 — 1230.

1234.56 / 100 = 12.3456, najbliższa całkowita to 12, czyli 1200 zł, a w górę — 13, czyli 1300 zł.

Zwróć uwagę, że mnożymy dopiero wynik llround — liczbę całkowitą — więc i wynik jest liczbą całkowitą.

Następna wielokrotność: ile czekasz na autobus?

Autobus odjeżdża co 15 minut: w minucie 0, 15, 30, 45, … Przychodzisz na przystanek w minucie t. Kiedy odjedziesz? Najbliższym odjazdem, który jest nie wcześniej niż t — czyli t zaokrąglonym w górę do wielokrotności 15. A ile poczekasz? Różnicę.

przystanek.cpp
int k = 15;   // autobus co 15 minut, pierwszy w minucie 0
for (int t : {7, 30, 31}) {
    int odjazd = (t + k - 1) / k * k;
    cout << "przychodzisz " << t << ", odjazd " << odjazd
         << ", czekasz " << odjazd - t << "\n";
}
▶ Wyjście
przychodzisz 7, odjazd 15, czekasz 8 przychodzisz 30, odjazd 30, czekasz 0 przychodzisz 31, odjazd 45, czekasz 14

Przychodząc w minucie 30, trafiasz idealnie na odjazd — czekasz 0 minut. Spóźnienie o minutę (t = 31) kosztuje cały kwadrans.

Czas czekania można też policzyć resztą z dzielenia: (k - t % k) % k. Zewnętrzne % k zamienia 15 na 0 w przypadku, gdy przyszedłeś równo z autobusem.

Ile wielokrotności leży w przedziale?

Ile jest wielokrotności liczby 7 od 1 do 100? Każda z nich to 7 · 1, 7 · 2, …, a ostatnia nie może przekroczyć 100 — więc jest ich tyle, ile pełnych siódemek mieści się w setce: 100 / 7 = 14. Ogólnie: od 1 do b jest b / k wielokrotności liczby k.

A w przedziale od a do b? Bierzemy wszystkie od 1 do b i odejmujemy te, które leżą przed a, czyli od 1 do a − 1. Wielokrotności 3 w przedziale [10, 20] to 12, 15 i 18. Wzór: 20 / 3 − 9 / 3 = 6 − 3 = 3. Zgadza się!

ile_wielokrotnosci.cpp
long long a, b, k;
cin >> a >> b >> k;
cout << b / k - (a - 1) / k << "\n";
▶ Wejście 1
10 20 3
▶ Wyjście 1
3
▶ Wejście 2
1 100 7
▶ Wyjście 2
14
▶ Wejście 3
15 15 5
▶ Wyjście 3
1

Dlaczego a - 1, a nie a? Bo sama liczba a ma się liczyć, jeśli jest wielokrotnością. W trzecim przykładzie przedział to jedna liczba 15 — a 15 dzieli się przez 5. Gdybyśmy odjęli 15 / 5 zamiast 14 / 5, wyszłoby 0.

Ten wzór działa w jednej chwili nawet dla b = 10¹⁸ — pętla po wszystkich liczbach trwałaby tysiące lat. Zakładamy tu, że a ≥ 1.

Sprawdź się w głowie

Najpierw odpowiedz w myślach — narysuj sobie na kartce kawałek osi liczbowej i zaznacz na niej liczbę — a dopiero potem kliknij „Pokaż odpowiedź”.

Co wypisze ten fragment?
cout << 1234 / 100 * 100;
Pokaż odpowiedź
12001234 / 100 = 12 pełnych setek, razy 100 to 1200 — zaokrąglenie w dół do setek.
Co wypisze ten fragment?
cout << (1234 + 99) / 100 * 100;
Pokaż odpowiedź
1300W górę do setek: 1333 / 100 = 13, razy 100 to 1300.
Co wypisze ten fragment?
cout << (1250 + 50) / 100 * 100;
Pokaż odpowiedź
13001250 to połówka między 1200 a 1300. Wzór „+ 50” zaokrągla ją w górę.
Co wypisze ten fragment?
cout << (1249 + 50) / 100 * 100;
Pokaż odpowiedź
12001299 / 100 = 12. Do 1300 brakuje jeszcze jednej jednostki.
Co wypisze ten fragment?
cout << (38 + 14) / 15 * 15;
Pokaż odpowiedź
4538 minut w górę do kwadransa: 52 / 15 = 3, a 3 · 15 = 45.
Ile wielokrotności trójki leży między 10 a 20? Co wypisze fragment?
cout << 20 / 3 - 9 / 3;
Pokaż odpowiedź
36 − 3 = 3: liczby 12, 15 i 18.
Co wypisze ten fragment?
cout << 100 / 7;
Pokaż odpowiedź
14Od 1 do 100 jest 14 wielokrotności siódemki — ostatnia to 98.
Co wypisze ten fragment?
cout << llround(1234.5 / 10) * 10;
Pokaż odpowiedź
12301234.5 / 10 = 123.45, najbliższa całkowita to 123, razy 10 to 1230.
Co wypisze ten fragment?
cout << 47 * 10 / 10 << " " << 47 / 10 * 10;
Pokaż odpowiedź
47 40Od lewej: 470 / 10 = 47, ale 4 · 10 = 40. Kolejność mnożenia i dzielenia ma znaczenie.
Ć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 →

Do groszy i do dziesiątych — zaokrąglanie i wyświetlanie

Ceny mają grosze, czasy w sporcie — setne części sekundy, a średnia ocen zwykle dwie cyfry po przecinku. Tu zaokrąglamy nie do całości, ale do dziesiątych, setnych albo tysięcznych. I znowu wystarczy znany trik: przesuń przecinek, zaokrąglij do całości i przesuń przecinek z powrotem. W tej części poznasz też ważną różnicę, o którą potyka się wielu początkujących: czym innym jest zaokrąglić liczbę, a czym innym — tylko ładnie ją wypisać.

round(x * 100) / 100 — do setnych

Chcemy zaokrąglić 3.14159 do dwóch miejsc po przecinku. round umie zaokrąglać tylko do całości — więc najpierw zróbmy z części, na której nam zależy, liczbę całkowitą. Mnożenie przez 100 przesuwa przecinek o dwa miejsca w prawo: 314.159. Teraz zaokrąglamy do całości: 314. I dzielimy przez 100, żeby przesunąć przecinek z powrotem: 3.14.

xx * 100round(…)… / 100
3.14159314.1593143.14
2.71828271.8282722.72
9.996999.6100010
0.0040.400
do_setnych.cpp
double x = 3.14159;
cout << round(x * 100) / 100 << "\n";     // do setnych
cout << round(x * 10) / 10 << "\n";       // do dziesiątych
cout << round(x * 1000) / 1000 << "\n";   // do tysięcznych
▶ Wyjście
3.14 3.1 3.142

Do ilu miejsc zaokrąglasz, tyle zer ma liczba, przez którą mnożysz i dzielisz: jedno miejsce — 10, dwa — 100, trzy — 1000.

To nic innego jak zaokrąglanie do wielokrotności z części 6, tylko że wielokrotnością jest teraz 0.01 zamiast 10: dzielenie przez 0.01 to to samo co mnożenie przez 100.

sto_czy_sto_zero.cpp
double x = 7.256;
cout << llround(x * 100) / 100 << "\n";     // 7 — dzielenie całkowite!
cout << llround(x * 100) / 100.0 << "\n";   // 7.26
▶ Wyjście
7 7.26

Uwaga, pułapka! round oddaje double, więc round(x * 100) / 100 dzieli z ułamkiem. Ale llround oddaje liczbę całkowitą — i llround(x * 100) / 100 to dzielenie dwóch liczb całkowitych, które ucina wynik do 7.

Jeśli używasz llround, dziel przez 100.0.

W dół i w górę do groszy

Ten sam trik działa z floor i ceil. Bank, który dopisuje odsetki, zwykle obcina je do pełnych groszy (floor) — nie dopisze Ci ułamka grosza. A sklep, który dolicza opłatę, zaokrągla ją w górę (ceil) — nie odda Ci ułamka grosza.

grosze.cpp
double x = 12.3456;
cout << floor(x * 100) / 100 << "\n";   // obcięte do groszy
cout << ceil(x * 100) / 100 << "\n";    // w górę do groszy
cout << round(x * 100) / 100 << "\n";   // do najbliższego grosza
▶ Wyjście
12.34 12.35 12.35

12.3456 · 100 = 1234.56. W dół to 1234, w górę 1235, a najbliżej też 1235 (bo .56 to więcej niż połowa). Po podzieleniu przez 100: 12.34, 12.35 i 12.35.

Zaokrąglanie a wyświetlanie

Z lekcji o wejściu i wyjściu znasz fixed << setprecision(2). To też „zaokrągla do dwóch miejsc” — ale tylko na ekranie. Liczba w pamięci się nie zmienia. Za to round(x * 100) / 100 zmienia samą liczbę, na zawsze. Zobacz różnicę:

wyswietlanie.cpp
double x = 3.14159;
cout << fixed << setprecision(2);
cout << x << "\n";         // tylko na ekranie: 3.14
cout << x * 100 << "\n";   // x dalej ma wszystkie cyfry
double y = round(x * 100) / 100;
cout << y << "\n";         // naprawdę 3.14
cout << y * 100 << "\n";
▶ Wyjście
3.14 314.16 3.14 314.00

x wypisało się jako 3.14, ale x * 100 to 314.159…, czyli 314.16 — w pamięci x wciąż ma wszystkie cyfry.

y naprawdę jest równe 3.14, więc y * 100 to dokładnie 314.

Kiedy to ma znaczenie? Gdy zaokrąglony wynik jest potrzebny do dalszych obliczeń. Na przykład cena za kilogram jest zaokrąglana do groszy, a potem mnożona przez wagę — wtedy trzeba zaokrąglić samą liczbę. Jeśli tylko wypisujesz wynik — wystarczy setprecision.

zera_na_koncu.cpp
double cena = round(3.0999 * 100) / 100;           // 3.1
cout << cena << "\n";
cout << fixed << setprecision(2) << cena << "\n";
▶ Wyjście
3.1 3.10

Zaokrąglenie nie dopisuje zer: 3.0999 po zaokrągleniu do groszy to 3.1, a cout nie pokazuje zbędnych zer na końcu. Jeśli zadanie każe wypisać dokładnie dwie cyfry po przecinku, i tak musisz dodać fixed << setprecision(2).

Często więc oba narzędzia pracują razem: round ustala wartość, a setprecision — wygląd.

Niespodzianka: setprecision i połówki

W lekcji o wejściu i wyjściu napisaliśmy, że setprecision zaokrągla „tak jak w szkole”. To prawie prawda — z jednym wyjątkiem. Gdy liczba leży dokładnie w połowie, setprecision nie idzie zawsze w górę, tylko wybiera cyfrę parzystą: 0.5 → 0, 1.5 → 2, 2.5 → 2, 3.5 → 4. Takie zaokrąglanie nazywa się bankierskim — przy wielu połówkach w górę i w dół wychodzi mniej więcej tyle samo razy, więc błędy się znoszą.

bankierskie.cpp
cout << fixed << setprecision(0);
cout << 0.5 << " " << 1.5 << " " << 2.5 << " " << 3.5 << "\n";
cout << round(0.5) << " " << round(1.5) << " "
     << round(2.5) << " " << round(3.5) << "\n";
cout << setprecision(2) << 0.125 << " " << 0.375 << "\n";
▶ Wyjście
0 2 2 4 1 2 3 4 0.12 0.38

Pierwszy wiersz to wypisywanie połówek przez setprecision(0) — do parzystej. Drugi to round — zawsze dalej od zera. W ostatnim wierszu 0.125 ma trzecią cyfrę 5, więc to połówka przy dwóch miejscach: wybieramy parzyste 2. Przy 0.375 parzysta jest 8.

Ten wyjątek dotyczy tylko liczb, które w pamięci komputera są idealnie w połowie. W części 8 zobaczysz, że takich liczb jest mniej, niż się wydaje — na przykład 2.675 wcale nie jest połówką…

Kiedy round, a kiedy setprecision? Zadanie mówi „wypisz wynik z dokładnością do dwóch miejsc po przecinku” — wystarczy fixed << setprecision(2). Zadanie mówi wprost, jak zaokrąglać („połówki w górę”, „obetnij do groszy”, „zaokrąglij w górę”) albo zaokrąglony wynik idzie do dalszych obliczeń — najpierw zaokrąglij wartość (round, floor, ceil razy i przez 100), a potem wypisz z setprecision.

Najpierw zaokrąglić, czy na końcu?

Ostatnia ważna sprawa: kolejność. Śrubka kosztuje 0.334 zł, a kupujesz trzy. Jeśli sklep najpierw zaokrągli cenę jednej śrubki do groszy (0.33 zł), zapłacisz 0.99 zł. Jeśli policzy cenę trzech (1.002 zł) i zaokrągli dopiero sumę — zapłacisz 1.00 zł. Oba sposoby są „poprawne” — dlatego w zadaniu zawsze czytaj, co i kiedy trzeba zaokrąglić.

kolejnosc.cpp
double cena = 0.334;   // cena za sztukę
int ile = 3;
cout << fixed << setprecision(2);
double a = round(cena * 100) / 100 * ile;   // najpierw cena sztuki
double b = round(cena * ile * 100) / 100;   // dopiero suma
cout << a << "\n" << b << "\n";
▶ Wyjście
0.99 1.00

a: round(33.4) / 100 = 0.33, a 0.33 · 3 = 0.99.

b: 0.334 · 3 = 1.002, razy 100 to 100.2, zaokrąglone — 100, czyli 1.00.

Różnica jednego grosza wygląda niewinnie, ale sprawdzarka porównuje znak po znaku — więc dla niej to po prostu zła odpowiedź.

Sprawdź się w głowie

Najpierw odpowiedz w myślach — narysuj sobie na kartce kawałek osi liczbowej i zaznacz na niej liczbę — a dopiero potem kliknij „Pokaż odpowiedź”.

Co wypisze ten fragment?
cout << round(2.468 * 100) / 100;
Pokaż odpowiedź
2.47246.8 zaokrąglone do całości to 247, a po podzieleniu przez 100 — 2.47.
Co wypisze ten fragment?
cout << floor(2.468 * 100) / 100;
Pokaż odpowiedź
2.46Obcinamy do groszy: floor(246.8) = 246, czyli 2.46.
Co wypisze ten fragment?
cout << ceil(2.461 * 100) / 100;
Pokaż odpowiedź
2.47W górę do groszy: ceil(246.1) = 247, czyli 2.47.
Co wypisze ten fragment?
cout << fixed << setprecision(2) << 3.0;
Pokaż odpowiedź
3.00fixed i setprecision(2) zawsze wypisują dwie cyfry po kropce, także zera.
Co wypisze ten fragment?
cout << llround(7.256 * 100) / 100;
Pokaż odpowiedź
7llround daje liczbę całkowitą 726, a 726 / 100 na liczbach całkowitych to 7.
Co wypisze ten fragment?
cout << fixed << setprecision(0) << 4.5;
Pokaż odpowiedź
4Wypisywanie połówki wybiera cyfrę parzystą — 4, a nie 5.
Co wypisze ten fragment?
cout << fixed << setprecision(0) << round(4.5);
Pokaż odpowiedź
5round(4.5) = 5.0 (połówka dalej od zera), a 5.0 wypisuje się bez kropki jako 5.
Co wypisze ten fragment?
double x = 1.234;
cout << fixed << setprecision(1) << x << " " << x * 10;
Pokaż odpowiedź
1.2 12.3setprecision zmienia tylko wygląd: x wciąż wynosi 1.234, więc x * 10 to 12.34, czyli 12.3.
Co wypisze ten fragment?
cout << round(1234.5678 / 100) * 100;
Pokaż odpowiedź
1200Dzielenie przez 100 i mnożenie z powrotem to zaokrąglenie do setek: 12.345678 → 12 → 1200.
Ć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 →

Pułapki liczb z przecinkiem — grosze, epsilon i pierwiastki

Do tej pory liczby z przecinkiem zachowywały się grzecznie. Czas na złą wiadomość: komputer nie pamięta większości z nich dokładnie. Zwykle tego nie widać, bo cout pokazuje tylko 6 cyfr. Ale przy zaokrąglaniu widać — i to boleśnie: cena 0.29 zł potrafi zamienić się w 28 groszy. W tej części zobaczysz, skąd biorą się takie błędy, jak je rozpoznać i jak się przed nimi bronić. Najlepsza obrona okaże się bardzo prosta: liczby całkowite.

0.1 + 0.2 to nie 0.3

zero_trzy.cpp
double a = 0.1 + 0.2;
cout << (a == 0.3) << "\n";              // 0 — fałsz!
cout << a << "\n";                       // tak to wygląda...
cout << setprecision(17) << a << "\n";   // ...a tak jest naprawdę
▶ Wyjście
0 0.3 0.30000000000000004

Komputer twierdzi, że 0.1 + 0.2 to nie jest 0.3. Na ekranie wynik wygląda jak 0.3, bo cout pokazuje tylko 6 cyfr. Gdy poprosimy o 17 cyfr, prawda wychodzi na jaw: na końcu siedzi maleńka czwórka.

To nie jest błąd w C++. Tak samo liczą Python, Java, JavaScript i kalkulatory w telefonach — taka jest natura liczb double.

Skąd to się bierze? Spróbuj zapisać ułamek 1/3 w systemie dziesiętnym: 0.333333… — trójki nigdy się nie kończą, więc na kartce zawsze musisz gdzieś przestać i zapisujesz liczbę odrobinę mniejszą niż 1/3. Komputer zapisuje liczby w systemie dwójkowym, a w nim nieskończonymi ułamkami są… 0.1, 0.2, 0.29 i większość „zwykłych” ułamków dziesiętnych. Komputer musi je gdzieś uciąć, więc w pamięci siedzi liczba bardzo bliska, ale nie dokładnie ta. Dokładnie zapisać da się tylko ułamki złożone z połówek, ćwiartek, ósemek i tak dalej: 0.5, 0.25, 0.75, 0.125.

Zajrzyj sam do pamięci komputera. Wpisz liczbę albo kliknij jeden z przycisków i zobacz, co naprawdę siedzi w zmiennej double — i co z tego wynika po pomnożeniu przez 100:

Zajrzyj do pamięci komputera
Podgląd działa po włączeniu JavaScriptu.

Pułapka 1: (int) i floor po mnożeniu

Najczęstszy przypadek w zadaniach: cena w złotych, którą trzeba zamienić na grosze.

grosze_zle.cpp
double cena = 0.29;
cout << (int)(cena * 100) << "\n";     // 28 — miało być 29!
cout << floor(cena * 100) << "\n";     // 28
cout << llround(cena * 100) << "\n";   // 29 — dobrze
▶ Wyjście
28 28 29

0.29 w pamięci to 0.28999999999999998…, więc po pomnożeniu przez 100 wychodzi 28.999999999999996. (int) i floor ucinają wszystko po kropce — zostaje 28.

llround zaokrągla do najbliższej całkowitej — a najbliżej 28.999999999999996 jest 29. Maleńki błąd znika.

Złote na grosze: tylko llround Zamieniając liczbę z przecinkiem na liczbę całkowitą „jednostek” (złote na grosze, metry na centymetry, sekundy na setne), pisz zawsze llround(x * 100). Nigdy (int)(x * 100) ani floor(x * 100) — dla wielu cen (0.29, 0.57, 1.15, 4.35…) dadzą o jeden za mało.

Pułapka 2: floor i ceil po obliczeniach — epsilon

Czasem musisz zaokrąglić w dół albo w górę wynik obliczeń na liczbach double. Jeśli matematycznie wynik jest liczbą całkowitą, komputer może go policzyć odrobinę za dużo albo odrobinę za mało — i wtedy ceil skacze o jeden w górę, a floor o jeden w dół.

epsilon.cpp
double x = 0.1 * 3;                      // powinno być 0.3
cout << ceil(x * 10) << "\n";            // a powinno 3!
cout << ceil(x * 10 - 1e-9) << "\n";
double y = 1.15;
cout << floor(y * 100) << "\n";          // a powinno 115!
cout << floor(y * 100 + 1e-9) << "\n";
▶ Wyjście
4 3 114 115

0.1 · 3 · 10 powinno dać 3, a komputer liczy 3.0000000000000004 — i ceil daje 4. Podobnie 1.15 · 100 to w pamięci 114.99999999999999, więc floor daje 114.

Ratunek to epsilon: maleńka liczba, na przykład 1e-9, czyli 0.000000001 (zapis 1e-9 to „1 razy 10 do potęgi −9”). Przed ceil ją odejmujemy, przed floor — dodajemy. Jest dużo mniejsza od każdego sensownego ułamka w zadaniu, ale dużo większa od błędów komputera, więc „zjada” błąd i niczego więcej nie psuje.

Pułapka 3: porównywanie liczb double

porownywanie.cpp
double a = 0.1 + 0.2, b = 0.3;
if (a == b) cout << "rowne\n";
else cout << "rozne\n";
if (abs(a - b) < 1e-9) cout << "rowne\n";
else cout << "rozne\n";
▶ Wyjście
rozne rowne

Ten sam epsilon przydaje się do porównań. Zamiast pytać „czy a jest równe b?”, pytamy „czy a i b różnią się o mniej niż epsilon?”: abs(a - b) < 1e-9.

Uwaga: to dotyczy liczb, które są wynikiem obliczeń. Gdy porównujesz liczby wczytane prosto z wejścia (np. czy x jest całkowite), zwykłe == działa dobrze.

Najlepsza obrona: liczby całkowite

Epsilon pomaga, ale trzeba pamiętać o nim w każdym miejscu programu. Jest prostszy sposób: zamień liczby z przecinkiem na całkowite od razu po wczytaniu i licz już tylko na liczbach całkowitych. Ceny trzymaj w groszach, długości w milimetrach, czasy w setnych sekundy. Liczby całkowite są w komputerze zawsze dokładne, a zaokrąglanie robisz wzorami z części 5 i 6 — bez żadnych epsilonów.

Na koniec wypisujesz wynik z powrotem jako złote: część całkowita to grosze / 100, a grosze to grosze % 100 — zawsze dwie cyfry, więc z setw(2) i setfill('0') z lekcji o wejściu i wyjściu (żeby 5 groszy wypisało się jako „05”).

suma_cen.cpp
int n;
cin >> n;
long long suma = 0;                 // w groszach!
for (int i = 0; i < n; i++) {
    double cena;
    cin >> cena;
    suma += llround(cena * 100);    // złote → grosze
}
cout << suma / 100 << "." << setw(2) << setfill('0') << suma % 100 << "\n";
▶ Wejście 1
3 0.29 0.29 0.42
▶ Wyjście 1
1.00
▶ Wejście 2
2 19.99 5.06
▶ Wyjście 2
25.05
po_rowno.cpp
long long rachunek = 10000;   // 100.00 zł w groszach
int osoby = 3;
long long kazdy = (rachunek + osoby - 1) / osoby;   // w górę do grosza
long long napiwek = kazdy * osoby - rachunek;
cout << kazdy / 100 << "." << setw(2) << setfill('0') << kazdy % 100 << "\n";
cout << napiwek << " gr\n";
▶ Wyjście
33.34 2 gr

Z lewej: suma trzech cen to dokładnie 100 groszy, czyli „1.00”. W drugim przykładzie 2505 groszy wypisuje się jako „25.05” — bez setw(2) i setfill('0') wyszłoby „25.5”, czyli zupełnie inna kwota.

Z prawej: rachunek 100 zł dzielimy na trzy osoby, każda płaci w górę do pełnego grosza: 33.34 zł. Razem zapłacą 100.02 zł — 2 grosze napiwku. Wszystko liczone dokładnie, bez cienia błędu.

Wielkie liczby w double

Ostatnia pułapka dotyczy liczb całkowitych, które trafiają do double. Typ double pamięta tylko około 15–16 cyfr znaczących. Liczby całkowite do około 9 · 1015 pamięta dokładnie, ale większe — już nie. W części 5 widziałeś, że przez to ceil((double)n / k) psuje się dla ogromnych n.

wielkie_double.cpp
long long n = 999999999999999999LL;   // 18 dziewiątek
double d = n;
cout << fixed << setprecision(0) << d << "\n";
cout << (long long)d - n << "\n";     // o ile się pomylił?
▶ Wyjście
1000000000000000000 1

Zwykłe przepisanie liczby z long long do double już ją zmienia: 18 dziewiątek zamienia się w 10¹⁸. Różnica wynosi tylko 1, ale w zadaniu z dokładnym wynikiem to po prostu błąd.

Zasada: liczby całkowite większe od mniej więcej 10¹⁵ nigdy nie powinny przechodzić przez double.

Pierwiastek całkowity

Ta pułapka ma też ważne zastosowanie. Biblioteka <cmath> ma funkcję sqrt — pierwiastek kwadratowy: sqrt(16) to 4, bo 4 · 4 = 16. W zadaniach często potrzebny jest pierwiastek całkowity z n: największa liczba całkowita k, dla której k · k ≤ n. Na przykład dla n = 20 to 4 (bo 4 · 4 = 16 ≤ 20, a 5 · 5 = 25 > 20). Wygląda na floor(sqrt(n)) — i dla małych n to działa.

sqrt.cpp
cout << sqrt(16) << " " << sqrt(2) << " " << floor(sqrt(20)) << "\n";
▶ Wyjście
4 1.41421 4

sqrt, tak jak floor, oddaje double. Pierwiastek z 2 nie jest liczbą całkowitą, więc widzimy jego przybliżenie.

Ale dla wielkich n sqrt liczy na double — i potrafi się pomylić o jeden. Ratunek jest prosty: weź wynik sqrt jako pierwsze przybliżenie i popraw je na liczbach całkowitych, sprawdzając warunek k · k ≤ n.

pierwiastek.cpp
long long n = 999999999999999999LL;
cout << (long long)sqrt(n) << "\n";   // o jeden za dużo!
long long k = sqrt(n);
while (k * k > n) k--;                // za duże? zmniejsz
while ((k + 1) * (k + 1) <= n) k++;   // za małe? zwiększ
cout << k << "\n";
▶ Wyjście
1000000000 999999999

sqrt dostał n zamienione na double, czyli 10¹⁸ (pamiętasz, że 18 dziewiątek nie mieści się w double?), więc odpowiedział 10⁹. Ale 10⁹ · 10⁹ = 10¹⁸ > n — to za dużo.

Pierwsza pętla zmniejsza k, dopóki k · k jest za duże. Druga zwiększa k, dopóki następna liczba też się mieści. Obie wykonają się najwyżej raz czy dwa — przybliżenie z sqrt jest bardzo bliskie prawdy.

Trzy zasady bezpiecznego zaokrąglania 1) Dane z przecinkiem zamieniaj na liczby całkowite od razu po wczytaniu: llround(x * 100) — i licz dalej na long long. 2) Jeśli musisz zostać przy double, przed floor dodaj 1e-9, przed ceil odejmij 1e-9, a liczby porównuj przez abs(a - b) < 1e-9. 3) Wielkie liczby całkowite (powyżej ~10¹⁵) nie przechodzą przez double — ani w ceil((double)a / b), ani w sqrt bez poprawki.

A obiecana zagadka z części 7? Liczba 2.675 w pamięci to 2.674999999999999822… — odrobinę mniej niż połowa między 2.67 a 2.68 (sprawdź to sam w podglądzie pamięci powyżej). Dlatego fixed << setprecision(2) << 2.675 wypisuje 2.67, choć „w szkole” wyszłoby 2.68. Gdy w zadaniu liczy się każdy grosz — licz w groszach.

Sprawdź się w głowie

Najpierw odpowiedz w myślach — narysuj sobie na kartce kawałek osi liczbowej i zaznacz na niej liczbę — a dopiero potem kliknij „Pokaż odpowiedź”.

Co wypisze ten fragment?
cout << (0.5 + 0.25 == 0.75);
Pokaż odpowiedź
1Połówki i ćwiartki komputer zapisuje dokładnie, więc tym razem równość jest prawdziwa.
Co wypisze ten fragment?
cout << (0.1 + 0.7 == 0.8);
Pokaż odpowiedź
00.1 i 0.7 nie mają dokładnego zapisu dwójkowego — suma wychodzi odrobinę mniejsza niż 0.8.
Co wypisze ten fragment?
cout << (int)(0.57 * 100);
Pokaż odpowiedź
560.57 · 100 to w pamięci 56.99999999999999, a (int) ucina do 56.
Co wypisze ten fragment?
cout << llround(0.57 * 100);
Pokaż odpowiedź
57llround wybiera najbliższą całkowitą — 57.
Co wypisze ten fragment?
cout << floor(0.57 * 100 + 1e-9);
Pokaż odpowiedź
57Epsilon przepycha 56.99999999999999 za kreskę 57, więc floor daje 57.
Co wypisze ten fragment?
long long g = 1999;
cout << g / 100 << "." << setw(2) << setfill('0') << g % 100;
Pokaż odpowiedź
19.991999 groszy to 19 złotych i 99 groszy.
Co wypisze ten fragment?
long long g = 105;
cout << g / 100 << "." << setw(2) << setfill('0') << g % 100;
Pokaż odpowiedź
1.05105 % 100 = 5, a setw(2) z setfill('0') dopisuje zero z przodu: „05”.
Co wypisze ten fragment?
long long k = 3;
while ((k + 1) * (k + 1) <= 20) k++;
cout << k;
Pokaż odpowiedź
44 · 4 = 16 ≤ 20, więc k rośnie do 4. 5 · 5 = 25 > 20, więc pętla się zatrzymuje. Pierwiastek całkowity z 20 to 4.
Co wypisze ten fragment?
double x = 4.35;
cout << (int)(x * 100);
Pokaż odpowiedź
4344.35 · 100 to w pamięci 434.99999999999994 — (int) ucina do 434. Z llround byłoby 435.
Ć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ń: zaokrąglanie w praktyce

Znasz już wszystkie narzędzia: oś liczbową i sąsiadów liczby, floor, ceil, round i llround, ucinanie (int) i dzielenie liczb ujemnych, dzielenie w górę i do najbliższej na liczbach całkowitych, zaokrąglanie do dziesiątek, kwadransów i dowolnych wielokrotności, do miejsc po przecinku, różnicę między zaokrąglaniem a wypisywaniem, grosze bez błędów, epsilon i pierwiastek całkowity. Czas na zadania, które łączą kilka z tych rzeczy naraz. Są ułożone od najłatwiejszego do najtrudniejszego: najpierw rozgrzewka z jednym, dwoma pomysłami, potem zadania średnie, a na końcu trudne — z wielkim finałem.

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

Ściąga: gotowe schematy

Cztery kierunki

floor(x)   // w dół
ceil(x)    // w górę
llround(x) // do najbliższej
(int)x     // w stronę zera

Połówki: round — dalej od zera. Dla liczb ujemnych (int) to nie floor!

Wynik jako liczba całkowita

(long long)floor(x)
long long w = ceil(x);
llround(x)
ceil((double)a / b)

Bez 1.23457e+06 i bez -0. Rzutuj przed dzieleniem, nie po.

Dzielenie bez ułamków

n / k              // w dół
(n + k - 1) / k    // w górę
n / k + (n % k != 0)
(n + k / 2) / k    // najbliższa

Dla n ≥ 0 i k > 0. Przy dużych liczbach — long long.

Dzielenie z minusem

long long q = a / b;
if (a % b < 0) q--;   // w dół
long long r = a - q * b; // 0..b-1

Dla b > 0. Zwykłe a / b ucina w stronę zera.

Wielokrotności k

a / k * k            // w dół
(a + k - 1) / k * k  // w górę
(a + k / 2) / k * k  // najbliższa
b / k - (a - 1) / k  // ile w [a, b]

Podziel, zaokrąglij, pomnóż z powrotem.

Miejsca po przecinku

round(x * 100) / 100
floor(x * 100) / 100
llround(x * 100) / 100.0
cout << fixed << setprecision(2);

setprecision tylko wypisuje, a połówki zaokrągla do cyfry parzystej.

Grosze bez błędów

long long g = llround(x * 100);
cout << g / 100 << "."
     << setw(2) << setfill('0')
     << g % 100;

Nigdy (int)(x * 100). Licz na liczbach całkowitych.

Epsilon i pierwiastek

floor(x + 1e-9)   ceil(x - 1e-9)
abs(a - b) < 1e-9
long long k = sqrt(n);
while (k * k > n) k--;
while ((k+1) * (k+1) <= n) k++;

Wielkie liczby całkowite nie przechodzą przez double.

Jak rozwiązywać zadania z zaokrąglaniem 1) Ustal kierunek: „pełne”, „całe”, „zmieści się” → w dół; „potrzeba”, „rozpoczęte”, „żeby wystarczyło” → w górę; „zaokrąglij”, „około” → do najbliższej — i sprawdź w treści, co z połówkami. 2) Sprawdź, czy liczby mogą być ujemne — jeśli tak, używaj floor i ceil albo poprawki z resztą, a nie (int) i wzorów dla dodatnich. 3) Dane są całkowite? Zostań przy liczbach całkowitych i wzorach z części 5 i 6. 4) Są ceny albo ułamki? Zamień je od razu na grosze: llround(x * 100). 5) Wynik ma być liczbą całkowitą — wypisz long long; ma mieć k miejsc po przecinku — fixed << setprecision(k). 6) Przetestuj skrajności: dzielenie bez reszty, zero, połówki, liczby ujemne i ogromne wartości.
łatwe

Rozgrzewka · zadania 1–10

Jeden, dwa pomysły naraz: pizza dla klasy, spływ kajakowy, ocena ze sprawdzianu, cena po rabacie, wypożyczalnia rowerów, płot, tankowanie, średnia temperatura, czytanie książki i bankomat.

1 Pizza dla klasyłatwe✓ zaliczone Ile pizz zamówić, żeby każdy zjadł tyle kawałków, ile chce? dzielenie w góręreszta Rozwiąż 2 Spływ kajakowyłatwe✓ zaliczone Kajaki dwuosobowe płatne za każdą rozpoczętą godzinę. Ile kajaków i ile złotych? dwa dzielenia w góręiloczyn Rozwiąż 3 Ocena ze sprawdzianułatwe✓ zaliczone Procent punktów obcięty w dół i ocena według progów. 100 * p / Mprogi if / else Rozwiąż 4 Cena po rabaciełatwe✓ zaliczone Obniż ceny o r procent i zaokrąglij do pełnego grosza. groszedo najbliższejfixed i setprecision Rozwiąż 5 Wypożyczalnia rowerówłatwe✓ zaliczone Pierwsze 15 minut gratis, potem za każdą rozpoczętą godzinę. dzielenie w góręifsuma Rozwiąż 6 Płotłatwe✓ zaliczone Słupki co k metrów i na obu końcach. Ile słupków i jak długie ostatnie przęsło? dzielenie w góręo jeden więcej Rozwiąż 7 Tankowanie w trasiełatwe✓ zaliczone Ile razy zatankujesz do pełna po drodze, jeśli wyjeżdżasz z pełnym bakiem? dzielenie w góręjednostkilong long Rozwiąż 8 Średnia temperaturałatwe✓ zaliczone Średnia z pomiarów (także na minusie) zaokrąglona do dziesiątych. średnia doubleround(x * 10) / 10setprecision(1) Rozwiąż 9 Czytanie książkiłatwe✓ zaliczone Ile dni zajmie lektura i którego dnia Ola przeczyta daną stronę? dzielenie w góręzapytania Rozwiąż 10 Bankomatłatwe✓ zaliczone Bankomat ma tylko jeden nominał. Najbliższe kwoty, które może wypłacić. wielokrotności kw dół i w górę Rozwiąż
średnie

Średnie · zadania 11–20

Kilka sztuczek naraz: średnia ważona, ocena w gwiazdkach, kratki na mapie, taksówka, licznik wyświetleń, cyfry znaczące, noty bez skrajnych, godziny pracy, dzień tygodnia za d dni i rozkład jazdy.

11 Średnia ważonaśrednie✓ zaliczone Średnia z wagami zaokrąglona do setnych — i ocena według zaokrąglonej średniej. suma iloczynówdo setnychprogi na liczbach całkowitych Rozwiąż 12 Ocena w gwiazdkachśrednie✓ zaliczone Średnia ocen zaokrąglona do połowy gwiazdki. zaokrąglanie do 0.5llround(2.0 * suma / n)setprecision(1) Rozwiąż 13 Kratki na mapieśrednie✓ zaliczone W ilu różnych kratkach coś znaleziono i gdzie najwięcej? floorvector parsort i grupy Rozwiąż 14 Taksówkaśrednie✓ zaliczone Opłata za rozpoczęte kilometry, a w nocy półtorej raza — w górę do grosza. dzielenie w góręgrosze3 * cena / 2 w górę Rozwiąż 15 Licznik wyświetleńśrednie✓ zaliczone Skróć liczbę do 1.2k, 15.3M albo 2B — obcinając, a nie zaokrąglając. obcinanie do dziesiątychdzielenie całkowitelong long Rozwiąż 16 Cyfry znacząceśrednie✓ zaliczone Zaokrąglij liczbę do k pierwszych cyfr: 123 456 → 120 000. liczba cyfrpotęga dziesiątkido wielokrotności Rozwiąż 17 Noty bez skrajnychśrednie✓ zaliczone Odrzuć najwyższą i najniższą notę, a z reszty policz średnią do setnych. max i minśrednia do setnychfixed i setprecision Rozwiąż 18 Godziny pracyśrednie✓ zaliczone Każda wizyta rozliczana za rozpoczęte kwadranse. Ile czasu i ile pieniędzy? hh:mmdzielenie w góręgrosze Rozwiąż 19 Za d dniśrednie✓ zaliczone Jaki dzień tygodnia będzie za d dni — albo był d dni temu? dzielenie w dółreszta 0..6long long Rozwiąż 20 Rozkład jazdyśrednie✓ zaliczone Pociągi co k minut od P do O. Kiedy odjedzie pasażer — o ile w ogóle? następna wielokrotnośćhh:mmwarunek końca Rozwiąż
trudne

Trudne · zadania 21–28

Histogram, średnia wielkich liczb, podział mandatów, kwadraty i sześciany, spłata kredytu, odcinki na osi, tempo biegu — a na koniec wielki finał: wycieczka klasowa.

21 Histogramtrudne✓ zaliczone Rozdziel pomiary na przedziały szerokości w — bez potknięć na granicach. dzielenie w dół z minusemliczenie w setnychtablica liczników Rozwiąż 22 Średnia wielkich liczbtrudne✓ zaliczone Średnia tysiąca liczb do 10¹⁸ — suma nie mieści się w long long. iloraz i resztazaokrąglanie bez przepełnienialong long Rozwiąż 23 Podział mandatówtrudne✓ zaliczone Metoda największych reszt: najpierw w dół, potem reszta mandatów dla największych ułamków. floor ilorazureszty z dzieleniasortowanie z regułą Rozwiąż 24 Kwadraty i sześcianytrudne✓ zaliczone Ile liczb z przedziału to kwadraty albo sześciany? Pierwiastki całkowite z poprawką. pierwiastek całkowitycbrt z poprawkąwłączanie i wyłączanie Rozwiąż 25 Spłata kredytutrudne✓ zaliczone Odsetki co miesiąc zaokrąglane do grosza. Ile miesięcy i ile w sumie? symulacja w groszachdo najbliższejpromile Rozwiąż 26 Odcinki na ositrudne✓ zaliczone Ile liczb całkowitych przykrywa co najmniej jeden odcinek? ceil i floor końcówsortowanie przedziałówscalanie Rozwiąż 27 Tempo biegutrudne✓ zaliczone Średnie tempo na kilometr i przewidywany czas maratonu — co do sekundy. metry i sekundydo najbliższejh:mm:ss Rozwiąż 28 Wielki finał: wycieczka klasowatrudne✓ zaliczone Autobusy, rozpoczęte godziny, darmowe bilety, składka w górę do 10 groszy — wszystko naraz. dzielenie w góręgroszedo wielokrotnościformatowanie kwot Rozwiąż

Częste błędy i dobre praktyki

🪚
(int) to nie floor
Dla liczb ujemnych (int)x idzie w górę: (int)(-2.5) to −2, a floor(-2.5) to −3. Gdy zadanie mówi „w dół”, a liczby mogą być ujemne — floor.
🔢
Wynik to double
floor, ceil i round oddają double: duży wynik wypisze się jako 1.23457e+06, a zero z minusem jako -0. Zamień wynik na long long albo użyj llround.
➗
Dzielenie przed zaokrągleniem
ceil(a / b) dla dwóch int-ów zaokrągla wynik, który już został ucięty. Pisz ceil((double)a / b) albo (a + b - 1) / b.
➕
k zamiast k − 1
(n + k) / k daje o jeden za dużo, gdy n dzieli się przez k bez reszty. W dzieleniu w górę dodajesz k - 1 — największą możliwą resztę.
💥
Przepełnienie we wzorze
Gdy n i k sięgają miliarda, n + k - 1, 2 * n czy 100 * a nie mieszczą się w int. Liczby do wzorów trzymaj w long long.
➖
Wzory tylko dla dodatnich
(n + k - 1) / k i a / k * k zakładają n ≥ 0. Dzielenie w C++ ucina w stronę zera, więc dla ujemnych poprawiaj wynik resztą (if (a % b < 0) q--;) albo użyj floor i ceil.
0️⃣
Zgubione grosze
llround(x * 100) / 100 dzieli liczby całkowite i gubi grosze — dziel przez 100.0. A grosze wypisuj z setw(2) i setfill('0'), bo 5 groszy to „05”.
🎭
Wygląd to nie wartość
setprecision zmienia tylko wypisywanie, a idealne połówki zaokrągla do cyfry parzystej. Gdy zaokrąglony wynik idzie do dalszych obliczeń albo zadanie każe „połówki w górę” — najpierw round.
🧮
Kolejność zaokrągleń
Zaokrąglenie każdej ceny osobno i zaokrąglenie sumy to dwie różne rzeczy — wyniki potrafią różnić się o grosz. Przeczytaj w treści, co dokładnie i kiedy trzeba zaokrąglić.
🪙
(int)(x * 100)
0.29 · 100 to w pamięci 28.999…, więc (int) i floor dają 28. Złote na grosze, metry na centymetry — tylko llround(x * 100).
🎯
Porównanie ==
Wyniki obliczeń na double rzadko są dokładnie równe: 0.1 + 0.2 == 0.3 to fałsz. Porównuj przez abs(a - b) < 1e-9 albo licz na liczbach całkowitych.
🐘
Wielkie liczby w double
Powyżej około 10¹⁵ double gubi cyfry: ceil((double)a / b) i sqrt(n) potrafią pomylić się o jeden. Używaj wzorów na liczbach całkowitych i poprawiaj pierwiastek pętlą.

Co dalej?

Zaokrąglanie spotkasz w każdym zadaniu, w którym coś się dzieli: przy autobusach, stronach, groszach i procentach. Wzór (a + b - 1) / b, zamiana złotych na grosze i pierwiastek całkowity z poprawką to narzędzia, które zostaną z Tobą aż do olimpiady. Następna lekcja to kolejne narzędzie matematyczne: silnia — i pierwsze naprawdę wielkie liczby. A jeśli chcesz trenować z mentorami — dołącz do T-Olimpians.