Fachrat Informatik - Forum

;-) Hab Spielfeld["zeile"]["spalte"] als boolean angelegt, dass true ist, wenn die Zelle lebt und false, wenn sie tot ist. Denke gerade darüber nach, wie des mit den Rändern verkleben war. Hab irgendwas mit modulo im Kopf, muss ich noch bißchen nachdenken Ansonsten läuft es schon so wie es soll...

manuelles kopieren ;-) spiegelarray = originalesarray *gg*

Überlege derzeit noch, wie des für die Überschreitung im negativen Bereich aussieht. Also nach links und oben, dort würde ich alles = -1 setzen und wenn -1 erreicht wird, dann springe auf maxzeilen-1 (unten, rechts). Ansonsten ist es eigentlich nur zeile mod maxzeilen (zb 21 mod 20 = 1), usw. da ist eine Überschreitung gut machbar...

Meine Zählschleife würde dann von -1 bis <= maxzeilen+1 zählen, müsste dann nur noch die Verklebung des Feldes setzen, aber mal schauen, ist ja noch ordentlich Zeit, derweil arbeite ich dann an der Konsolenausgabe.

hmm .. inwiefern denn modulo?
Ich hab n bissl drüber nachdedacht und kam zu keiner sinnvollen anwendung ...
selbst wenn du die summe der lebenden zellen drumrum modulo 4 nimmst, kannst du dir bei nem Wert von X nicht sicher sein, dass nicht gerade X+4 Zellen leben .....

Mata ne
Warui

