Lehrzeit

Schule & Informatik

Kategorie: Java für Fortgeschrittene (Seite 1 von 9)

Programmieraufgabe 100

Yeah! Geschafft! 100! Ich wiederhole HUNDERT(!) Programmieraufgaben. Aus dem Unterricht… für den Unterricht. Und manchmal ein wenig darüber hinaus.

Und anders als bei der 99. Aufgabe angedeutet, kommt jetzt doch noch eine Aufgabe basierend auf processing. Eine, bei der ich selbst nicht auf eine wirklich gute Lösung gekommen bin, aber dazu gleich mehr. Das genaue Arbeitsblatt gibt es weiter unten zum Herunterladen.

Aufgabe

Implementiere basierend auf processing und dem vorangegangenen Projekt „Schneefall“.

Die Schneeflocken sollen unterschiedlich groß sein und unterschiedlich schnell nach unten fallen. Sind sie außerhalb des unteren Randes, sollen sie gelöscht werden. Dafür werden neue Schneeflocken am oberen Rand erzeugt, die wiederum nach unten fallen.  Die maximale Anzahl an Schneeflocken soll in einem Attribut definiert worden sein.

Im zugehörigen Arbeitsblatt (ArbeitsblattSchneefall) wird das noch genauer beschrieben und es werden für ambitioniertere Schüler noch weitere Anregungen gegeben: Wind, Schmelzen der Schneeflocken.

Den interessantestes Effekt ist aber das Liegenbleiben des Schnee am unteren Rand. Und dabei meine ich nicht, dass es am unteren Rand eine schneeflocken dicke Schicht gibt. Ich hätte gerne wachsende Schneeberge. Nur ist das genau auch der Punkt an dem ich gerade hänge. Denn woher weiß die Schneeflocke, dass sie

  • die erste am Boden ist,
  • gleich auf eine andere stößt, die aber nicht fällt, sondern auch schon am Boden liegt
  • bzw. die oberste eines Schneehaufens ist.

Ich habe hierfür zwei ArrayList

  • ArrayList<SnowFlake> fallingSnow;
  • ArrayList<SnowFlake> snowOnGrnd;

definiert, die die entsprechenden Schneeflocken verwalten. Aber der Durchlauf durch all diese Daten gestaltet sich durchaus zäh. Und um einzelne Schneeflocken-Türme zu verhindern, werden aus fallenden Schneeflocken kleine Rechtecke. Damit habe ich aber jetzt ein anderes Problem: Es bilden sich Hohlräume.

(Man beachte die „Ente“ unten im mittleren Bereich.)

Leider ist der ganze Ansatz ziemlich unbefriedigend, da ich eigentlich noch Wind und die damit einhergehenden Schneeverwehung simulieren wollte. Ich spiele daher mit dem Gedanken auf einzelne Pixel zu wechseln und dann jeweils das ganze Bild bei jedem Durchgang neu zu zeichnen. Da bricht dann aber auch die Performance ein.

Von irgendwelchen Schmelzvorgängen, die ein nach unten sacken der Schneeberge erzeugen würde mal ganz zu schweigen. Das habe ich irgendwie mit Schnee-„Stacks“ versucht, hat aber auch nicht wirklich geklappt.

Ich habe alles diesmal mit dem processing-Editor gemacht und konnte daher jetzt für alle Plattformen exportieren. Einfach auspacken und mit Doppelklick starten (Eine Java-Installation wird aber vorausgesetzt) Das wäre 34MB groß geworden. Daher jetzt nur die jar-Datei gezippt snowfall.jar  und den Quelltext in einem BlueJ-Projekt: SnowFallc_v3

Wenn jemand also eine Idee hat oder einen funktionierenden SourceCode kennt…

Ansonsten wünsche ich allen frohes Faschingstreiben. Wenn man die Schneeflocken bunt macht, hat man einen Konfetti-Effekt. Passend zu Fasching.

 

 

Tiefensuche mit Processing

