Maximilian.pottgiesser: Die Seite wurde neu angelegt: „{{DISPLAYTITLE:Zahlensysteme – Übungsaufgaben}} Kategorie:IT-Grundlagen Kategorie:Zahlensysteme Kategorie:Übungen Hier kannst du das Gelernte…“

2026-05-04T15:43:32Z

Die Seite wurde neu angelegt: „{{DISPLAYTITLE:Zahlensysteme – Übungsaufgaben}} Kategorie:IT-Grundlagen Kategorie:Zahlensysteme Kategorie:Übungen Hier kannst du das Gelernte…“

Neue Seite

{{DISPLAYTITLE:Zahlensysteme – Übungsaufgaben}}
[[Kategorie:IT-Grundlagen]]
[[Kategorie:Zahlensysteme]]
[[Kategorie:Übungen]]

Hier kannst du das Gelernte testen. Die Aufgaben sind in drei Schwierigkeitsstufen eingeteilt. '''Versuche jede Aufgabe selbst zu lösen''', bevor du die Lösung aufklappst.

Hilfe: [[Zahlensysteme – Ausführliche Rechenbeispiele]] · [[Zahlensystem-Umrechner]]

__TOC__

== Hinweise zum Lösen ==

=== Hilfsmittel: Die Stellenwerttabelle ===

Schreibe dir diese Zeile auf einen Zettel – sie reicht für alle Binäraufgaben:

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

=== Hilfsmittel: Die Hex-Zeichen ===

{| class="wikitable" style="text-align:center;"
! Hex !! 0 !! 1 !! 2 !! 3 !! 4 !! 5 !! 6 !! 7 !! 8 !! 9 !! A !! B !! C !! D !! E !! F
|-
| Dez || 0 || 1 || 2 || 3 || 4 || 5 || 6 || 7 || 8 || 9 || 10 || 11 || 12 || 13 || 14 || 15
|}

---

== Stufe 1 – Einsteiger ==

=== Aufgabe 1.1: Dezimal → Binär ===

Rechne folgende Dezimalzahlen in Binär (8 Bit) um:

# 8
# 16
# 64
# 128
# 255

{{Lösung|
# 8 = <code>00001000</code> (nur Bit 5 an: 8)
# 16 = <code>00010000</code> (nur Bit 4 an: 16)
# 64 = <code>01000000</code> (nur Bit 2 an: 64)
# 128 = <code>10000000</code> (nur Bit 1 an: 128)
# 255 = <code>11111111</code> (alle 8 Bits an: 128+64+32+16+8+4+2+1 = 255)

'''Tipp:''' Diese sind besonders einfach, weil es jeweils genau ein Bit (oder alle Bits) sind. Im Netzwerkalltag begegnen dir diese Werte ständig.
}}

---

=== Aufgabe 1.2: Binär → Dezimal ===

Rechne folgende Binärzahlen in Dezimal um:

# <code>00000001</code>
# <code>00000100</code>
# <code>00010000</code>
# <code>01000000</code>
# <code>10000000</code>

{{Lösung|
# <code>00000001</code> = '''1''' (Bit 8: Stellenwert 1)
# <code>00000100</code> = '''4''' (Bit 6: Stellenwert 4)
# <code>00010000</code> = '''16''' (Bit 4: Stellenwert 16)
# <code>01000000</code> = '''64''' (Bit 2: Stellenwert 64)
# <code>10000000</code> = '''128''' (Bit 1: Stellenwert 128)
}}

---

=== Aufgabe 1.3: Hex-Zeichen kennen ===

Welchen Dezimalwert haben diese Hex-Zeichen?

# F
# A
# C
# E
# B

{{Lösung|
# F = '''15'''
# A = '''10'''
# C = '''12'''
# E = '''14'''
# B = '''11'''

'''Merkhilfe:''' A=10, B=11, C=12, D=13, E=14, F=15 – einfach rückwärts von F=15 aus zählen.
}}

---

=== Aufgabe 1.4: Einfache Hex → Dezimal ===

Rechne um (zweistellige Hex-Werte):

# <code>10</code> (hex)
# <code>20</code> (hex)
# <code>0F</code> (hex)
# <code>FF</code> (hex)

