Maximilian.pottgiesser: Die Seite wurde neu angelegt: „{{DISPLAYTITLE:Zahlensysteme – Ausführliche Rechenbeispiele}} Kategorie:IT-Grundlagen Kategorie:Zahlensysteme Diese Seite zeigt jeden Umrechnungswe…“

2026-05-04T15:43:12Z

Die Seite wurde neu angelegt: „{{DISPLAYTITLE:Zahlensysteme – Ausführliche Rechenbeispiele}} Kategorie:IT-Grundlagen Kategorie:Zahlensysteme Diese Seite zeigt jeden Umrechnungswe…“

Neue Seite

{{DISPLAYTITLE:Zahlensysteme – Ausführliche Rechenbeispiele}}
[[Kategorie:IT-Grundlagen]]
[[Kategorie:Zahlensysteme]]

Diese Seite zeigt jeden Umrechnungsweg mit '''mehreren ausführlichen Beispielen''' – jeden Schritt einzeln erklärt, so dass man dem Rechenweg folgen kann ohne Vorkenntnisse.

Siehe auch: [[Binärsystem]] · [[Hexadezimalsystem und IP-Adressen]] · [[Zahlensystem-Umrechner]] · [[Zahlensysteme – Übungsaufgaben]]

__TOC__

== Grundprinzip: Stellenwerte ==

In jedem Zahlensystem hat jede Stelle einen '''Stellenwert'''. Im Dezimalsystem kennt man das schon:

{| class="wikitable" style="text-align:center;"
! !! Tausender !! Hunderter !! Zehner !! Einer
|-
| '''Stellenwert''' || 1000 || 100 || 10 || 1
|-
| '''Beispiel: 1347''' || 1 || 3 || 4 || 7
|-
| '''Rechnung''' || 1×1000 || 3×100 || 4×10 || 7×1
|}

1000 + 300 + 40 + 7 = '''1347''' — das macht man automatisch, ohne nachzudenken.

Genau dasselbe Prinzip gilt für Binär (Basis 2) und Hex (Basis 16). Nur die Stellenwerte ändern sich.

---

== Dezimal → Binär ==

=== Methode: Subtraktionsmethode (empfohlen für Einsteiger) ===

Die 8 Stellenwerte von links nach rechts abarbeiten: '''128 – 64 – 32 – 16 – 8 – 4 – 2 – 1'''

Für jede Stelle die Frage: ''Ist mein aktueller Restwert größer oder gleich diesem Stellenwert?''
* Ja → Bit = '''1''', Stellenwert vom Restwert abziehen
* Nein → Bit = '''0''', Restwert bleibt gleich

---

=== Beispiel 1: 42 → Binär ===

{| class="wikitable"
! Schritt !! Stellenwert !! Restwert vorher !! Frage !! Bit !! Restwert nachher
|-
| 1 || 128 || 42 || 42 ≥ 128? Nein || '''0''' || 42
|-
| 2 || 64 || 42 || 42 ≥ 64? Nein || '''0''' || 42
|-
| 3 || 32 || 42 || 42 ≥ 32? Ja || '''1''' || 42 − 32 = 10
|-
| 4 || 16 || 10 || 10 ≥ 16? Nein || '''0''' || 10
|-
| 5 || 8 || 10 || 10 ≥ 8? Ja || '''1''' || 10 − 8 = 2
|-
| 6 || 4 || 2 || 2 ≥ 4? Nein || '''0''' || 2
|-
| 7 || 2 || 2 || 2 ≥ 2? Ja || '''1''' || 2 − 2 = 0
|-
| 8 || 1 || 0 || 0 ≥ 1? Nein || '''0''' || 0
|}

Bits von oben nach unten ablesen: <code>'''00101010'''</code>

'''Probe:''' 32 + 8 + 2 = '''42''' ✔

---

=== Beispiel 2: 195 → Binär ===

{| class="wikitable"
! Schritt !! Stellenwert !! Restwert vorher !! Frage !! Bit !! Restwert nachher
|-
| 1 || 128 || 195 || 195 ≥ 128? Ja || '''1''' || 195 − 128 = 67
|-
| 2 || 64 || 67 || 67 ≥ 64? Ja || '''1''' || 67 − 64 = 3
|-
| 3 || 32 || 3 || 3 ≥ 32? Nein || '''0''' || 3
|-
| 4 || 16 || 3 || 3 ≥ 16? Nein || '''0''' || 3
|-
| 5 || 8 || 3 || 3 ≥ 8? Nein || '''0''' || 3
|-
| 6 || 4 || 3 || 3 ≥ 4? Nein || '''0''' || 3
|-
| 7 || 2 || 3 || 3 ≥ 2? Ja || '''1''' || 3 − 2 = 1
|-
| 8 || 1 || 1 || 1 ≥ 1? Ja || '''1''' || 1 − 1 = 0
|}

