Algorytmy konwersji DEC-BIN, DEC-HEX, DEC-OCT i odwrotnie
ð Podstawa programowa: I.2aAby zamienic liczbe dziesietna na binarna, dzielimy ja kolejno przez 2 i zapisujemy reszty z dzielenia. Wynik odczytujemy od dolu do gory.
Przyklad: 42 (DEC) -> BIN
42 / 2 = 21 reszta 0
21 / 2 = 10 reszta 1
10 / 2 = 5 reszta 0
5 / 2 = 2 reszta 1
2 / 2 = 1 reszta 0
1 / 2 = 0 reszta 1
Odczytujemy od dolu: 101010
Wynik: 42 (DEC) = 101010 (BIN)
Mnopymy kazda cyfre binarna przez odpowiednia potege liczby 2 (od prawej: 2^0, 2^1, 2^2...) i sumujemy wyniki.
Przyklad: 110101 (BIN) -> DEC
Pozycja: 5 4 3 2 1 0
Cyfra: 1 1 0 1 0 1
Potega: 2^5 2^4 2^3 2^2 2^1 2^0
Wartosc: 32 16 0 4 0 1
Suma: 32 + 16 + 0 + 4 + 0 + 1 = 53
Wynik: 110101 (BIN) = 53 (DEC)
Dzielimy liczbe kolejno przez 16 i zapisujemy reszty. Pamietaj: reszty 10-15 zapisujemy jako A-F.
Przyklad: 500 (DEC) -> HEX
500 / 16 = 31 reszta 4 -> 4
31 / 16 = 1 reszta 15 -> F
1 / 16 = 0 reszta 1 -> 1
Odczytujemy od dolu: 1F4
Wynik: 500 (DEC) = 1F4 (HEX)
Mnopymy kazda cyfre szesnastkowa przez odpowiednia potege liczby 16 i sumujemy.
Przyklad: 2B7 (HEX) -> DEC
Pozycja: 2 1 0
Cyfra: 2 B(11) 7
Potega: 16^2 16^1 16^0
Wartosc: 512 176 7
Suma: 512 + 176 + 7 = 695
Wynik: 2B7 (HEX) = 695 (DEC)
Dzielimy liczbe kolejno przez 8 i zapisujemy reszty od dolu.
Przyklad: 200 (DEC) -> OCT
200 / 8 = 25 reszta 0
25 / 8 = 3 reszta 1
3 / 8 = 0 reszta 3
Odczytujemy od dolu: 310
Wynik: 200 (DEC) = 310 (OCT)
Kazda cyfra szesnastkowa odpowiada dokladnie 4 bitom. Dlatego mozna szybko konwertowac miedzy BIN a HEX, grupujac bity po 4 (od prawej):
Przyklad: 10110111 (BIN) -> HEX
Grupujemy po 4 bity od prawej:
1011 | 0111
B 7
Wynik: 10110111 (BIN) = B7 (HEX)
---
Przyklad odwrotny: A3 (HEX) -> BIN
A = 1010
3 = 0011
Wynik: A3 (HEX) = 10100011 (BIN)
Kazda cyfra osemkowa odpowiada dokladnie 3 bitom:
Przyklad: 110101011 (BIN) -> OCT
Grupujemy po 3 bity od prawej:
110 | 101 | 011
6 5 3
Wynik: 110101011 (BIN) = 653 (OCT)
# Ogolna funkcja konwersji z DEC na dowolny system
def dec_na_system(liczba, podstawa):
cyfry = "0123456789ABCDEF"
if liczba == 0:
return "0"
wynik = ""
while liczba > 0:
reszta = liczba % podstawa
wynik = cyfry[reszta] + wynik
liczba = liczba // podstawa
return wynik
# Testy
print(dec_na_system(42, 2)) # 101010
print(dec_na_system(500, 16)) # 1F4
print(dec_na_system(200, 8)) # 310
Zamien nastepujace liczby dziesietne na binarne (pokaz caly proces dzielenia):
a) 25
b) 100
c) 64
a) 25 / 2 = 12 r 1
12 / 2 = 6 r 0
6 / 2 = 3 r 0
3 / 2 = 1 r 1
1 / 2 = 0 r 1
25 (DEC) = 11001 (BIN)
b) 100 / 2 = 50 r 0
50 / 2 = 25 r 0
25 / 2 = 12 r 1
12 / 2 = 6 r 0
6 / 2 = 3 r 0
3 / 2 = 1 r 1
1 / 2 = 0 r 1
100 (DEC) = 1100100 (BIN)
c) 64 / 2 = 32 r 0
32 / 2 = 16 r 0
16 / 2 = 8 r 0
8 / 2 = 4 r 0
4 / 2 = 2 r 0
2 / 2 = 1 r 0
1 / 2 = 0 r 1
64 (DEC) = 1000000 (BIN)
Zamien nastepujace liczby binarne na dziesietne:
a) 100112
b) 11100102
c) 111111112
a) 10011 = 1x16 + 0x8 + 0x4 + 1x2 + 1x1 = 19
b) 1110010 = 64 + 32 + 16 + 0 + 0 + 2 + 0 = 114
c) 11111111 = 128+64+32+16+8+4+2+1 = 255
Wykonaj konwersje (pokaz pelny proces):
a) 255 (DEC) na HEX
b) 1000 (DEC) na HEX
c) 3C7 (HEX) na DEC
d) BABE (HEX) na DEC
a) 255 / 16 = 15 r 15 -> F
15 / 16 = 0 r 15 -> F
255 (DEC) = FF (HEX)
b) 1000 / 16 = 62 r 8 -> 8
62 / 16 = 3 r 14 -> E
3 / 16 = 0 r 3 -> 3
1000 (DEC) = 3E8 (HEX)
c) 3C7 = 3x256 + 12x16 + 7x1 = 768 + 192 + 7 = 967
d) BABE = 11x4096 + 10x256 + 11x16 + 14x1
= 45056 + 2560 + 176 + 14 = 47806
Uzyj metody grupowania po 4 bity:
a) 11011110 (BIN) na HEX
b) 101011110011 (BIN) na HEX
c) F0A (HEX) na BIN
a) 1101 | 1110 -> D | E = DE (HEX)
b) 1010 | 1111 | 0011 -> A | F | 3 = AF3 (HEX)
c) F = 1111, 0 = 0000, A = 1010
F0A = 111100001010 (BIN)
Wykonaj konwersje:
a) 511 (DEC) na OCT
b) 1234 (OCT) na DEC
c) 777 (OCT) na BIN (przez DEC lub metoda skrotowa)
a) 511 / 8 = 63 r 7
63 / 8 = 7 r 7
7 / 8 = 0 r 7
511 (DEC) = 777 (OCT)
b) 1234 (OCT) = 1x512 + 2x64 + 3x8 + 4x1
= 512 + 128 + 24 + 4 = 668 (DEC)
c) Metoda skrotowa (grupowanie po 3 bity):
7 = 111, 7 = 111, 7 = 111
777 (OCT) = 111111111 (BIN)
Sprawdzenie: 111111111 = 511 (DEC) - zgadza sie!
Wykonaj pelny lancuch konwersji dla liczby 199:
DEC -> BIN -> OCT -> HEX
Sprawdz wynik konwertujac HEX z powrotem na DEC.
DEC -> BIN:
199/2=99 r1, 99/2=49 r1, 49/2=24 r1, 24/2=12 r0
12/2=6 r0, 6/2=3 r0, 3/2=1 r1, 1/2=0 r1
199 (DEC) = 11000111 (BIN)
BIN -> OCT (grupowanie po 3):
011 | 000 | 111 = 307 (OCT)
BIN -> HEX (grupowanie po 4):
1100 | 0111 = C7 (HEX)
Sprawdzenie HEX -> DEC:
C7 = 12x16 + 7x1 = 192 + 7 = 199 - zgadza sie!