Wolisz obejrzeć?
Olimpijskie Koło Informatyczne nagrywa swoje zajęcia i udostępnia je za darmo. Poniżej 2 odcinki o tym temacie — dobre uzupełnienie, jeśli wolisz obejrzeć niż przeczytać.
Co już umiesz i czego się nauczysz
Ta lekcja zakłada, że przerobiłeś wszystkie poprzednie: Typy zmiennych, Input / Output, If / Else, While loop, For loop, Modulo, Tablice, String, Pair, Vector, Sortowanie 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.
W dół, w górę, do najbliższej
Oś liczbowa i sąsiedzi liczby, potem gotowe funkcje: floor, ceil i round.
Minusy i liczby całkowite
Ucinanie (int), wszystkie cztery sposoby dla liczb ujemnych i dzielenie w górę bez ułamków.
Do dziesiątek i do groszy
Wielokrotności, kwadranse i ceny, zaokrąglanie do miejsc po przecinku i wypisywanie z setprecision.
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.
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:
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.
| liczba | sąsiedzi | w dół | w górę | do najbliższej | dlaczego |
|---|---|---|---|---|---|
| 2.3 | 2 i 3 | 2 | 3 | 2 | do 2 jest 0.3, do 3 jest 0.7 |
| 2.7 | 2 i 3 | 2 | 3 | 3 | do 3 jest 0.3, do 2 jest 0.7 |
| 0.4 | 0 i 1 | 0 | 1 | 0 | do 0 jest 0.4, do 1 jest 0.6 |
| 9.99 | 9 i 10 | 9 | 10 | 10 | do 10 brakuje tylko 0.01 |
| 2.5 | 2 i 3 | 2 | 3 | 3 | dokładnie pośrodku — umawiamy się: w górę |
| 5 | — | 5 | 5 | 5 | leż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.
double x;
cin >> x;
int calk = (int)x; // część całkowita
double ulamek = x - calk; // część ułamkowa
cout << calk << "\n";
cout << ulamek << "\n";
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.
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";
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.
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ę.
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";
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.
for (double x : {2.3, 2.5, 2.7, 0.49, 9.5}) {
cout << x << " -> " << (int)(x + 0.5) << "\n";
}
| x | x + 0.5 | (int)(x + 0.5) |
|---|---|---|
| 2.3 | 2.8 | 2 |
| 2.5 | 3.0 | 3 |
| 2.7 | 3.2 | 3 |
| 0.49 | 0.99 | 0 |
| 9.5 | 10.0 | 10 |
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.
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.
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!
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.
Najpierw odpowiedz w myślach — narysuj sobie na kartce kawałek osi liczbowej i zaznacz na niej liczbę — a dopiero potem kliknij „Pokaż odpowiedź”.
cout << (int)7.9;
Pokaż odpowiedź
double x = 3.25;
cout << x - (int)x;
Pokaż odpowiedź
double x = 6;
int d = (int)x;
int g = d;
if (x > d) g = d + 1;
cout << d << " " << g;
Pokaż odpowiedź
cout << (int)(4.5 + 0.5) << " " << (int)(4.49 + 0.5);
Pokaż odpowiedź
cout << (int)(-3.8);
Pokaż odpowiedź
double x = 9.5;
int d = (int)x;
if (x - d < 0.5) cout << d;
else cout << d + 1;
Pokaż odpowiedź
cout << (int)(-0.7);
Pokaż odpowiedź
int a = 7, b = 2;
cout << a / b << " " << (double)a / b;
Pokaż odpowiedź
double x = 2.999;
cout << (int)x << " " << (int)(x + 0.5);
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ę.
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
#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;
}
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.
| x | floor(x) | ceil(x) | uwagi |
|---|---|---|---|
| 2.3 | 2 | 3 | zwykła liczba dodatnia |
| 2.9 | 2 | 3 | floor nie patrzy, jak blisko jest trójka |
| 2.01 | 2 | 3 | ceil — wystarczy odrobina po kropce |
| 0.5 | 0 | 1 | między 0 a 1 |
| 5 | 5 | 5 | liczba całkowita zostaje sobą |
| −1.2 | −2 | −1 | w dół to dalej od zera! |
| −2.7 | −3 | −2 | w dół to dalej od zera! |
| −5 | −5 | −5 | liczba 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.
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”.
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";
−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:
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
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:
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
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.
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.
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
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.
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.
// 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";
// 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";
Ś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ę.
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.
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";
}
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.
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";
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.
Najpierw odpowiedz w myślach — narysuj sobie na kartce kawałek osi liczbowej i zaznacz na niej liczbę — a dopiero potem kliknij „Pokaż odpowiedź”.
cout << floor(3.9) << " " << ceil(3.1);
Pokaż odpowiedź
cout << floor(-3.9) << " " << ceil(-3.1);
Pokaż odpowiedź
cout << floor(8) << ceil(8);
Pokaż odpowiedź
cout << ceil(9 / 4);
Pokaż odpowiedź
cout << ceil(9 / 4.0);
Pokaż odpowiedź
cout << floor(7.5) / 2;
Pokaż odpowiedź
cout << ceil(-0.2);
Pokaż odpowiedź
cout << (long long)ceil(-0.2);
Pokaż odpowiedź
cout << floor(2.5) + ceil(2.5);
Pokaż odpowiedź
double a = -1.5, b = 1.5;
cout << floor(b) - ceil(a) + 1;
Pokaż odpowiedź
8 ćwiczeń do tej części
Kliknij zadanie — otworzy się w sprawdzarce w nowej karcie. Napisz program u siebie, sprawdź go na przykładzie, wklej cały kod i kliknij Wyślij. Utknąłeś? Każde zadanie ma wskazówkę.
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
double x;
cin >> x;
cout << round(x) << "\n";
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.
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).
for (double x : {0.5, 1.5, 2.5, -0.5, -1.5, -2.5}) {
cout << x << " -> " << round(x) << "\n";
}
| x | round(x) | dlaczego |
|---|---|---|
| 2.4 | 2 | na lewo od połówki 2.5 |
| 2.5 | 3 | połówka — dalej od zera |
| 2.6 | 3 | na prawo od połówki |
| −2.4 | −2 | bliżej −2 (o 0.4) niż −3 (o 0.6) |
| −2.5 | −3 | połówka — dalej od zera |
| −2.6 | −3 | bliżej −3 |
| 0.5 | 1 | połówka — dalej od zera |
| 7 | 7 | liczba 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).
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
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.
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:
for (double x : {2.7, 2.5, -2.2, -2.5, -2.7}) {
cout << x << ": " << (int)(x + 0.5) << " " << llround(x) << "\n";
}
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.
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
Ś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:
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
Ś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.
for (double x : {3.8, 7.25, -1.9}) {
cout << x << ": najblizsza " << llround(x);
cout << ", odleglosc " << abs(x - round(x)) << "\n";
}
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”.
Najpierw odpowiedz w myślach — narysuj sobie na kartce kawałek osi liczbowej i zaznacz na niej liczbę — a dopiero potem kliknij „Pokaż odpowiedź”.
cout << round(4.49) << " " << round(4.5);
Pokaż odpowiedź
cout << round(-4.5);
Pokaż odpowiedź
cout << round(-4.49);
Pokaż odpowiedź
cout << llround(0.5) << llround(1.5) << llround(2.5);
Pokaż odpowiedź
cout << (int)(-1.6 + 0.5) << " " << llround(-1.6);
Pokaż odpowiedź
cout << round(7 / 2) << " " << round(7 / 2.0);
Pokaż odpowiedź
cout << fixed << setprecision(1) << round(2.45);
Pokaż odpowiedź
cout << abs(3.8 - round(3.8));
Pokaż odpowiedź
cout << llround(-0.4) << " " << round(-0.4);
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ę.
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ę.
for (double x : {2.7, -2.7, 0.9, -0.9}) {
cout << x << ": " << (int)x << " " << trunc(x) << "\n";
}
(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.
int a = 2.9; // przypisanie do int też ucina
int b = -2.9;
cout << a << " " << b << "\n";
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.
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";
}
| x | floor | ceil | round | (int) |
|---|---|---|---|---|
| 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 |
Porównaj kolumny floor i (int). Dla liczb dodatnich są identyczne, dla ujemnych — (int) pokrywa się z ceil.
(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…
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ół”
−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:
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";
}
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.
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.
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
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.
double x = -2.3;
long long doZera = trunc(x); // -2
long long odZera = (x >= 0 ? ceil(x) : floor(x)); // -3
cout << doZera << " " << odZera << "\n";
Ciekawostka: round zaokrągla połówki właśnie „od zera” — dlatego round(-2.5) to −3.
(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).
Najpierw odpowiedz w myślach — narysuj sobie na kartce kawałek osi liczbowej i zaznacz na niej liczbę — a dopiero potem kliknij „Pokaż odpowiedź”.
cout << (int)5.99 << " " << trunc(5.99);
Pokaż odpowiedź
cout << (int)(-5.99);
Pokaż odpowiedź
cout << floor(-5.99) << " " << (int)(-5.99);
Pokaż odpowiedź
cout << -9 / 4 << " " << -9 % 4;
Pokaż odpowiedź
cout << floor(-9 / 4.0);
Pokaż odpowiedź
int a = -9, b = 4;
int q = a / b;
if (a % b < 0) q--;
cout << q;
Pokaż odpowiedź
int k = 7.99;
cout << k;
Pokaż odpowiedź
cout << trunc(-0.3);
Pokaż odpowiedź
cout << -1 / 7 << " " << floor(-1 / 7.0);
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ę.
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
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";
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).
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:
int k = 5;
for (int n = 20; n <= 26; n++) {
cout << n << ": " << n / k << " " << (n + k - 1) / k << "\n";
}
| n | n + 4 | (n + 4) / 5 |
|---|---|---|
| 20 | 24 | 4 |
| 21 | 25 | 5 |
| 24 | 28 | 5 |
| 25 | 29 | 5 |
| 26 | 30 | 6 |
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.
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
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.
(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.
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
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).
int k = 4;
for (int n : {5, 6, 7}) {
cout << n << " / " << k << " = " << (double)n / k
<< " -> " << (2 * n + k) / (2 * k) << "\n";
}
int zdali = 17, wszyscy = 23;
cout << 100 * zdali / wszyscy << "%\n"; // w dół
cout << (200 * zdali + wszyscy) / (2 * wszyscy) << "%\n"; // do najbliższej
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
int n = -9, k = 3;
cout << (n + k - 1) / k << "\n"; // -2 — źle!
cout << n / k << "\n"; // -3 — dobrze
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.
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";
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";
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.
Najpierw odpowiedz w myślach — narysuj sobie na kartce kawałek osi liczbowej i zaznacz na niej liczbę — a dopiero potem kliknij „Pokaż odpowiedź”.
cout << (17 + 4) / 5;
Pokaż odpowiedź
cout << (20 + 4) / 5;
Pokaż odpowiedź
cout << (21 + 4) / 5;
Pokaż odpowiedź
int n = 9, k = 3;
cout << n / k + (n % k != 0);
Pokaż odpowiedź
int n = 10, k = 3;
cout << n / k + (n % k != 0);
Pokaż odpowiedź
cout << (2 * 7 + 4) / (2 * 4);
Pokaż odpowiedź
cout << (2 * 5 + 4) / (2 * 4);
Pokaż odpowiedź
int c = 23, n = 4;
cout << c / n << " " << c % n;
Pokaż odpowiedź
cout << (0 + 9) / 10;
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ę.
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).
for (int a : {40, 41, 44, 45, 47, 49}) {
cout << a << ": " << a / 10 * 10 << " " << (a + 9) / 10 * 10
<< " " << (a + 5) / 10 * 10 << "\n";
}
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 k | wzór | przykład: a = 52, k = 15 |
|---|---|---|
| w dół | a / k * k | 52 / 15 = 3, 3 · 15 = 45 |
| w górę | (a + k - 1) / k * k | 66 / 15 = 4, 4 · 15 = 60 |
| do najbliższej (połówki w górę) | (a + k / 2) / k * k | 59 / 15 = 3, 3 · 15 = 45 |
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
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.
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.
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
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ę.
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";
}
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ę!
long long a, b, k;
cin >> a >> b >> k;
cout << b / k - (a - 1) / k << "\n";
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.
Najpierw odpowiedz w myślach — narysuj sobie na kartce kawałek osi liczbowej i zaznacz na niej liczbę — a dopiero potem kliknij „Pokaż odpowiedź”.
cout << 1234 / 100 * 100;
Pokaż odpowiedź
cout << (1234 + 99) / 100 * 100;
Pokaż odpowiedź
cout << (1250 + 50) / 100 * 100;
Pokaż odpowiedź
cout << (1249 + 50) / 100 * 100;
Pokaż odpowiedź
cout << (38 + 14) / 15 * 15;
Pokaż odpowiedź
cout << 20 / 3 - 9 / 3;
Pokaż odpowiedź
cout << 100 / 7;
Pokaż odpowiedź
cout << llround(1234.5 / 10) * 10;
Pokaż odpowiedź
cout << 47 * 10 / 10 << " " << 47 / 10 * 10;
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ę.
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.
| x | x * 100 | round(…) | … / 100 |
|---|---|---|---|
| 3.14159 | 314.159 | 314 | 3.14 |
| 2.71828 | 271.828 | 272 | 2.72 |
| 9.996 | 999.6 | 1000 | 10 |
| 0.004 | 0.4 | 0 | 0 |
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
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.
double x = 7.256;
cout << llround(x * 100) / 100 << "\n"; // 7 — dzielenie całkowite!
cout << llround(x * 100) / 100.0 << "\n"; // 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.
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
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ę:
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";
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.
double cena = round(3.0999 * 100) / 100; // 3.1
cout << cena << "\n";
cout << fixed << setprecision(2) << cena << "\n";
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ą.
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";
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ą…
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ć.
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";
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ź.
Najpierw odpowiedz w myślach — narysuj sobie na kartce kawałek osi liczbowej i zaznacz na niej liczbę — a dopiero potem kliknij „Pokaż odpowiedź”.
cout << round(2.468 * 100) / 100;
Pokaż odpowiedź
cout << floor(2.468 * 100) / 100;
Pokaż odpowiedź
cout << ceil(2.461 * 100) / 100;
Pokaż odpowiedź
cout << fixed << setprecision(2) << 3.0;
Pokaż odpowiedź
cout << llround(7.256 * 100) / 100;
Pokaż odpowiedź
cout << fixed << setprecision(0) << 4.5;
Pokaż odpowiedź
cout << fixed << setprecision(0) << round(4.5);
Pokaż odpowiedź
double x = 1.234;
cout << fixed << setprecision(1) << x << " " << x * 10;
Pokaż odpowiedź
cout << round(1234.5678 / 100) * 100;
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ę.
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
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ę
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:
Pułapka 1: (int) i floor po mnożeniu
Najczęstszy przypadek w zadaniach: cena w złotych, którą trzeba zamienić na grosze.
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
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.
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ół.
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";
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
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";
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”).
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";
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";
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.
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ł?
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.
cout << sqrt(16) << " " << sqrt(2) << " " << floor(sqrt(20)) << "\n";
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.
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";
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.
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.
Najpierw odpowiedz w myślach — narysuj sobie na kartce kawałek osi liczbowej i zaznacz na niej liczbę — a dopiero potem kliknij „Pokaż odpowiedź”.
cout << (0.5 + 0.25 == 0.75);
Pokaż odpowiedź
cout << (0.1 + 0.7 == 0.8);
Pokaż odpowiedź
cout << (int)(0.57 * 100);
Pokaż odpowiedź
cout << llround(0.57 * 100);
Pokaż odpowiedź
cout << floor(0.57 * 100 + 1e-9);
Pokaż odpowiedź
long long g = 1999;
cout << g / 100 << "." << setw(2) << setfill('0') << g % 100;
Pokaż odpowiedź
long long g = 105;
cout << g / 100 << "." << setw(2) << setfill('0') << g % 100;
Pokaż odpowiedź
long long k = 3;
while ((k + 1) * (k + 1) <= 20) k++;
cout << k;
Pokaż odpowiedź
double x = 4.35;
cout << (int)(x * 100);
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ń: 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.
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.
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.
Ś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.
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.