Lernpfad:Das Dualsystem/4

Du kennst vielleicht noch die visuelle Programmierumgebung Scratch. Mit Ihr lassen sich auch Programme zur Umrechnung von Dualzahlen erstellen. Dazu findest Du hier einige Hinweise, die Dir bei der Entwicklung helfen.

Du solltest schon einmal mit Scratch gearbeitet haben und die folgenden Konzepte kennen, damit Du die Programme erfolgreich umsetzen kannst:

• Ich kenne bedingte Anweisungen (falls <> dann :: stack),
• ich kenne Schleifen (wiederhole bis <> :: stack, wiederhole () mal :: stack),
• ich kenne Variablen ((dezimal), setze (dezimal) auf (), ändere (dezimal) um ()).

Dezimalzahlen in Dualzahlen umrechnen

Um eine Dezimalzahl in eine Dualzahl umzurechnen, hast Du das Moduloverfahren kennengelernt. Dieses lässt sich relativ leicht in Scratch als Programm umsetzen.

Arbeitsauftrag

Frische Dein Wissen über das Moduloverfahren auf und wende es auf die folgenden Beispiele an:

1. [math]\displaystyle{ (65)_{10} }[/math]
2. [math]\displaystyle{ (71)_{10} }[/math]
3. [math]\displaystyle{ (1000)_{10} }[/math]

Lösung

1. [math]\displaystyle{ (65)_{10} = (1000001)_2 }[/math]
2. [math]\displaystyle{ (71)_{10} = (1000111)_2 }[/math]
3. [math]\displaystyle{ (1000)_{10} = (1111101000)_2 }[/math]

Beispiel zur Umrechnung:

[math]\displaystyle{ \begin{align*} 65 : 2 &= 32 \,\text{R} 1 \\ 32 : 2 &= 16 \,\text{R} 0 \\ 16 : 2 &= 8 \,\text{R} 0 \\ 8 : 2 &= 4 \,\text{R} 0 \\ 4 : 2 &= 2 \,\text{R} 0 \\ 2 : 2 &= 1 \,\text{R} 0 \\ 1 : 2 &= 0 \,\text{R} 1 \\ \end{align*} }[/math]

Also [math]\displaystyle{ (65)_{10} = (1000001)_2 }[/math]

Das Programm setzt das Verfahren genau um. Erstelle dazu ein neues Projekt in Scratch und wähle die Figur der Scratch-Katze aus. Erstelle folgendes Grundgerüst des Programms:

Wenn diese Figur angeklickt wird :: events hat
frage [Gib eine Dezimalzahl ein.] und warte
setze [dezimal v] auf (Antwort)
setze [binaer v] auf ( )
 // füge hier weitere Blöcke ein
sage (binaer)

Die Blöcke für die Variablen (dezimal) und (binaer) müsst Ihr dazu zunächst im Bereich  Variablen erstellen.

Arbeitsauftrag

Vervollständige das Programm zur Umrechnung von Dezimalzahlen in Dualzahlen mittels des Moduloverfahrens.

Zu beachten ist, dass die Binärzahl nicht als Zahl generiert wird, sondern als Text! Du kannst zwei Texte mit dem Block (verbinde ( ) und ( ) :: operators) zusammenfügen.

Du kannst versuchen, selber eine Lösung zu finden, oder die folgenden Tipps verwenden. Sobald das Programm funktioniert, kannst Du Deine Lösung mit der Musterlösung vergleichen.

Tipp 1

Um das Programm zu vervollständigen, reichen die folgenden Blöcke:

• wiederhole bis < >
• <( ) = (0)>
• setze [ v] auf ( )
• setze [ v] auf ( )
• (verbinde ( ) und ( ) :: operators)
• (( ) mod ( )) (die Modulo-Operation, also teilen mit Rest)
• ([abrunden v] von ( )
• (( ) / (2))
• (dezimal)
• (dezimal)
• (dezimal)
• (binaer)

Tipp 2

Überlege zunächst, wie Du das "Teilen mit Rest" in Scratch umsetzen kannst. Eine Modulo-Operation ist in Scratch vorhanden. Um das Ergebnis der Division mit Rest zu finden, kannst Du auch eine normale Division (ohne Rest) durchführen und das Ergebnis abrunden!

Das Ergebnis der Modulo-Operation kannst Du mit dem "verbinden" Block mit Deiner binear Variable verknüpfen. Überlege, an welcher Seite der bestehenden Binärzahl die neue Ziffer angefügt wird.

Überlege zuletzt, wie oft der Vorgang durchgeführt werden muss. Was ist die "Abbruchbedingung", ab der die Schleife aufhören soll, die Befehle in ihrem Inneren auszuführen?

Lösung

Wenn diese Figur angeklickt wird :: events hat
frage [Gib eine Dezimalzahl ein.] und warte
setze [dezimal v] auf (Antwort)
setze [binaer v] auf ( )
wiederhole bis <(dezimal) = (0)>
  setze [binear v] auf (verbinde ((dezimal) mod (2)) und (binear) :: operators)
  setze [dezimal v] auf ([abrunden v] von ((dezimal) / (2)))
end
sage (binaer)

Dualzahlen in Dezimalzahlen umrechnen

Das Umrechnen von Dualzahlen in Dezimalzahlen ist auf dem Papier leicht zu machen. Die Formel zur Umrechnung hast Du bereits kennengelernt:

[math]\displaystyle{ (1100111)_2 = 1\cdot 2^6 + 1\cdot 2^5 + 0\cdot 2^4 + 0\cdot 2^3 + 1\cdot 2^2 + 1\cdot 2^1 + 1\cdot 2^0 = (103)_{10} }[/math]

Arbeitsauftrag

Rechne die Zahlen ins Dezimalsystem um:

1. [math]\displaystyle{ (1101)_{2} }[/math]
2. [math]\displaystyle{ (101101)_{2} }[/math]
3. [math]\displaystyle{ (1000)_{2} }[/math]

Lösung

1. [math]\displaystyle{ (1101)_{2} = (13)_{10} }[/math]
2. [math]\displaystyle{ (101101)_{2} = (45)_{10} }[/math]
3. [math]\displaystyle{ (1000)_{2} = (8)_{10} }[/math]

Die Umsetzung in Scratch ist allerdings etwas schwieriger, da es keine Potenzieren-Operation gibt. Die Rechnung [math]\displaystyle{ 2^n }[/math] lässt sich daher nicht so einfach lösen.

Arbeitsauftrag

Entwickle ein Scratch-Programm, dass eine (positive ganze) Zahl [math]\displaystyle{ b }[/math] mit einem (positive ganzen) Exponenten [math]\displaystyle{ e }[/math] potenziert. Also die Aufgabe [math]\displaystyle{ b^e }[/math] löst.

Erstelle dafür in Deinem bestehenden Programm von oben eine weitere Figur, in der Du arbeitest.

Tipp

Mach Dir klar, wie eine Potenz durch Additionen berechnet werden kann.

Beachte auch den Sonderfall [math]\displaystyle{ e = 0 }[/math], denn dann ist das Ergebnis immer [math]\displaystyle{ 1 }[/math]!

Die Umsetzung in Scratch erfolgt mit einer Zählschleife.

Lösung

Wenn diese Figur angeklickt wird :: events hat
frage [Gib eine Basis ein.] und warte
setze [b v] auf (Antwort)
frage [Gib einen Exponenten ein.] und warte
setze [e v] auf (Antwort)
setze [potenz v] auf (1)
wiederhole (e) mal
  setze [potenz v] auf ((potenz) * (b))
end
sage (potenz)

Arbeitsauftrag

Entwickle ein Scratch-Programm zur Umrechnung einer Dualzahl in eine Dezimalzahl.

Nutze dazu Dein Potenzieren-Programm von oben.

Dieses Programm ist deutlich komplexer, als das zur Umrechnung einer Dezimalzahl mit dem Moduloverfahren. Scheue Dich also nicht, die Tipps anzusehen, falls Du nicht weiter kommst.

Tipp

Die eingegebene Dualzahl ist wieder keine Zahl, sondern ein Text mit einzelnen Zeichen, die entweder 0 oder 1 sind. Das Ziel ist es, die Dualzahl Zeichen für Zeichen von rechts nach links durchzugehen und bei einer 1 die entsprechende Potenz von 2 auf das Ergebnis zu addieren.

Dazu musst Du

• eine Zählvariable (z.B. i) erstellen, die auf 0 gesetzt wird,
• eine Schleife starten, die so oft durchläuft, wie die Binärzahl Zeichen hat (Länge der Binärzahl),
  • auf das i-te Zeichen von rechts zugreifen (also das Zeichen an Stelle "Länge der Binärzahl minus i"),
  • wenn das Zeichen eine 1 ist,
    • die Potenz [math]\displaystyle{ 2^i }[/math] berechnen,
    • die Potenz auf das Ergebnis addieren.
  • i um 1 erhöhen.

Lösung

Wenn diese Figur angeklickt wird :: events hat
frage [Gib eine Binärzahl ein.] und warte
setze [binaer v] auf (Antwort)
setze [dezimal v] auf (1)
setze [i v] auf (0)
wiederhole (Länge von (binaer)) mal
  falls <(Zeichen ((Länge von (binaer)) - (i)) von (binaer)) = (1)> dann
    setze [potenz v] auf (1)
    wiederhole (i) mal
      setze [potenz v] auf ((potenz) * (2))
    end
    ändere [dezimal v] um (pow)
  end
  ändere [i v] um (1)
end
sage (dezimal)