meine erste Idee war, dass ich module MAXZEILEN rechnen muss, MAXZEILEN ist der Wert, der das Array baut. Ist dieser z.B. 20, so hat das Array 20 Felder (0-19), der Wert 20=MAXZEILEN kann eigentlich nicht erreicht werden. Aber kann ja bis MAXZEILEN+1 zählen bei den Nachbarn und dann festlegen, wenn MAXZEILEN erreicht wird, dass man bei Null wieder anfängt (positiver Überlauf). Daher meine Idee mit module MAXZEILEN, so liegen die Werte x mod Xmax immer zwischen 0 und Xmax-1 und er sollte von alleine springen. Inzwischen habe ich eine andere Methode, die aber auch nicht so ganz funktioniert. Tja, diesmal spielt mir die Mathematik, besser gesagt meine fehlenden mathematischen Kenntnisse einen Streich :-(

wie wäre es damit:
8 Methoden, die je ein Nachbarfeld der Zelle repräsentieren.
Als erstes zwei lokale Variablen die die 'Koordinaten' im Array bzgl. der Position der Stammzelle zuweisen (zB. lokalx = x-1; lokaly = y-1).
Dann mit 2 if abfragen testen, ob eine Überschreitung des Randes vorliegt, zB. bei x=0, y=0: if (x == 0) lokalx = xAusdehnung-1; (wg. der Zählweise des Arrays). Genauso für y.
Dann muss nur noch getestet werden, ob der Array an der Stelle [lokalx][lokaly] true ist, und man gibt eine 1 zurück.
Dies für alle 8 Methoden, und man ist fertig.

Ich bitte um konsruktive Kritik.

Quoted

Original von sos1981
8 Methoden, die je ein Nachbarfeld der Zelle repräsentieren.

Acht Methoden finde ich auf den ersten Blick nicht besonders elegant.

Quoted

Dann muss nur noch getestet werden, ob der Array an der Stelle [lokalx][lokaly] true ist, und man gibt eine 1 zurück.
Dies für alle 8 Methoden, und man ist fertig.

So ganz kann ich Deinen Text nicht nachvollziehen, aber falls Du für jede Zelle in jedem Schritt acht Methoden aufrufen willst, halte ich das für Overkill. Ich vermute, daß es einfacher geht, indem man sich zum Beispiel (zusätzlich zum Array, das den aktuellen Zustand jeder Zelle erfaßt) ein Array anlegt, in dem für jede Zelle die Anzahl der Nachbarn gespeichert ist. Bei einem Wechsel zum nächsten Schritt wird dann dieses Array aus dem vorherigen Inhalt des Arrays neu berechnet. Das hat den Vorteil, daß ein Auslesen und Ändern der Nachbarzellen nur noch erforderlich ist, wenn sich der Zustand einer Zelle ändert. Im "Normalfall" sind das im Mittel also deutlich unter 8 Operationen.

Und statt der acht Methodenaufrufe ist es vielleicht schlauer, sich zusätzlich zu dem Variablenpaar (lokalX, lokalY) noch acht weitere Paare (obenLinksX, obenLinksY), ... als Variablen zu erzeugen, deren Wert jeweils mit dem Wert des Paares (lokalX, lokalY) geändert wird. Dadurch hat man also insgesamt 9 Variablenpaare, die sich wie ein "Fenster" der Größe 3x3 über das Array bewegen.

PS: Vielleicht läßt sich dieses Fenster sogar elegant als eigene Klasse formulieren (mit entsprechenden Methoden wie "bewege Fenster" usw.). Das könnte eine gute Abstraktion darstellen.

Habe ein Array Nachbarn[][] angelegt, welches die Werte für einen Nachbarn speichert. Es gibt acht Nachbarn, somit acht Wertepaare. Ich schaue dabei in die Richtungen, in der Mitte liegt mein Feld (x,y). Dann ist zb (x-1,y-1) ein Nachbar, als Arrayteil wäre das Nachbar[-1][-1]. Das habe ich dann für alle möglichen Nachbarn gebaut und kann somit später im Programm leicht die Nachbarn feststellen. Dieser Aufbau sollte auch unabhängig von Rändern sein. Derweil verhaue ich mich mit der Prüfung auf Nachbarn, da ich die Randfälle einfach nicht in den Griff kriege... aber ein paar Tage sind noch. Die Idee mit den acht Methoden finde ich interessant,a ber auch kompliziert wegen der Fallunterscheidung... man muss ja immer alle acht Methoden betrachten...

Quoted

Original von ruffy85
Habe ein Array Nachbarn[][] angelegt, welches die Werte für einen Nachbarn speichert. Es gibt acht Nachbarn, somit acht Wertepaare. Ich schaue dabei in die Richtungen, in der Mitte liegt mein Feld (x,y). ...

genau so habe ich das auch gemacht. man muss nur die 4 spezialfälle beachten, wenn das zielfeld(xy) an eines der 4 ränder grenzt. 8 methoden halte ich hierbei für etwas aufwändig.

2 dinge sind mir nur aus der aufgabenstellung heraus nicht ganz schlüssig:

ich verstehe nicht ganz ob ich die berechnung der neuen zustände, für die zellen, in "einSchritt" oder in "naechstesBild" unterbringen soll.
es heißt ja in "einSchritt": wir sollen ein temporäres array erstellen und dort die zustände speichern und sie dann mittels "kopiereZustand" in das array des spielfeldes kopieren, also müsste die berechnung der zustände ja auch in "einSchritt" stattfinden. wozu brauche ich dann noch "naechstesBild"???

Quoted

Geben Sie überall sinnvolle Modifier an, kapseln/verbergen Sie so viel wie möglich.

soll ich jetzt den quellcode wegzaubern oder was!?
sorry, aber bin etwas ratlos was damit gemeint ist.


gruß, kk

Quoted

soll ich jetzt den quellcode wegzaubern oder was!?

Nein, ich glaube, daß damit gemeint ist, möglichst viele Methoden und Variablen als 'private' laufen zu lassen, was dann von Außen ja wie unsichtbar wirkt.

Hallo,

ich dachte immer, ohne die Vorlesungsfolien auszukommen, aber die Aufgabe sieht mir doch jetzt wirklich etwas seltsam aus. Außerdem wird auf der Seite ja explizit darauf hingewiesen, man solle sich die Dokumentation ansehen.

Meine Bitte: Könnte mir jemand das Passwort für die Java'06-Seite zukommen lassen?

Danke schön.

die vorlesungsfolien können hilfreich sein?!?
ich dachte bis jetzt, dass da das gleiche drin steht wie in dem skript, aber wenn das so ist würde ich auch ganz gern das passwort wissen.


gruß, kk

Will dann mal auch nen Beitrag leisten.
Mit dem Modulo-Operator bin ich auch nicht wirklich weiter gekommen, habe daher eine Funktion gemacht, die eine Koordinate mit einem Code-Integer übergeben bekommt.

Und zwar ist für eine x-Koordinate ja nur der linke und rechte Nachbar wichtig (es geht hier nur um die Rand-Problematik!) und für die y-Koordinate der untere und rechte Nachbar.

Und man muss ja im Prinzip die Nachbarn nach diesem Schema suchen:

123
8X4
765

X ist dabei der Punkt. Demnach gibt es ja allgemeine Regeln (wie schon erwähnt), also Punkt1=(x-1,y-1), Punkt 2=(x,y-1) usw.

Also kann man das nach meiner obigen Logik doch auch so sehen: Suche für Punkt eins den linken Nachbarn der x-Koordinate und den oberen Nachbarn der y-Koordinate, sodass man den linken oberen Nachbarn vom Punkt x bekommt.
Also lautet bei mir ein Funktionsaufruf, der auf Ränder untersucht:



Nachteil bei dieser Lösung liegt auf der Hand: Die Funktion "validNeighbour" wird sehr oft aufgerufen, allerdings funktioniert diese Lösung.
Der Vorteil liegt darin, dass wenn eine übergebene Koordinate entweder 0 oder xAusdehnung ist (entsprechendes beim y), dass dann einfach davon der logische Nachbar returned wird.

Womit ich allerdings Probleme hab ist die Implementierung vom Interface, womit man das Applet zum Laufen kriegt.

Hatte mir das Interface noch gar nicht angesehen, sondern hatte bereits alle möglichen Funktionen, die den Anforderungen des Interfaces genügen, fertig (xAusdehnung ist ja zB nur eine simple getter-Funktion, die bei mir lautete, also hab ich die geforderte Funktion xAusdehnung so implementiert, dass sie macht. Vielleicht scheitert es ja daran?

Hat jemand schon Erfolg gehabt?

also bei mir funktioniert es inzwischen mit modulo *shy*

Ich iteriere also über zwei Schleifen von -1 bis 1, und wenn nich grade beide Schleifen bei 0 sind, betrachte ich neu_x und neu_y in zusammenhang mit den schleifenvariablen (also addition/subtraktion) ... wie schon richtig erwähnt addiere ich dann xAusdehnung/yAusdehnung dazu und mache ein Modulo über dieselben.
Dann frage ich eigentlich nur noch ab, ob das Feld true/false zurückgibt und setze dementsprechend eine Zählervariable


Kleiner Tipp, an dem ich lange gesessen hab:
Boolesche Logik nochmal anschauen


Mata ne
Warui

Wenn ich es mit dem GUI versuche gibt er mir folgende Meldung aus:
Kopieren Sie Ihre Datei "Spielfeld.class" (und ggf. dazugehörige weitere Klassen) mit in das Verzeichnis, um die grafische Anzeige Ihrer Game Of Life-Applikation zu ermöglichen
Dabei habe ich doch alles in dem Verzeichnis

Irgendwie scheint es jetzt doch zu funktinieren,naja,wie auch immer*G

Bei mir läuft das gegebene Applet nicht, damit stürzt mein Browser nur ab Keine Ahnung warum, habe mir eine Konsolen GUI geschrieben, die reicht vollkommen aus, wenn sie jemand haben will, dann eine E-Mail an mich Müsst nur die Methodennamen vllt anpassen, halte mich bei den Methodennamen an das Aufgabenblatt.

Habe das Randproblem noch nicht gelöst. Lasse mittels zwei verschachtelter for-Schleifen jede zulässige Position einer Zelle (x,y) auf Nachbarn prüfen, in den Grenzen 0 bis < MAXZEILEN && 0 < MAXSPALTEN. Habe das inzwischen abegändert auf MAX+1 und wenn Nachbarzelle = MAX... -> setze Nachbarzelle auf x0, bzw. y0. Das scheint zu funktioniernieren, beim kompilieren kein Fehler, werd ich noch mal testen. Nur wie kriege ich dann das für den linken, bzw. oberen Rand hin?! Würde das = -1 setzen... aber keine genaue Ahnung, vielleicht denke ich zu kompliziert, weil mir die Mathematik für dieses Problem fehlt.

Vielleicht hat ja jemand etwas und möchte Gedankengut austauschen meine ICQ Nr. ist ja hier hinterlegt...

@ruffy

Wegen deines Randproblems: Du kannst doch, bevor du das Array nach dem Schema if(array[1][1]) abfragst, doch die Werte (in meinem Beispiel 1 und 1) überprüfen, ob sie über dem Rand liegen. Und das ist doch nur genau dann der Fall, wenn entweder die x ODER die y-Koordinate entweder <0 oder >x/yAusdehnung ist (bzw. beides zusammen), also überprüf doch einfach mal mit einer Extra-Funktion, ob die x- und y-Werte, die du in die Array-Abfrage tust, überhaupt innerhalb des Arrays liegen und wenn NICHT, dann form die logisch um.

Schreib mir mal ne PN, wennde nich weiterkommst, geb dir dann ggf. meine icq-nr.

Quoted

Original von ruffy85
Nur wie kriege ich dann das für den linken, bzw. oberen Rand hin?!

die 3 linken nachbarn(oben,mitte,unten) haben ja jeweils als x-koordinate (x-1), vom zielfeld aus gesehen. wenn dieses zielfeld nun auf dem rand liegt musst du einfach nur als (x-1) den wert der variable der breite des spielfeldes einsetzen(diese sollte ja als datenelement in der klasse existieren), da links neben dem ersten feld ja logisch das letzte feld des arrays liegen muss.
beim oberen rand wäre dies ja dann jeweils das unterste feld und somit die variable für die höhe.
ich hatte bei mir das problem, dass bei meinem array[x][y] die x koordinate nicht die breite, sondern die höhe war und umgekehrt.


gruß, kk