FISI // Zahlensysteme umrechnen: Dezimal, Binär, Hexadezimal

Ob Subnetzmaske, MAC-Adresse, Farbcode im HTML oder Fehlercode im Ereignisprotokoll: Als Fachinformatiker begegnen dir Binär- und Hexadezimalzahlen ständig. In der Berufsschule und in der Abschlussprüfung kommen sie als Rechenaufgabe, meistens ohne Taschenrechner mit Programmiermodus. Du musst die Umrechnung also von Hand beherrschen, und zwar zügig.

Gute Nachricht: Es gibt im Kern nur zwei Verfahren. Eines für den Weg vom Dezimalsystem weg, eines für den Weg zurück. Dazu kommt eine Abkürzung zwischen Binär und Hex, die du nach ein paar Übungen im Kopf rechnest.

Ziel

Nach diesem Beitrag kannst du

• erklären, wie ein Stellenwertsystem aufgebaut ist und was die Basis bedeutet,
• Dezimalzahlen mit der Division mit Rest ins Binär- und Hexadezimalsystem umrechnen,
• Binär- und Hexzahlen über die Stellenwerte zurück ins Dezimalsystem rechnen,
• zwischen Binär und Hexadezimal direkt über 4er-Gruppen (Nibbles) wechseln,
• deine Ergebnisse mit PowerShell gegenprüfen.

Stellenwertsysteme in zwei Minuten

Alle drei Systeme funktionieren nach demselben Prinzip. Jede Stelle hat einen Wert, der eine Potenz der Basis ist. Ganz rechts steht die Basis hoch 0, also immer 1. Nach links wird es jeweils um den Faktor der Basis mehr.

Im Hexadezimalsystem reichen die Ziffern 0 bis 9 nicht aus, deshalb stehen A bis F für die Werte 10 bis 15. Die Zuordnung solltest du auswendig können:

Die kleine tiefgestellte Zahl (Index) oder der Buchstabe hinter der Zahl ist wichtig. „10“ kann zehn sein, zwei (binär) oder sechzehn (hex). Ohne Kennzeichnung ist die Aufgabe mehrdeutig, und in der Prüfung kostet ein fehlender Index gern einen Punkt.

Der Grund, warum es Hex überhaupt gibt: 16 ist 2⁴. Eine Hexziffer entspricht damit genau vier Bit, zwei Hexziffern genau einem Byte. Lange Bitfolgen werden dadurch kurz und lesbar, ohne dass beim Umrechnen etwas verloren geht. Wie Text, Bilder und Töne überhaupt zu Bits werden, steht im Beitrag Datendarstellung.

Dezimal in Binär: Division mit Rest

Du teilst die Dezimalzahl immer wieder ganzzahlig durch 2 und notierst jeweils den Rest. Das machst du so lange, bis das Ergebnis der Division 0 ist. Danach liest du die Reste von unten nach oben. Der erste Rest ist das niederwertigste Bit (ganz rechts), der letzte das höchstwertige (ganz links).

Beispiel: 45₁₀ in Binär

Von unten nach oben gelesen: 45₁₀ = 101101₂

Die Gegenprobe machst du über die Stellenwerte: 32 + 8 + 4 + 1 = 45. Passt.

Das Verfahren heißt auch Modulo-Rechnung, weil der Rest genau das ist, was der Operator mod (in PowerShell %) liefert.

Alternative: Stellenwerte abziehen

Bei kleinen Zahlen ist ein zweiter Weg oft schneller. Du schreibst dir die Zweierpotenzen auf (128, 64, 32, 16, 8, 4, 2, 1) und ziehst von links nach rechts ab, was hineinpasst. Wo etwas abgezogen wurde, steht eine 1, sonst eine 0.

Beispiel: 200₁₀

200 − 128 = 72, 72 − 64 = 8, 8 − 8 = 0. Ergebnis: 200₁₀ = 11001000₂

Dieser Weg ist bei IP-Adressen und Subnetzmasken praktisch, weil du dort ohnehin in Oktetten mit 8 Bit denkst. Mehr dazu im Beitrag zu den IPv4-Adressklassen.

Dezimal in Hexadezimal

Gleiches Verfahren, nur teilst du durch 16. Reste von 10 bis 15 schreibst du sofort als Buchstaben A bis F, sonst steht am Ende eine zweistellige Zahl in einer einzigen Stelle und das Ergebnis ist falsch.

Beispiel: 300₁₀ in Hex

Von unten nach oben: 300₁₀ = 12C₁₆

