Lernpfad:Das Dualsystem/4 - Versionsgeschichte

Ngb am 23. August 2023 um 16:04 Uhr

2023-08-23T16:04:44Z

← Nächstältere Version		Version vom 23. August 2023, 18:04 Uhr
Zeile 187:		Zeile 187:
	</scratchblocks>		</scratchblocks>
	{{Lösung:End}}		{{Lösung:End}}

	~~== Sprinteraufgabe ==~~
	~~{{Aufgabe:Start}}~~
	~~Überlege, wie Du die Programme von oben anpassen musst, damit Du beliebige Stellenwertsysteme (mit beliebiger Basis) in Dezimalzahlen und zurück umrechnen kannst (maximal Basis 16).~~
	~~{{Aufgabe:End}}~~

Ngb am 23. August 2023 um 16:04 Uhr

2023-08-23T16:04:11Z

← Nächstältere Version		Version vom 23. August 2023, 18:04 Uhr
Zeile 187:		Zeile 187:
	</scratchblocks>		</scratchblocks>
	{{Lösung:End}}		{{Lösung:End}}

			== Sprinteraufgabe ==
			{{Aufgabe:Start}}
			Überlege, wie Du die Programme von oben anpassen musst, damit Du beliebige Stellenwertsysteme (mit beliebiger Basis) in Dezimalzahlen und zurück umrechnen kannst (maximal Basis 16).
			{{Aufgabe:End}}

Ngb am 22. August 2023 um 11:05 Uhr

2023-08-22T11:05:43Z

← Nächstältere Version		Version vom 22. August 2023, 13:05 Uhr
Zeile 156:		Zeile 156:
	{{Aufgabe:End}}		{{Aufgabe:End}}
	{{Tipp:Start}}		{{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}}		{{Tipp:End}}
	{{Lösung:Start}}		{{Lösung:Start}}

Ngb am 22. August 2023 um 11:00 Uhr

2023-08-22T11:00:05Z

← Nächstältere Version		Version vom 22. August 2023, 13:00 Uhr
Zeile 166:		Zeile 166:
	setze [i v] auf (0)		setze [i v] auf (0)
	wiederhole (Länge von (binaer)) mal		wiederhole (Länge von (binaer)) mal
	falls <(Zeichen ((Länge von (binaer)) - (i)) von (binaer)) = (1)>, dann		falls <(Zeichen ((Länge von (binaer)) - (i)) von (binaer)) = (1)> dann
	setze [potenz v] auf (1)		setze [potenz v] auf (1)
	wiederhole (i) mal		wiederhole (i) mal

Ngb am 22. August 2023 um 10:58 Uhr

2023-08-22T10:58:14Z

← Nächstältere Version		Version vom 22. August 2023, 12:58 Uhr
Zeile 99:		Zeile 99:

	== Dualzahlen in Dezimalzahlen umrechnen ==		== 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 +
			1\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}}

			{{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}}

Ngb am 22. August 2023 um 10:36 Uhr

2023-08-22T10:36:58Z

← Nächstältere Version		Version vom 22. August 2023, 12:36 Uhr
Zeile 60:		Zeile 60:
	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.		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}}		{{Aufgabe:End}}
	{{Tipp:Start}}		{{Tipp:Start\|Tipp 1}}
	Um das Programm zu vervollständigen, reichen die folgenden Blöcke:		Um das Programm zu vervollständigen, reichen die folgenden Blöcke:

Ngb am 22. August 2023 um 10:36 Uhr

2023-08-22T10:36:37Z

← Nächstältere Version		Version vom 22. August 2023, 12:36 Uhr
Zeile 75:		Zeile 75:
	* <sb>(dezimal)</sb>		* <sb>(dezimal)</sb>
	* <sb>(binaer)</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}}		{{Tipp:End}}
	{{Lösung:Start}}		{{Lösung:Start}}

Ngb am 22. August 2023 um 10:32 Uhr

2023-08-22T10:32:34Z

← Nächstältere Version		Version vom 22. August 2023, 12:32 Uhr
Zeile 55:		Zeile 55:
	{{Aufgabe:Start}}		{{Aufgabe:Start}}
	Vervollständige das Programm zur Umrechnung von Dezimalzahlen in Dualzahlen mittels des Moduloverfahrens.		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.		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.

Ngb am 22. August 2023 um 10:30 Uhr

2023-08-22T10:30:58Z

← Nächstältere Version		Version vom 22. August 2023, 12:30 Uhr
Zeile 62:		Zeile 62:

	* <sb>wiederhole bis < ></sb>		* <sb>wiederhole bis < ></sb>
	* <sb><(~~dezimal~~) = (0)></sb>		* <sb><( ) = (0)></sb>
	* <sb>setze [ v] auf ( )</sb>		* <sb>setze [ v] auf ( )</sb>
	* <sb>setze [ v] auf ( )</sb>		* <sb>setze [ v] auf ( )</sb>
Zeile 69:		Zeile 69:
	* <sb>([abrunden v] von ( )</sb>		* <sb>([abrunden v] von ( )</sb>
	* <sb>(( ) / (2))</sb>		* <sb>(( ) / (2))</sb>
			* <sb>(dezimal)</sb>
			* <sb>(dezimal)</sb>
			* <sb>(dezimal)</sb>
			* <sb>(binaer)</sb>
	{{Tipp:End}}		{{Tipp:End}}
	{{Lösung:Start}}		{{Lösung:Start}}

Ngb am 22. August 2023 um 10:28 Uhr

2023-08-22T10:28:20Z

@@ Zeile 38: / Zeile 38: @@
 Also <math>(65)_{10} = (1000001)_2</math>
 {{Lösung:End}}
 == Dualzahlen in Dezimalzahlen umrechnen ==