Lehrzeit

Schule & Informatik

Kategorie: Aufgaben (Seite 1 von 32)

Aufgabengenerator Java

Vor kurzem hat Herr Rau auf seinem Blog einen Aufgabegenerator zum Erzeugen von Klassenkarten und zugehörigen Testklassen zum Download angeboten. Das habe ich nun getan und wollte hierzu kurz wie versprochen mein Feedback schreiben.

Zunächst mal muss ich sagen, dass ich Aufgabengeneratoren klasse finde. Ich selbst habe früher einige auf JavaScript-Basis für meinen Mathe-Unterricht geschrieben. Immer angeregt durch die Seite von Arndt Brünner. Manchmal bin ich aber auch an meinen Erwartungen gescheitert. So habe ich für geometrische Konstruktionen mal einen Parser schreiben wollen, hatte aber zum damaligen Zeitpunkt noch keine Ahnung wie man so etwas macht. Habe ich auch immer noch nicht zu 100%, deswegen kann man nur den Ansatz anschauen. Irgendwann sollte ich das noch mal neu ansetzen. Genauso wie den Aufgaben-Generator zum Üben der Potenzgesetze. Noch weniger fertig und mit noch höheren Ambitionen angefangen (Zwei Potenzen anklicken und das zugehörige Gesetz auswählen mit dem vereinfacht werden soll). Beides habe ich im Übrigen vor knapp 15 Jahren angefangen zu schreiben. Wahnsinn, wozu ich früher noch Zeit hatte.

Zurück zu m Java-Generator von Herrn Rau. Ich finde den Aufgaben-Generator prima. Die Oberfläche entspricht nicht ganz meinem Stil, aber die Auswahl-Möglichkeiten sind gut. Man kann die Anzahl der Attribute bestimmen, ob 2 Konstruktoren umgesetzt werden sollen, ob es Startwerte für die Attribute geben soll, ob diese private sein sollen und ob es Methoden geben soll. Den letztere Punkt finde ich zu „übertrieben“, da es sich nur um die Standard get/set-Methoden der Attribute handelt. Herauskommen tut dann so etwas:

|--------------------
| Mensch
|--------------------
| bunt: boolean
| haeufigkeit: double
| typ: char
| postleitzahl: int
|--------------------
| Mensch()
| Mensch(boolean, double, char, int)
| getBunt(): boolean
| getHaeufigkeit(): double
| getTyp(): char
| getPostleitzahl(): int
| setBunt(boolean): void
| setHaeufigkeit(double): void
| setTyp(char): void
| setPostleitzahl(int): void
|--------------------
Der Wert des Attributs 'bunt' soll am Anfang sein: true
Der Wert des Attributs 'haeufigkeit' soll am Anfang sein: -2.447199215281726
Der Wert des Attributs 'typ' soll am Anfang sein: 'S'
Der Wert des Attributs 'postleitzahl' soll am Anfang sein: 61

Schön ist hierbei, dass die Beschreibung in UML erfolgt, also der Datentyp bzw. Rückgabewert mit Doppelpunkt angehängt wird. Das finde ich in den Schulbüchern ein Unding. Dafür fehlt mir jetzt das – bzw. + für private und public. Das das Rechteck nicht geschlossen ist, kann ich zwar nachvollziehen, hätte man aber vielleicht korrigieren können.  So sieht es irgendwie halb fertig aus. Den Startwert für den double-Wert finde ich ein wenig übertrieben. Da hätte so etwas wie „Zufallswert(0,100) . Zufallswert(0,100)“ es auch getan. Und für die Postleitzahl sollte es dann auch fünfstellig sein.

Als Methode würde ich immer auch noch eine toString()-Methode ergänzen… die kann man später immer mal gebrauchen.

Das aber absolut beste an dem Generator ist, dass er parallel eine Testklasse erzeugt. Im Gegensatz zu einer Musterlösung, die im Zweifelsfall nur irgendwie kopiert wird, lässt sich so herausfinden, ob man alle gewünschten Anforderungen erfüllt hat. Das finde ich wirklich großartig.

Hier ein kleiner Auszug:

import static org.junit.Assert.*;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class MenschTest {
    Mensch testObject;
    public MenschTest() {}

    @Before
    public void setUp() {
        testObject = new Mensch();
    }

    @Test
    public void initialisierungVonBunt() {
        assertEquals(testObject.getBunt(), true);
    }

    @Test
    public void initialisierungVonHaeufigkeit() {
        assertEquals(testObject.getHaeufigkeit(), -2.447199215281726, 0.00001);
    }

So wird mit der letzten Methode geprüft, ob der Startwert um maximal 0.00001 vom Wert -2.447199215281726 abweicht. Das macht hier zwar wenig Sinn, aber bei Methoden, die etwas wirklich berechnen sollen, macht die Benutzung einer Delta-Abweichung durchaus Sinn.

Fazit: Ich finde die Arbeit von Herrn Rau großartig und werde sie auch einsetzen. Ich würde mir für Kollegen noch ein paar einfachere Erweiterungsmöglichkeiten wünschen (Andere Klassen, Attribute, Methoden über eine Text-Datei integrieren) und das -/+ für private und public wünschen, aber das wärs auch schon. Danke Thomas für deine Arbeit.

 

Programmieraufgabe 93

Vor ein paar Tagen war die freie App der Woche bei iTunes das Spiel „Lifeline: Das Experiment„. Hierbei geht es irgendwie darum, einem in der Arktis Gestrandeten zu helfen. Er weiß nicht mehr wer ist oder warum er dort ist. Das Ganze ist als reines Textadventure angelegt, da die einzige Kommunikation mit der Figur Adams über einen Kommunikator läuft. Das Spiel verläuft mehr oder weniger im Echtzeitmodus. Wenn er also beispielsweise schreibt, dass er Holz suchen geht, hört man auch mal drei Stunden nichts. Das macht die Sache ganz angenehm, aber auch manchmal langweilig, da man ewig warten muss bis es weiter geht.

Praktisch finde ich dagegen die Steuerung. Man muss keinen Text eingegeben, sondern bekommt nur zwei Antwortalternativen von denen man eine anklickt. Auf einen Parser wie bei den Spielen von Infocom, die wohl einen der besten entwickelt haben, wird dabei verzichtet. Das macht das Spiel auch praktisch für unterwegs auf dem Handy. Man ist allerdings auch nicht wirklich frei in den Spielzügen. Dass es dennoch genügend Spielsituationen gibt, kann man mit seinen Schülern in 11/2 beim Thema Binärbäume ja mal überlegen.

Jetzt aber zur Aufgabe, die sich wunderbar in der 10. Klasse, wenn man Verzweigungen eingeführt hat, schon mal umsetzen kann. Sicher nicht die beste Möglichkeit, aber EINE Möglichkeit.

Aufgabe

Erstelle ein Textadventure bei dem eine Spielfigur mit dem eigentlichen Spieler schriftlich kommuniziert.

Der Spieler kann dabei immer nur zwischen den Alternativantworten A und B wählen. Die Spielfigur erzählt was sie macht oder sieht und fragt dann immer weiter, wie es weitergehen soll.

Das Ganze kann man natürlich auch mit Arrays später nochmal machen. Denn Binärbäume lassen sich auch in einem Array speichern, wie man bei wikipedia u.a. nachlesen kann.

Wer noch einen drauflegen will, der packt die Aufgabe dann doch in die 11. Klasse. Hier lässt sich dann noch wunderbar über das Zurücknehmen der Züge nachdenken. Denn wenn einem die Spielfigur weg stirbt, kann man zu einem beliebigen Punkt zurückgehen und seine Entscheidung ändern. Das Merken der Züge passiert dann entweder in einem Stack, der wieder abgebaut wird oder das Spiel wurde tatsächlich als Binärbaum aufgebaut und der Spieler, in dem Fall ich, kann einfach die Vorgängerknoten in dem Baum Richtung Wurzel zurückgehen.

Eine andere Variante wäre noch die Implementierung mit Hilfe eines Zustandsautomaten in der 10. Klasse. Das Alphabet besteht aus den Buchstaben A und B (s.o.). Je nach aktuellem Spielzustand wird abhängig vom ausgewählten Zustand einer von zwei möglichen Nachfolgezuständen ausgewählt. Durch den Übergang wird ein anderer Text der Spielfigur angezeigt.

Alles in allem also eine wirklich schöne Aufgabe, egal, ob sie nun umgesetzt wird oder ob man nur mal darüber redet.

Ach ja, was man nicht vergessen darf, ist die Problematik der Geschichte. Hier kann man eventuell auf (Kurz)geschichte versuchen auszuweichen. Oder man schreibt selbst welche. Letzteres würde ich irgendwie versuchen auf die gesamte Klasse zu verteilen.

Die Schüler sind dann quasi die Zustände oder Knoten. Ein Schüler wird zur Wurzel erklärt und schreibt die Einleitung (5 Sätze oder so). Am Ende schreibt er zwei Antwortalternativen auf. Die zwei Nachfolgezustände (zwei andere Schüler), schreiben dann wieder ca. 5 Sätze dazu und geben wieder zwei Antwortalternative an. Bei rund 30 Schülern kommt man so auf knapp 5 Entscheidungen des Spielers. Noch nicht so viel, aber wenn man die Figur frühzeitig Sterben lässt, fallen ganze Zweige der Baumstruktur weg und man kann die Entscheidungstiefe vergrößern. Im Idealfall hat dann jeder Schüler was zu schreiben und für die nächste Runde muss dann die Hälfte aller Antwortalternativen direkt zum Tod der Spielfigur führen. Man erzeugt einen nicht vollständigen Baum mit genau so viel Verzweigungen pro Ebene, wie Schüler in der Klasse.

So kann man als Lehrer die Blätter am Ende eines Zyklus immer einsammeln, ich als Lehrer entscheide, welche Antwort zum Tod führt und markiere die Alternative dementsprechend und kontrolliere, dass es wirklich genau so viel Antworten wie Schüler übrigbleiben. Danach verteile ich die Texte wieder an die Schüler. Jede Geschichte ist damit ein Pfad von der Wurzel bis zu einem Blatt.

Das ließe sich im übrigen auch digital machen, in dem die Texte an einer zentralen Stelle, wegen mir auch mebis, verwaltet werden. Schöner wäre jetzt eine Software, aber da kenne ich keine. Vielleicht kann man so etwas im Rahmen eines P-Seminars ja mal programmieren.

Insofern kann man aus dieser Aufgabe gleich noch zwei weitere erzeugen:

Aufgabe 1

Schreibe mit deiner Klasse eine Geschichte als Basis für ein solches Spiel

Aufgabe 2

Entwickle eine Software zum Erzeugen solcher Geschichten.

Programmieraufgabe 92

Aufgabe

Erstelle ein Programm zur Verwaltung von Hausaufgaben. Die Hausaufgabe (Fach, Datum, Priorität, Inhalt,…) wird über eine GUI eingegeben und in einer linearen Liste unter Verwendung des Entwurfsmusters Kompositum verwaltet.

Eine Liste aller zu machenden Hausaufgaben eines Tages soll angezeigt werden.

Alles andere ist im Wesentlichen optional.

Ich weiß, dass eine ArrayList einfacher wäre, aber laut Lehrplan soll das Kompositum-Muster hierfür benutzt werden. Also dann so. Am Ende der elften Klasse kann dann ja auf ArrayLists und / oder Datenbanken gewechselt werden.

Ergänzung: Dieses Aufgabe hatte ich bereits Anfang Dezember geschrieben, aber konnte es wegen der Lösung noch nicht anzeigen. Das ist ja jetzt anders: HA_Verwaltung

Ich muss aber gestehen, dass ich an manchen Stellen getrickst habe – zwar legal, aber ich habe getrickst. So ist der Aufbau des Menüs mit den Daten der Hausaufgaben von der Idee her über eine Liste gelöst, allerdings habe ich keine benutzt. Ich habe stattdessen mit Strings und dem Symbol # gearbeitet, um so schrittweise die Informationen zusammen zu suchen. Am Ende wird dann über die Funktion split der String wieder in ein Array umgewandelt:

//Alle Infos vom Backend (Model) als String holen.
//Die einzelnen HA werden dabei mit # getrennt
//Den String an der Stelle der # aufbrechen und in ein Array umwandeln.
String[] arrayOfAllHA = myHA_list.getAllInfosForGUI().split(„#“);

//Durchsuchen aller HA
String allHAofOneDate = „“;
for (int i = 0; i

//Die Einzelinformation aufsplitten
//Der 1. Wert ist das datum
String curDate = arrayOfAllHA[i].split(„;“)[0];

//Wenn das Datum übereinstimmt, aufnehmen
if (choosedDate.equals(curDate)) {
allHAofOneDate += „#“+arrayOfAllHA[i];
}
}

//Den ersten Hash # entfernen
allHAofOneDate = allHAofOneDate.substring(1, allHAofOneDate.length());

//Den Lösungsstring mit allen Daten wieder splitten und
//die Anzeige aktualisieren
jNumberField1_anzahl.setInt(allHAofOneDate.split(„#“).length);

Selbstverständlich hätte man auch ein Array vom Model zurückgeben lassen können, aber das schrittweise hinzufügen etc. fand ich einfach zu komplex, da schnell bei zweidimensionalen Arrays landet, die ich noch nicht behandelt hatte.

Ältere Beiträge

© 2017 Lehrzeit

Theme von Anders NorénHoch ↑