Ergebnis: <code>'''11000011'''</code>

'''Probe:''' 128 + 64 + 2 + 1 = '''195''' ✔

---

=== Beispiel 3: 172 → Binär (typische IP-Adresse) ===

172 ist der erste Teil von <code>172.16.x.x</code> – einem privaten Netzbereich.

{| class="wikitable"
! Schritt !! Stellenwert !! Restwert vorher !! Frage !! Bit !! Restwert nachher
|-
| 1 || 128 || 172 || 172 ≥ 128? Ja || '''1''' || 172 − 128 = 44
|-
| 2 || 64 || 44 || 44 ≥ 64? Nein || '''0''' || 44
|-
| 3 || 32 || 44 || 44 ≥ 32? Ja || '''1''' || 44 − 32 = 12
|-
| 4 || 16 || 12 || 12 ≥ 16? Nein || '''0''' || 12
|-
| 5 || 8 || 12 || 12 ≥ 8? Ja || '''1''' || 12 − 8 = 4
|-
| 6 || 4 || 4 || 4 ≥ 4? Ja || '''1''' || 4 − 4 = 0
|-
| 7 || 2 || 0 || 0 ≥ 2? Nein || '''0''' || 0
|-
| 8 || 1 || 0 || 0 ≥ 1? Nein || '''0''' || 0
|}

Ergebnis: <code>'''10101100'''</code>

'''Probe:''' 128 + 32 + 8 + 4 = '''172''' ✔

---

== Binär → Dezimal ==

=== Methode: Stellenwerte der aktiven Bits addieren ===

Jedes Bit mit dem Wert '''1''' trägt seinen Stellenwert zur Summe bei. Bits mit '''0''' werden ignoriert.

Stellenwerte zur Erinnerung:
{| class="wikitable" style="text-align:center;"
! Position (von links) !! 1 !! 2 !! 3 !! 4 !! 5 !! 6 !! 7 !! 8
|-
| Stellenwert || 128 || 64 || 32 || 16 || 8 || 4 || 2 || 1
|}

---

=== Beispiel 1: <code>01101101</code> → Dezimal ===

{| class="wikitable" style="text-align:center;"
! Position !! 1 !! 2 !! 3 !! 4 !! 5 !! 6 !! 7 !! 8
|-
| Stellenwert || 128 || 64 || 32 || 16 || 8 || 4 || 2 || 1
|-
| Bit || 0 || 1 || 1 || 0 || 1 || 1 || 0 || 1
|-
| Beitrag || – || '''64''' || '''32''' || – || '''8''' || '''4''' || – || '''1'''
|}

64 + 32 + 8 + 4 + 1 = '''109'''

---

=== Beispiel 2: <code>11111100</code> → Dezimal (Subnetzmaske /30) ===

{| class="wikitable" style="text-align:center;"
! Position !! 1 !! 2 !! 3 !! 4 !! 5 !! 6 !! 7 !! 8
|-
| Stellenwert || 128 || 64 || 32 || 16 || 8 || 4 || 2 || 1
|-
| Bit || 1 || 1 || 1 || 1 || 1 || 1 || 0 || 0
|-
| Beitrag || '''128''' || '''64''' || '''32''' || '''16''' || '''8''' || '''4''' || – || –
|}

128 + 64 + 32 + 16 + 8 + 4 = '''252'''

Das ist die Subnetzmaske für /30 – man erkennt das Muster: Subnetzmasken haben immer erst lauter Einsen, dann lauter Nullen.

---

=== Beispiel 3: <code>10000000</code> → Dezimal (Subnetzmaske /25) ===

{| class="wikitable" style="text-align:center;"
! Position !! 1 !! 2 !! 3 !! 4 !! 5 !! 6 !! 7 !! 8
|-
| Stellenwert || 128 || 64 || 32 || 16 || 8 || 4 || 2 || 1
|-
| Bit || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 0
|-
| Beitrag || '''128''' || – || – || – || – || – || – || –
|}

Nur das erste Bit ist an: '''128'''

Das ist das letzte Oktett der Subnetzmaske 255.255.255.128 = /25.

---

== Dezimal → Hexadezimal ==

=== Methode: Division durch 16 ===

# Den Wert durch 16 dividieren
# Den '''Rest''' notieren (das ist die rechte Hex-Stelle)
# Das '''Ergebnis''' wieder durch 16 dividieren
# Wiederholen bis das Ergebnis 0 ist
# Reste von unten nach oben lesen – Werte 10–15 als A–F schreiben

---

=== Beispiel 1: 200 → Hex ===