Basierend auf meinem letzten Beitrag habe ich jetzt noch die Tiefensuche mit Hilfe einer Adjazenzmatrix implementiert. Besuchte Knoten werden mit Gelb markiert und der aufspannenden Baum besteht aus gelben Kanten.

Die Knoten 1 und 7 wurden nicht besucht, was man an dem fehlenden gelben Punkt sieht. Ob ein Graph zusammenhängend ist, lässt sich daher mit der Tiefesuche feststellen.

Zum besseren Verständnis habe ich noch das in meinem Fall benötigte besucht[]:boolean – Feld ausgeben lassen, sowie den zu jedem Knoten gehörigen Vorgänger-Knoten, den ich in einem Feld vorgaenger[]:int speichere.

Die darüberstehenden Zahlen gibt die Durchlaufreihenfolge der Knoten wieder.

Den bisherigen Stand biete ich hier wieder zum Download an: ProcessingTiefensuche

Im nächsten Schritt möchte ich natürlich den schrittweisen Durchlauf animiert darstellen. Aber dazu muss ich die rekursive Implementierung des Algorithmus aufbrechen, damit bei jedem Durchlauf der draw()-Methode nur 1 Schritt gemacht wird.

Graphen und Processing

Angeregt durch die Videos von Daniel Shiffman möchte ich dieses Jahr das Implementieren der Graphenalgorithmen in der elften Jahrgangsstufe auf Basis von processing mit wie immer Java machen.

Hierzu habe ich jetzt in BlueJ ein Grundprojekt programmier, dass den Schüler als Vorlage zum Weitermachen dienen soll. Folgende Features habe ich dabei umgesetzt:

  1. Graphen werden per Zufall erzeugt.
    Hierzu werden 20 Knoten zufällig im Fenster erzeugt, Die Kanten werden ebenfalls zufällig erzeugt. Um nicht nur vollständige Graphen zu bekommen, habe ich zu folgender Implementierung gegriffen:

    for(int i=0; i < maxKnoten; i=i+1) {
        for(int j=0; j < maxKnoten; j=j+1) {
            if(i==j) { //Diagonale mit Nullen belegen
                adjazenzmatrix[i][j] = 0;
            } else {
                int zufallsGewicht = (int)random(1,60);
                 //Die 3 oder das == durch != ersetzen
                if (zufallsGewicht%3==0)
                    adjazenzmatrix[i][j] = zufallsGewicht;
                else
                    adjazenzmatrix[i][j] = 0;
            }
        }
    }
    

    Dadurch erhalte ich alle möglichen Graphen mit einer unterschiedlichen Anzahl an Kanten. Auch mal nicht zusammenhängende Graphen.

  2. Ist der Graph mal erzeugt können die Knoten mit der Maus noch verschoben werden. Hierzu muss der Graph aber im Verschiebmodus sein. Dieser ist standardmäßig aktiviert und kann durch Drücken der Taste ‚m‘ verändert werden.
  3. Durch Drücken der Taste ‚i‘ werden die Knotennamen eingeblendet. Die Kantengewichte werden durch Drücken der Taste ‚e‘ ausgegeben.
    Die erstmalige Anzeige der Knotennamen dauert am Anfang etwas. Warum weiß ich nicht.
  4. Durch Drücken der Taste ‚a‘ wird ein Algorithmus gestartet, wobei im Moment noch keiner implementiert ist.
  5. Durch Drücken der Taste ’s‘ und mit einem Mausklick wird ein möglicher Startknoten grün markiert oder entmarkiert.
  6. Durch Drücken der Taste ‚t‘ und mit einem Mausklick wird ein möglicher Zielknoten rot markiert oder entmarkiert.
  7. Durch Drücken der Taste ‚h‘ kann auch während der Benutzung des Programms die Hilfe angezeigt werden. Auch das dauert am Anfang etwas.

Hier noch die zip-Datei zum Runterladen und weiterentwickeln:  ProcessingAdjazenzMatrix.

Ältere Beiträge

© 2018 Lehrzeit

Theme von Anders NorénHoch ↑