Ein Tipp für die Division durch 16 ohne Taschenrechner: Schreib dir das Sechzehner-Einmaleins an den Rand (16, 32, 48, 64, 80, 96, 112, 128, 144, 160 …). Dann siehst du schnell, dass 300 zwischen 288 (18 · 16) und 304 liegt, und der Rest ist 300 − 288 = 12.

Zurück ins Dezimalsystem: Stellenwerte addieren

Für den Rückweg multiplizierst du jede Ziffer mit ihrem Stellenwert und addierst alles. Bei Binärzahlen ist das besonders einfach, weil jede Ziffer 0 oder 1 ist. Du addierst also nur die Stellenwerte, unter denen eine 1 steht.

Beispiel binär: 1100101₂

64 + 32 + 4 + 1 = 101₁₀

Beispiel hexadezimal: 2F4₁₆

512 + 240 + 4 = 756₁₀

Rechne die Stellen immer von rechts aus durch und fang bei Potenz 0 an. Wer links mit 16¹ startet, liegt bei jeder Stelle um den Faktor 16 daneben.

Binär und Hexadezimal direkt umrechnen

Hier lohnt sich der Umweg über das Dezimalsystem nicht. Weil eine Hexziffer genau vier Bit entspricht, kannst du stellenweise übersetzen. Eine Gruppe aus vier Bit heißt Nibble (Halbbyte), die Stellenwerte darin sind immer 8, 4, 2, 1.

Hex in Binär

Jede Hexziffer wird einzeln durch ihre vier Bit ersetzt. Aus n Hexstellen werden immer 4 · n Bit.

Beispiel: 7E₁₆ → 7 = 0111, E = 1110 → 0111 1110₂ (= 126₁₀)

Ein Beispiel aus dem Admin-Alltag: Die IPv4-Adresse 192.168.10.1 sieht in Hex so aus: C0.A8.0A.01. Jedes Oktett sind genau zwei Hexziffern. In Paketmitschnitten mit Wireshark begegnet dir diese Darstellung ständig.

Binär in Hex

Du teilst die Bitfolge von rechts beginnend in Vierergruppen. Bleibt links eine unvollständige Gruppe übrig, füllst du sie gedanklich mit führenden Nullen auf. Danach übersetzt du jede Gruppe in eine Hexziffer.

Beispiel: 111010110₂

1 1101 0110      von rechts gruppiert
0001 1101 0110   links mit Nullen aufgefüllt
  1    D    6

Ergebnis: 111010110₂ = 1D6₁₆

Gegenprobe über Dezimal: 1 · 256 + 13 · 16 + 6 = 256 + 208 + 6 = 470. Und binär: 256 + 128 + 64 + 16 + 4 + 2 = 470. Beide Wege kommen auf dieselbe Zahl.

Und Oktal?

Das Oktalsystem (Basis 8, Ziffern 0–7) funktioniert genauso, nur mit Dreiergruppen statt Vierergruppen. In der Praxis siehst du es fast nur noch bei Linux-Dateirechten: chmod 750 heißt binär 111 101 000, also rwx für den Besitzer, r-x für die Gruppe und nichts für alle anderen. In Prüfungen ist Oktal selten, das Gruppierungsprinzip solltest du aber kennen.

Praxis: Ergebnisse mit PowerShell prüfen

In der Prüfung hilft dir PowerShell nicht, beim Üben schon. Damit kontrollierst du deine Lösungen, ohne dass dir jemand die Rechenwege vorgibt. Für die einfachen Fälle reichen .NET-Bordmittel:

# Dezimal -> Binär / Oktal (Basis 2, 8 oder 16 als zweiter Parameter)
[Convert]::ToString(45, 2)          # 101101
[Convert]::ToString(488, 8)         # 750

# Dezimal -> Hex über den Format-Operator (X = Großbuchstaben, X2 = mindestens zwei Stellen)
'{0:X}'  -f 300                     # 12C
'{0:X2}' -f 10                      # 0A

# Binär / Hex -> Dezimal
[Convert]::ToInt32('101101', 2)     # 45
[Convert]::ToInt32('2F4', 16)       # 756

# PowerShell versteht Hex-Literale direkt, ab Version 7 auch Binär-Literale
0x2F4                               # 756
0b101101                            # 45

# IPv4-Adresse oktettweise in Hex
('192.168.10.1'.Split('.') | ForEach-Object { '{0:X2}' -f [int]$_ }) -join ' '   # C0 A8 0A 01