{| class="wikitable"
! Schritt !! Rechnung !! Ergebnis !! Rest !! Rest als Hex
|-
| 1 || 200 ÷ 16 || 12 || 8 || 8
|-
| 2 || 12 ÷ 16 || 0 || 12 || C
|}

Reste von unten nach oben: '''C8'''

'''Probe:''' C = 12, also 12 × 16 + 8 = 192 + 8 = '''200''' ✔

---

=== Beispiel 2: 255 → Hex ===

{| class="wikitable"
! Schritt !! Rechnung !! Ergebnis !! Rest !! Rest als Hex
|-
| 1 || 255 ÷ 16 || 15 || 15 || F
|-
| 2 || 15 ÷ 16 || 0 || 15 || F
|}

Ergebnis: '''FF'''

255 = FF – das ist der maximal mögliche Wert eines Bytes, und der Wert für „alle Bits an" in einer Subnetzmaske.

---

=== Beispiel 3: 192 → Hex ===

{| class="wikitable"
! Schritt !! Rechnung !! Ergebnis !! Rest !! Rest als Hex
|-
| 1 || 192 ÷ 16 || 12 || 0 || 0
|-
| 2 || 12 ÷ 16 || 0 || 12 || C
|}

Ergebnis: '''C0'''

192 = C0 – das erste Oktett jeder 192.168.x.x-Adresse ist in Hex immer C0.

---

=== Beispiel 4: 172 → Hex ===

{| class="wikitable"
! Schritt !! Rechnung !! Ergebnis !! Rest !! Rest als Hex
|-
| 1 || 172 ÷ 16 || 10 || 12 || C
|-
| 2 || 10 ÷ 16 || 0 || 10 || A
|}

Ergebnis: '''AC'''

'''Probe:''' A = 10, C = 12 → 10 × 16 + 12 = 160 + 12 = '''172''' ✔

---

== Hexadezimal → Dezimal ==

=== Methode: Stellenwerte multiplizieren und addieren ===

Hex-Stellenwerte (von rechts): 16⁰ = 1, 16¹ = 16, 16² = 256, …

Bei zweistelligen Hex-Werten (= ein Byte):
* Linke Stelle × 16
* Rechte Stelle × 1
* Beide addieren

Buchstaben umrechnen: A=10, B=11, C=12, D=13, E=14, F=15

---

=== Beispiel 1: B4 → Dezimal ===

{| class="wikitable"
! Stelle !! Zeichen !! Wert (Dezimal) !! × Stellenwert !! Beitrag
|-
| Links || B || 11 || × 16 || 176
|-
| Rechts || 4 || 4 || × 1 || 4
|}

176 + 4 = '''180'''

---

=== Beispiel 2: FE → Dezimal ===

{| class="wikitable"
! Stelle !! Zeichen !! Wert (Dezimal) !! × Stellenwert !! Beitrag
|-
| Links || F || 15 || × 16 || 240
|-
| Rechts || E || 14 || × 1 || 14
|}

240 + 14 = '''254'''

FE = 254 – das ist die Subnetzmaske /31 als letztes Oktett.

---

=== Beispiel 3: A8 → Dezimal ===

{| class="wikitable"
! Stelle !! Zeichen !! Wert (Dezimal) !! × Stellenwert !! Beitrag
|-
| Links || A || 10 || × 16 || 160
|-
| Rechts || 8 || 8 || × 1 || 8
|}

160 + 8 = '''168'''

A8 = 168 – das zweite Oktett von 192.'''168'''.x.x in Hex.

---

== Binär → Hexadezimal ==

=== Methode: Nibble-Methode (schnellster Weg) ===

Ein Byte wird in zwei '''Nibbles''' (je 4 Bit) aufgeteilt. Jedes Nibble wird separat in eine Hex-Ziffer umgewandelt.

Nibble-Tabelle:
{| class="wikitable" style="text-align:center;"
! Binär !! Dezimal !! Hex
|-
| 0000 || 0 || 0
|-
| 0001 || 1 || 1
|-
| 0010 || 2 || 2
|-
| 0011 || 3 || 3
|-
| 0100 || 4 || 4
|-
| 0101 || 5 || 5
|-
| 0110 || 6 || 6
|-
| 0111 || 7 || 7
|-
| 1000 || 8 || 8
|-
| 1001 || 9 || 9
|-
| 1010 || 10 || A
|-
| 1011 || 11 || B
|-
| 1100 || 12 || C
|-
| 1101 || 13 || D
|-
| 1110 || 14 || E
|-
| 1111 || 15 || F
|}

---

=== Beispiel 1: <code>11000000</code> → Hex ===

Aufteilen: <code>1100</code> | <code>0000</code>

{| class="wikitable"
! Nibble !! Binär !! Dezimal !! Hex
|-
| Links || 1100 || 12 || C
|-
| Rechts || 0000 || 0 || 0
|}

