[1. Woche] Mit Python beginnen: IDLE und der Structorizer
Struktogramme
Diese Unterrichtseinheit beschäftigt sich mit dem Umsetzen von Algorithmen in Programme. Für die Algorithmen verwenden wir die Darstellung in Struktogrammen, die wir mit dem Structorizer gestalten, einem Programm, das wir in der Schule schon installiert haben und das Du Dir hier selbst herunterladen kannst. Die Anleitung zur Installation steht hier. Die Installationsanweisungen sind für Deinen heimischen Rechner gedacht.
Außerdem werden wir unsere Programme in der Programmiersprache Python umsetzen, die von der schematischen Struktogramm-Darstellung in Quelltexte wechselt, die die meistverwendete Darstellungsform für Programme sind.
Wie Du mit dem Structorizer arbeitest, habe ich dir in diesem Video [Klick] erklärt. Es zeigt an der einfachen Umrechnung von Geschwindigkeiten von m/s in km/h das Funktionsprinzip.
Das Struktogramm, das in diesem Video entwickelt wird, enthält nur eine Abfolge von einfachen Anweisungen, eine Sequenz. Der Algorithmus wird von oben nach unten abgearbeitet.
Nun werden wir nach einem Struktogramm, das nur eine Sequenz beinhaltet, eine Entscheidung (genauer gesagt zwei) einbauen. Der Algorithmus soll in einem Geschäft Rabatte für Preise berechnen, die sich nach der Art des Käufers richten. Großhändler erhalten 15%, Einzelhändler 10%, alle anderen in dieser Woche immerhin 5%.
In dem Struktogramm werden mehrere Variablen verwendet. Bedenke, dass Variablennamen immer zusammenhängend geschrieben werden müssen. Aus der Art des Käufers wird artDesKaeufers. Den Umlaut ä schreiben wir ae.
Hier ist das Erklärvideo zu dem Rabattprogramm.
Aufgaben
Aufgabe 1: Starte den Structorizer und gib das Geschwindigkeitsprogramm aus dem 1. Video ein. Teste das Programm. Jede Angabe in m/s muss korrekt in km/h umgerechnet werden (also mal 3.6 gehen). Achtung:
3 Punkt 6, nicht 3 Komma 6, beim Programmieren sind die Zahlen englisch! Das gilt auch für eingegebene Zahlen. Speichere das Struktogramm als geschwindigkeit.nsd
Aufgabe 2: Setze das Struktogramm zur Rabattberechnung mit dem Structorizer um und teste es mit verschiedenen einfachen und schwierigeren Zahlen sowie mit allen Arten von Käufern. Was passiert, wenn Als Art des Käufers 4 eingegeben wird? Der Dateiname ist Rabatt.nsd
Python-Programme
Jetzt schreiben wir den Rabatt-Algorithmus als richtiges Python-Programm.
Die Anleitung zur Installation von Python steht hier.
Wenn du Python erfolgreich installiert hast , startest du das Programm IDLE. Nun beginnst du ein neues Projekt (Menü File/New File). Der Editor öffnet sich, und du speicherst das Programm als rabatt.py
In den Quelltext des Programms, der im Augenblick noch nichts tut, habe ich schon einen Kommentar eingetragen. Kommentare beginnen mit einem # und werden nicht ausgeführt. Nun führe das leere Programm aus (Menü Run/Run Module). Das Programm wird nun in die Sprache, die der Computer versteht, übersetzt und gleich ausgeführt. Eine Erfolgsmeldung "RESTART..." ziert nun das Ausgabefenster:
Das Ausgabefenster.Achtung: Wir haben es mit zwei Fenstern zu tun, dem Editor für das eigene Programm und der IDLE-Shell, die das Python-System bedient.
Ersetze den kompletten Quelltext des Editorfensters durch diesen Text. Der beste Weg ist es, den Text selbst zu tippen.
#///////////Anfang////////////
#Aufgabe 4: Rabatte
#Name des Autors
# Großhändler bekommen 15%, Einzelhändler 10%, normale Kunden 5%
#Den Preis eingeben
gezahlterBetrag = int(input("Zu zahlender Betrag in EUR: "))
print("1=Großhändler, 2=Einzelhändler, 3=normaler Kunde")
#Die Art des Käufers eingeben:
artDesKaeufers = int(input("Geben Sie die Art des Käufers ein: "))
#Der Kunde bestimmt den Rabatt
if artDesKaeufers == 1:
rabatt = 0.15 * gezahlterBetrag
else:
if artDesKaeufers == 2:
rabatt = 0.1 * gezahlterBetrag
else:
rabatt = 0.05 * gezahlterBetrag
print("Rabatt: ", rabatt, "€")
rechnung = gezahlterBetrag - rabatt
print("Sie müssen ", rechnung, " € bezahlen.")
#//////////////////Ende//////////////////////
Python hat bei der Formatierung eine Besonderheit: Steht am Ende der Zeile ein Doppelpunkt, so wird die nächste Zeile eingerückt (als wenn man den Tabulator drückt)
Nun starte das Programm (F5), es wird in die IDLE-Shell gewechselt, und die Ausschriften werden angezeigt. Gib als Betrag 300 ein und als Kundentyp 2. Als Ergebnis sollte ein um 10% verminderter Betrag von 270 Euro erscheinen.
Erläuterungen zu dem Rabatt-Quelltext
Das Programm gehört zur Aufgabe 4 des Algorithmen-Hefts (Download hier), dort sind ab Seite 6 die Aufgaben abgedruckt.
Der obige Quelltext setzt diesen Algorithmus um:
Was ist im Python-Programm neu?
- Die Eingabeaufforderung. In der Anweisung
artDesKaeufers = int(input("Geben Sie die Art des Käufers ein: "))
steht in Anführungszeichen der Text, der als Eingabeaufforderung (Prompt) angezeigt wird. input löst das Warten auf eine Eingabe aus. Die Eingabe ist immer eine Zeichenkette, also insbesondere keine Zahl. Mit der Funktion int() wird aus der Eingabe aber doch eine Zahl, die in der Variable artDesKaeufers gepeichert wird. Diese Konstruktion merken wir uns gut für Zahleingaben. - Variablen. Jede Variable muss deklariert (Namen festlegen, Speicher reservieren) werden, bevor sie verwendet wird. So muss rabatt am besten vor der ersten Entscheidung bereitstehen (spätestens aber bei der ersten Verwendung, so wie hier), für rechnung genügt der Quelltext nach den Alternativen.
- Die Schreib-Anweisung ist print() . Möchte man Text und Variablen hintereinander ausgeben, so werden sie durch Komma getrennt (im Structorizer nimmt man dort ein +):print("Sie müssen ", rechnung, " € bezahlen.")
- Nach jeder Anweisung wird eine neue Zeile begonnen. Folgt ein untergeordneter Text, so endet die vorangegangene Zeile mit einem Doppelpunkt (:).
- Untergeordneter Quelltext. Jeder Ja- und Nein-Zweig der if-Anweisung wird eingerückt.
- Zuweisung: In Python gilt das Gleichheitszeichen = (im Structorizer := oder <-). Links vom = steht die Variable, der ein Wert zugewiesen wird. Rechts davon steht der Rechenausdruck, dessen Wert der Variablen zugewiesen wird.
- Vergleich: In Python gilt das doppelte Gleichheitszeichen == (im Structorizer = )
Algorithmen in Python umsetzen
In diesem Abschnitt werden wir unsere mit dem Structorizer erarbeiteten Algorithmen in Python umsetzen. Dazu nutzen wir die Struktogramme aus dem vorhergehenden Unterrichtsblock.
Lege für jedes Programm ein neues Python-Programm an bzw. ein neues Codiva-Projekt. Wenn du nicht in Codiva angemeldet bist, dann kopiere die Quelltexte in einen Editor und speichere sie als Programmname.py.
Algorithmen mit Alternative (if-Anweisung)
Setze diese beiden Programme in Python um und teste die Programme:
Projekt "Bankgebuehren" (Aufgabe 2 auf Seite 6)
Anmerkungen:
- Die if-Anweisung wird so formuliert: if anzahlBuchungen <= 10:
- Die Grundrechenoperationen sind + - * / mit runden Klammern.
Testfälle: 8/12/23 Buchungen ergeben 0, 60 bzw. 360 Cent.
Programm "LineareGleichung.py"
(bitte keine Leerzeichen in den Programmnamen)
Programm "LineareGleichung" (Aufgabe 3 auf Seite 6)
Anmerkungen:
- Durch die Zuweisung x = -n/m wird x automatisch in eine Gleitpunktzahl gewandelt, auch wenn m und n als int eingegeben wurden. Noch besser ist es, m und n gleich als float festzulegen:m = float(input("m= "))
- "Ungleich" ist in Python != und "Gleich" ist ==
Testfälle: m=2, n=5 ergibt eine Lösung -2.5, m=0 und n=0 ergibt L=R; m=0 und n=2 ergibt L={}
Aufgaben
In dieser Woche werden wir verstärkt in unser Algorithmen-Heftchen blicken (Download). Auf den Seiten 6-8 sind die Aufgaben.
Aufgabe: Fertige die beiden Projekte Bankgebuehren und LineareGleichung an und probiere die Programme aus. Speichere die Quelltexte als Bankgebuehren.py und LineareGleichung.py; bei Codiva kopierst du den Quelltext in einen leeren Editor und benennst die Datei entsprechend).
Viel Erfolg!
Viel Erfolg!
Wiederholung: Ein- und Ausgabe, Alternative (if-Anweisung)
Aufgabe 1: Fertige zur Aufgabe S. 6 Nr. 5 ein Struktogramm an (oder finde es in Deinem Hefter :-) und implementiere den Algorithmus in Python: Programm quader.py. Nimm als Entscheidungsgrundlage ein Menü, das ganze Zahlen zur Auswahl anbietet. Benutze dazu eine Variable antwort, die z. B. für den einen Fall den Wert 1 und für den anderen den Wert 2 annimmt. Denke bei den Quader-bezogenen Variablen daran, sie möglichst spät (=unten) zu deklarieren.
Aufgabe 2: Fertige zur Aufgabe S. 6 Nr. 6 ein Struktogramm an (oder finde es in Deinem Hefter :-) und implementiere den Algorithmus in Python: Programm briefporto.py
[2. Woche]
Struktur eines Python-Programms
Die Anweisungen eines Python-Programms sind - wie die beim Struktogramm - untereinander angeordnet und werden von oben nach unten abgearbeitet.
Durch if-, while- oder for-Anweisungen (Alternativen und Schleifen) werden untergeordnete Quelltextabschnitte erzeugt, die um jeweils eine Tabulatorbreite eingerückt sind. Dies wird im Python-Editor durch den Doppelpunkt automatisch erzeugt.
Ist eine Einrückung beendet, wird der Quelltext wieder weiter vorn begonnen.
Stehen ein if und ein else genau untereinander, gehören sie zur gleichen Ebene.
Ein Python-Programm richtig speichern und kopieren
Bei einfachen Programmen genügt eine Datei. Besteht ein Projekt aus mehreren Dateien, so sollten sie in einem separaten Ordner gespeichert werden.
Beim Senden einer .py-Datei kann es vorkommen, dass der E-Mail-Provider ein Problem anzeigt, weil .py-Dateien ja ausführbar sind. In diesem Fall kann die Nutzung einer Cloud hilfreich sein.
Umgang mit Fehlermeldungen
Fehler können an verschiedenen Stellen vorkommen. Hier sind einige davon beschrieben. Die Fehler müssen in der Regel behoben werden, weil das Programm sonst nicht arbeiten kann.
Eine Fehlermeldung.Es gibt Fehlermeldungen, die in einem solchen Meldungsfenster angezeigt werden. Andere stehen rot eingefärbt in der IDLE Shell als Teil des Nutzerdialogs. "Syntax Error" bedeutet, der Quelltext ist an sich falsch. Hier können unterschiedliche Gründe vorkommen.
Hier fehlt die Einrückung, denn nach dem Doppelpunkt braucht man eine.
Fehler werden erst angezeigt, wenn sie auftreten, da jede Anweisung für sich übersetzt und ausgeführt wird (Interpreterprinzip). Hier läuft das Programm bis zum falsch geschriebenen Befehl "prit()" korrekt, dann wird sogar ein Vorschlag gemacht.
Hier ist ein häufig auftretender Fehler passiert. Statt eines Gleichheitszeichens == steht hier eine Zuweisung =. Auch hier ist der Vorschlag zielführend.
Hier habe ich einen bösen Schnitzer eingebaut, es wird durch 0 geteilt. Das ist ein sog. Laufzeitfehler. Die Syntax an sich ist nicht falsch, aber die Aufgabe lässt sich nicht rechnen. Meist tritt der Fehler auf, wenn durch eine Variable geteilt wird, zum ungünstigen Zeitpunkt Null beträgt. Dieser Fehler tritt gern bei der Abarbeitung von Schleifen auf, in denen sich der Wert eines Divisors ändert.
Schleifen
FOR-Schleife (gezählte Schleife)
Es soll eine Tabelle der Quadratzahlen erstellt werden. Das Programm zählt die Variable zaehler hoch und berechnet in jedem Durchlauf die Variable quadrat. Beide werden in je einer Zeile angezeigt.
Hier ist das Programm:
Die Schleifenvariable zaehler wird in der for-Anweisung deklariert, nicht vorher. range bedeutet Bereich, er muss bis eins weiter nach dem geplanten Ende (hier 11 statt 10) geplant werden. Der Start ist aber wie geplant 1.
Hier siehst du die Ausgabe des Programms.
Die Grenzen der Laufvariable können selbst auch Variablen sein: Im Summieralgorithmus "Gauss" wird von a bis b (a<b) jede ganze Zahl addiert (das ist Aufgabe 13 im Algorithmenheft).
Hier ist Aufgabe 15, die Berechnung aller Teiler einer ganzen Zahl mit Abkürzung, in dem nur die Teiler bis zur Wurzel der Zahl berechnet werden und die Gegenteiler zahl/teiler gleich mit ausgegeben werden.
Für 12 sind dann die Teilerpaare (1,12), (2,6), (3,4), dann sind alle Teiler komplett:
Die Wurzel berechnet man mit der Anweisung wurzel = int(math.sqrt(n))
Am Anfang des Programms muss
import math
stehen (dann kann sqrt verwendet werden. sqrt bedeutet square root, also Quadratwurzel).
Aufgaben der 2. Woche:
Du kannst jederzeit Fragen zu den Aufgaben stellen.
Bitte notiere, wie lange du gebraucht hast. Die 4 Pflichtaufgaben sollten in 3x45min geschafft sein.
- Berechne die Tabelle der ganzen Quadratzahlen von 1 bis 20 (vorwärts und rückwärts. Erweitere den Zahlenraum und beobachte, bis zu welcher Zahl sich sinnvoll Berechnungen durchführen lassen. Programm: Tabelle.py
- Setze den Gauß-Algorithmus um (man sagt "Implementiere den Gauß-Agorithmus"). Programm: Gauss.py
- Implementiere die Teilerberechnung gemäß dem obigen Struktogramm. Programm: Teiler.py
- Noch eine Aufgabe zu if-Anweisungen: Setze den Algorithmus zur Lösung der quadratischen Gleichung in Normalform 0=x²+px+q um. Falls Du den Algorithmus nicht aus der Schule parat hast, entwirf ihn auf dem Papier neu. Programm: QuadratischeGleichung.py
Zusatzaufgabe: Setze die Suche nach der Quadratzahl, die gleichzeitig eine Dreieckzahl ist (Dagobert-Aufgabe 11) um. Du kannst Edwins Struktogramm nutzen (siehe unten). Die while-Anweisung geht so:
while ausgabe < 1000000:
Anweisungen #unbedingt einrücken
Edwins Dagobert-Struktogramm, das die magische Zahl findet.[3. Woche]
Algorithmen in Python implementieren
In dieser Woche werden wir wieder in unser Algorithmen-Heftchen blicken (Download). Auf den Seiten 6-8 sind die Aufgaben.
Schleifen: Wahl der Schleifenart
Um einen Programmabschnitt mehrmals ablaufen zu lassen, gibt es in Python zwei Möglichkeiten. Es gibt die gezählte Schleife und die Solange-Schleife. Die Wiederhole-bis-Schleife aus dem Structorizer gibt es Python nicht, sie muss durch eine Solange-Schleife ersetzt werden.
Die gezählte Schleife verwendet man, wenn man die Anzahl der Durchläufe kennt. Ihr habt sie bei der Gauß-Aufgabe verwendet, und sie wurde in der vorigen Woche besprochen.
Diesmal steht die Solange-Schleife im Fokus.
Als Beispielaufgabe nehmen wir Nr. 8, hier werden Zahlen genannt, von denen die bisher kleinste bzw. größte genannt werden soll. Als Abbruch nehmen wir die Eingabe einer negativen Zahl.
Als Bedingung der Schleife gilt: Solange (die eingegebene Zahl nichtnegativ ist). Also geben wir einmal eine Zahl vor dem Start der Schleife ein und setzen die Variablen groesste und kleinste auf ihren Wert. Sodann begeben wir uns in die Schleife. Den Quelltext zeige ich Dir hier:
Hier ist ein Protokoll:
Im Protokoll wird nach der Eingabe der negativen Zahl das Programm zwar beendet, aber die -1 wird noch als kleinste Zahl ausgegeben. Mit einer geeigneten if-Anweisung kann diese Ausgabe noch verhindert werden.
Aufgabe 1: Die Nr. 9 auf Seite 6 des Hefts ist ähnlich. Schreibe das Python-Programm mittel.py zu dieser Aufgabe.
Aufgabe 2: Entspricht Aufgabe 10 aus dem Heft. Schreibe das zugehörige verallgemeinerte Python-Programm im Projekt nEck.py.
Zusatzaufgabe: Wähle aus einer der Aufgaben 16 oder 18 auf Seite 7.
Nun wünsche ich Euch viel Erfolg beim Lösen. Wenn Ihr Fragen habt, schreibt mir bitte.
[4. Woche] Schleifen
Mit unseren Textausgaben können wir auch geometrische Formen (in gewissen Grenzen) gestalten und dabei unsere Fähigkeiten im Programmieren von Schleifen verbessern. Die Programme beruhen auf dem einzelnen Ausgeben des Sternchen-Symbols mit der Anweisung
print("*")
(Ausgabe untereinander, also mit Zeilenschaltung) und dem Weglassen einer Zeilenschaltung mit der Anweisung
print(end = "*")
Weiterhin werden for-Schleifen der Form
for zeile in range(10):
benutzt: Der Zähler der Schleife heißt hier zeile, er beginnt mit dem Wert 0. Die Schleife wird bis zeile==9 wiederholt, also 10-mal (Schleifenbedingung). Nach jeder Ausführung des Schleifenkörpers wird der Zähler um 1 erhöht, damit die Schleife auch enden kann.
Diese Schleife kann auch rückwärts ausgeführt werden:
Hier ist das Programm mit seiner Ausgabe. Es wird ein 5 Zeilen hohes und 10 Spalten breites Rechteck ausgegeben.
Ausgabe des ProgrammsAufgabe 1 Führe für die 5 die Variable zeilenzahl und für die 10 die Variable spaltenzahl ein. Lass das Programm die beiden Zahlen einlesen und gib ein Rechteck mit variabler Zeilen- und Spaltenzahl aus. Projekt: rechteckvariabel.py
In der nächsten Schleife geben wir nur so viele Sterne aus, wie die Nummer der jeweiligen Zeile ist. Damit läuft die innere Schleife bis zum Wert der Variable zeile:
Aufgabe 2 Ändere das Programm so ab, dass das Dreieck auf der Spitze steht (Hinweis: Lasse die äußere Schleife rückwärts ablaufen - for zeile in reversed(range(6)): Programm: dreieckzurueck.py):
Aufgabe 3 Lass das Programm vor den Sternchen einige Leerzeichen ausgeben (" "). Dann sollen einige Sternchen folgen. Gestalte folgende Muster, wieder mit geschachtelten for-Schleifen:
parallelogramm.pyAufgabe 4 Jetzt wird's schwieriger: Für diese Grafiken gibt es verschiedene Lösungsmöglichkeiten. Am besten verwendest Du zwei aufeinanderfolgende for-Schleifen innerhalb der äußeren for-Schleife (Projekt aufgabe4.py)
Aufgabe 5 Löse eine der beiden Aufgaben: S. 7 Nr. 18 (zahlenraten.py) oder S. 8 Nr. 19 (diophant.py) in einem Python-Programm.
[5. Woche] Der Zufall und der Computer
Wenn man ein wenig über Algorithmen nachdenkt, stellt man sicher fest, dass der Zufall im Computer offensichtlich keinen Platz hat, denn der Computer kann ja mittels seiner Programme nur Algorithmen ausführen, die bekanntlich deterministisch sind, d. h. unter gleichen Voraussetzungen gleiche Ergebnisse liefern.
Über dieses Problem haben die Programmierer nachgedacht und eine Lösung gefunden. Es gibt bestimmte Funktionen, die auf besondere Weise arbeiten: Rechnet man mit ihnen aus einem Argument x einen Funktionswert y aus, nimmt diesen wieder als neues Argument x und beginnt von vorn usw., dann entsteht eine Folge von Zahlen, die recht gut gleichverteilt sind, d. h. innerhalb eines Bereichs sind dann alle Werte etwa gleich oft vertreten.
Das Problem ist jetzt nur noch, nicht immer die gleiche Startzahl zu wählen, denn sonst entsteht immer die gleiche Zahlenfolge. Man löst dieses letzte Problem, indem man als Startzahl die augenblickliche Uhrzeit (bzw. eine davon abgeleitete Zahl) verwendet. So kann man immer in eine andere Stelle der der Pseudo-Zufallszahlenfolge einsteigen.
Wir wollen die Pseudozufallszahlen vereinfacht Zufallszahl nennen.
Wie geht der Zufall nun in Python?
Dieses kurze Programm erzeugt eine Zufallszahl zwischen 0 und 1 (1 ist nicht enthalten) und zeigt sie an:
Aufgabe 0: Gib das Programm ein und starte es mehrmals. Du wirst immer ein anderes Ergebnis erhalten. Für diese Aufgabe musst Du nichts einsenden.
Hier müssen wir - wie weiter oben bei der Quadratwurzel - wieder ein Paket einbinden, diesmal random.
Möchte man einen anderen Bereich als [0;1), so multipliziert und addiert man:
random.random() * 7 + 1
Hier wird ein Wert von 1 bis unter 8 bestimmt.
random.randint(1,6)
Manchmal werden nur ganze Zahlen gebraucht, um z. B. einen Würfel zu simulieren. Starte das Programm immer wieder, Du bekommst jetzt immer Zahlen von 1 bis 6 errechnet.
Um die Aufgabe 20 aus unserem Algorithmenheftchen lösen zu können, haben wir nun alle Voraussetzungen. Im einfachsten Fall führst Du jetzt einfach eine Strichliste.
Der Computer kann die Zählung aber auch selbst vornehmen. Dazu führst Du für jede Würfelzahl einen Zähler ein und zählst die Werte mit. Das Zählen und die Zufallszahlenermittlung gehört natürlich in eine Schleife, die wir z. B. 6000-mal ausführen. Damit müsste jede Zahl etwa 1000-mal vorkommen.
In meinem Versuch ist die 4 genau 1009-mal gewürfelt worden.
Aufgabe 1: Löse die Aufgabe 20 im Heft, indem Du das obenstehende Programm mit Deiner Anzahl der Versuche ausprobierst und Deine Statistik erstellst. Sende Deine Tabelle ein.
Aufgabe 2: Löse die Aufgabe 21. Anleitung: Nimm einen Zähler, der immer um 1 hochgezählt wird, wenn keine 6 erscheint. Kommt eine 6, so wird er ausgegeben und wieder auf 0 gesetzt. Sammle die Zähler in einer Summe, zähle die Sechsen mit und bestimme nach einer Weile den Mittelwert (siehe Mittelwertprogramm).
Zusatzaufgabe: Löse Aufgabe 22.
[6. Woche] Übungen
Übungen zum Zufall werden mit Deinen Kenntnissen aus den vorangegangenen Wochen kombiniert.
Wähle aus den 4 Aufgaben drei aus
Aufgabe 1: Schreibe ein Programm, das eine ganze Zufallszahl im Bereich von 20 bis 50 ausgibt. aufgabe1.py
Aufgabe 2: Verändere Aufgabe 1 wie folgt: Das Programm soll 1000 Zufallszahlen im Bereich von 20 bis 50 ausgeben. Anschließend wird der Mittelwert der berechneten Zahlen ausgegeben. Entspricht der Mittelwert Deinen Erwartungen? erwartungswert.py
Aufgabe 3: Schreibe ein Programm, das eine zufällige gerade Zahl im Bereich von 1 bis 100 ausgibt. zufallgerade.py
Aufgabe 4: Zahlenraten , umgekehrt. Der Computer "denkt" sich eine ganze Zahl im Bereich von 1 bis 1000 (er ermittelt eine Zufallszahl, die er nicht anzeigt), die Nutzerin / der Nutzer muss sie erraten. Das Programm soll den Rateprozess bis zur richtig erratenen Zahl durchführen. zahlenratenUser.py
Zusatzaufgabe: Erweitere das Programm aus Aufgabe 4 mit einem Zähler. Lobe den User, wenn er nur wenige Zahlen tippen musste, tadle ihn, wenn es zu viele waren. Die Maximalzahl notwendiger Ratevorgänge errechnet sich übrigens aus der Anzahl der Teilungen von 1000, bis man auf 1 kommt (das ist der Logarithmus von 1000 zur Basis 2). zufallsraten.py
[7. Woche]
Compiler und Interpreter
Sieh Dir dieses Video über den Java-Interpreter an. In ihm werden die Begriffe Compiler und Interpreter erläutert. In Python wird ein Interpreter verwendet.
Aufgabe 1: Wenn man Interpreter und Compiler mit den beiden Tätigkeiten "ein ganzes Buch übersetzen" und "ein Gespräch dolmetschen" vergleicht, welche Tätigkeit entspricht dann welchem Prinzip? Ordne Interpreter und Compiler den beiden Tätigkeiten zu und begründe Deine Wahl.
Aufgaben zur Teilbarkeit
In dieser Woche geht es um Teilbarkeit. Wir erinnern uns: für int-Zahlen drückt die Bedingung
(zahl % teiler == 0)
aus, dass zahl durch teiler teilbar ist. Das haben wir vor einigen Wochen schon in dem Programm genutzt, das die Teiler einer Zahl berechnete. Dieses Programm könnt Ihr zur Weiterentwicklung verwenden.
Diesmal berechnen wir Primzahlen. Sie zeichnen sich dadurch aus, dass sie genau 2 Teiler haben, die 1 und sich selbst.
Aufgabe 2: Das Programm primzahl.java soll eine natürliche Zahl einlesen und durch Zählung der Teiler bestimmen, ob es eine Primzahl war. Ausgegeben wird die Meldung "Primzahl" oder "keine Primzahl".
Aufgabe 3: Umgib das Programm aus Aufgabe 2 mit einer for-Schleife, die von einem Startwert bis zu einem Endwert (natürliche Zahlen) alle Primzahlen ausgibt. Alle Nicht-Primzahlen sollen nicht ausgegeben werden. Beispiel: Eingabe 10, 20. Ausgabe: 11, 13, 17, 19. Programm: primzahlfolge.java
Zusatzaufgabe: Ein Programm soll die Primfaktorzerlegung einer gegebenen natürlichen Zahl bestimmen. Anleitung: Teile zunächst so oft durch 2, wie das geht. Dann nimm 3 als möglichen Teiler, dann 4 usw.
Die Zusatzaufgabenleute der letzten Woche lösen nur Aufgabe 1, 3 und die Zusatzaufgabe.
[8. und 9. Woche]
Größter gemeinsamer Teiler
Zur Berechnung des größten gemeinsamen Teilers (ggT) zweier natürlicher Zahlen kann man einen Algorithmus mit einer Schleife programmieren. Er basiert auf folgender Idee:
Es machen mit: Die Zahlen a und b, der ggT und ein Rest r. Heute dürft Ihr einmal einbuchstabige Variablen nehmen! Ohne Beschränkung der Allgemeinheit sei a >= b.
Die Idee des Algorithmus ist: Der ggT passt vollständig mehrmals in a und in b hinein, sonst wäre es kein Teiler.
Nun berechnen wir den Rest r = a % b, der beim Teilen von a durch b entsteht.
Nun beobachten wir: Wenn der ggT in a und in b vollständig hineinpasst, dann auch in den Rest r.
Jetzt tauschen die Variablen die Rollen: b wird das neue a (Anweisung a = b;), der Rest r wird das neue b (Anweisung b = r;). Dann geht der Algorithmus wieder von vorn los.
Wieder berechnen wir den Rest r = a % b. Wieder bleibt etwas übrig (in diesem Beispiel sehen wir schon, der ggT. Aber das weiß der Algorithmus noch nicht.).
Erneuter Rollentausch, erneute Resteberechnung:
Nun ist der Rest gleich Null:
Damit hören wir auf (Ende der Schleife: Sie endet, wenn der Rest gleich Null ist).
Das Ergebnis steht fest: Das letzte b ist der gesuchte ggT.
Nicht erschrecken, die Aufgaben sind diesmal weniger komplex, und sie sollen für 2 Wochen reichen.
Aufgabe 1: Spiele den Algorithmus mit den Zahlenpaaren (21,15) (Ergebnis: 3), (7,7) (Ergebnis 7) und (19,12) (Ergebnis 1) durch. Schreibe an die Zahlen jeweils a, b oder r.
Aufgabe 2: Der Algorithmus soll zwei int-Zahlen zahl1 und zahl2 entgegennehmen und die beiden eingegebenen Zahlen zunächst so a und b zuordnen, dass a größer oder gleich b ist (in Java: a >= b). Entwirf diesen Abschnitt des Algorithmus als Struktogramm.
Aufgabe 3: Formuliere den gesamten Algorithmus für den ggT als Struktogramm. Im Klassenzimmer kannst Du den Structorizer nehmen oder ihn für daheim hier herunterladen. Papier geht auch.
Aufgabe 4: Schreibe das Programm ggTeiler.java, das dem Struktogramm entspricht. Teste das Programm mit verschiedenen Eingaben, wie in 1.
Aufgabe 5: Im Text stand folgender Satz:
Jetzt tauschen die Variablen die Rollen: b wird das neue a (Anweisung a = b;), der Rest r wird das neue b (Anweisung b = r;). Die beiden Zuweisungen dürfen nur in dieser Reihenfolge abgearbeitet werden. Warum?
Aufgabe 6: Zahlen unter 1 dürfen nicht eingegeben werden. Vervollständige das Programm, das dann solche Zahlen abwehrt.
Aufgaben ohne ggT
Aufgabe 7: Entwirf (Struktogramm) und implementiere (Java) ein Programm, das eine positive ganze Zahl einliest, die Summe der Ziffern der Zahl berechnet und die Summe ausgibt!
Beispiel: Eingabe 4132 -> Verarbeitung 4+1+3+2 -> Ausgabe 10. Programm: quersumme.java
Hinweis: Auch hier kannst Du wieder mit Resten und einer Schleife arbeiten. Keine Strings notwendig!
Zusatzaufgabe: Anja merkt sich zwei positive ganze Zahlen. Jede Zahl ist kleiner oder gleich 100. Anja addiert die beiden Zahlen und nennt Peter die Summe. Dann multipliziert Anja die beiden Zahlen und nennt Peter das Produkt. Nun soll Peter die beiden Zahlen ermitteln, die sich Anja gemerkt hat. summeprodukt.java
[9. Woche] Pixelgrafik
Hier kommt das nächste Thema: Computergrafik, hier: Pixelgrafik.
Das Python-Programm für den Einstieg findet Ihr hier:
Als Programmbibliothek nutzen wir pygame. Es gibt noch weitere Bibliotheken, z. B. stddraw, GUI-Werkzeuge wie wxPython, Tkinter oder PyQt und spezialisierte Bibliotheken wie Matplotlib oder Turtle. Alle haben ihre Vor- und Nachteile. pygame ist für den Einstieg leicht verständlich und trotzdem sehr mächtig.
Installation von pygame
Wir installieren pygame mit dem pip-Befehl auf der Konsole des Betriebssystems. Für Windows sieht das so aus:
Danach sollte in der IDLE-Konsole diese Begrüßungsmeldung kommen:
Eine neue Sicht auf Programme
Bisher endeten die Programme gleich nach der Abarbeitung, es sei denn, eine Schleife lief ewig weiter. Nun aber wird ein Fenster geöffnet, das weiterexistiert, bis es vom Nutzer geschlossen wird, auch wenn die Zeichnung schon fertiggezeichnet ist. Solche Programme nennt man grafische Benutzeroberflächen (graphical user interface, GUI). Und wer jetzt denkt, da laufen wohl Schleifen weiter, geht nicht fehl: In den GUI-Programmen läuft eine sogenannte Ereignisschleife, die fortlaufend auf Ereignisse wartet. Das einzige, das bei den ersten Programmen erwartet wird, ist das Drücken des Schließknopfes (und das Verschieben des Fensters auch).
Ein GUI-Programm erschaffen
Es genügt ein einfacher Quelltext (orientierung.py). Nach dem Start des Programmes zeigt sich ein neues Fenster mit der Zeichnung, das erst mit seinem Schließknopf geschlossen werden kann. Zum Weiterprogrammieren muss das Fenster wieder geschlossen werden!
Die erzeugte Computergrafik sieht so aus:
Hier kommen die Erläuterungen zu dem erzeugten Fenster:
Eine Überraschung bringt das Koordinatensystem: Zwar geht die x-Achse nach rechts, aber der Ursprung ist in der linken oberen Ecke, und die y-Achse geht nach unten. Die Anweisungsfolge
schwarz = (0,0,0)
anfang = (100,50)
ende = (300,200)
pygame.draw.line( fenster, schwarz, anfang, ende, 1)
zeichnet also eine Strecke von einem Punkt, der 100 Pixel vom linken Rand und 50 Pixel vom oberen Rand entfernt ist, nach (300,200). schwarz steht für die verwendete Farbe, anfang für den Startpunkt der Strecke, ende für den Endpunkt. 1 kennzeichnet die Breite der Linie. Der Farbwert wird additiv aus den Rot-, Grün- und Blauanteilen (jeweils 0-255) errechnet, hier also (0,0,0) "alles dunkel"=schwarz.
Aufgabe 0: Richte Deinen Computer mit dem Beispielprogramm oben ein und probiere es aus.
Was wir an import-Anweisungen brauchen
Zusätzlich zu den unteren drei, die schon im obigen Programm standen, nehmen wir noch import-Anweisung für den Zufall (kennen wir schon) ins Programm.
Im Bild sind 200 zufällig ermittelte Strecken dargestellt, die vollständig in ein Rechteck vorgegebener Größe passen. In der Übung nehmen wir ein 600x400 Pixel großes Rechteck zum Maßstab und richten danach die Zufallszahlenermittlung aus. Das können wir für den x-Wert mit zufall.nextInt(600) und für die Ordinate mit zufall.nextInt(400) gewährleisten.
Die 200 Strecken lassen wir in einer Schleife zeichnen, da jede Strecke im Prinzip auf die gleiche Weise erzeugt wird.
Damit werden der Startpunkt anfang und der Endpunkt ende der Strecken jeweils im vorgesehenen Bereich ermittelt. Den Zufallsgenerator initialisieren wir durch die Ausführung der ersten random-Anweisung (also indirekt, wir müssen nichts tun).
Die Strecken färben wir noch ein. Dazu gibt es die Anweisungsfolge
rot = random.randint(0,255)
gruen = random.randint(0,255)
blau = random.randint(0,255)
farbe = (rot,gruen,blau)
#... hier noch die Ermittlung von anfang und ende
pygame.draw.line( fenster, farbe, anfang, ende, 1)
mit Werten von 0 bis 255 für die Grundfarben (0=dunkel, 255=hell). Das Ergebnis mit 500 Strecken ist neben dem Quelltext zu sehen. Hier ist der gesamte Quelltext:
In unserem Programm wird die Grafik einmal erzeugt. Man kann auch Zeichnungen ständig neu zeichnen lassen, dies kann durch gleichartige Anweisungen vor der flip()-Anweisung geschehen. Genutzt wird dies vor allem, um Bewegungen darzustellen.
Aufgabe 1: Setze das Programm in der angegebenen Weise um. Achte darauf, dass die Farbwerte immer im Bereich 0 bis 255 bleiben, sonst gibt es eine Fehlermeldung. Sende nur den Quelltext und einen Screenshot des Fensters ein. Den Quelltext kannst Du in die E-Mail kopieren. Bilddatei: strecken.png (oder jpg)
Aufgabe 2: Eine Ellipse wird mit der Anweisungsfolge
linksoben = (100,100)
breitehoehe = (70,50)
rechteck = (linksoben,breitehoehe)
pygame.draw.ellipse( fenster, farbe, rechteck)
gezeichnet Dabei wird zunächst ein umgebendes Rechteck mit seinem linken oberen Eckpunkt (hier 100,100) und seinen Ausmaßen (70 breit, 50 hoch) angegeben. Dann kann die ellipse()-Anweisung aus den gegebenen Werten die runde Figur zeichnen. Erzeuge ein Bild der oben gezeigten Art. Achte darauf, dass Breite und Höhe der Ellipsen wesentlich kleiner sein müssen als die Position (x,y), weil die Ellipsen auf das Bild passen müssen. Sende den Quelltext und das Bild ellipsen.png ein.
Aufgabe 3: Zeichne mit
linksoben = (100,100)
breitehoehe = (70,50)
rechteck = (linksoben,breitehoehe)
pygame.draw.rect( fenster, farbe, rechteck)
Rechtecke ähnlich wie oben, die nur Rottöne enthalten. Sende den Quelltext und das Bild roterechtecke.png ein.
[10. Woche] Fadengrafiken
Fotos Mirko König
Auf den Bildern seht Ihr drei Arbeiten, die in der Freien Fröbelschule Keilhau bei Rudolstadt angefertigt worden sind. Das mittlere Motiv symbolisiert die drei Spielgaben Friedrich Fröbels für Kinder - die Kugel auf der Walze, die auf dem Würfel steht. Was hier mit gespannten Fäden durch Löcher im Papier hergestellt wird, können wir mit unseren drawLine-Anweisungen in einem Javaprogramm auch zeichnen. Für unsere Programmierung ist es reizvoll, dass viele Regelmäßigkeiten in kurz formulierten Algorithmen darstellbar sind.
Wie entsteht so eine Grafik? Sehen wir uns das linke Quadrat an. Offensichtlich gibt es nur (gerade) Strecken, die interessanterweise eine gebogene Hüllkurve haben. Überdies ist das Quadrat aus vier rechten Winkeln zusammengesetzt, die mit Strecken ausgekleidet sind und ihren Scheitel in den Ecken des Quadrats haben. Einen der rechten Winkel habe ich hervorgehoben.
Wir verschaffen uns zunächst einen Überblick über die Koordinaten, in denen die Zeichnung liegen soll. Wir nehmen 50 Pixel Entfernung vom Rand links und oben, und da das Fenster 400 Pixel hoch ist, wird das umgebende Quadrat 300 Pixel hoch und breit sein. Somit wird die Zeichnung auch 50 Pixel über dem unteren Rand enden.
In der vereinfachten Ansicht seht Ihr 6 Strecken, deren Startpunkte links übereinander und deren Endpunkte unten nebeneinander aufgereiht sind, immer im Abstand von 60 Pixeln. Hier sind die zugehörigen Grafikanweisungen:
So könnte man das Programm natürlich schon schreiben. Jedoch wäre ein Abstand von 60 Pixeln ziemlich grob, 20 oder 10 wären ansehnlicher, wie in dem Bild oben. Dann aber artet das Vorhaben in Schreibarbeit aus, was wir als Programmierer überhaupt nicht schätzen. Was man automatisieren kann, sollte man auch vom Computer erledigen lassen!
Sehen wir uns also die Zahlen etwas genauer an:
Die Abszisse x der Startpunkte ist immer 50, ihre Ordinate y steigt ab 50 in 60er-Schritten.
Die Abszisse der Endpunkte steigt ab 50 in 60er-Schritten, ihre Ordinate ist konstant 350.
Die Variable steigt also in diesem Bild immer von 50 bis 350 . Dies lässt sich mit einer while-Schleife realisieren, die die Schleifenvariable i immer in 60er-Schritten wachsen lässt. Den Basiswert 50 nehmen wir als Summanden für i:
Nun fällt uns die Vervielfachung der Strecken leicht: Die Erhöhung geht in 20er- oder 10er-Schritten.
Damit haben wir das Programm für einen Winkel fertig.
Und so plant Ihr Eure Fadengrafik (ein Winkel):
- Legt die Koordinaten der Eckpunkte fest.
- Welches sind die Startpunkte, welches die Endpunkte der Strecken (sie liegen jeweils auf einer Geraden)?
- Schreibt die line()-Anweisung für die erste Strecke auf, dann die für die letzte Strecke.
- Welche Koordinaten sind konstant, welche sind variabel? In welchen Schritten steigen/fallen die Werte?
- Führt eine Schleifenvariable (hier: i) für die while-Schleife ein. Achtung: Für einen Winkel braucht Ihr nur eine Schleifenvariable, so kompliziert die Zeichnung auch scheinen mag!
Die 4 Teilwinkel "Links oben", "Links unten", "Rechts oben" und "Rechts unten" - LO, LU, RO, RU
Aufgabe 1: Entwickle die while-Schleifen für diese 4 Teilwinkel. Probiere sie im Programm aus. Für diese Aufgabe ist nichts einzusenden.
Aufgabe 2: Schreibe die vier while-Schleifen nacheinander in den Quelltext, um das komplette Quadrat in einem Programm zu zeichnen. Rechts neben dem fertigen Quadrat siehst Du, wie man zwei while-Schleifen nacheinander schreiben kann. Die RU-Schleife gibts als Geschenk :-) Sende die Datei quadrat.jpg und den Quelltext ein.
Links: Die beiden while-Schleifen nacheinander. Rechts: So geht's auch!
Für die nächste Aufgabe ändern wir die LU-Schleife leicht ab. Die Startpunkte liegen jetzt auf der Diagonalen des Quadrats. Dafür ist die Abszisse des Startpunkts variabel, nämlich 350-i (der Wert fällt). Vielleicht überrascht es, dass wir nach wie vor nur mit der Variable i auskommen (das habe ich ja oben schon geschrieben).
Man kann auch die Veränderung in x-Richtung verlangsamen und halb so schnell fallen lassen: 200-i/2
Dreieck 
ZeltAufgabe 3: Realisiere dieses Dreieck als Programm und schicke dreieck.jpg sowie den Quelltext.
Aufgabe 4: Schicke zelt.jpg und den entsprechenden Quelltext.
Zusatzaufgabe: Realisiere die untenstehende Grafik komplex.jpg. Achte auf Symmetrien, mit denen Du die Programmierung erleichtern kannst. Sende auch den Quelltext ein. Für die Zusatzaufgabe können 2 andere Aufgaben gestrichen werden.
komplex[11. Woche] Mehr Fadengrafiken
In dieser Arbeit der Keilhauer Fröbel-Schüler scheint eine Reihe Würfel dargestelt zu sein. Die uns zugewandten Seiten sind gelb, die Oberseiten orange, die linken und rechten Seitenflächen schwarz - scheinbar. Das gesamte Bild reizt vielleicht zum Nachprogrammieren, aber: Die extrem vielen Teilfiguren schafft man in drei Stunden gar nicht.
Wirklich nicht?
Im Bild sind jede Menge Quadrate und Parallelogramme dargestellt, die ihrerseits aus je 4 Winkeln bestehen, die wir als rechten Winkel in der 10. Woche ausführlich besprochen haben. Störend ist jetzt nicht mehr viel, außer der Vielzahl und der unterschiedlichen Position der Eckpunkte. Diese letzte Komplexität bewältigen wir mit - Variablen!
Wir verallgemeinern das Problem so: Gegeben sind drei nicht auf einer Geraden liegende und voneinander verschiedene Punkte A, S und B, wobei S den Scheitel des Winkels ASB bildet, und AS sowie BS die Schenkel des Winkels sind. Als Variablen im Programm dienen die Koordinaten der drei Punkte vom Typ int:
Punkt A: Abszisse ax, Ordinate ay
Punkt S: sx, sy
Punkt B: bx, by
Deklaration: int ax,ay,sx,sy,bx,by;
Initialisierung: ax=150; ay=30; // usw.
Damit können wir ein Programmstück schreiben, das aus gegebenen 6 Koordinaten eine Fadengrafik ausrechnet.
Die erste Strecke würde mit
pygame.draw.line(fenster,farbe, (ax,ay),(sx,sy) ,1);
gezeichnet, die letzte mit
pygame.draw.line(fenster,farbe, (sx,sy),(bx,by) ,1);
Die Reihe der Startpunkte der Strecken würde also in gleichmäßigen Schritten von A bis S laufen, die Endpunkte gehen von S bis B.
Angenommen, es gibt 6 Strecken (wie oben im Bild), dann müssen in x- und y-Richtung 6 gleichmäßig auf einer Linie verteilte Startpunkte gezeichnet werden. Dann gibt es übrigens 5 Zwischenräume.
Nach den Strahlensätzen sollte klar sein, dass die x- und y-Werte wie die Punkte selbst in gleichen Abständen wachsen bzw. fallen. Es sind also gleiche Bruchteile der Differenzen ax-sx sowie ay-sy, um die die Koordinaten der Startpunkte wachsen oder fallen. Nun ans Werk:
Aufgabe 1: Errechne die Koordinaten der 6 Start- und Endpunkte allgemein aus den Koordinaten ax, ay, sx, sy, bx, by. Punkt A muss also schrittweise in S übergehen, S schrittweise in B.
Aufgabe 2: Lege drei Punkte A, S, B mit ihren je 2 Koordinaten im Fenster fest. Formuliere die Reihe der Koordinaten in line()-Anweisungen. Beachte die Tücken der ganzzahligen Division. Probiere die 6 Anweisungen im Programm aus und überzeuge Dich davon, dass die gewünschten 6 Strecken angezeigt werden. (Anweisungen bitte einsenden, Bild 6strecken.jpg einsenden).
Aufgabe 3: Mach aus den 6 einzelnen Anweisungen eine for-Schleife, die die 6 Strecken selbständig zeichnet. Ändere die Schleife so ab, dass 11 oder 21 Strecken gezeichnet werden (10 bzw. 20 Zwischenräume). (Sende die Schleife ein und das Bild for10.jpg)
Aufgabe 4: Es soll ein "Würfel" wie im Bild gezeichnet werden. Dazu sind 12 Winkel zu zeichnen. Anleitung: Lege für jeden Winkel zunächst die 6 Koordinaten ax, ay, sx, sy, bx, by fest und kopiere die Schelife aus Aufgabe 3 dahinter. Sende die Anweisungen und das Bild wuerfel.jpg ein.
Löse die Zusatzaufgaben als Ersatz für die Aufgaben 1-4.
Zusatzaufgabe 1: Gestalte einen größeren Ausschnitt aus dem Bild ganz oben (mehrere Würfel). Anleitung: Für 4 Eckpunkte eines Quadrats muss immer die gleiche Folge von 4 for-Schleifen ausgeführt werden. Versuche, aus gegebenen 4 Eckpunkten eines Quadrats / Parallelogramms die Anweisungsfolge möglichst allgemein zu formulieren. Sende den Quelltext und das Bild wuerfellandschaft.jpg ein.
Zusatzaufgabe 2: Ändere die Fadengrafik wie im Bild ab und finde eine allgemeine Lösung für 4 Punkte A,B,C und D. Sende den Quelltext und das Bild sattelkurve.jpg ein.
[12. Woche] Übungen zur Grafik
Diesmal soll die Grafik Zahlen in einem Diagramm darstellen. Die Zahlen stellen wir vor der Erstellung der Grafik (vor den line()-Anweisungen) als Zufallszahlen bereit.
Zum Vergleich mit der grafischen Darstellung geben wir die Zahlen auf der Konsole aus. So könnte die Darstellung aussehen:
In diesem Beispiel habe ich Zufallszahlen bis 300 gebildet, damit die Linien so lang wie die entsprechenden Zahlen sind.
Aufgaben
Von den insgesamt 6 Aufgaben löse drei und sende den Quelltext und einen Screenshot ein.
Aufgabe 1: Setze das Programm um und lasse das oben gezeigte Diagramm entstehen (line()-Anweisung).
Aufgabe 2: Ergänze Anweisungen, die an das Diagramm zwei Achsen mit Beschriftung zeichnen. Informiere Dich dazu über die Textausgabe auf pygame-Fenstern. Genauigkeit und Gestaltung sind Dir überlassen.
Aufgabe 3: Ersetze die Strecken durch Rechtecke (Säulendiagramm (links), Balkendiagramm (Mitte)).
Aufgabe 4: Zu guter Letzt soll ein Liniendiagramm entstehen (rechts).
---------------Ende der Python-Ausführungen----------------------------
Steuerung mit der Maus
Wir können die Grafik auch mit der Maus beeinflussen. Dazu geben wir der Zeichenfläche (dem JPanel) einen MouseListener mit, der laufend (in der Ereignisschleife nämlich (siehe 9. Woche)) die Mauskoordinaten abfragt und beim Klick reagieren kann. Im Beispielprogramm wird das Ereignis mousePressed() verwendet. Es zählt immer die Mausklicks mit. Sind es drei, dann wird aus den drei angeklickten Punkten ein beschrifteter Winkel oder ein Dreieck. Anschließend fängt die Zählung wieder bei 1 an.
Lade den Quelltext herunter (NetBeans: Lege ein Projekt Mausinteraktion an und kopiere den Quelltext Mausinteraktion.java hinein. repl.it: Lege ein neues Swing-Projekt (oder kopiere eines mit fork) und kopiere den Quelltext Main.java hinein). Probiere das Programm aus. Nach 6 Klicks sollte das Ergebnis etwa so aussehen:
Mausaufgabe 5: Ändere das Programm so ab, dass statt einem einfachen Winkel ein Fadengrafik-Winkel mit den Punkten A, S und B entsteht. Wenn Du die Buchstaben bei der Zeichnung weglässt, kannst Du sogar die Würfelaufgabe aus der letzten Woche leicht mit der Maus lösen :-). Quelltext und mausfadenwinkel.png bitte an mich. (linkes Bild)
Mausaufgabe 6: Ändere das Programm so ab, dass aus vier angeklickten Punkten A, B, C, D jeweils eine Sattelkurve wird (rechtes Bild). Quelltext und maussattel.png bitte an mich.
Knobelaufgabe: Auf dieser Seite findest Du eine Knobelaufgabe. Es kommen mehr solche Aufgaben hinzu.
[13. Woche] Anwenden, üben, knobeln
Die letzte Woche haben wir alte Aufgaben aufgearbeitet. In dieser Woche gibt es neue, die Ihr mit Euren Kenntnissen sicher wieder gut lösen werdet. Löse 2 der vier Aufgaben (freie Auswahl)
Aufgabe 1: Es heißt, dass zwischen einer gegebenen natürlichen Zahl n und ihrem Doppelten 2n (n>1) mindestens eine Primzahl existiert. Das Programm primzahldoppelt.java soll zu einer gegebenen natürlichen Zahl n die kleinste Primzahl zwischen n und 2n bestimmen, sofern sie existiert. Falls nicht, soll eine Meldung "keine Primzahl" ausgegeben werden. (ohne Grafik lösbar)
Aufgabe 2: In Woche 12 haben wir Diagramme für Zufallszahlen von 0 bis 299 gezeichnet. Diesmal soll der Bereich zunächst aus zwei natürlichen Zahlen unten und oben (unten < oben) ermittelt werden. Diese beiden Zahlen sollen mit dem Zufallsgenarator ermittelt werden und müssen selbstverständlich unterschiedlich sein. Anschließend sollen 5 Zufallszahlen im Bereich von unten bis oben ermittelt werden und in einem Diagramm Deiner Wahl (Linie, Säule, Balken) dargestellt werden. Die Achsen sollen beschriftet werden, und der Platz auf dem Fenster soll ausgenutzt werden (z. B. 600x450 wie in Woche 12, oder größer). (Grafik notwendig, ein Programm der 12. Woche kann umgebaut werden) Einzusenden ist das Programm und der Screenshot diagrammuntenoben.jpg
Mausaufgabe 3: Kaleidoskop. Beim Klicken auf einen Punkt im Fenster soll ein kleiner Kreis an dem Punkt gezeichnet werden. Durch die Mitte des Fensters - senkrecht und waagerecht - sollen Spiegelachsen verlaufen, die nicht gezeichnet werden. Nun soll sich der gezeichnete Punkt vervielfältigen - seine beiden Spiegelbilder bezüglich der Achsen sowie das Spiegelbild an der Senkrechten, das an der Waagerechten gespiegelt wird, sollen ebenfalls gezeichnet werden. Beziehe Farben mit ein. Sende das Programm und einen schönen Screenshot kaleidoskop.jpg ein.
Knobelaufgabe 4: Löse eine der Aufgaben der Knobelaufgabenseite, die du noch nicht gelöst hast.