{{Lösung|
# <code>10</code> = 1×16 + 0×1 = '''16'''
# <code>20</code> = 2×16 + 0×1 = '''32'''
# <code>0F</code> = 0×16 + 15×1 = '''15'''
# <code>FF</code> = 15×16 + 15×1 = 240+15 = '''255'''
}}

---

== Stufe 2 – Fortgeschritten ==

=== Aufgabe 2.1: Dezimal → Binär (gemischte Werte) ===

Rechne um:

# 42
# 77
# 100
# 200
# 223

{{Lösung|
'''1. 42 → Binär'''

128>42 → 0 · 64>42 → 0 · 32≤42 → 1, Rest 10 · 16>10 → 0 · 8≤10 → 1, Rest 2 · 4>2 → 0 · 2≤2 → 1, Rest 0 · 1>0 → 0

Ergebnis: <code>'''00101010'''</code> · Probe: 32+8+2 = 42 ✔

---

'''2. 77 → Binär'''

128>77 → 0 · 64≤77 → 1, Rest 13 · 32>13 → 0 · 16>13 → 0 · 8≤13 → 1, Rest 5 · 4≤5 → 1, Rest 1 · 2>1 → 0 · 1≤1 → 1, Rest 0

Ergebnis: <code>'''01001101'''</code> · Probe: 64+8+4+1 = 77 ✔

---

'''3. 100 → Binär'''

128>100 → 0 · 64≤100 → 1, Rest 36 · 32≤36 → 1, Rest 4 · 16>4 → 0 · 8>4 → 0 · 4≤4 → 1, Rest 0 · 2>0 → 0 · 1>0 → 0

Ergebnis: <code>'''01100100'''</code> · Probe: 64+32+4 = 100 ✔

---

'''4. 200 → Binär'''

128≤200 → 1, Rest 72 · 64≤72 → 1, Rest 8 · 32>8 → 0 · 16>8 → 0 · 8≤8 → 1, Rest 0 · 4>0 → 0 · 2>0 → 0 · 1>0 → 0

Ergebnis: <code>'''11001000'''</code> · Probe: 128+64+8 = 200 ✔

---

'''5. 223 → Binär'''

128≤223 → 1, Rest 95 · 64≤95 → 1, Rest 31 · 32≤31 → 1, Rest -1...

Warte – 31<32 → 0 · 16≤31 → 1, Rest 15 · 8≤15 → 1, Rest 7 · 4≤7 → 1, Rest 3 · 2≤3 → 1, Rest 1 · 1≤1 → 1, Rest 0

Ergebnis: <code>'''11011111'''</code> · Probe: 128+64+16+8+4+2+1 = 223 ✔
}}

---

=== Aufgabe 2.2: Binär → Dezimal (gemischte Werte) ===

Rechne um:

# <code>10110100</code>
# <code>01111110</code>
# <code>11100000</code>
# <code>00111111</code>
# <code>11010101</code>

{{Lösung|
'''1. <code>10110100</code>'''

Aktive Bits (Stellen mit 1): Position 1 (128), 3 (32), 4 (16), 6 (4)

128 + 32 + 16 + 4 = '''180'''

---

'''2. <code>01111110</code>'''

Aktive Bits: 64, 32, 16, 8, 4, 2

64+32+16+8+4+2 = '''126'''

''(Merke: Das ist die maximale Anzahl Hosts in einem /25-Netz!)''

---

'''3. <code>11100000</code>'''

Aktive Bits: 128, 64, 32

128+64+32 = '''224'''

''(Das ist die Subnetzmaske /27 als letztes Oktett: 255.255.255.224)''

---

'''4. <code>00111111</code>'''

Aktive Bits: 32, 16, 8, 4, 2, 1

32+16+8+4+2+1 = '''63'''

---

'''5. <code>11010101</code>'''

Aktive Bits: 128, 64, 16, 4, 1

128+64+16+4+1 = '''213'''
}}

---

=== Aufgabe 2.3: Dezimal → Hex ===

Rechne um:

# 16
# 31
# 160
# 171
# 240