Ergebnis: '''C0''' (= 192 dezimal)

---

=== Beispiel 2: <code>10101000</code> → Hex ===

Aufteilen: <code>1010</code> | <code>1000</code>

{| class="wikitable"
! Nibble !! Binär !! Dezimal !! Hex
|-
| Links || 1010 || 10 || A
|-
| Rechts || 1000 || 8 || 8
|}

Ergebnis: '''A8''' (= 168 dezimal)

---

=== Beispiel 3: <code>11111000</code> → Hex ===

Aufteilen: <code>1111</code> | <code>1000</code>

{| class="wikitable"
! Nibble !! Binär !! Dezimal !! Hex
|-
| Links || 1111 || 15 || F
|-
| Rechts || 1000 || 8 || 8
|}

Ergebnis: '''F8''' (= 248 dezimal – Subnetzmaske /29)

---

== Hexadezimal → Binär ==

=== Methode: Jede Hex-Ziffer einzeln in 4 Bit umwandeln ===

---

=== Beispiel 1: <code>C0</code> → Binär ===

{| class="wikitable"
! Hex-Ziffer !! Dezimalwert !! Binär (4 Bit)
|-
| C || 12 || 1100
|-
| 0 || 0 || 0000
|}

Zusammensetzen: <code>'''11000000'''</code> (= 192)

---

=== Beispiel 2: <code>FF</code> → Binär ===

{| class="wikitable"
! Hex-Ziffer !! Dezimalwert !! Binär (4 Bit)
|-
| F || 15 || 1111
|-
| F || 15 || 1111
|}

Zusammensetzen: <code>'''11111111'''</code> (= 255 – alle Bits an)

---

=== Beispiel 3: <code>3D</code> → Binär ===

{| class="wikitable"
! Hex-Ziffer !! Dezimalwert !! Binär (4 Bit)
|-
| 3 || 3 || 0011
|-
| D || 13 || 1101
|}

Zusammensetzen: <code>'''00111101'''</code>

'''Probe (Dezimal):''' 32 + 16 + 8 + 4 + 1 = '''61''' · und 3×16 + 13 = 48 + 13 = '''61''' ✔

---

== Praxisbeispiel: Komplette IP-Adresse umrechnen ==

=== Beispiel: 192.168.10.1 → Binär und Hex ===

Jedes Oktett wird einzeln umgerechnet:

{| class="wikitable"
! Oktett !! Dezimal !! Rechnung Binär !! Binär !! Rechnung Hex !! Hex
|-
| 1 || 192 || 128+64 || <code>11000000</code> || 192÷16=12 R0 → C0 || <code>C0</code>
|-
| 2 || 168 || 128+32+8 || <code>10101000</code> || 168÷16=10 R8 → A8 || <code>A8</code>
|-
| 3 || 10 || 8+2 || <code>00001010</code> || 10÷16=0 R10 → 0A || <code>0A</code>
|-
| 4 || 1 || 1 || <code>00000001</code> || 1÷16=0 R1 → 01 || <code>01</code>
|}

'''Ergebnisse:'''
* Dezimal: <code>192.168.10.1</code>
* Binär: <code>11000000.10101000.00001010.00000001</code>
* Hex: <code>C0.A8.0A.01</code>

---

=== Beispiel: Subnetzmaske /26 vollständig darstellen ===

/26 bedeutet: die ersten 26 Bits sind 1, der Rest ist 0.

26 Bits aufgeteilt auf 4 Oktette: 8 + 8 + 8 + 2 → letztes Oktett hat 2 Einsen, 6 Nullen.

{| class="wikitable"
! Oktett !! Bits !! Binär !! Dezimal !! Hex
|-
| 1 || 8× Eins || <code>11111111</code> || 255 || FF
|-
| 2 || 8× Eins || <code>11111111</code> || 255 || FF
|-
| 3 || 8× Eins || <code>11111111</code> || 255 || FF
|-
| 4 || 2× Eins + 6× Null || <code>11000000</code> || 192 || C0
|}

Subnetzmaske /26 = '''255.255.255.192''' = <code>FF.FF.FF.C0</code>

== Weiterführende Seiten ==

* [[Zahlensysteme – Übungsaufgaben]] – Jetzt selbst üben!
* [[Zahlensystem-Umrechner]] – Nachschlagetabelle 0–255
* [[Binärsystem]] · [[Hexadezimalsystem und IP-Adressen]]

Zahlensysteme Ausführliche Rechenbeispiele - Versionsgeschichte

Maximilian.pottgiesser: Die Seite wurde neu angelegt: „{{DISPLAYTITLE:Zahlensysteme – Ausführliche Rechenbeispiele}} Kategorie:IT-Grundlagen Kategorie:Zahlensysteme Diese Seite zeigt jeden Umrechnungswe…“