Ne0Nebul0sa
-
Gesamte Inhalte
21 -
Benutzer seit
-
Letzter Besuch
Inhaltstyp
Profile
Forum
Downloads
Kalender
Blogs
Shop
Beiträge von Ne0Nebul0sa
-
-
OOP soll möglichst nahe an die Realität angelehnt werden, also wäre eben eine Dame ohne Brett nicht möglich ( siehe http://de.wikipedia.org/wiki/Assoziation_(UML) ). Eine Klasse Brett ist sicherlich in Ordnung, man kann das natürlich auch allgemeiner machen.
Gut, das liegt nahe - Hatte ich ja bereits geschlussfolgert. Okay, inwiefern allgemeiner? Also das keine explizite Klasse Brett existiert, sondern eine Oberklasse, wie z.B. bei einer Ameise mit der Oberklasse Tier? - Das also hier lediglich beispielhaft die Klasse "Tier" existiere?
Du brauchst Koordinaten, aber Du musst 2 Fragen klären, wie stellst Du sicher, dass die Dame immer auf gültigen Koordinaten steht, d.h. also nicht außerhalb des Bretts und wer speichert die Koordinaten, das Brett oder die Dame oder irgendetwas anderes.
Indem ich von vornherein festlege, dass die Dame sich nur in den angegebenen Längen und Breiten bewegen darf und das Brett dementsprechend groß gestalte?
Die Koordinaten sollte die jeweilige Dame speichern, oder? Dann könnte sie beim Aufrufen direkt ihre Koordinaten mitgeben und jeweils angeben, ob eine Kollision existiert.
Joah das ist doch so alles richtig. Naja was ist denn die Steigung und die Konstante, sind doch eigentlich nur Zahlen und diese Werten in eine bestimmte Form gebracht f(x) = m*x+b. x wollen wir flexibel einsetzen können
Wunderbar. Das sollte ja mit der von Dir genannten Methode gehen.
Naja, also um lineare Funktionen OOP-like zu verwenden reicht eine Klasse. Ich meine nur mal so als Gedanke, Du musst Dir ja irgendwie überlegen, wie Du die Steigung und die Konstante berechnest. Das ist Teil der linearen Funktion, d.h. Du kannst in Deine Klasse eben etwas Code setzen, das Dir z.B. aus zwei Punkten die Funktion aufstellt, d.h. Du gibst dann an die Methode einfach zwei Koordinatenpaare und bekommst ein Objekt "linearFunction" und dann kannst Du einfach "linearFunction.getValue(5)" machen und bekommst, dann den Wert für Y, wenn Du als X=5 einsetzt.
Natürlich, logisch. Darauf hätte ich wirklich selber kommen können. Naja.. gut.. Haken wir das ab.
Mal schauen, ob ich das später auch programmieren kann
Ja das passt so. Es ist nicht rekursiv, sondern iterativ, soviel zum fachlichen. Das hier kannst Du als Struktogramm darstellen, aber es wird nachher nur eine einzelne Methode.
Wenn ich die Methode in der Methode selbst erneut aufrufe (s. erster Entwurf), dann ist es doch rekursiv, oder nicht?
Dieser Fall ist erst beim Backtracking relevant. Wenn Du Brett mit NxN Feldern hast, dann kannst <= N Damen definitiv positionieren.
Okay.
Du brauchst schon Schleifen, aber diese haben im Hauptprogramm nichts zu suchen.
Dann bin ich auf deinen Ansatz gespannt, obwohl ich in meinem Entwurf (immerhin) nur noch eine nutze :-).
OOP und Rekursion sind zwei "Strukturansätze". OOP ist ein Programmierparadigma und Rekursion in diesem Fall eine Entwurfsstruktur für einen Algorithmus. Die Frage ist ähnlich zu der Frage ob ich einen Obstsalat mit Äpfeln machen kann.
Ah okay. Für mich gehören Äpfel immer in einen Obstsalat, womit sich für mich auch die Frage nach den "Strukturansätzen" geklärt hätte - obwohl ich glaube, dass es nicht so einfach zu übertragen ist
Nein 2 Bretter beliebiger Größe mit n verschiedenen Damen, d.h. wenn ein Brett 8x8 stehen dort 8 Damen drauf, wenn es 200x200 eben 200 Damen
Ja, okay. Meintest Du, dass ich jetzt selbst das nDamen Problem nachstellen sollte mit Papier und Stift oder worauf möchtest Du hinaus?
*g* naja ich geb' mal den Hinweis darauf, aus was besteht denn das Schachbrett und wie beschreibe ich jede Position auf dem Brett, jetzt sollte es klingeln.....
Aus Nummern und Buchstaben, in Programmierfall nur Zahlen (Nummern). Diese geben die eindeutige Position der Dame an.
Naja aber Du zeigst doch gerade, dass Du langsam in die Richtung läuft, langsam aber es wird....
Schön :-)
Mein Tipp: Programmieren ist wie eine mathematische Funktion (naja rein formal liegt hinter einer Programmiersprache auch nur formale Logik). Beschränke Dich auf das Wesentliche. Hab Dir noch eine PN geschrieben
Na, wenn das (für mich) mal so einfach wäre. Dabei ist, Du wirst es kaum glauben, Mathe ein für mich eher gutes Fach (Naja, sagen wir Durchschnitt
).Ja, danke, die PN habe ich gelesen.
-
Sorry für den Doppelpost, allerdings kann ich meinen letzten Post nicht mehr editieren.
Ich habe mit meinem bisherigen Wissensstand versucht einen neuen Anlauf zu starten für das nDamen Problem. Wo ich mir nicht sicher war, schlichtweg nicht weiter kam oder einfach kommentieren wollte habe ich Hinweise hinterlassen.
Teils habe ich deshalb auch Pseudocode benutzt (insgesamt liegt eine Art Mischcode (Pseudocode) vor).
Bestimmte Zeilen sind von ihrer Syntax nicht korrekt (zb. "this.xy();", obwohl die Methode nicht in der eigenen Klasse steht) oder enthalten kleinere Fehler. Mir geht es aber erst einmal nur um den Inhalt.
..Ich hoffe, dass Du mir nicht wieder meine Illusion von einem Erfolg nimmst, sonst wirds langsam sehr demotivierend für mich
Hier meine drei Klassen: Hauptprogramm, Dame, Brett:
Klasse Dame:
/** * @author * @version */ public class Damen { // Bezugsobjekte Dame aktuelleDame; // Attribute // Konstruktor public Damen(Dame paktuelleDame) { zaktuelleDame = paktuelleDame; } // Dienste public boolean waagerecht() { if() { return true; } else { return false; } } public boolean senkrecht() { if() { return true; } else { return false; } } public boolean diagonal1() { if() { return true; } else { return false; } } public boolean diagonal2() { if() { return true; } else { return false; } } public Kollision() { boolean zKollision; if(this.waagerecht() || this.senkrecht() || this. diagonal1() || this.diagonal2() ) { zKollision = true; } else { zKollision = false; } } public boolean vorherigeDame() { return zaktuelleDame; } }Klasse Hauptprogrammimport sum.werkzeuge.*; /** * @author * @version */ public class Hauptprogramm { // Bezugsobjekte Rechner hatRechner; // Attribute // Konstruktor public Hauptprogramm() { hatRechner = new Rechner(); } // Dienste public static void main(String[] argc) { Brett x = new Brett(2); Brett y = new Brett(8); System.out.println("Ausgabe Brett 1:\n"+x); System.out.println("Ausgabe Brett 2:\n"+y); } public boolean alleDamengesetzt() { if() //Funktion DameSetzen n-mal ausgefuehrt? Variable uebergeben { return true; } else { return false; } } public void DameSetzen() { //aktuelle Dame setzen; naechsteDame = null; //Variable leeren , benoetigt? } public void Backtracking() { //fuer 8 Felder; Variable muss uebergeben werden ersteDame = new Dame(hatRechner.ganzeZufallszahl(1,8),hatRechner.ganzeZufallszahl(1,8)); do { if(naechsteDame == null) //keine Dame ausgewaehlt -- pruefe ob nicht die vorherige Dame aufgerufen wurde { naechsteDame = new Dame(hatRechner.ganzeZufallszahl(1,8),hatRechner.ganzeZufallszahl(1,8)); } this.Kollision(); if(zKollision = true) //wie wird geprueft, ob die alle anderen Damen kollidieren? { if() //noch nichtalle Versuche gemacht { naechsteDame = naechsteDame(hatRechner.ganzeZufallszahl(1,8),hatRechner.ganzeZufallszahl(1,8)); } else { this.vorherigeDame(); //vorherige Dame aufrufen -- was passiert mit "naechsteDame"? this.Backtracking(); //Prozedur von vorne beginnen und pruefen; rekursiv } } else { Damesetzen(); } }while(this.alleDamengesetzt()); } }Klasse Brett:/** * @author * @version */ public class Brett { // Bezugsobjekte // Attribute // Konstruktor public Brett(int pFelder) { zFelder = pFelder; } // Dienste public void erzeugeSchachbrett() { int zCounter = 0; while(zCounter < zFelder) { //erzeuge ein neues Feld zCounter++; } } } -
Die main-Methode ist der Einstiegspunkt für die JRE. Noch einmal als Anmerkung, kann eine Dame ohne Schachbrett existieren, also ist dies sinnvoll? Damit kannst Du die Frage auch selbst beantworten.
Rein theoretisch kann sie das. Aber es würde, für mich jedenfalls, keinen Sinn machen. Zumindest im Schachspiel ;-)
Insofern brauche ich ein Schachbrett (..und damit eine Klasse Brett?). Die muss ja nicht unbedingt optisch, also durch eine Gui dargestellt werden.
Wie lasse ich aber Schachbrett und Dame miteinader kommunizieren? Also wie weiß die Dame, wo sie steht, wenn nicht durch Koordinaten?
Ja Du kannst doch auch z.B. wenn der König im Schach stehen würde ihn nicht auf dieses Feld setzen
Okay. :-)
Das ist das gleiche Problem, wie bei Deinem Damenproblem, Du musst Dir überlegen durch welche Komponenten eine lineare Funktion repräsentiert ist
...
Durch einen Steigungseinheit und einer Schnittpunktkonstante, wenn ich die einzelnen Komponenten so nennen darf. Rein mathematisch ist mir das klar. Aber ich kann es einfach nicht auf Java anwenden :-(
und Du kannst dies z.B. sehr allgemein halten und wenn Du es sehr detailliert machen willst als eigene OOP Struktur entwerfen (theoretisch brauchst Du dies hier aber nicht, zur Übung wäre es aber sinnvoll). Sprich was muss eine lineare Funktion alles an Eigenschaften und Methoden haben, damit Du sie eben der mathematischen Repräsentation verwenden kannst.
In diesem Fall reicht mir die leichtere Variante. Die Aufwändige mache ich lieber später.
Aber ich kann es einfach nicht übertragen. Mir scheint einfach ein Teil des Gehirns zu fehlen, der dafür zunständig ist. Tut mir Leid :-(
Ich komme einfach damit nicht weiter.
Soweit klar. Zunächst wird eine Dame zufällig gesetzt.
Den Algorithmus würde ich wie folgt gestalten:
Es wird eine zweite Dame probeweise an eine Stelle gezogen (zufällig oder strukturiert? - ich würde allerdings die zufällige Variante bevorzugen, da somit alle Lösungen ausgegeben werden können, was bei der strukturierten nicht der Fall wäre) und dann geschaut, ob sie mit der ersten kollidiert. Ist dies nicht der Fall wird sie gesetzt. Danach wird eine dritte Dame an eine zufällige Position gezogen und es wird mit der ersten und der zweiten auf Kollision geprüft. ..und immer so weiter.. Falls eine Dame nicht an die Stelle passt wird sie auf eine neue Position gesetzt und die Prozedur beginnt von vorne (rekursiv ;-)).
Sollte es vorkommen, dass keine Position für die Dame verfügbar ist, wird die zuletzt gesetzte Dame wieder angewählt (die andere Dame wird erst einmal beiseite gelegt) und auf eine neue Position mit der Kollisionsfrage gesetzt. Dabei sollte diese natürlich nicht gleich der letzten Position sein. Dies geschiet solange, bis alle Damen erfolgreich gesetzt wurden.
Wie gesagt: Ich würde es in (for-/while-)-Schlangen machen. Aber wäre das dann OOP?
Was dann?
Das ist mir auch klar. Aber in diesem Fall ist es doch kombinierbar, oder nicht?
Ich brauche de fakto das Programm bis Donnerstag, und falls ich es nicht mit Dir rechtzeitig schaffe muss ich ein fertiges Programm von irgendwo nehmen. Das ist aber nicht mein eigentliches Ziel. Das wäre nur eine Notlösung :-/.
Sprich zwei Bretter mit, wie in diesem Fall, jew. zwei Damen ? Ich hatte das Beispiel mit 8 Damen auf einem 8x8 Brett und da fiel auf, dass die Damen in "Springer-Abständen" (dh. wie ein Springer "läuft") positioniert waren.
..oder was meinst Du konkret?
Nun gut :-)
Das habe ich in einem ersten Entwurf somit in die Klasse Dame gepackt. So in Ordnung?
Dann finde ich, dass sie zur Dame gehören sollte ;-)
Jop. Ähm.. Ich denke es ist ein Schachbrett :bimei. Sorry, aber die Frage setzte solch eine Antwort doch voraus
Stimmt, da die einzelnen linearen Funktionen das Feld ebenfalls "blockieren".
Mhnm okay. Das mag sein, und ich schätze deine Kritik, aber sei so lieb und zeige mir doch, wie es richtig geht, denn im Moment suche ich die Nadel im Heuhaufen und bemühe mich, aber tappe im Dunkeln :-(
Das erscheint mir logisch, aber nicht umsonst sagen mir viele, dass ich viel zu komplex denke und einfache Zusammenhänge unnötig beschreibe (in den Naturwissenschaften). Im Sprachlichen Gebiet bin ich i.d.R. deutlich präziser.
Ne0
-
wir kommen langsam in die richtige Richtung. Mein Tipp, die lineare Funktion wird einfacher, wenn man immer die Dame, die man schon auf dem Brett stehen hat, gedanklich in den Koordinatenursprung legt.
Super, danke.
Ich hatte was über Klassen geschrieben und ich hatte etwas Pseudocode zur Kollisionserkennung gepostet. Du brauchst keine Liste mit Koordinaten
Mh, okay. Dann bin ich wohl noch immer auf den Holzweg. Wärst Du so nett mir die entsprechende Stelle zu zitieren? Ich bin nicht sicher, was Du meinst :-)
Erzeugung = Konstruktor
Entfernen = Destruktor, brauchst Du hier aber nicht
laufen = anderes Feld besetzen
Kollision erkennen mit einer anderen Dame
Also stelle ich im Hauptprogramm lediglich durch den Konstruktor die entsprechenden Damen etc. her, bzw. durch eine Main-Methode?
Ach, und ich setze die Damen nicht sondern prüfe vorher ob sie passen und falls nicht, dann setzen?
Wie müsste ich denn die linearen Funktionen, die ich gepostet habe, in Java umsetzen?
Habe mit linearen Funktionen noch nicht programmiert - zumindest nicht absichtlich ;-)
..und damit kann ich dann auch die Damenkollision erkennen.
Ein Struktogramm bringt Dir hier nichts, außerdem ist es auch eine veraltete Darstellung. Ein Struktogramm kannst Du nur verwenden, wenn Du eine einzelne Methode darstellen willst, für die Strukturen von Klassen wird UML verwendet (bzw. andere Diagramme)
Richtig, danke. Das Aktivitätsdiagramm und das Sequenzdiagramm werde ich mir mal anschauen.
OOP ist nichts anderes als das man "jedes Ding aus der realen Welt" in eine Klassenstruktur packt und sich eben überlegt was dieses "Ding" innerhalb des Programms können muss (=Methodenname). Welche Inhalte das "Ding" dann hat ist dann das Property.
Also Auto, Farbe, fahren:
Auto = Klasse
Farbe = Property
fahren = Methode
Jedes "Ding" also jede Klasse, steht mit anderen "Dingen" in Bezieheung z.B. Auto und Reifen.
Das ist mir in der Theorie auch bewusst - meist fehlt mir die logische Übetragung auf das Praxisbeispiel :-(
Wie wäre es, wenn Du diesen Quark von SuM in die Tonne trittst und es erst mal mit den normalen Standard Java Strukturen machst
Random (Java 2 Platform SE v1.4.2)
"generatePosition" ist einfach ein Methodenname, man kann selbst die Namen festlegen. Dieser Methodenname sollte verdeutlichen, dass eine Position erzeugt (generiert) wird.
Nichts lieber als das. Allerdings bin ich durch die Schule genötigt diesen Quark zu nutzen :-(. Insofern wäre ich froh, wenn wir damit, so schwer es auch sein mag, weiterarbeiten könnten.
Okay, danke. Da kann ich wieder auf SuM zurückgreifen, wenn ich es schon nutzen muss kann ich es ja auch benutzen :-).
Wieso generiert das Schachbrett die Positionen? Das Brett hat keine Position. Das Brett ist lediglich ein Koordinatensystem und hat eine Liste mit n Damen.
Wieso wird in der Schleife gezeichnet, wenn es OOP sein soll, dann muss das Brett sich zeichnen können und jedes Objekt, das durch das Brett dargestellt wird, muss zeichnen können.
Aber GUI fällt raus, ebenso wie SuM !
Soll es ja nicht. Also doch eine Liste? Du verwirrst mich :-D :-D
Mh, okay. Aber wie realisiere ich das ganze in OOP? Meinst Du damit rekursiv?
Ich würde gerne die GUI am Ende machen, ist das okay?
Wieso soll das Hauptprogramm generierePositionen aufrufen? Ich kann keine Dame ohne ein Schachbrett setzen und wieso "alleDamensetzen", Du setzt eine Dame nach der anderen
Nun, da die erste Position der Dame generiert wird, oder nicht? Mit "alleDamensetzen" meinte ich eben die Prozedur, eine zweite Dame an eine bestimmte Stelle zu setzen und wenn diese kollidiert, diese auf eine andere Position zu verschieben (sollte ich das auch zufällig machen oder eher strukturiert?).
Wieso eine seperate Klasse?
Nun, da die Methoden nicht mehr zum Hauptprogramm oder zur Dame gehören, oder?
Noch einmal der Hinweis den Algorithmus kann man ohne SuM machen. Du solltest erst einmal versuchen, dass Du ein Schachbrett beliebiger Größe erzeugen kannst und darauf n Damen platzierst, wobei auf jedem Feld immer nur eine Dame stehen darf.
Klar :-). Hier nochmal die Frage: Wie mache ich das Schachbrett objektorientiert? Rekursiv?
..und n Damen platziere ich indem nach oben genannten Muster.
Dein Hauptprogramm soll somit verschiedene Schachbretter unterschiedlicher oder gleicher Größe erzeugen können und auf jedem dieser Bretter sollen einfach n Damen platziert werden ohne dass zwei Damen auf den gleichen Positionen stehen. Das Ergebnis kannst Du auf der Konsole ausgeben. Das Hauptprogramm sollte dann ungefähr so aussehen:
...
Okay, die Main-Methode soweit klar. Ich könnte ja zusätzlich noch bei der Kollision abfragen, ob die Damenposition bereits belegt ist indem ich die gesetzte Position der Dame mit der neuen vergleiche.
Wie ich auf die Idee mit der Liste kam:
Wie kann ich den prüfen, wenn beispielsweise 6 (von 8) Damen platziert sind, ob die 7te nicht mit einer der anderen sechs kollidiert? Ich meine, ich könnte mir die letzte Dame (und ihre Position) in einer Variable merken, aber alle sechs Damen (und ihre Positionen?)
Da liegt auch noch eine gedankliche Lücke.
Danke Dir und viele Grüße
Ne0
-
Wie bedeutet denn "bedroht"? Das heißt, dass eine Dame auf der gleichen Horizontalen / Vertikalen / Diagonalen steht, wie schon eine andere. Du kannst die Horizontale und Vertikale extrem einfach prüfen, die Diagonale durch die lineare Funktion, d.h. Du musst eine Funktion aufstellen, in die Du die x-Koordinate einer neuen Dame einsetzt, diese Funktion berechnet dann eine Y-Koordinate und wenn diese gleich der Y-Position der neuen Dame ist, dann hast Du eine Kollision. Wie man diese lineare Funktion aufstellt, steht in den Verlinkten Wikipediaartikeln (Stichwort Steigungsdreieck)
okay, für die Diagonalen müsste gelten:
f(x) = -1/2x+8 (von oben links nach unten rechts) und f(x) = 1/2x von unten links nach oben rechts, wenn der Ursprung unten links liegt.
für die x-Koordinate setze bspw. 4 ein. Dann ist der y-Wert 6 bzw. 2?.
..und wenn ich das richtig verstanden habe tritt eine Kollision auf, wenn die neue Dame (also die Dame, dessen Position ich eben ermittelt habe) die gleiche y-Koordinate hat wie die bereits vorhandene Dame. Dazu müsste ich mir alle Koordinaten der bereits erfolgreich gesetzten Damen merken, oder?
Dann könnte ich die Werte in einer Liste speichern und diese mit den neuen Koordinaten abfragen. Aber wie durchsuche ich die Liste (programmiertechnisch)? ..und wie gebe ich diese lineare Funktion in Java an?
für die Horizontalen:
f(x) = b (b ist variabel für die einzelnen Horizontalen)
für die Vertikalen:
f(x) = x
Was muss denn eine Damen alles können?Ehrlich gesagt weiß ich nicht, was die Dame können muss. Ich finde, sie sollte sich selbst erzeugen und entfernen können und wissen, wie sie laufen kann damit sie weiß, ob sie kollidiert. Aber wie die einzelnen Methoden aussehen, ist mir wieder schleierhaft.
Im Moment knallst Du den Quellcode in eine Klasse ohne sinnvoll zu strukturieren. Das was Du dort fabrizierst ist Spagetthicode. Ich habe schon so viele Anregungen gepostet (auch im letzten Post), im Grunde muss Du das nur noch in Quellcode gießen.Das ich weder nach dem MVC-Prinzip strukturiert habe, ist mir jetzt auch klar geworden :upps
Der Rest liegt wohl daran, dass mir der Durchblick fehlt - trotz vorheriges Struktogramm.
Daher auch der
. Nettes Wort übrigensSpagetthicodeIch habe schon so viele Anregungen gepostet (auch im letzten Post), im Grunde muss Du das nur noch in Quellcode gießen.Das mag sein, ich habe doch auch versucht zu einer Lösung zu kommen - auch wenn mein Spaghetticode sicherlich andere Bände spricht. Aber ich schaffe es einfach nicht
Man braucht weder setze noch lösche Dame, denn ich kann durch einen einzigen Aufruf (generatePosition) die Koordinaten für eine Dame generieren und kann dann prüfen, ob eine Kollision auftritt, wenn ja generiere ich neue Positionen."generatePosition" kannte ich nicht. Es gibt wohl in SuM eine Methode die eine Zufallsposition generiert :upps:upps (ganzeZufallszahl).
Dass heißt ich gestalte meine Methode wie folgt:
Generiere Position auf dem Schachbrett (für ein Schachbrett mit 8x8 Feldern):
derRechner.ganzeZufallszahl(1,8),derRechner.ganzeZufallszahl(1,8)
alle Damen setzen: for-schleife: bis 8 Damen:derRechner.ganzeZufallszahl(1,8),derRechner.ganzeZufallszahl(1,8) if(kollision) derRechner.ganzeZufallszahl(1,8),derRechner.ganzeZufallszahl(1,8) else zeichneDame
Aber das wäre doch kein Backtracking?
Bei Dir klappt noch nicht einmal der Algorithmus und bevor der nicht funktioniert, würde ich an so etwas wie GUI überhaupt nicht denken. GUI kommt zum Schluss.Alles klar, chef.
auch das habe ich in meinem letzten Post ausgeführt, nennt sich genetische Algorithmen.Fang doch einmal damit an überhaupt ohne diesen ganzen sum.kern Quatsch das Problem zu lösen. Schreibe ein einfaches Hauptprogramm und dann brauchst Du dazu zwei Klassen mehr nicht um den Algorithmus überhaupt erst einmal funktionsfähig zu bekommen. Erst wenn der Algorithmus fest ist, dann kannst Du über die GUI nachdenken.
Okay. Zunächst erst einmal ohne genetische Algorithmen.
Den Pseudocode den ich oben gepostet habe: ist der so in Ordnung?
Mein Hauptprogramm sollte (nach meinen bisherigen Ideen) folgendes machen, also: Methode "generierePosition" aufrufen, dann "alleDamensetzen". Mehr denke ich nicht.
Die beiden Methoden würde ich in eine seperate Klasse packen (nicht in die Klasse "Dame").
Passt das soweit?
Vielen Dank & viele Grüße
Ne0
-
Hi DerEinwanderer, Hi Flashpixx,
Ich habe mittlerweile auch mein Programm umgesetzt, sehe aber den Wald vor lauter Bäumen nicht mehr..
Zum einen habe ich zwar die Backtracking-methode, aber die wird in meinem Programm nicht genutzt, da ich den wichtigen Teil des Backtrackings irgendwie in die Methode "SchachbrettDurchlaufen" eingebaut habe.
Bei der Methode "bedroht" weiß ich leider noch immer nicht, wie ich die linearen Funktionen nutzen soll und dementsprechend scheiter ich auch daran. Meine Idee ist eher quantitativ als qualitativ.
Weiter weiß ich nicht, wie ich die Klasse "Dame" aufbauen soll. Ich habe im Moment lediglich Methoden, die die Dame zeichnen und ich denke nicht, dass damit genüge getan ist.
Allgemein weiß ich auch nicht, ob ich nicht lieber ein Typ Objekt statt des Typs Dame nehmen sollte. Denn meine Klasse Dame kann nichts, was sie grundlegend von einem Element/Objekt unterscheidet.
Ob die Methoden "setzeDame" und "loescheDame" richtig sind, weiß ich auch nicht. Bisher ist mein ganzes Projekt eher ein Scheiterhaufen als ein wirklicher Erfolg :-D
Mein eigentliches Ziel ist das nDamen Problem mit einer GUI darzustellen (also ein Schachbrett mit n*n Feldern und n platzierten Damen). Ich habe allerdings gehört, dass das Problem bis maximal 25 Damen (25*25 Feldern) umsetzbar sei. Danach muss wohl ein weiterer "Trick" her.
Letztendlich soll das fertige Programm in etwa aussehen wie in diesem Video:
Ich weiß, der Uploader stellt den Quellcode zur Verfügung, aber es wäre gut, wenn ich mit eurer Hilfe auf die Lösung käme :-)
Nun mein Programmfortschritt:
import sum.kern.*; /** * @author * @version */ public class nDamen { // Bezugsobjekte Bildschirm hatBildschirm; Stift hatStift; // Attribute // Konstruktor public nDamen(int DamenAnzahl) //bis maximal 25 moeglich! { hatBildschirm = new Bildschirm(); hatStift = new Stift(); } // Dienste public void DameSetzen(int x, int y, Dame pDame) { int N = 8; for(int i=0; i<N; i++)//zunaechst 8DamenPrblem DamenAnzahl) { this.SchachbrettDurchlaufen(x,y, pDame); } } public void SchachbrettDurchlaufen(int x, int y,Dame pDame) { this.zeichnen(); while(y<=8) { while(x<=8) { if(this.bedroht(pDame, x, y)) { x++; } else { this.setzeDame(pDame); } } y++; x=1; } } public void Backtracking(Dame pDame, int x, int y) { if(x == 8 && y == 8) { this.loescheDame(x, y); if(x<8) x++; else if(y<8) { y++; x=1; } else { hatStift.hoch(); hatStift.bewegeBis(500,500); hatStift.runter(); hatStift.schreibeText("Es gibt keine Loesung!"); hatStift.hoch(); } this.setzeDame(pDame); } else this.Backtracking(pDame, x, y); } public void loescheDame(int x, int y) { hatStift.radiere(); this.zeichnen(); hatStift.normal(); } public void zeichnen() { for(int i=1; i<=4; i++) { hatStift.runter(); hatStift.bewegeUm(1); hatStift.dreheUm(90); } hatStift.hoch(); hatStift.bewegeUm(1); } public boolean bedroht(Dame pDame, int x, int y) { if(x == zH) return false; else if(y == zV) return false; else if(x - y == zH - zV) return false; else if(x + y == zH + zV) return false; else return true; } public void setzeDame(Dame pDame) { this.zeichnen(); } }Meine Klasse Dame sieht wie folgt aus:import sum.kern.*; import sum.strukturen.*; /** * @author * @version */ public class Dame { // Bezugsobjekte Stift hatStift; // Attribute // Konstruktor public Dame() { hatStift = new Stift(); } // Dienste public void zeichneDame() { hatStift.runter(); hatStift.bewegeUm(1); hatStift.hoch(); hatStift.bewegeUm(-0,5); hatStift.runter(); hatStift.dreheUm(90); hatStift.bewegeUm(1); } }Danke für die Hilfe und viele Grüße
Ne0
Nachtrag: Mir ist noch aufgefallen, dass bisher nur ein Feld des Schachbretts gezeichnet würde. Das ist aber für mich erst einmal nebensächlich und ist später mit weiteren Schleifen zu lösen :-)
-
Überleg Dir das doch einfach mal etwas praktisch, wenn Du zwei Damen hast, wann tritt eine "Kollision" auf, einmal wenn zwei Damen in der gleichen Zeile oder Spalte oder Diagonalen stehen. Nehmen wir mal praktisch an, Du hast eine Dame auf dem Feld (3,4) stehen, welche Felder sind dann ausgeschlossen, auf denen Du eine Dame stellen kannst?
Auf den Feldern (1-8,4), (3,1-8), (3,4), (4,3), (5,2), (6,1), (3,4), (2,5), (1,6), (2,3), (1,2), (4,5), (5,6), (6,7) und (7,8)
Das hatte mich auf den Ansatz
Methode(c) [ist die Dame bedroht?]: Allgemeiner Gedanke: Fall 1 - Diagonaler Lauf (rechts unten nach oben links): x-y=1 Fall 2 - Diagonaler Lauf (links oben nach rechts unten): x+y=11 Von x,y = 1 ausgehend: Fall 3 - waagerechter Lauf: y festgelegt, x+1 Fall 4 - senkrechter Lauf: x festgelegt, y+1
gebracht
:-)
Danke Dir & viele Grüße
Ne0
-
also sieht schon mal gar nicht schlecht aus, leicht verwirrend Dein Pseudocode aber durchaus okay. Ob es jetzt performant und auch korrekt arbeitet habe ich auf die Schnelle nicht geprüft.
Hört sich gut an :-)
Wie verwirrend er ist, ist mir aufgefallen, als ich ihn geschrieben hatte. Davor war ich mit der korrekten Entzerrung der einzelnen Methoden und Funktionen so sehr beschäftigt, dass es mir nicht einmal auffiel
Ich werde "das" auf jedenfall nochmal als übersichtlicheres Struktogramm umschreiben, sodass ich auch selbst einen Durchblick in der Programmierungsphase habe.
Danke!
Ob es jetzt performant und auch korrekt arbeitet habe ich auf die Schnelle nicht geprüft.Naja, das werd ich dann wohl in der Testphase sehen
Da werd ich ja gleich rot.......Solange Du nicht blau anläuftst und dich übergibst ist mir das recht ;-)
Also so grob wäre das meine Überlegung, d.h. ich reduziere einmal via Rekursion das 8-Damenproblem auf ein 7-Damenproblem usw.Hört sich auch gut an. Mich plagt aber das Gefühl, dass ich zwar weiß, was Du mit "linearer Funktion" meinst, aber ich nicht weiß, wie ich das umsetzen soll. Ich kann ja bspw. schlecht für die Horizontale schreiben
lineare Funktion: f(x)= mx+b <=> f(x) = b
:DDu kannst auch um es zu vereinfachen, einfach die Damen via Schleife setzen und nur die Position backtracken.Genau das hatte ich vor (ist hoffentlich aus dem Pseudocode ersichtlich) :bimei.
ob Du eine Heuristik nimmst um die Dame zu setzen, d.h. also eine zufallsbasierte Struktur, wobei man dort auch noch mal optimieren kann, wenn man sich überlegt welche Felder nicht belegt werden dürfen.Das mit der Heuristik baue ich vielleicht noch ein. Das ist mit dem Bibs von SuM relativ einfach möglich
Aber die Felderüberlegung ist mir glaube ich zu weit. Dazu muss ich erst einmal an vielen anderen Stellen ansetzen.
Aber beachte, dass wenn Du das Problem auf n Damen und einem beliebig großen Feld machst ggf keine Lösung existiert, wenn nämlich sehr viele Damen verwendet werden, das muss man ggf im Quellcode dann besonders im "setzeDame" abfangen, wenn also kein Feld mehr gefunden werden kannWenn kein Feld mehr gefunden wird, so wird mein Code mit "return false" gestoppt - oder so ähnlich. Zumindest hatte ich in der Überlegungsphase daran gedacht
;)Naja, ich schaue mal, ob und wie ich das die Tage realisieren kann und melde mich ggf. nochmal -wenn ich darf ;-)
Viele liebe Grüße & danke
Ne0
-
Guten Tag liebes Forum,
Zunächst als Hinweis: Mir ist bekannt, dass das Problem möglicherweise auf Wikipedia behandelt wurde, aber ich möchte gerne selbst zum Ziel kommen ohne "abzuschreiben".
Ich stehe vor einem neuen "Problem" mit hoffentlich etwas mehr Wissen.
Bei der Umsetzung des s.g. 8-Damen Problems sollen zunächst zwei Ablaufmodelle (Struktogramme) erstellt werden. Das erste soll den Ablauf mit Backtracking beschreiben (natürlich auf das Projekt bezogen), das andere den Algorithmus für die "Kollision","Bedrohung" oder "Berührung" zweier Damen.
Das Schachbrett ist 8x8 Felder groß und es sollen acht Damen gesetzt werden.
Schön wäre es, wenn mir jemand sagen könnte, ob mein Pseudocode korrekt ist und ob es noch Optimierungen im Performancebereich gibt
Da wende ich mich insbesondere an Flashpixx, der mir letztes Mal (teilweise über private Nachrichten) gute Hinweise und Tipps gegeben hat.
Zur Problemlösung habe ich mir folgende Gedanken gemacht:
Einmalig: int x,y = 1 Methode(a) [Damen setzen]: Solange noch nicht alle acht Damen gesetzt wurden -> rufe Methode( auf Methode( [Damen setzen: durchlaufe das Schachbrett]: 1. Struktogramm: (2te Schleife in erster Schleife) 1. (while-)Schleife: Solange y kleiner gleich 8 1.2. (while-)Schleife: Solange x kleiner gleich 8 1.2.1 if-Abfrage: Dame bedroht? 1.2.1.1 Fall ja (erhält false - s. anderes Struktogramm): x+1 1.2.1.2 Fall nein (erhält true - s. anderes Struktogramm): Dame setzen, return true. 1. y+1, x=1 setzen (eigentliches Backtracking) 1.2.2 if-Abfrage: x,y gleich 8 1.2.2.1 Fall ja: gehe zu Position letzte Dame, lösche letzte Dame, 1.2.2.1.1 if-Abfrage: x kleiner 8 1.2.2.1.1.1 Fall ja: x+1 1.2.2.1.1.2 Fall nein: y+1, x=1 setzen 1.2.2.1.2 Dame setzen 1.2.2.2 Fall nein : rufe Methode rekursiv auf Methode(c) [ist die Dame bedroht?]: [I]Allgemeiner Gedanke:[/I] Fall 1 - Diagonaler Lauf (rechts unten nach oben links): x-y=1 Fall 2 - Diagonaler Lauf (links oben nach rechts unten): x+y=11 Von x,y = 1 ausgehend: Fall 3 - waagerechter Lauf: y festgelegt, x+1 Fall 4 - senkrechter Lauf: x festgelegt, y+1 2. Struktogramm Algorithmus durchlaufen: Methode(d): 1. If-Abfrage für Fälle 1+2 1.1 Fall ja: return false (s. anderes Struktogramm) 1.2 Fall nein: return true (s. anderes Struktogramm) Methode(e): 2. if-Abfrage für Fälle 3+4 1.1 Fall ja: return false (s. anderes Struktogramm) 1.2 Fall nein: 1.2.1 while-Schleife für Fälle 3+4: Solange x/y kleiner 8 1.2.1 x/y++ 1.2.1 rufe Methode(e) rekursiv auf 1.2. return true (s. anderes Struktogramm)[/code]
Ich hoffe, dass mir geholfen wird und irgendjemand den Pseudocode durchschaut
Viele liebe Grüße & Danke
Ne0
PS: Diesmal sind alle Gedanken zum Code von mir - nicht wie letztes Mal ;-)
-
[...] Hier wird nichts komprimiert sondern eine geometrische Ordnung wiederhergestellt. [..]
Alles klar. Da lag mein gedanklicher Fehler.
[...] Du hast ja ein Interface Ordnungsobjekt geschrieben, das ist auch gut wie du das gemacht hast. Es ist allerdings sinnvoller, die von Java mitgelieferten Standards(Comparable) zu nutzen. [..]Danke. Allerdings habe ich die Schnittstelle nicht selbst programmiert, sondern quasi vorgelegt bekommen. Aber ich werde meine Lehrerin mal darauf ansprechen.
Danke jedenfalls schonmal. Ich werde mit Java generell erst einmal einige Schritte nach hintne machen, wie flashpixx es empfohlen hat.
Viele Grüße
Ne0Nebul0sa
-
Die Methode public int compareTo des Interfaces Comparable musst du eh selbst in deiner Klasse Visitenkarte programmieren. -1 wird zurückgegebn wenn es kleiner ist 0 wenn gleich und 1 wenn größer. Kann sein, dass ich mich da vertan habe.
Die Methode gibts übrigens bereits. Insofern fällt das bei mir weg. Mit der Rückgabe bin ich aber auch nicht so sicher, deshalb auch meine Rückfrage.
Bei der Klasse Baum, von der du ableitest hast du das Problem, dass du ja nicht dirkt über this.kenntlinks auf den linken Teilbaum zugreifen kannst. Dies sollte man protected machen, damit du in deiner Klasse SuchBaum darauf zugreifen kannst.Alles klar, danke.
[..]. Oben in meinem Beispiel siehst du z.B. in der Methode einfügen, dass ich direkt mit this.left!=null oder this.element auf die nötigen Attribute zugreifen kann. Dies vereinfacht die Arbeit ungemein. Zweitens ist dort ein generischer Ansatz gewählt worden, dass heißt, dass du später jede Klasse die das Interface Comparable implementiert in diesen SuchBaumContainer reinstecken kannst.Doppelt gut. Eigentlich sollte ich solche Dinge doch nach einem Jahr bereits vermittelt bekommen haben, nicht wahr?
Du siehst dass der Baum die Tiefe 4 hat. Ein AVL-Baum würde jetzt eine Rotation durchführen sodass die Tiefe nur noch 3 wäre, dass heißt nur noch 3 anstatt 4 Schritte um zu suchen. Geh einfach mal auf Wikipedia AVL BaumOkay, also quasi eine Art Komprimierung. Ähnlich dem Huffmann-Algorithmus, bloß dass dieser überflüssigen (leeren) Speicher neu besetzt, solange das Gleichgewicht gewährt ist.
Erscheint logisch. Traversierung in Inorder-Ausgabe. Eine bisher simple Sache.
-
Den Teil
this.element.compareTo(element) < 0
verstehe ich nicht ganz. Müsste dieser nicht genau anders herum sein? Denn bisher wird verglichen, ob das aktuelle Element verglichen mit dem anderen Element kleiner 0 ist?
Die Methode "sortiere" wird höchstwahrscheinlich den Baum anhand eines Algorithmus sortieren, nicht wahr?
Ist interessanterweise eine Musterlösung. Aber danke für den Hinweis.Die Klasse Baum die du oben vorgestellt hast ist nicht wirklich gut, denn die Attribute müssten protected sein, [..]Sinnvoll könnte es sein, den Suchbaum als AVL-Baum zu programmieren, da dieser effizient ist in der Suche. Hier wird immer eine Ordnung eingehalten, dass heißt das beim Einfügen/Löschen immer geguckt wird, ob die balance noch gegeben ist um dann evtl. diese durch Rotationen wiederherzustellen.Verstehe ich noch nicht ganz (aufgrund der Wortwahl), davon wird aber auch erst später Gebrauchst gemacht - zumindest ist hiervon noch keine Rede im Lehrbuch.
Danke.Um ein Element zu finden, ist es sinnfrei den Baum erst durch die In-Order Traversierung in einer sortierte Liste zu verwandeln um diese dann anschließend nach dem gesuchten Objekt zu durchsuchen. Hier reicht der Code der Methode contains aus.
Naheliegend.An der Stelle wo dort return true steht ist das Element gefunden worden.
Okay, danke - Darf ich fragen, weswegen Du den Gedanken angebracht hast?Es ist besser deinen Suchbaum nicht von der Klasse Baum abzuleiten und direkt eine eigene Klasse Baum zu schreiben, die dem Grundgerüst der obigen Klasse entspricht. -
Man erkennt an Deinem Code, dass Du hier drauflos programmiert hast, anstatt Dir vorher Gedanken zu machen
Nichts anderes hab ich behauptet ;-)
Ferner kann ich die Fehlermeldung interpretieren (s. Begründungen bei den einzelnen Fehlern); doch hin und wieder fehlen mir die Lösungswege - die Lösungsansätze sind vorhanden.
Ich dachte hier eigentlich neben der Hilfe auch konstruktive Kritik zu erhalten. Anfangs hattest Du diese auch noch gegeben, aber Aussagen wie
solltest Du (nach einem Jahr Einarbeitung) interpretieren könnensind meiner Aufassung nach weder konstruktiv noch hilfreich und rein persönlich bezogen (wenn auch wie in diesem Fall nicht allzu dramatisch).
Zu Bewerten wie weit und wie intensiv ich etwas erlerne, liegt, finde ich, nicht in der Relevanz für die Frage. Solche Aussagen helfen niemand weiter und je drastischer die Formulierung, desto sinnloser die Aussage.
Nun zu argumentieren ich könnne keine Kritik vertragen wäre ebenso nicht nachvollziehbar. Ich habe mehrmals unterstreicht, dass ich meine Fehler versuchen werde zu beheben und darum gebeten, wenn auch indirekt, dass sich jeder dessen bewusst sein sollte.
Umso trauriger finde ich es, wenn sich ein Moderator - seines Ranges und der damit verbundenden Verantwortung bewusst - dann dazu äußert.
Wenn ich deinen oder den allgemeinen Anforderungen nicht genüge, dann ist das leider meine Schwäche.
Ich möchte hier keinen Konflikt anzetteln, aber da sicherlich viele hobbymäßig im Forum unterwegs sind (und möglicherweise beruflich programmieren), erhoffe ich einen gewissen Spaßfaktor bei der Sache.
Ich möchte darauf aber auch nicht zu sehr herumreiten.
Deine Kritik, sofern konstruktiv, ist angebracht und berechtigt.
Vererbung bekannt ist, dann darf wohl die fachliche Frage berechtigt sein, warum nutzt Du sie dann nicht und baust hier eine komplexe und unübersichtliche Codestruktur auf, die nicht notwendig ist.Um einmal die Katze aus dem Sack zu lassen: Ich habe nach dem Programm online gesucht, da es Teil der schulbezogenen Programmierung ist und ich ferner nicht der erste sein sollte, der sich damit befasst hat. So habe ich hier ein Beispiel gefunden, das Programm kopiert und auf meine Bibliothek angepasst.
Insofern ist meine Aussage
so gesehen nicht korrekt. Ich habe den Code lediglich modifiziert.Die Methoden "sortiereListe","suche" und "fuegeEin" sind selbst programmiertDiskrepanzen..aus Faulheit und teilweise nicht vorhandenen Wissen (deshalb auch die berechtigte Kritik).
Zudem habe ich manchmal das Gefühl, dass Du meine Antworten nicht richtig liest, denn:
ah ja und was nützt das, wenn Du etwas falsch gelernt hast?habe ich bereits angeführt mit:
Gleichwohl hast Du natürlich Recht, wenn die Grundsätze bereits falsch gelernt werden, überträgt sich das ganze später im beruflichen LebenDer Satz
aber dann kann ich immernoch meine Lehrerin verantwortlich machen :bimeiwar ein Zusatz um die Atmosphäre ein wenig zu lockern - daher auch der Smiley.
Nachdem ich weiter oben bereits gesagt hatte, warum der Code so aufgebaut ist, hat sich diese Frage auch geklärt:
[..]Vererbung bekannt ist, dann darf wohl die fachliche Frage berechtigt sein, warum nutzt Du sie dann nicht und baust hier eine komplexe und unübersichtliche Codestruktur auf, die nicht notwendig ist.Was ich noch anführen wollte ist folgendes:
Ich entsinne mich nicht, das innerhalb des Thread gesagt zu haben.Was vollkommen korrekt ist. Ich hatte den Satz auch nur als einen Hinweis - Tipp angeführt. Ich hatte gehofft damit ein Signal versendet zu haben.
Denn auch wenn Deine Kritik (größtenteils) angebracht ist, so wirkst Du für mich leider ein bischen "hochnäsig" oder vorsichtiger wie ein "Mann des leichten Wortes", was ich persönlich sehr schade finde, denn meiner Meinung nach ist der Moderator (und der Administrator, bzw. die leitende Gruppe) das Vorbild für jedes Mitglied.
Container Klasse von Java (ArrayList, Vector, ...) und die Comparable-Schnittstelle[...]was Du hier anhand der Aufgabenstellung hättest machen sollenAuch wenn ich rein fachlich nicht beurteilen kann, ob Du Recht hast, so war es nicht in der Aufgabenstellung gefordert. Weder direkt noch indirekt. Die Schnittstelle (Interface) sollten wir uns allerdings sehr wohl anschauen - was meiner Ansicht nach der von Dir angsprochene Punkt ("Comparable-Schnittstelle") entspricht?
Rein gedanklich habe ich mir inzwischen folgendes überlegt:
Zunächst wird abgefragt, ob der Baum leer ist, um einen möglichen NullPointer zu vermeiden.
Falls ja: Es wird ein neuer Baum erzeugt.
Falls nein: Überprüfe, ob Teilbäume existieren (bzw. nicht leer sind).
Nun wird gefragt, ob die vorliegende Visitenkarte größerAls die im Baum liegende Visitenkarte (Ordnungsobjekt) ist.
Falls nein & nicht gleich der aktuellen & und das Blatt nicht gleich null: linker Teilbaum.
Falls nein & gleich der aktuellen: Methode gleichWie aufrufen.
Falls ja und das Blatt nicht gleich null: gehen einen Schritt in den rechten Teilbaum.
--Falls das Blatt gleich null & nicht gleich der akteullen Karte: lege Karte ab und lösche aktuelle Visitenkarte aus der Liste. (gilt sowohl für den rechtenTB als auch für den linkenTB).
Methode GleichWie:
lösche Karte. (,da sonst doppelt existent)
Falls wir am Ende sind (keine Visitenkarte mehr vorhanden):
Programm durchgelaufen. Ende.
Nun gut. Lediglich ein paar Gedanken für das Programm. Die Methoden "istGleichWie", "istGroesserAls" und "istKleinerAls" kann ich ja mit Hilfe der Schnittstelle benutzen.
Verbesserungsvorschläge gerne gesehen :cool:
Viele Grüße
Ne0Nebul0sa
-
Warum nutzt Du dann in Deiner Baumklasse eine Klasse "Ordnungsobjekt" und Deine Visitenkartenklasse hat damit nichts zu tun !? Deine Casts in der Klasse sind völlig überflüssig und machen Deinen Code nur unleserlich.
Wenn Du die Definition des Suchbaumes ( Suchbaum ) wirklich verstanden hättest, dann würdest Du sehen, dass ein Suchbaum nur ein abstraktes Modell ist und sich gar nicht als konkrete implementierte Klasse umsetzen lassen würde, sondern eine konkrete Implementation wäre ein kd-Tree, oder AVL-Tree, ....
Dein kompletter Code ist unstrukturiert und unsystematisch aufgebaut. Es lässt sich nicht wirklich anhand des Codes erkennen, welchen konkreten Baum Du überhaupt implementiert hast. Zusätzlich solltest Du den Code entsprechend layouten, damit er leserlich ist. Du verwendest keine Vererbung innerhalb Deiner Klassen wie z.B. generell Traversierungsmöglichkeiten des Baumes, die dann durch Vererbung entsprechend zur Verfügung stehen. Zusätzlich empfehle ich, dass Du Dich mit den Java Generics ( Generische Programmierung in Java ) vertraut machst, denn damit lassen sich viele Strukturen direkt passend anlegen, so dass Dein Baum z.B. nur Visitenkartenobjekte enthält. Letztendlich sollten 3 Klassen (ggf 4, wenn man mehrere Suchbäume implementieren will) genügen um das Problem zu lösen.
Vielleicht solltest Du nicht vergessen, dass ich mich noch in der Lernphase befinde und das Visitenkartenprojekt eher effektiv als effizient arbeiten sollte.
Das heißt, dass das Programm erst einmal nur laufen muss und später keinen kommerziellen Schwerpunkt hat sondern rein aufgrund des Wunsches zu Lernen entstanden ist. Insofern darf der Code auch ruhig ein wenig wilder ausfallen. Gleichwohl hast Du natürlich Recht, wenn die Grundsätze bereits falsch gelernt werden, überträgt sich das ganze später im beruflichen Leben - aber dann kann ich immernoch meine Lehrerin verantwortlich machen :bimei
Letztlich ist meine Umsetzung auch nur eine Reflektion der Qualität des Unterrrichts, falls ich einem durchschnittlichen Schüler entspreche, und das kann ich bei der Betrachtung der Qualitäten meines Kurses mit einiger Sicherheit sagen :upps.
Ich werde mir deine Kritik zu Herzen nehmen und mir in Ruhe nochmal die angesprochenen Bereiche anschauen.
Wie dem auch sei. Mein Programm sollte eigentlich nur funktionieren, und auch wenn ich konstruktive Kritik schätze und sicherlich angebracht ist, hatte ich mir doch einen Lösungsweg bis zum Ziel erhofft, wie bspw. angestrebt durch den User "Aliter". Danke rechtherzlich dafür.
Vielleicht finde ich ja mit den neuen Erkenntnissen einen Weg.
Defakto ist, dass ich selbst noch lerne und viele Dinge noch nicht kenne. Zumal Java meine erste Progammiersprache ist, die ich aktiv erlerne und seit ca. einem Jahr durch die Schule vermittelt bekomme.
Insofern - nobody's perfect.
Ich wette noch nicht mal Du ;-)
Viele Grüße
Ne0Nebul0sa
-
Ich verweise auf http://de.wikipedia.org/wiki/Vererbung_(Programmierung)
Du solltest Dir ganz dringend Gedanken über die Struktur Deiner Klassen machen. Z.B. ist ein Suchbaum immer noch ein Baum, nur mit bestimmten weiteren Anforderungen, d.h. aber dass der Suchbaum von Baum erbt. Im Normalfall würde man mit Hilfe von Vererbung einmal den Baum aufbauen, zusätzlich erhält ein Objekt, das in den Baum eingefügt wird eine "comparable" Schnittstelle, mit Hilfe man eben prüfen kann, ob ein Objekt größer, kleiner oder gleich ist, damit man in dem Baum richtig einfügen kann.
Sprich Dein Visitenkartenobjekt kann entscheiden, ob es kleiner größer oder gleich einem anderen Visitenkartenobjekt ist. Der Suchbaum erbt alles von Baum und zusätzlich enthält er noch entsprechende Strukturen für die Ordnungsrelation, die wiederum auf die in dem Visitenkartenobjekt hinterlegte Struktur für die Ordnung zurückgreift.
Das Prinzip der Vererbung ist mir grundsätzlich bekannt. Ich glaube auch nicht, dass dort mein Problem liegt, da ich in einem vorhergegangenen Projekt bereits erfolgreich mit dieser Methode gearbeitet habe. Ich glaube nur, dass ich mich mit dem Baum selbst nochmals Vetraut machen und insbesondere auch meine Handlungsstränge (Struktogramm) protokollieren sollte. Sonst wirkt es ein wenig unstrukturiert und wild.
Vielleicht finde ich ja dann meine Lösung..
Danke jedenfalls für eure Hilfe.
Grüße
Ne0Nebul0sa
-
Der Cast würde nicht funktionieren. "fuegeEin" müsste ein Baum zurückgeben, statt ein Ordnungsobjekt. Eigentlich sollte das return in "fuegeEin" schon nicht funktionieren (Typ Baum wird zurückgegeben, Ordnungsobjekt wird aber erwartet).
Ich hab die Klasse heute ein wenig umprogrammiert.. Von der Syntax her passt sie jetzt auch (s.unten).
Die Klasse Visitenkartenanwendung liefert folgenden Fehler: "fuegeEin(Baum,bspg.strukturen.Ordnungsobjekt) in Suchbaum cannot be applied to (Visitenkarte)"
Das liegt offensichtlich daran, dass die Visitenkartenanwendung versucht eine Visitenkarte mitzuliefern, aber die Methode im Suchbaum wie folgt ausschaut:
fuegeEin(Baum lBaum, Ordnungsobjekt pObjekt)
Aber wie verknüpfe ich jetzt die beiden Klassen? Danke nochmals für eure Hilfe! Ne0Nebul0sa Klasse Suchbaum:import bspg.strukturen.*; public class Suchbaum { private Baum lBaum; public Suchbaum() { lBaum = new Baum(null); } private Baum fuegeEin(Baum lBaum, Ordnungsobjekt pObjekt){ if(!lBaum.istLeer()){ Ordnungsobjekt wurzel = (Ordnungsobjekt) lBaum.inhalt(); if(pObjekt.istKleinerAls(wurzel)) return new Baum(wurzel,fuegeEin(lBaum.linkerTeilbaum(), pObjekt),lBaum.rechterTeilbaum()); else if(pObjekt.istGroesserAls(wurzel)) return new Baum(wurzel,lBaum.linkerTeilbaum(),fuegeEin(lBaum.rechterTeilbaum(), pObjekt)); else return lBaum; } else return new Baum(pObjekt); } public Visitenkarte insertItem(Ordnungsobjekt pObjekt, Visitenkarte lVisitenkarte) { if (lBaum.istLeer()) lBaum= new Baum(pObjekt); else lBaum = fuegeEin(lBaum, pObjekt); return lVisitenkarte; } private void loesche(){ ; } private void lwr(Baum lBaum, Liste liste){ if (!lBaum.istLeer()){ lwr(lBaum.linkerTeilbaum(),liste); liste.fuegeDahinterEin(lBaum.inhalt()); //liste.next(); lwr(lBaum.rechterTeilbaum(),liste); } } private Ordnungsobjekt sucheInBaum(Baum lBaum, Ordnungsobjekt pObjekt){ if (lBaum.istLeer()) return null; Ordnungsobjekt root = (Ordnungsobjekt)lBaum.inhalt(); if (root.istGleichWie(pObjekt)) return root; else if (pObjekt.istKleinerAls(root)) return sucheInBaum(lBaum.linkerTeilbaum(),pObjekt); else return sucheInBaum(lBaum.rechterTeilbaum(),pObjekt); } } -
Ja, das ist mir klar.. Aber ich suche eine Lösung, ohne den Konstruktor des Baumes zu verändern.. Sprich muss ich meinen jetzigen Code i-wie ändern. Die Klasse Ordnungsobjekt ist ein Interface:In dieser Zeilereturn new Baum(inhalt(), fuegeEin(lBaum.linkerTeilbaum(),lVKarte),rechterTeilbaum());
willst du einen neuen Baum erstellen, rufst dabei aber eine Methode auf ("fuegeEin"), welche ein "Ordnungsobjekt" (Kannst du davon den Code posten? Ist das ein Interface/Klasse?) zurückgibt. Der Konstruktor erwartet aber entwederpublic Baum(Object pInhalt) { kenntInhalt = pInhalt; kenntLinks = null; kenntRechts = null; }oderpublic Baum(Object pInhalt, Baum pLinks, Baum pRechts) { kenntInhalt = pInhalt; kenntLinks = pLinks; kenntRechts = pRechts; }public interface Ordnungsobjekt { // Dienste public boolean istGroesserAls(Ordnungsobjekt pObjekt); public boolean istKleinerAls(Ordnungsobjekt pObjekt); public boolean istGleichWie(Ordnungsobjekt pObjekt); }Entweder ist also mein Gedanke falsch oder ich muss das Ordnungsobjekt überreden, zu einem Baum zu werden (Cast?)
-
Hi,
Danke für die Antwort.
cannot find symbol - constructor Baum(java.lang.Object,bspg.strukturen.Ordnungsobjekt,Baum)Wie gesagt:
(edit): Ich hoffe natürlich auf einen Lösungsvorschlag, der nicht den Konstruktor des Baumes verändern möchte :-).:-)
Viele Grüße
Ne0Nebul0sa
-
Natürlich. Danke für die Hilfe.
Habe ich geändert. Ebenso noch 2 andere, kleine Fehler.
Momentaner Fehler: Der Konstruktor der Klasse "Baum" kommt nicht mit der Struktur (Object, Ordnungsobjekt, Baum) klar (s. neuen Code). Ist naheliegend, da er so programmiert wurde, dass, nur folgende Konstruktoren möglich sind:
public Baum(Object pInhalt)
oderpublic Baum(Object pInhalt, Baum pLinks, Baum pRechts)
Irgendwelche Lösungsansätze? Der jetzige Code sieht wie folgt aus:public Ordnungsobjekt fuegeEin(Baum lBaum,Ordnungsobjekt pInhalt) { //erg�nze String lName, lTelefon, lEmail; if(!this.istLeer()) { lVKarte = new Visitenkarte(lName, lTelefon, lEmail); if(lVKarte.istKleinerAls(pOrdnungsobjekt)) { return new Baum(inhalt(), fuegeEin(lBaum.linkerTeilbaum(),lVKarte),rechterTeilbaum()); } else if(lVKarte.istGroesserAls(pInhalt)) { return new Baum(inhalt(), linkerTeilbaum(),fuegeEin(lBaum.rechterTeilbaum(),lVKarte)); } else { return lBaum; } } else { return new Baum(pInhalt); } }Bin ein wenig ratlos. Danke für die Hilfe nochmals!
(edit): Ich hoffe natürlich auf einen Lösungsvorschlag, der nicht den Konstruktor des Baumes verändern möchte :-).
-
Hallo liebes Forum,
Ich sitze gerade an einem Projekt "Visitenkarten", welches in Java programmiert werden soll. Ich benutze die SuM-Bibliothek und programmiere (zwangsweise) mit BlueJ.
Das Projekt beschäftigt sich mit dem Erarbeiten eines Suchbaums (ähnlich dem Binärbaum).
Der bisherige Projektfortschritt:
Klasse Suchbaum:
import bspg.strukturen.*; public class Suchbaum extends Baum { // Bezugsobjekte Visitenkarte lVKarte; // Attribute // Konstruktor public Suchbaum(Ordnungsobjekt pInhalt) { super(pInhalt); } // Dienste public void fuegeEin(Ordnungsobjekt pInhalt) { String lName, lTelefon, lEmail; if(!this.istLeer()) { lVKarte = new Visitenkarte(lName, lTelefon, lEmail); if(this.istKleinerAls(pInhalt)) { return new Baum(inhalt(), fuegeEin(linkerTeilbaum(),lVKarte),rechterTeilbaum()); } else if(this.istGroesserAls(pInhalt)) { return new Baum(inhalt(), linkerTeilbaum(),fuegeEin(rechterTeilbaum(),lVKarte)); } else { return lBaum; } } else { return new Baum(pInhalt); } } public void sortiereListe() { if(!this.istLeer()) { sortiereListe(linkerTeilbaum(), lListe); lListe.FuegeDahinterEin(inhalt()); this.vor(); sortiereListe(rechterTeilbaum(), lListe); } } public Ordnungsobjekt suche(Ordnungsobjekt pInhalt) { //erg�nze Liste lListe = new Liste(); sortiereListe(lBaum, lListe); return lListe; }Der Code ist ansich recht verständlich und gut übersichtlich. Die Methoden "sortiereListe","suche" und "fuegeEin" sind selbst programmiert und ich weiß deshalb nicht, ob sie korrekt sind. Ich bekomme zur Zeit immer den Fehler "cannot find symbol - Method IstKleinerAls(bspg.strukturen.Ordnungsobjekt)". Der Fehler sagt offentsichtlich aus, dass die Methode nicht gefunden wurde. Allerdings bin ich zu blauäugig die Problemlösung zu sehen. Da ich mir aber überhaupt nicht sicher bin, ob mein Gedankengang im Programm selbst und die Syntax korrekt ist, stelle ich lieber gleich die Frage "der Elite" ;-) (edit): Mir fehlt auch noch die Abfrage, wenn die Teilbäume leer sind. Diese müssen dann logischerweise erzeugt werden. - Dazu in der If-Abfrage (in den Methoden IstKleinerAls,etc.) eine neue If-Afrage mit sowas wie "!linkerTeilBaum.istLeer()" und wenn false (für den else-Zweig) "new Baum(null, liTB, null);" ? Ferner danke ich euch jetzt schon einmal für alle Hilfen, Antworten und Ideen und wünsche einen angenehmen Wochenstart. Viele Grüße Ne0Nebul0sa --Anhang: Zum Nachvollziehen einzelner Methoden auch noch die Klasse Visitenkarte (funktioniert und ursprl. vorgegeben):import bspg.strukturen.*; /** * @author Bernard Schriek * @version 08.08.2006 */ public class Visitenkarte implements Ordnungsobjekt { // Bezugsobjekte // Attribute private String zName; private String zTelefon; private String zEmail; // Konstruktor public Visitenkarte(String pName, String pTelefon, String pEmail) { zName = pName; zTelefon = pTelefon; zEmail = pEmail; } // Dienste public String name() { return zName; } public String telefon() { return zTelefon; } public String email() { return zEmail; } public String toString() { return zName + " " + zTelefon + " " + zEmail; } public boolean istGroesserAls(Ordnungsobjekt pOrdnungsobjekt) { Visitenkarte lVisitenkarte; lVisitenkarte = (Visitenkarte)pOrdnungsobjekt; return this.name().compareTo(lVisitenkarte.name()) > 0; } public boolean istKleinerAls(Ordnungsobjekt pOrdnungsobjekt) { Visitenkarte lVisitenkarte; lVisitenkarte = (Visitenkarte)pOrdnungsobjekt; return this.name().compareTo(lVisitenkarte.name()) < 0; } public boolean istGleichWie(Ordnungsobjekt pOrdnungsobjekt) { Visitenkarte lVisitenkarte; lVisitenkarte = (Visitenkarte)pOrdnungsobjekt; return this.name().compareTo(lVisitenkarte.name()) == 0; } }Sowie, falls benötigt, noch die Klasse Visitenkartenanwendung:/** * Die Klasse Visitenkartenanwendung wurde automatisch erstellt: * * @author Bernard Schriek * @version 11.8.2006 */ import sum.komponenten.*; import sum.werkzeuge.*; import sum.ereignis.*; import bspg.strukturen.*; public class Visitenkartenanwendung extends EBAnwendung { // Objekte private Etikett hatEtikettSuchbaumtest; private Knopf hatKnopfEinfuegen; private Knopf hatKnopfLoeschen; private Knopf hatKnopfSuchen; private Zeilenbereich hatZeilenbereichSuchbaum; private Etikett hatEtikettSuchbaum; private Knopf hatKnopfBeenden; private Etikett hatEtikettMeldung; private Etikett hatEtikettName; private Etikett hatEtikettTelefon; private Etikett hatEtikettEmail; private Textfeld hatTextfeldName; private Textfeld hatTextfeldTelefon; private Textfeld hatTextfeldEmail; private Knopf hatKnopfErzeugen; private Suchbaum hatSuchbaum; private Rechner hatRechner; // Attribute /** * Konstruktor */ public Visitenkartenanwendung() { //Initialisierung der Oberklasse super(650, 430); hatEtikettSuchbaumtest = new Etikett(140, 4, 100, 25, "Suchbaumtest"); // Ausrichtung hatEtikettSuchbaumtest.setzeAusrichtung(Ausrichtung.LINKS); hatKnopfEinfuegen = new Knopf(423, 182, 100, 30, "Einf�gen"); hatKnopfEinfuegen.setzeBearbeiterGeklickt("hatKnopfEinfuegenGeklickt"); hatKnopfLoeschen = new Knopf(424, 222, 100, 30, "L�schen"); hatKnopfLoeschen.setzeBearbeiterGeklickt("hatKnopfLoeschenGeklickt"); hatKnopfSuchen = new Knopf(424, 260, 100, 30, "Suchen"); hatKnopfSuchen.setzeBearbeiterGeklickt("hatKnopfSuchenGeklickt"); hatZeilenbereichSuchbaum = new Zeilenbereich(14, 80, 400, 300, ""); hatEtikettSuchbaum = new Etikett(14, 42, 100, 25, "Suchbaum"); // Ausrichtung hatEtikettSuchbaum.setzeAusrichtung(Ausrichtung.LINKS); hatKnopfBeenden = new Knopf(425, 348, 100, 30, "Beenden"); hatKnopfBeenden.setzeBearbeiterGeklickt("hatKnopfBeendenGeklickt"); hatEtikettMeldung = new Etikett(15, 393, 300, 25, "Meldung"); // Ausrichtung hatEtikettMeldung.setzeAusrichtung(Ausrichtung.LINKS); hatEtikettName = new Etikett(422, 81, 60, 25, "Name"); // Ausrichtung hatEtikettName.setzeAusrichtung(Ausrichtung.RECHTS); hatEtikettTelefon = new Etikett(422, 115, 60, 25, "Telefon"); // Ausrichtung hatEtikettTelefon.setzeAusrichtung(Ausrichtung.RECHTS); hatEtikettEmail = new Etikett(422, 148, 60, 25, "Email"); // Ausrichtung hatEtikettEmail.setzeAusrichtung(Ausrichtung.RECHTS); hatTextfeldName = new Textfeld(489, 81, 150, 25, ""); // Ausrichtung hatTextfeldName.setzeAusrichtung(Ausrichtung.LINKS); hatTextfeldTelefon = new Textfeld(489, 115, 150, 25, ""); // Ausrichtung hatTextfeldTelefon.setzeAusrichtung(Ausrichtung.LINKS); hatTextfeldEmail = new Textfeld(490, 148, 150, 25, ""); // Ausrichtung hatTextfeldEmail.setzeAusrichtung(Ausrichtung.LINKS); hatKnopfErzeugen = new Knopf(425, 300, 100, 30, "Erzeugen"); hatKnopfErzeugen.setzeBearbeiterGeklickt("hatKnopfErzeugenGeklickt"); hatSuchbaum = new Suchbaum(null); hatRechner = new Rechner(); } /** * Vorher: Ereignis GeklicktvonhatKnopfEinfuegen fand statt. * Nachher: (schreiben Sie, was in dieser Methode ausgefuehrt wird) */ public void hatKnopfEinfuegenGeklickt() { Visitenkarte lVisitenkarte; String lName, lTelefon, lEmail; lName = hatTextfeldName.inhaltAlsText(); lTelefon = hatTextfeldTelefon.inhaltAlsText(); lEmail = hatTextfeldEmail.inhaltAlsText(); lVisitenkarte = new Visitenkarte(lName, lTelefon, lEmail); hatSuchbaum.fuegeEin(lVisitenkarte); hatZeilenbereichSuchbaum.setzeInhalt(hatSuchbaum.toString()); hatEtikettMeldung.setzeInhalt("Visitenkarte wurde eingef�gt"); } /** * Vorher: Ereignis GeklicktvonhatKnopfLoeschen fand statt. * Nachher: (schreiben Sie, was in dieser Methode ausgefuehrt wird) */ public void hatKnopfLoeschenGeklickt() { Visitenkarte lVisitenkarte; String lName; lName = hatTextfeldName.inhaltAlsText(); lVisitenkarte = new Visitenkarte(lName, "", ""); hatSuchbaum.loesche(lVisitenkarte); hatZeilenbereichSuchbaum.setzeInhalt(hatSuchbaum.toString()); hatEtikettMeldung.setzeInhalt("Visitenkarte wurde gel�scht"); } /** * Vorher: Ereignis GeklicktvonhatKnopfSuchen fand statt. * Nachher: (schreiben Sie, was in dieser Methode ausgefuehrt wird) */ public void hatKnopfSuchenGeklickt() { Visitenkarte lVisitenkarte, lGesuchteVisitenkarte; String lName; lName = hatTextfeldName.inhaltAlsText(); lVisitenkarte = new Visitenkarte(lName, "", ""); lGesuchteVisitenkarte = (Visitenkarte)hatSuchbaum.suche(lVisitenkarte); if (lGesuchteVisitenkarte != null) { hatEtikettMeldung.setzeInhalt("Visitenkarte wurde gefunden"); hatTextfeldTelefon.setzeInhalt(lGesuchteVisitenkarte.telefon()); hatTextfeldEmail.setzeInhalt(lGesuchteVisitenkarte.email()); } else { hatEtikettMeldung.setzeInhalt("Visitenkarte wurde nicht gefunden"); hatTextfeldTelefon.loescheAlles(); hatTextfeldEmail.loescheAlles(); } } /** * Vorher: Ereignis GeklicktvonhatKnopfBeenden fand statt. * Nachher: (schreiben Sie, was in dieser Methode ausgefuehrt wird) */ public void hatKnopfBeendenGeklickt() { this.beenden(); } /** * Vorher: Ereignis GeklicktvonhatKnopfErzeugen fand statt. * Nachher: (schreiben Sie, was in dieser Methode ausgefuehrt wird) */ public void hatKnopfErzeugenGeklickt() { int lZahl; String lName, lTelefon, lEmail; Visitenkarte lVisitenkarte; for (int i = 0; i < 1000; i++) { lZahl = hatRechner.ganzeZufallszahl(1000, 9999); lName = "Meier" + lZahl; lTelefon = "0211/" + lZahl; lEmail = "User" + lZahl + "@xyz.de"; lVisitenkarte = new Visitenkarte(lName, lTelefon, lEmail); hatSuchbaum.fuegeEin(lVisitenkarte); } hatEtikettMeldung.setzeInhalt("1000 neue Visitenkarten erzeugt."); hatZeilenbereichSuchbaum.setzeInhalt(hatSuchbaum.toString()); } }Die Klasse Baum wird in diesem Fall zwar ebenfalls benötigt, ist aber eigentlich nur indirekt von Relevanz - zur Sicherheit aber trotzdem:public class Baum { // Bezugsobjekte Object kenntInhalt; Baum kenntLinks; Baum kenntRechts; // Attribute // Konstruktor public Baum(Object pInhalt) { kenntInhalt = pInhalt; kenntLinks = null; kenntRechts = null; } public Baum(Object pInhalt, Baum pLinks, Baum pRechts) { kenntInhalt = pInhalt; kenntLinks = pLinks; kenntRechts = pRechts; } // Dienste public Object inhalt() { return kenntInhalt; } public void setzeInhalt(Object pInhalt) { kenntInhalt = pInhalt; } public Baum linkerTeilbaum() { return kenntLinks; } public boolean istLeer() { return kenntInhalt == null; } public void setzeLinkenTeilbaum(Baum pBaum) { kenntLinks = pBaum; } public Baum rechterTeilbaum() { return kenntRechts; } public void setzeRechtenTeilbaum(Baum pBaum) { kenntRechts = pBaum; } public boolean istBlatt() { return kenntInhalt != null && kenntLinks == null && kenntRechts == null; } }
BlueJ: Das 8-Damen Problem (Backtracking)
in Java
Geschrieben · Bearbeitet von Ne0Nebul0sa
s. Nachtrag
Hi Kai - ich hoffe, dass ich Dich so nennen darf, denn das macht die Diskussion ein wenig lockerer ;-),
Danke Dir für Deine einführenden Worte. Das Projekt sollte natürlich OOP umgesetzt werden.
Ich hatte einen halbwegs vollständigen Peusocode gepostet und mein erster Entwurf war doch noch recht weit weg vom endgültigen Produkt.
Dank flashpixx und einer langen Nacht nun passé, bzw. abgehakt. Wichtige Gedanken und den Quellcode hat flashpixx ja veröffentlicht, sodass das Problem nun für jedermann lösbar sein sollte.
Interessante Frage. Explizit gab es dafür keine Vorgabe [...](s. Nachtrag).
Nachtrag: Die bessere Formulierung wäre vielleicht: Eine aller möglichen Lösungen ausgeben zu lassen, denn die Positionen der Damen werden nicht statisch (fest) vergeben, sondern in jedem Programmlauf heuristisch generiert. Insofern trifft
zu.Exakt diesen Ablauf haben wir auch versucht und, soweit ich das beurteilen kann, erfolgreich gemeistert. Wie flashpixx schon sagte: Ein Struktogramm kann, muss aber nicht, hilfreich sein. Gerade für Anfänger halte ich das Lösungsprinzip für nicht schlecht, da viele damit eine Programmierungsgrundlage besitzen, da viele einfach drauf los programmieren wollen (huch, spreche ich da etwa aus Erfahrung
?).
Nichtdestoweniger sollte der generelle Ablauf und auch die objektorientierte Umsetzung mit UML-Diagrammen (sofern ich das richtig verstanden habe) umgesetzt werden (,was auch Bestandteil meines Informatikunterrichts ist).
Danke dafür. Allerdings kommt Deine Hilfe wohl "zu spät", denn mein Programm ist bereits, zumindest iterativ, umgesetzt worden. Flashpixx hat sogar beide Varianten.
Insofern: Danke für Deine Hilfe
Das ist mir auch klar geworden. Leider, das kann ich im Nachhinein sagen, ist die grafische Umsetzung in meinem Unterricht meist der erste umgesetzte Bereich. Es wird leider erst danach mit dem eigentlichen Programmieren begonnen...
Danke, ja, Flashpixx hat den selben Ansatz gewählt
..und, in der Tat, es hat sich gelohnt!
Danke, schöne Grüße zurück.
Wir beide haben ja jezt auch zwei Programme rumliegen. Wenn Du magst, poste doch mal Dein Programm, dann haben wir einen regelrechten Auswahlpool, der späteren Interessenten eine Betrachtung des Problems aus vielen Perspektiven bietet.
Nun zu Flashpixx: Gute Anmerkung, allerdings solltest Du erwähnen, dass mein Programm überhaupt erst durch eine lange Programmierungsnacht mit Dir entstehen konnte. Zudem hat es uns beide, aber vor allem Dich, viele Nerven gekostet.
Deshalb: Nochmals vielen Dank dafür - und lasse Dir dein Prestige ruhig zuschreiben, das hast Du in diesem Fall wirklich verdient!
Viele Grüße
Alex aka Ne0