Lernpfad:Das Dualsystem/4: Unterschied zwischen den Versionen

← Zum vorherigen Versionsunterschied

Lernpfad:Das Dualsystem/4 (Quelltext anzeigen)

Version vom 23. August 2023, 18:04 Uhr

6.548 Bytes hinzugefügt , 18:04, 23. Aug. 2023

keine Bearbeitungszusammenfassung

Ngb

Bürokraten, Oberflächenadministratoren, Administratoren, Benutzer

493

Bearbeitungen

@@ Zeile 18: / Zeile 18: @@
 # <math>(1000)_{10}</math>
 {{Aufgabe:End}}
+{{Lösung:Start}}
+# <math>(65)_{10} = (1000001)_2</math>
+# <math>(71)_{10} = (1000111)_2</math>
+# <math>(1000)_{10} = (1111101000)_2</math>
+'''Beispiel zur Umrechnung''':
+<math>
+\begin{align*}
+: 2 &= 32 \,\text{R} 1 \\
+: 2 &= 16 \,\text{R} 0 \\
+: 2 &= 8 \,\text{R} 0 \\
+: 2 &= 4 \,\text{R} 0 \\
+: 2 &= 2 \,\text{R} 0 \\
+: 2 &= 1 \,\text{R} 0 \\
+: 2 &= 0 \,\text{R} 1 \\
+\end{align*}
+</math>
+Also <math>(65)_{10} = (1000001)_2</math>
+{{Lösung:End}}
+Das Programm setzt das Verfahren genau um. Erstelle dazu ein neues Projekt in {{Scratch|link}} und wähle die Figur der Scratch-Katze aus. Erstelle folgendes Grundgerüst des Programms:
+<scratchblocks>
+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)
+</scratchblocks>
+Die Blöcke für die Variablen <sb>(dezimal)</sb> und <sb>(binaer)</sb> müsst Ihr dazu zunächst im Bereich {{Scratch3/Kategorie|Variablen}} erstellen.
+{{Aufgabe:Start}}
+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 <sb>(verbinde ( ) und ( ) :: operators)</sb> 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.
+{{Aufgabe:End}}
+{{Tipp:Start|Tipp 1}}
+Um das Programm zu vervollständigen, reichen die folgenden Blöcke:
+* <sb>wiederhole bis < ></sb>
+* <sb><( ) = (0)></sb>
+* <sb>setze [ v] auf ( )</sb>
+* <sb>setze [ v] auf ( )</sb>
+* <sb>(verbinde ( ) und ( ) :: operators)</sb>
+* <sb>(( ) mod ( ))</sb> (die Modulo-Operation, also teilen mit Rest)
+* <sb>([abrunden v] von ( )</sb>
+* <sb>(( ) / (2))</sb>
+* <sb>(dezimal)</sb>
+* <sb>(dezimal)</sb>
+* <sb>(dezimal)</sb>
+* <sb>(binaer)</sb>
+{{Tipp:End}}
+{{Tipp:Start|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 <code>binear</code> 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?
+{{Tipp:End}}
+{{Lösung:Start}}
+<scratchblocks>
+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)
+</scratchblocks>
+{{Lösung:End}}
 == 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:
+<center><math>(1100111)_2 = 1\cdot 2^6 + 1\cdot 2^5 + 0\cdot 2^4 + 0\cdot 2^3 + 1\cdot 2^2 +
+\cdot 2^1 + 1\cdot 2^0 = (103)_{10}</math></center>
+{{Aufgabe:Start}}
+Rechne die Zahlen ins Dezimalsystem um:
+# <math>(1101)_{2}</math>
+# <math>(101101)_{2}</math>
+# <math>(1000)_{2}</math>
+{{Aufgabe:End}}
+{{Lösung:Start}}
+# <math>(1101)_{2} = (13)_{10}</math>
+# <math>(101101)_{2} = (45)_{10}</math>
+# <math>(1000)_{2} = (8)_{10}</math>
+{{Lösung:End}}
+Die Umsetzung in {{Scratch}} ist allerdings etwas schwieriger, da es keine Potenzieren-Operation gibt. Die Rechnung <math>2^n</math> lässt sich daher nicht so einfach lösen.
+{{Aufgabe:Start}}
+Entwickle ein {{Scratch}}-Programm, dass eine (positive ganze) Zahl <math>b</math> mit einem (positive ganzen) Exponenten <math>e</math> potenziert. Also die Aufgabe <math>b^e</math> löst.
+Erstelle dafür in Deinem bestehenden Programm von oben eine weitere Figur, in der Du arbeitest.
+{{Aufgabe:End}}
+{{Tipp:Start}}
+Mach Dir klar, wie eine Potenz durch Additionen berechnet werden kann.
+Beachte auch den Sonderfall <math>e = 0</math>, denn dann ist das Ergebnis immer <math>1</math>!
+Die Umsetzung in {{Scratch}} erfolgt mit einer Zählschleife.
+{{Tipp:End}}
+{{Lösung:Start}}
+<scratchblocks>
+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)
+</scratchblocks>
+{{Lösung:End}}
+{{Aufgabe:Start}}
+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.
+{{Aufgabe:End}}
+{{Tipp:Start}}
+Die eingegebene Dualzahl ist wieder keine Zahl, sondern ein Text mit einzelnen Zeichen, die entweder <code>0</code> oder <code>1</code> sind. Das Ziel ist es, die Dualzahl Zeichen für Zeichen ''von rechts nach links'' durchzugehen und bei einer <code>1</code> die entsprechende Potenz von 2 auf das Ergebnis zu addieren.
+Dazu musst Du
+* eine Zählvariable (z.B. <code>i</code>) 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 <code>i</code>-te Zeichen von rechts zugreifen (also das Zeichen an Stelle "Länge der Binärzahl minus <code>i</code>"),
+** wenn das Zeichen eine <code>1</code> ist,
+*** die Potenz <math>2^i</math> berechnen,
+*** die Potenz auf das Ergebnis addieren.
+** <code>i</code> um 1 erhöhen.
+{{Tipp:End}}
+{{Lösung:Start}}
+<scratchblocks>
+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)
+</scratchblocks>
+{{Lösung:End}}