{{Lösung|
'''1. 16 → Hex'''
16 ÷ 16 = 1, Rest 0 → 10 ÷ 16 = 0, Rest 1
Von unten: '''10''' · Probe: 1×16+0 = 16 ✔

---

'''2. 31 → Hex'''
31 ÷ 16 = 1, Rest 15 (=F) → 1 ÷ 16 = 0, Rest 1
Von unten: '''1F''' · Probe: 1×16+15 = 31 ✔

---

'''3. 160 → Hex'''
160 ÷ 16 = 10 (=A), Rest 0 → 10 ÷ 16 = 0, Rest 10 (=A)
Von unten: '''A0''' · Probe: 10×16+0 = 160 ✔

---

'''4. 171 → Hex'''
171 ÷ 16 = 10 (=A), Rest 11 (=B) → 10 ÷ 16 = 0, Rest 10 (=A)
Von unten: '''AB''' · Probe: 10×16+11 = 160+11 = 171 ✔

---

'''5. 240 → Hex'''
240 ÷ 16 = 15 (=F), Rest 0 → 15 ÷ 16 = 0, Rest 15 (=F)
Von unten: '''F0''' · Probe: 15×16+0 = 240 ✔

''(F0 = 240 ist die Subnetzmaske /28 als letztes Oktett)''
}}

---

=== Aufgabe 2.4: Binär ↔ Hex (Nibble-Methode) ===

Rechne mit der Nibble-Methode um (je 4 Bit = 1 Hex-Zeichen):

# <code>10110111</code> → Hex
# <code>01001110</code> → Hex
# <code>D4</code> (hex) → Binär
# <code>9E</code> (hex) → Binär

{{Lösung|
'''1. <code>10110111</code> → Hex'''

Aufteilen: <code>1011</code> | <code>0111</code>
* 1011 = 8+2+1 = 11 = '''B'''
* 0111 = 4+2+1 = 7 = '''7'''
Ergebnis: '''B7'''

---

'''2. <code>01001110</code> → Hex'''

Aufteilen: <code>0100</code> | <code>1110</code>
* 0100 = 4 = '''4'''
* 1110 = 8+4+2 = 14 = '''E'''
Ergebnis: '''4E'''

---

'''3. <code>D4</code> → Binär'''

* D = 13 = 1101
* 4 = 4 = 0100
Ergebnis: <code>'''11010100'''</code>

---

'''4. <code>9E</code> → Binär'''

* 9 = 9 = 1001
* E = 14 = 1110
Ergebnis: <code>'''10011110'''</code>

Probe (Dezimal): 128+16+8+4+2 = 158 · und 9×16+14 = 144+14 = 158 ✔
}}

---

== Stufe 3 – Netzwerkbezug ==

=== Aufgabe 3.1: IP-Adresse vollständig umrechnen ===

Rechne die IP-Adresse '''10.0.0.1''' komplett in Binär und Hex um.

{{Lösung|
{| class="wikitable"
! Oktett !! Dezimal !! Binär !! Hex
|-
| 1 || 10 || <code>00001010</code> || 0A
|-
| 2 || 0 || <code>00000000</code> || 00
|-
| 3 || 0 || <code>00000000</code> || 00
|-
| 4 || 1 || <code>00000001</code> || 01
|}

* Binär: <code>00001010.00000000.00000000.00000001</code>
* Hex: <code>0A.00.00.01</code>

10.0.0.0/8 ist ein privater Adressbereich (RFC 1918). Das erste Oktett 10 = 0A in Hex.
}}

---

=== Aufgabe 3.2: Subnetzmaske bestimmen ===

Welche Dezimal-Subnetzmaske gehört zu diesen CIDR-Angaben?

# /25
# /27
# /28
# /29

Hinweis: Das letzte Oktett entscheidet – die ersten drei Oktette sind immer 255.