Wenn du den Rechenweg sehen willst, um deine Zwischenschritte zu vergleichen, hilft eine kleine Funktion. Sie macht genau das, was du auf dem Papier machst: Division mit Rest, bis der Quotient 0 ist.

function ConvertTo-Basis {
    param(
        [Parameter(Mandatory)][ValidateRange(0, [int]::MaxValue)][int]$Zahl,
        [ValidateSet(2, 8, 16)][int]$Basis = 2
    )
    $ziffern  = '0123456789ABCDEF'
    $rest     = $Zahl
    $ergebnis = ''

    # Division mit Rest, bis der Quotient 0 ist
    do {
        $quotient = [math]::Floor($rest / $Basis)
        $r        = $rest % $Basis
        Write-Host ('{0,6} : {1,2} = {2,6}   Rest {3,2}  ->  {4}' -f $rest, $Basis, $quotient, $r, $ziffern[$r])
        # neuer Rest kommt nach VORNE, das entspricht "von unten nach oben lesen"
        $ergebnis = $ziffern[$r] + $ergebnis
        $rest     = $quotient
    } while ($rest -gt 0)

    $ergebnis
}

ConvertTo-Basis -Zahl 300 -Basis 16

Ausgabe unter PowerShell 7:

   300 : 16 =     18   Rest 12  ->  C
    18 : 16 =      1   Rest  2  ->  2
     1 : 16 =      0   Rest  1  ->  1
12C

Der Kniff steckt in $ergebnis = $ziffern[$r] + $ergebnis. Jeder neue Rest wird vorne angehängt. Das ist dasselbe wie das Lesen von unten nach oben auf dem Papier. Über $ziffern[$r] wird aus einem Rest von 12 automatisch das C.

Stolperfallen

Reste in der falschen Richtung gelesen. Der häufigste Fehler überhaupt. Der erste Rest gehört ganz nach rechts. Wer von oben nach unten liest, bekommt die Bitfolge gespiegelt: 45 wird dann zu 101101, was zufällig passt, aber 200 wird zu 00010011 statt 11001000. Mach immer die Gegenprobe.

Zu früh aufgehört. Die Division läuft, bis das Ergebnis 0 ist, nicht bis es 1 ist. Die letzte Zeile (1 : 2 = 0 Rest 1) liefert das höchstwertige Bit. Fehlt sie, fehlt die führende 1.

Zweistellige Reste bei Hex. Ein Rest von 12 ist die Ziffer C. Wer „1 2“ statt „C“ hinschreibt, hat eine Stelle zu viel und das Ergebnis ist falsch.

Von links gruppiert. Beim Wechsel von Binär nach Hex wird immer von rechts in Vierergruppen geteilt. 111010110 von links gruppiert ergibt 1110 1011 0 und damit Unsinn. Fehlende Stellen werden links mit Nullen aufgefüllt, nie rechts.

Stellenwert bei 1 statt 0 angefangen. Die rechte Stelle hat immer den Wert Basis⁰ = 1. Wer mit 16¹ beginnt, multipliziert alles mit 16 zu viel.

Index vergessen. Schreib bei jedem Ergebnis dazu, in welchem System es steht (₂, ₁₆, B, H oder 0x). Ohne Index ist 100 nicht eindeutig.

Negative Zahlen. Das Divisionsverfahren gilt für positive ganze Zahlen. Für negative Werte brauchst du das Zweierkomplement. Wie das funktioniert, steht in Zweierkomplementdarstellung im Binärsystem verstehen, Wertebereiche und Rechnen damit in Teil 2.

Zum Üben

Rechne diese Aufgaben von Hand und prüf sie danach mit PowerShell:

1. 86₁₀ in Binär und in Hex
2. 10111100₂ in Hex und in Dezimal
3. 3A7₁₆ in Binär und in Dezimal
4. 250₁₀ in Binär mit der Subtraktionsmethode

Lösungen: 1. 1010110₂ und 56₁₆, 2. BC₁₆ und 188₁₀, 3. 0011 1010 0111₂ und 935₁₀, 4. 11111010₂.

Fazit

Für jede Richtung gibt es ein festes Verfahren. Vom Dezimalsystem weg teilst du mit Rest durch die Zielbasis und liest die Reste von unten nach oben. Zurück ins Dezimalsystem multiplizierst du jede Ziffer mit ihrem Stellenwert und addierst. Zwischen Binär und Hex gehst du über Vierergruppen, von rechts gezählt. Mit diesen drei Werkzeugen und der Gegenprobe am Ende sind Umrechnungsaufgaben in der Prüfung sichere Punkte.