Systemy liczbowe - teoria
Wprowadzenie
Systemy liczbowe to sposób reprezentacji liczb przy użyciu określonego zestawu symboli i reguł. W życiu codziennym używamy systemu dziesiętnego (10 cyfr: 0-9), ale komputery operują na systemie binarnym (2 cyfry: 0-1).
Zrozumienie różnych systemów liczbowych jest kluczowe dla: - Programowania niskopoziomowego (assembler, sterowniki) - Operacji bitowych (flagi, maski, optymalizacje) - Debugowania (analiza pamięci, rejestrów) - Kryptografii (kodowanie, szyfrowanie) - Sieci komputerowych (adresy IP, maski podsieci) - Grafiki komputerowej (kolory RGB w HEX)
System pozycyjny - podstawy
Definicja systemu pozycyjnego
System pozycyjny o podstawie b używa b różnych cyfr do reprezentacji liczb, gdzie wartość każdej cyfry zależy od jej pozycji.
Liczba w systemie o podstawie b:
N = dₙ × b^n + dₙ₋₁ × b^(n-1) + ... + d₁ × b^1 + d₀ × b^0
gdzie:
- b - podstawa systemu
- dᵢ - cyfra na pozycji i (0 ≤ dᵢ < b)
- Pozycje numerowane od prawej (od 0)
Przykład: System dziesiętny (DEC)
Podstawa: b = 10 Cyfry: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
Liczba 1234₁₀:
1234₁₀ = 1×10³ + 2×10² + 3×10¹ + 4×10⁰
= 1×1000 + 2×100 + 3×10 + 4×1
= 1000 + 200 + 30 + 4
= 1234
Interpretacja:
- Cyfra 4 na pozycji 0 (jedności)
- Cyfra 3 na pozycji 1 (dziesiątki)
- Cyfra 2 na pozycji 2 (setki)
- Cyfra 1 na pozycji 3 (tysiące)
Podstawowe systemy liczbowe
1. System binarny (BIN, dwójkowy)
Podstawa: b = 2 Cyfry: 0, 1
Przykład: 1011₂
1011₂ = 1×2³ + 0×2² + 1×2¹ + 1×2⁰
= 1×8 + 0×4 + 1×2 + 1×1
= 8 + 0 + 2 + 1
= 11₁₀
Zastosowania: - Reprezentacja danych w komputerach - Logika cyfrowa (0 = fałsz, 1 = prawda) - Operacje bitowe
Notacja:
- Prefiks: 0b (Python: 0b1011)
- Indeks: 1011₂ lub 1011B
2. System ósemkowy (OCT)
Podstawa: b = 8 Cyfry: 0, 1, 2, 3, 4, 5, 6, 7
Przykład: 157₈
157₈ = 1×8² + 5×8¹ + 7×8⁰
= 1×64 + 5×8 + 7×1
= 64 + 40 + 7
= 111₁₀
Zastosowania:
- Uprawnienia plików w Unix/Linux (chmod 755)
- Kompaktowa reprezentacja binarna (3 bity → 1 cyfra OCT)
Notacja:
- Prefiks: 0o (Python: 0o157)
- Indeks: 157₈
3. System szesnastkowy (HEX)
Podstawa: b = 16 Cyfry: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F
Mapowanie:
0-9 → 0-9 (wartość dziesiętna)
A → 10, B → 11, C → 12, D → 13, E → 14, F → 15
Przykład: 2F₁₆
2F₁₆ = 2×16¹ + F×16⁰
= 2×16 + 15×1
= 32 + 15
= 47₁₀
Zastosowania:
- Adresy pamięci (0x7FFF)
- Kolory w HTML/CSS (#FF5733)
- Kody błędów systemowych
- Bardzo kompaktowa reprezentacja binarna (4 bity → 1 cyfra HEX)
Notacja:
- Prefiks: 0x (Python: 0x2F, C: 0x2F)
- Indeks: 2F₁₆ lub 2Fh
- HTML: #2F (kolory)
Porównanie systemów
| System | Podstawa | Cyfry | Przykład | Wartość DEC |
|---|---|---|---|---|
| Binarny (BIN) | 2 | 0, 1 | 1010 |
10 |
| Ósemkowy (OCT) | 8 | 0-7 | 12 |
10 |
| Dziesiętny (DEC) | 10 | 0-9 | 10 |
10 |
| Szesnastkowy (HEX) | 16 | 0-9, A-F | A |
10 |
Ta sama wartość w różnych systemach:
Liczba 255 (dziesiętnie):
DEC: 255
BIN: 11111111
OCT: 377
HEX: FF
Relacje między systemami
BIN ↔ OCT (prosty związek)
1 cyfra OCT = 3 bity BIN
OCT → BIN (grupowanie po 3 bity od prawej):
157₈ = 001 101 111₂
1 5 7
BIN → OCT:
001101111₂ = 157₈
Tabela mapowania:
OCT | BIN
----|------
0 | 000
1 | 001
2 | 010
3 | 011
4 | 100
5 | 101
6 | 110
7 | 111
BIN ↔ HEX (bardzo prosty związek)
1 cyfra HEX = 4 bity BIN
HEX → BIN (grupowanie po 4 bity od prawej):
2F₁₆ = 0010 1111₂
2 F
BIN → HEX:
00101111₂ = 2F₁₆
Tabela mapowania:
HEX | BIN | DEC
----|------|----
0 | 0000 | 0
1 | 0001 | 1
2 | 0010 | 2
3 | 0011 | 3
4 | 0100 | 4
5 | 0101 | 5
6 | 0110 | 6
7 | 0111 | 7
8 | 1000 | 8
9 | 1001 | 9
A | 1010 | 10
B | 1011 | 11
C | 1100 | 12
D | 1101 | 13
E | 1110 | 14
F | 1111 | 15
Implementacja w Pythonie
Reprezentacja liczb w różnych systemach
Wyjście:
DEC: 255
BIN: 0b11111111
OCT: 0o377
HEX: 0xFF
Wszystkie równe? True
Konwersja między systemami
Wyjście:
=== Reprezentacje liczby 42 ===
Liczba: 42
DEC: 42
BIN: 0b101010
OCT: 0o52
HEX: 0x2a
Bez prefiksów:
DEC: 42
BIN: 101010
OCT: 52
HEX: 2A
Parsowanie z różnych systemów
Wyjście:
=== Parsowanie z różnych systemów ===
'101010' (BIN) = 42
'52' (OCT) = 42
'2A' (HEX) = 42
'0b101010' = 42
'0o52' = 42
'0x2A' = 42
'0b101010' (auto) = 42
'0o52' (auto) = 42
'0x2A' (auto) = 42
Właściwe liczby w różnych systemach
Liczby specjalne
Wyjście:
=== Potęgi dwójki ===
Potęga DEC BIN HEX
---------------------------------------------
2^0 1 1 1
2^1 2 10 2
2^2 4 100 4
2^3 8 1000 8
2^4 16 10000 10
2^5 32 100000 20
2^6 64 1000000 40
2^7 128 10000000 80
2^8 256 100000000 100
2^9 512 1000000000 200
2^10 1024 10000000000 400
Maksymalne wartości dla typów całkowitych
Praktyczne zastosowania
1. Kolory w grafice (RGB w HEX)
Wyjście:
=== Kolory RGB ↔ HEX ===
RGB(255, 0, 0) → #FF0000 → RGB(255, 0, 0)
RGB( 0, 255, 0) → #00FF00 → RGB(0, 255, 0)
RGB( 0, 0, 255) → #0000FF → RGB(0, 0, 255)
RGB(255, 255, 0) → #FFFF00 → RGB(255, 255, 0)
RGB(128, 0, 128) → #800080 → RGB(128, 0, 128)
RGB(255, 165, 0) → #FFA500 → RGB(255, 165, 0)
2. Adresy IP (reprezentacja binarna)
Wyjście:
=== Adresy IP ===
192.168.1.1 → 11000000.10101000.00000001.00000001
(weryfikacja: 192.168.1.1)
10.0.0.1 → 00001010.00000000.00000000.00000001
(weryfikacja: 10.0.0.1)
255.255.255.0 → 11111111.11111111.11111111.00000000
(weryfikacja: 255.255.255.0)
8.8.8.8 → 00001000.00001000.00001000.00001000
(weryfikacja: 8.8.8.8)
3. Uprawnienia Unix (chmod w OCT)
Wyjście:
=== Uprawnienia Unix (chmod) ===
rwxr-xr-x → chmod 755 → rwxr-xr-x
rw-r--r-- → chmod 644 → rw-r--r--
rwxrwxrwx → chmod 777 → rwxrwxrwx
r-------- → chmod 400 → r--------
Systemy o dowolnych podstawach
Konwersja do dowolnej podstawy
Wyjście:
=== Konwersja do różnych podstaw ===
Liczba 1000 w różnych systemach:
Podstawa 2: 1111101000 (weryfikacja: 1000)
Podstawa 3: 1101001 (weryfikacja: 1000)
Podstawa 5: 13000 (weryfikacja: 1000)
Podstawa 7: 2626 (weryfikacja: 1000)
Podstawa 8: 1750 (weryfikacja: 1000)
Podstawa 12: 6B4 (weryfikacja: 1000)
Podstawa 16: 3E8 (weryfikacja: 1000)
Podstawa 20: 2A0 (weryfikacja: 1000)
Podstawa 36: RS (weryfikacja: 1000)
Arytmetyka w różnych systemach
Dodawanie binarne
Wyjście:
=== Dodawanie binarne ===
1011 (11)
+ 0110 (6)
--------------------
= 10001 (17)
Kroki:
Pozycja 0: 1 + 0 + 0(przeniesienie) = 1 → bit=1, carry=0
Pozycja 1: 1 + 1 + 0(przeniesienie) = 2 → bit=0, carry=1
Pozycja 2: 0 + 1 + 1(przeniesienie) = 2 → bit=0, carry=1
Pozycja 3: 1 + 0 + 1(przeniesienie) = 2 → bit=0, carry=1
Końcowe przeniesienie: 1
Podsumowanie
Kluczowe pojęcia
| Pojęcie | Definicja |
|---|---|
| System pozycyjny | Reprezentacja liczb gdzie wartość cyfry zależy od pozycji |
| Podstawa (base) | Liczba unikalnych cyfr w systemie |
| BIN (podstawa 2) | System używany przez komputery (0, 1) |
| OCT (podstawa 8) | Kompaktowa reprezentacja binarna (1 cyfra = 3 bity) |
| DEC (podstawa 10) | System dziesiętny używany przez ludzi |
| HEX (podstawa 16) | Bardzo kompaktowa reprezentacja (1 cyfra = 4 bity) |
Szybkie konwersje
BIN ↔ OCT: Grupuj po 3 bity
BIN ↔ HEX: Grupuj po 4 bity
HEX ↔ DEC: Użyj wag pozycji (16^i)
Praktyczne zastosowania
✅ Kolory: #FF5733 w HTML/CSS
✅ Adresy IP: binarna reprezentacja oktetów
✅ Uprawnienia Unix: chmod 755
✅ Adresy pamięci: 0x7FFF0000
✅ Debugowanie: analiza rejestrów, pamięci
Co dalej?
Po opanowaniu teorii systemów liczbowych, następne kroki to:
- Lekcja 61: Przeliczanie BIN ↔ DEC
- Algorytmy konwersji
- Implementacja od zera
-
Optymalizacje
-
Lekcja 62: Przeliczanie DEC ↔ HEX
- Konwersja szesnastkowa
-
Zastosowania w programowaniu
-
Lekcja 63: Przeliczanie między dowolnymi systemami
- Uniwersalne algorytmy
-
Systemy o podstawach > 36
-
Lekcja 64: Operacje bitowe w algorytmach
- AND, OR, XOR, NOT
- Przesunięcia bitowe
- Praktyczne zastosowania
Zadania praktyczne
Zadanie 1: Kalkulator systemów
Napisz kalkulator, który przyjmuje liczbę w dowolnym systemie i wyświetla ją we wszystkich popularnych systemach (BIN, OCT, DEC, HEX).
Zadanie 2: Konwerter kolorów
Stwórz program konwertujący między RGB, HEX i HSL (Hue, Saturation, Lightness).
Zadanie 3: Analiza adresów IP
Napisz funkcję sprawdzającą czy dwa adresy IP należą do tej samej podsieci na podstawie maski.
Zadanie 4: System o podstawie N
Zaimplementuj klasę reprezentującą liczby w systemie o dowolnej podstawie (2-62 używając cyfr, liter małych i wielkich).
Następna lekcja: Przeliczanie BIN ↔ DEC - algorytmy konwersji