{{Lösung|
'''Vorgehen:''' /25 bedeutet 25 Bits sind 1, also in den ersten drei Oktetten alle 24 Bits = 255.255.255, und im letzten Oktett noch 1 weiteres Bit von links.

{| class="wikitable"
! CIDR !! Bits im letzten Oktett !! Binär letztes Oktett !! Dezimal letztes Oktett !! Volle Maske
|-
| /25 || 1× Eins + 7× Null || <code>10000000</code> || 128 || 255.255.255.128
|-
| /27 || 3× Eins + 5× Null || <code>11100000</code> || 224 || 255.255.255.224
|-
| /28 || 4× Eins + 4× Null || <code>11110000</code> || 240 || 255.255.255.240
|-
| /29 || 5× Eins + 3× Null || <code>11111000</code> || 248 || 255.255.255.248
|}

'''Merke:''' Subnetzmasken haben immer einen Block Einsen, dann einen Block Nullen – nie gemischt.
}}

---

=== Aufgabe 3.3: IPv6-Kurzschreibweise ===

Kürze diese IPv6-Adressen so weit wie möglich:

# <code>2001:0db8:0000:0000:0000:0000:0000:0001</code>
# <code>fe80:0000:0000:0000:a1b2:c3d4:e5f6:0001</code>
# <code>0000:0000:0000:0000:0000:0000:0000:0001</code>

{{Lösung|
'''Regel 1:''' Führende Nullen in jeder Gruppe weglassen.

'''Regel 2:''' Die längste aufeinanderfolgende Sequenz von Null-Gruppen durch <code>::</code> ersetzen (nur einmal!).

---

'''1. <code>2001:0db8:0000:0000:0000:0000:0000:0001</code>'''

* Führende Nullen weg: <code>2001:db8:0:0:0:0:0:1</code>
* Fünf Nullgruppen (Gruppen 3–7) durch <code>::</code>: <code>'''2001:db8::1'''</code>

---

'''2. <code>fe80:0000:0000:0000:a1b2:c3d4:e5f6:0001</code>'''

* Führende Nullen weg: <code>fe80:0:0:0:a1b2:c3d4:e5f6:1</code>
* Drei Nullgruppen (2–4) durch <code>::</code>: <code>'''fe80::a1b2:c3d4:e5f6:1'''</code>

Dies ist eine typische Link-Local-Adresse (fe80::/10).

---

'''3. <code>0000:0000:0000:0000:0000:0000:0000:0001</code>'''

* Führende Nullen weg: <code>0:0:0:0:0:0:0:1</code>
* Sieben Nullgruppen durch <code>::</code>: <code>'''::1'''</code>

<code>::1</code> ist die IPv6-Loopback-Adresse – entspricht 127.0.0.1 bei IPv4.
}}

---

=== Aufgabe 3.4: MAC-Adresse analysieren ===

Gegeben ist die MAC-Adresse: <code>AC:DE:48:00:11:22</code>

# Wie viele Bytes hat eine MAC-Adresse?
# Welcher Teil identifiziert den Hersteller?
# Rechne das erste Byte <code>AC</code> in Dezimal und Binär um.
# Was bedeutet es, wenn das letzte Bit des ersten Bytes gesetzt ist?

{{Lösung|
'''1. Anzahl Bytes:''' Eine MAC-Adresse hat '''6 Bytes''' (48 Bit) – dargestellt als 12 Hex-Zeichen.

---

'''2. Hersteller-Teil:''' Die '''ersten 3 Bytes''' (<code>AC:DE:48</code>) sind der OUI (Organizationally Unique Identifier) und identifizieren den Hersteller der Netzwerkkarte. Die letzten 3 Bytes (<code>00:11:22</code>) sind die individuelle Gerätenummer.

---

'''3. <code>AC</code> umrechnen:'''

* A = 10, C = 12
* Dezimal: 10 × 16 + 12 = 160 + 12 = '''172'''
* Binär: A = 1010, C = 1100 → <code>'''10101100'''</code>

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

---

'''4. Letztes Bit des ersten Bytes (Multicast-Bit):'''

Das '''niedrigste Bit''' (rechtes Bit, Stellenwert 1) des ersten Bytes ist das sogenannte '''Multicast-Bit'''.
* Bit = 0 → Unicast-Adresse (normale Einzelgerät-Adresse)
* Bit = 1 → Multicast-Adresse (an eine Gruppe gerichtet)

Bei <code>AC</code> = <code>10101100</code>: Das letzte Bit ist '''0''' → Unicast ✔
}}

---

=== Aufgabe 3.5: Bonusaufgabe – Alles zusammen ===

Gegeben ist die IP-Adresse <code>172.31.255.254</code> mit der Subnetzmaske /16.

# Rechne alle vier Oktette der IP in Binär um.
# Rechne die Subnetzmaske /16 in Dezimal und Binär aus.
# Welche Bits gehören zum Netzanteil, welche zum Hostanteil?
# Wie viele Hosts passen maximal in dieses Netz?

{{Lösung|
'''1. IP-Adresse in Binär:'''

{| class="wikitable"
! Oktett !! Dezimal !! Binär
|-
| 1 || 172 || <code>10101100</code>
|-
| 2 || 31 || <code>00011111</code>
|-
| 3 || 255 || <code>11111111</code>
|-
| 4 || 254 || <code>11111110</code>
|}

172: 128+32+8+4 = 172 ✔ · 31: 16+8+4+2+1 = 31 ✔ · 254: 128+64+32+16+8+4+2 = 254 ✔

---

'''2. Subnetzmaske /16:'''

16 Bits sind 1 (die ersten beiden Oktette), die anderen 16 sind 0.

* Dezimal: '''255.255.0.0'''
* Binär: <code>11111111.11111111.00000000.00000000</code>

---

'''3. Netz- vs. Hostanteil:'''

* '''Netzanteil''' (erste 16 Bit): <code>10101100.00011111</code> = 172.31
* '''Hostanteil''' (letzte 16 Bit): <code>11111111.11111110</code> = 255.254

Die IP 172.31.255.254 liegt also im Netz 172.31.0.0/16.

---

'''4. Anzahl möglicher Hosts:'''

16 Bit für den Hostanteil → 2¹⁶ = 65.536 mögliche Adressen.

Davon abziehen: 1× Netzadresse (172.31.0.0) + 1× Broadcast (172.31.255.255) = '''65.534 nutzbare Hosts'''.

Die gegebene Adresse 172.31.255.254 ist die letzte nutzbare Hostadresse vor dem Broadcast.
}}

---

== Selbsttest: Schnellfragen ==

Beantworte diese Fragen ohne Hilfsmittel – die Antworten sollten nach dem Üben sitzen:

# Wie viele Bits hat ein Byte?
# Was ist der maximale Wert eines Bytes in Dezimal?
# Was ist FF in Dezimal?
# Was ist 192 in Hex?
# Was ist die Subnetzmaske /24 in Dezimal?
# Wie viele Zeichen hat eine IPv6-Adresse (vollständig, mit Doppelpunkten)?
# Was bedeutet <code>::1</code> in IPv6?
# Wie heißt der Hersteller-Teil einer MAC-Adresse?

{{Lösung|
# Ein Byte hat '''8 Bits'''.
# Maximalwert eines Bytes: '''255''' (= 11111111 = FF)
# FF = 15×16 + 15 = '''255'''
# 192 ÷ 16 = 12 (C), Rest 0 → '''C0'''
# /24 = '''255.255.255.0'''
# Vollständige IPv6: 8 Gruppen × 4 Zeichen + 7 Doppelpunkte = '''39 Zeichen'''
# <code>::1</code> ist die '''Loopback-Adresse''' (entspricht 127.0.0.1 bei IPv4)
# Der Hersteller-Teil heißt '''OUI''' (Organizationally Unique Identifier)
}}

---

== Weiterführende Seiten ==

* [[Zahlensysteme – Ausführliche Rechenbeispiele]] – Jeden Schritt nachlesen
* [[Zahlensystem-Umrechner]] – Vollständige Nachschlagetabelle 0–255
* [[Binärsystem]] · [[Hexadezimalsystem und IP-Adressen]]

Zahlensysteme – Übungsaufgaben - Versionsgeschichte

Maximilian.pottgiesser: Die Seite wurde neu angelegt: „{{DISPLAYTITLE:Zahlensysteme – Übungsaufgaben}} Kategorie:IT-Grundlagen Kategorie:Zahlensysteme Kategorie:Übungen Hier kannst du das Gelernte…“