# Aufgabenprojekt XXO



## schnosi (23. Dez 2009)

Hey Leute,

haben über die Weihnachts"ferien" eine etwas größere Aufgabe aufgekommen und ich weiß leider erstmal nicht so recht, wie ich anfangen soll. Habe wegen des Themas schon etwas gegoogelt und auch schon hier mit der Forensuche mir ein paar Sachen durchgelesen, aber im Enddefekt hat es mir nichts gebracht, da ich nur auf zu komplizierte Sachen gestoßen bin, die ich noch nicht verstehe und die auch Teilweise mit Applet und so'n Zeugs sind und davon habe ich bisher leider NULL Ahnung. (würde mir wünschen, das schon alles zu verstehen.)
Könntet ihr mir vielleicht ein paar Tipps zum Herangehen an die Aufgabe geben? Das wäre echt supi nett.




Hier nun die Aufgabe:

Aufgabe 1 (20 Punkte) Projekt: XXO
Diese Aufgabe soll zeigen, dass man mit dem bisher in dieser Veranstaltung gelernten Wissen
auch gr¨ oßere Projekte realisieren kann.
Sie sollen nun das bekannte Spiel XXO programmieren. Dieses ist auch unter weiteren Namen,
wie “Drei gewinnt”, “Tic, Tac, Toe”, “Kreis und Kreuz” oder “Noughts and Crosses” bekannt.
Falls Ihnen die Regeln nicht bekannt sind, so sind diese f¨      ur Sie hier kurz zusammmengefasst:
1. Gespielt wird auf einem Feld in der Gr¨     oße 3x3, das zu Anfang noch leer ist.
2. Es gibt 2 Parteien: “X” und “O”
3. Jede Partei darf abwechselnd auf ein noch nicht besetztes Feld sein Zeichen setzen.
4. Der Spieler mit dem “X” beginnt.
5. Wer zuerst 3 Felder in einer Reihe hat gewinnt. (Dies ist in den 3 waagerechten Zeilen,
den 3 senkrechten Spalten und den beiden Diagonalen m¨     oglich.)
6. Sind alle 9 Felder besetzt und hat kein Spieler einen Sieg erringen k¨            onnen, so endet das
Spiel unentschieden.
Da diese Aufgabe etwas umfangreicher ist, haben Sie f¨    ur die L¨ osung insgesamt drei Wochen Zeit.
Um Ihren Fortschritt zu kontrollieren, haben wir zwei Unteraufgaben abgegrenzt. Sie k¨        onnen die
Vorgabe-L¨ osungen der Unteraufgaben von der ISIS-Seite der Veranstaltung als .class-Dateien
herunterladen, um die von Ihnen entwickelte L¨ osung der jeweils anderen Aufgabe zu testen. Da
die Schnittstelle zwischen beiden Teilen durch ein Interface eindeutig spezifiziert ist, m¨             ussen
Ihre Teill¨ osungen mit Teilen der Musterl¨ osung zu einem funktionsf¨ ahigen Programm kombiniert
werden k¨ onnen.

1 Frontend - 8 Punkte

Als erstes sollten Sie das Frontend (Benutzerschnittstelle) des Spiels implementieren und dabei
f¨ ur das Backend (Spiellogik) auf die vorgegebene Klasse zur¨      uckgreifen. Laden Sie sich zun¨ achst
die Vorgaben-Dateien von der ISIS-Seite der Veranstaltung herunter. In ihnen finden Sie die
bereits kompilierte Klasse Spielbrett, sowie die Quelldatei des SpielbrettInterface, das
von ihr implementiert wird. Durch dieses wird die Spiellogik in die folgenden drei Methoden
gekapselt:
1. public void ausgeben();
Diese Methode gibt das Spielbrett auf der Konsole aus.
2. public boolean setzen(String partei, int zeile, int spalte);
Mit dieser Methode wird ein neuer Stein auf das Spielfeld gesetzt. Dabei muss partei
entweder “X” oder “O” sein. zeile und spalte geben zusammen die Position des Steines
an, wobei das Feld links oben die Position (0,0) darstellt. Konnte der Stein erfolgreich
gesetzt werden, liefert die Methode true zur¨    uck. Gab es Probleme, z.B. falls ein Parame-
ter unzul¨ assig war, das Feld bereits belegt ist oder das Spiel bereits geendet hat, ist die
R¨ uckgabe false.
3. public boolean checkSieg();
Diese Methode liefert genau dann true zur¨    uck, wenn einer der Spieler eine Siegbedingung
erf¨ ullt. (Hinweis: Um festzustellen, welche Partei gewonnen hat, sollte man pr¨          ufen, wer
zuletzt einen Stein gesetzt hat.)
4. public boolean checkUnentschieden();
Diese Methode liefert genau dann true zur¨ uck, wenn das Spiel unentschieden geendet hat.
Ihre Aufgabe besteht nun darin, eine Klasse XXO zu implementieren, in deren main-Methode ein
Spielablauf gekapselt wird. Sie k¨ onnen sich dabei an der folgenden Vorgehensweise orientieren:
1. Erzeugen Sie ein Objekt der Klasse Spielbrett und speichern Sie es in einer Variable vom
Typ SpielbrettInterface. Neue Spielbretter werden vom Konstruktor automatisch mit
leeren Feldern initialisiert.
2. Zeigen Sie das aktuelle Spielbrett auf der Konsole.
3. Fragen Sie nun den Benutzer nach der Zeile und Spalte, in die das n¨         achste Zeichen gesetzt
werden soll. Sie k¨ onnen die statische Methode public int askInt(String frage) der
Klasse Terminal aus der Vorgabe dazu benutzen. Sie gibt den Parameterstring als Auf-
forderung auf der Konsole aus, liest dann alle Zeichen bis zum n¨          achsten Zeilenumbruch
(“Enter”) von der Tastatur ein und gibt dies als int zur¨       uck. (Hinweis: Um die Fehlerbe-
handlung bei nicht-Interger Eingabe m¨ ussen Sie sich nicht k ¨ ummern.)
4. Setzen Sie das Zeichen des aktuellen Spielers an der gew¨      unschten Position auf das Spielfeld.
Bei Erfolg schalten Sie den aktuellen Spieler um, bei Fehlschlag geben Sie eine Fehlermel-
dung aus.
5. ¨ Uberpr¨ ufen Sie, ob das Spiel zu Ende ist. Wenn ja, geben Sie das Ergebnis und das aktuelle
Spielbrett auf der Konsole aus und beenden Sie das Programm. Wenn nein, gehen Sie
zur¨ uck zu Punkt 2.

2 Backend - 8 Punkte

Im zweiten Teil sollen Sie das Backend (Spiellogik) des Spiels implementieren, f¨        ur das Sie im ers-
ten Teil die Vorgabe-Klasse verwendet haben. Es soll aus einer Klasse Spielbrett bestehen, welche
das SpielbrettInterface aus der Vorgabe implementiert. Die Spezifikation der Methoden sollte
Ihnen aus der ersten Aufgabe bereits bekannt sein. Ihre Methoden m¨       ussen diese so erf¨ ullen, dass
eine Kombination aus Ihrem Spielbrett und der Klasse XXO aus der Vorgabe ein lau ¨            ahiges,
korrektes Spiel ergibt. Sie d¨ urfen allerdings die Ausgabe nach Ihren W¨    unschen gestalten und
versch¨ onern, so lange das Spielbrett grunds¨ atzlich erkennbar ist. Ihre Klasse Spielbrett muss
auch einen parameterlosen Konstruktor besitzen, der das Spielfeld leer initialisiert. Sie d¨           urfen
bei Bedarf ¨ uber die Spezifikation hinaus nat¨ urlich beliebige Attribute und Hilfsmethoden dekla-
rieren, m¨ ussen diese dann aber vor direktem Zugri  von ausserhalb der Klasse verstecken.

3 Kommentare - 4 Punkte

Je gr¨ oßer das Software-Projekt, desto wichtiger ist eine gute Dokumentation des Codes mit
Kommentaren. H¨ aufig m¨ ussen Programme von Entwicklern ausgebaut oder repariert werden,
die sie nicht selbst geschrieben haben. Achten Sie deshalb in diesem Aufgabenblatt besonders
darauf, Ihren Code so verst¨ andlich und vollst¨ andig zu kommentieren, dass ein fremder Pro-
grammierer auf Ihrem Wissensstand ihn nur anhand des Quellcodes sofort nachvollziehen und
an den richtigen Stellen modifizieren k¨ onnte. Zu einer guten Beschreibung mit Kommentaren
geh¨ oren die zul¨ assigen Zust¨ ande und Bedeutungen von Variablen, Attributen und Parametern,
die Auswirkungen von Methoden und nachvollziehbare Erkl¨      arungen von nicht-trivialen Pro-
grammabl¨ aufen.

___

Wer diese Aufgabe auf Grund des Unicodes nicht so gut lesen kann, für den habe ich sie als jpg nochmal im Anhang hinzugefügt.
Die Vorgaben, habe ich ebenso als Anhang hinzugefügt.

Ich bin für jede Hilfe echt sehr, sehr dankbar.

Schon einmal vielen Dank im Voraus.

Liebe Grüße,
schnosi.

P.S: Euch allen eine frohe Weihnachtszeit!


----------



## Ein Keks (23. Dez 2009)

ihr habt doch eine recht detaillierte aufgabenstellung...mach einfach das was in der aufgabe steht, einfach schrit für schritt druchgehn. kriegst sogar ne kleine hilfe (keine musterlösung aber recht hilfreich^^)
(wieso kann man hier keine java dateien anhängen ???:L dann eben als txt)

ansatz:

```
public class Spielbrett implements SpielbrettInterface{

    private int[][] field = new int[3][3];//falls ihr denn ein 2D-Array benutzen dürft ansonsten int[9] oder viel arbeit xD

	public void ausgeben(){

     }

	public boolean setzen(String partei, int zeile, int spalte){

     }

	public boolean checkSieg(){

     }

	public boolean checkUnentschieden(){

     }
}
```


----------



## schnosi (27. Dez 2009)

Soo,

erstmal sorry, dass ich mich die Tage nicht gemeldet habe, aber hab mir über die Weihnachtszeit auch mal eine kleine Auszeit gegönnt. So nun gehts aber wieder los.
Erstmal ganz herzlichen Dank an "Ein Keks" für die Hilfestellung. Ich glaube das bringt mich wirklich sehr gut weiter. Würde mich aber dennoch freuen, wenn ich nicht weiter komme, dass ihr mir noch etwas helfen könntet. Probier mich jetzt aber erstmal und melde mich dann einfach, wenn ich am verzweifeln bin 

Liebe Grüße,
schnosi


P.S: Ja wir sollen sogar 2D benutzen


----------



## schnosi (27. Dez 2009)

Mhh...also deine Textdatei hilft mir nicht wirklich viel. Das ist mir alles etwas zu kompliziert. Habe versucht das nachzuvollziehen, aber da sind teilweise Dinge, die wir noch nicht hatten und somit kann ich die in der Aufgabe auch nicht verwenden, weil der Kontrollierer sich dann wundert, wo ich sowas her hab. Allerdings konnte ich mit deinem Javacode etwas anfangen.
Habe das da bisher drauß gemacht:

[Java]
public class Spielbrett implements SpielbrettInterface{

    private int[][] field = new int[3][3];
	private String partei;
	private int zeile;
	private int spalte;

    public void ausgeben(){

     }

    public boolean setzen(String partei, int zeile, int spalte){
		this.partei = partei;
		this.zeile = zeile;
		this.spalte = spalte;
     }

    public boolean checkSieg(){

     }

    public boolean checkUnentschieden(){

     }
}
[/code]

Kann man das erstmal so nehmen?
Du sagst, dass die Aufgabe gut beschrieben ist Keks. Das finde ich leider absolut gar nicht. Ich komme mit der Aufgabenstellung überhaupt nicht klar. Da in Punkt 1 (Frontend) ...was meinen die mit Benutzerschnittstelle und Spiellogik. Was muss ich in der Klasse Spielbrett da jetzt noch tun und was in dem Interface SpielbrettInterface?
Tut mir wirklich leid, aber ich stehe offensichtlich auf'm Schlauch 

Bin über jede Hilfe dankbar!

Liebe Grüße,
Schnosi


----------



## Spin (27. Dez 2009)

Hi, deine Dateien beinhalten schon alles. Du kannst dir also deine Lösung anschauen.

Weiterhin ist es nicht gefordert, das Spielbrett zu bauen oder zu implementieren , sondern die Klasse XXO.
Du musst also nur alles aufrufen und dass in einer bestimmten reihenfolge.
Du kannst per Console die bereits kompilierten Dateien aufrufen.

Ich habe es mit Netbeans versucht , aber irgendwie schaff ich es nicht nur .class aufzurufen , also ohne vorher zu kompilieren.

Doch gehts per Console.

gruß


----------



## Ein Keks (28. Dez 2009)

er soll das ganze spiel implementieren also sowohl XXO als auch Spielbrett. die class dateien sind nur musterlösungen damit man ein besseres verständnis hat (und man z.B die eigene Spielbrett-Klasse mit der vorgegebenen XXO-Klasse schon mal testen kann)
natürlich kann man die beiden auch einfach mal decompilen und sich das ganze mal ansehen xD
(wurden halt leicht vom compiler verändert)

edit: irgendwann lass ich mich dafür bezahlen studenten die aufgaben zu machen xDD

```
public class Spielbrett implements SpielbrettInterface{

    private String[][] field = new String[3][3];//ein String[][] ergibt vielleicht etwas mehr sinn mein fehler 

    public Spielbrett(){
		for(int i=0;i<field.length;i++){
			for(int j=0;j<field[0].length;j++){
				field[i][j]=" ";
			}
		}
	}

    public void ausgeben(){
		// man is die Terminal-Klasse hässlich zu lesen echt übertrieben viele kommentare
		// und eindeutlich zu viele sternchen xD
		// mal ne beispiel ausgabe:
		// -------
		// |X|O| |
		// -------
		// | |X| |
		// -------
		// |X|O|O|
		// -------
		Terminal.println("-------");
		for(int i=0;i<field.length;i++){
			Terminal.print("|");
			for(int j=0;j<field[0].length;j++){
				Terminal.print(field[i][j]);
				Terminal.print("|");
			}
			System.out.println(); //absatz
			Terminal.println("-------");
		}
    }

    public boolean setzen(String partei, int zeile, int spalte){
		// stell dir das String[][] als ein feld von 3x3 kästchen vor
		// jetzt musst du da die partei setzen lassen wo sie angibt
		// wenn nicht gesetzt werden kann , weil schon besetzt return false;
		if(isValid(zeile) && isValid(spalte) && field[zeile][spalte].equals(" ")){
			field[zeile][spalte] = partei;
			return true;
		}else{
			return false;
		}
    }

    private boolean isValid(int value){  //gibt ja nur die auswahl 0, 1 und 2
		return value>-1 && value <3;
	}

    public boolean checkSieg(){
		if(/*die aktuelle partei hat eine reihe,spalte,diagonale in field*/){
			return true;
		}
		return false;
    }

    public boolean checkUnentschieden(){
		if(/*keine der parteien hat gewonnen*/){
			return true;
		}
		return false;
    }
}
```

implementier noch checkUnentschieden() und checkSieg() packs zusammen mit Terminal.class und XXO.class in einen ordner comile die Klasse und starte XXO.class über die console (java XXO) danns kanste das ganze testen
danach darfste selbst ne XXO-Klasse basteln xD

edit: ups das is ja aufgabe 2 aufgabe 1 is die XXO-klasse xD naja egal
hier ist aufgabe 1  :

```
public class XXO{

	public static void main(String[] ars){
		SpielbrettInterface spiel = new Spielbrett();
		String partei = "X";//start partei (warum fängt X immer an - voll unfair xDD)

		while(!spiel.checkSieg() && !spiel.checkUnentschieden()){ // wiederholung bis spielende
			spiel.ausgeben();
			Terminal.println("Der aktuelle Spieler ist Spieler "+ partei);
			Terminal.print("Bitte geben Sie eine Zeile ein: ");
			int zeile = Terminal.readInt();
			Terminal.print("Bitte geben Sie eine Spalte ein: ");
			int spalte = Terminal.readInt();
			if(spiel.setzen(partei,zeile,spalte)){ //setzen wenn möglich sonst fehler und kein parteiwechsel
				if(partei.equals("X")){//partei wechseln
					partei = "O";
				}else{
					partei = "X";
				}
			}else{
				Terminal.println("Die gewählte Position ist ungültig.");
			}
		}
		if(spiel.checkSieg()){//sieg oder unentschieden
			Terminal.println("Der Verlierer ist Spieler "+partei);
		}else{
			Terminal.println("Unentschieden!");
		}
	}
}
```

dafür will ich aber einen keks xD


----------



## schnosi (28. Dez 2009)

Vielen Dank erstmal Keks. Habe aber eine Frage dazu. Du hast in deinem Anhang eine Datei Spielbrett.java und dann hast du ja auch nochmal einen Quellcode angehängt. Welchen soll ich davon jetzt verwenden?
Ich nehme mal an deinen Quellcode oder?

Liebe Grüße und nochmal ganz herzlichen Dank

schnosi


----------



## Ein Keks (28. Dez 2009)

im anhang sind die beiden musterlösungen die dabei warn nochma decompiled. wär aber ein wenig auffällig die zu verwenden xD dachte nur wär ma ganz interressant für dich die zu sehen 
nimm meinen quellcode füll noch die lücken im ersten und viel spaß beim kommentieren (aufgabe 3) das würste ja noch allein hinkriegen oder?^^ ich geh jetzt nämlich avatar gucken xD


----------



## schnosi (28. Dez 2009)

Alles klar... vielen, vielen Dank dafür. Ja ich werde mich dann mal noch ranmachen und denke, dass ich den Rest noch hinbekommen werde.
Kommst du zufällig aus Berlin? Dann geb ich dir mal einen aus 

Liebe Grüße,
schnosi


----------



## schnosi (31. Dez 2009)

Hallo,
ich bins nochmal. Habe noch eine kleine Frage. Meine letzte Aufgabe war ja nun noch zu checken, ob ein Sieg bzw. ein Unentschieden vorhanden ist. Bei einem Sieg muss eine der Parteien 3 in einer Reihe/Spalte oder Diagonale haben. Das ist klar... aber wie wird das realisiert? Ich meine... da gibt es ja so viele möglichkeiten, dass man gewonnen haben kann...?!?!
Und ein Remis kommt ja zu Stande, wenn das Gegenteil eines Sieges der Fall ist. Somit müsste man das Ganze nur mit einem ! davor nehmen, oder?
Bitte um Hilfe!
Das wäre echt supi. Kommentiert und verstanden habe ich den Rest nun.

Liebe Grüße,
schnosi


----------



## schnosi (2. Jan 2010)

Hallo,
ich bin's nochmal. Habe das, was Keks mir gesagt hat, jetzt schon mehrmals probiert umzusetzen, aber ich scheitere immer wieder daran. Es will einfach nicht funktionieren. Muss das am Montag abgegeben und habe kaum mehr Zeit. Könntet ihr mir bitte noch bei dieser kleinen Sache helfen? Das wäre echt soo nett.
Liebe Dank!
Grüße,
schnosi


----------



## javimka (2. Jan 2010)

wo genau kommst du denn nicht weiter?


----------



## schnosi (3. Jan 2010)

Hallo,

ich komme in der Klasse Spielbrett, welche das SpielbrettInterface implementiert nicht weiter bei folgendem Punkt:

[Java]
public boolean checkSieg(){
        if(/*die aktuelle partei hat eine reihe,spalte,diagonale in field*/){
            return true;
        }
        return false;
    }

    public boolean checkUnentschieden(){
        if(/*keine der parteien hat gewonnen*/){
            return true;
[/Java]

Könntest du mir einen Tipp geben, was dort hinkommt?

Liebe Grüße,
schnosi


----------



## javimka (3. Jan 2010)

Wie ist denn gespeichert, wer wo seinen Stein gesetzt hat?

Bei checkSieg musst du alle möglichen Gewinnmöglichkeiten überprüfen. Hilfreich könnten for-Schleifen sein.

Bei checkUnentschieden musst du einfach testen, ob alle Felder besetzt sind, aber niemand gewonnen hat. Dann muss wohl unentschieden sein.


----------



## cavelera (3. Jan 2010)

Ich habe bishin diesen Ansatz, find den aber etwas kompliziert (obwohl mit copypast gehts...)

Aber ob das so auch richtig ist? Auch weiß ich nicht, wie ich das gleiche für O machen würde, weil wenn er X gecheckt hat, und da nicht true rauskommt, gibt er ja schon false zurück. Ob return partei="X" so funktioniert, weiß ich auch nicht :-/


```
public boolean checkSieg(){
            
		if { (field[0][0]="X" && field[0][1]="X" && field[0][2]="X")   		//1. Zeile voller X
		else if (field[1][0]="X" && field[1][1]="X" && field[1][2]="X")		//2. Zeile voller X
		else if (field[2][0]="X" && field[2][1]="X" && field[2][2]="X")		//3. Zeile voller X
		else if (field[0][0]="X" && field[1][0]="X" && field[2][0]="X")		//1. Spalte voller X
		else if (field[0][1]="X" && field[1][1]="X" && field[2][1]="X")		//2. Spalte voller X
		else if (field[0][2]="X" && field[1][2]="X" && field[2][2]="X")		//3. Spalte voller X
		else if (field[0][0]="X" && field[1][1]="X" && field[2][2]="X")		//1. Diagonale voller X
		else if (field[0][2]="X" && field[1][1]="X" && field[2][0]="X")		//2. Diagonale voller X
		
		return true;
		return partei="O";
        }
        return false;
```


----------



## javimka (3. Jan 2010)

Das musst du also schon noch etwas ändern., das kompiliert ja nicht mal annähernd.
Der Ausdruck [c]field[0][0]="X"[/c] heisst: Speichere "X" auf field[0][0]. Was du meinst ist ==
Doch selbst == ist falsch, denn Strings muss man mit equals vergleichen: [c]field[0][0].equals("X")[/c].
Dann hast du noch eine falsche { Klammer nach dem if.
Nach jedem Ausdruck muss irgendein Befehl stehen, z.B. [c]return true;[/c]
Die drei return Anweisungen am Schluss machen überhaupt keinen Sinn.

Mein Tipp:
Mach eine Methode hasPartyWon(String party). Diese Methode soll überprüfen, ob die Partei party gewonnen hat. Das kannst du dann sogar mit der korrigierten Version, die du oben gepostet hast, machen. Du musst dann einfach noch "X" durch party ersetzen.
Die Methode checkSieg kann dann hasPartyWon aufrufen und so das richtige Resultat finden.


----------



## cavelera (3. Jan 2010)

Wenn ich X durch party ersetze, macht doch:


```
field[0][0].equals("party") && field[0][1].equals("party") && field[0][2].equals("party")
```

überhaupt keinen Sinn?

Jetzt bin ich erstmal verwirrt


----------



## javimka (3. Jan 2010)

party soll ja auch ein Objekt und kein String sein:

```
private boolean hasPartyWon(String party) {

if (field[0][0].equals(party) && field[0][1]... ) return true;
else if (
...
else return false;
```


----------



## cavelera (3. Jan 2010)

```
private boolean hasPartyWon(String party) {
 
		if (field[0][0].equals(party) && field[0][1].equals(party) && field[0][2].equals(party) return true;
		else if (field[0][0].equals(party) && field[1][1].equals(party) && field[1][2].equals(party) return true;
		else if (field[1][0].equals(party) && field[0][1].equals(party) && field[0][2].equals(party) return true;
		else if (field[2][0].equals(party) && field[2][1].equals(party) && field[2][2].equals(party) return true;
		else if (field[0][0].equals(party) && field[1][0].equals(party) && field[2][0].equals(party) return true;
		else if (field[0][1].equals(party) && field[1][1].equals(party) && field[2][1].equals(party) return true;
		else if (field[0][2].equals(party) && field[1][2].equals(party) && field[2][2].equals(party) return true;
		else if (field[0][0].equals(party) && field[1][1].equals(party) && field[2][2].equals(party) return true;
		else if (field[0][2].equals(party) && field[1][1].equals(party) && field[2][0].equals(party) return true

		else return false;

		}


    public boolean checkSieg(){
            

		if hasPartyWon=true return true;
       	
        	else return false;
    }
```

So :bahnhof: ?

Woher weiß ich dann, ob party X oder O ist und wie soll das zurückgegeben werden?


----------



## javimka (3. Jan 2010)

ja, das ist richtig. Jetzt kannst du checkSieg folgenderamssen implementieren:

```
public boolean checkSieg() {
  return hasPartyWon("O") || hasPartyWon("X");
}
```


----------



## cavelera (3. Jan 2010)

Yeah, übelst geil, jetzt läufts :applaus:

Starkes Ding. Vielen Dank nochmals


----------



## eRaaaa (3. Jan 2010)

Wäre performanter man würde nur prüfen ob derjenige der den letzten Stein gesetzt hat gewonnen hat (der Andere kann ja in der Runde eh nicht gewonnen haben ;D - Steht sogar auch so in der Aufgabenstellung) (ausserdem weiß man doch so garnicht WER gewonnen hat oder? Hab allerdings jetzt nicht alles verfolgt)

Noch performanter wäre es vllt sogar bei der Initialisierung schon alle möglichen Kombinationen in einem boolean Array abzulegen, aber das führt jetzt vllt zu weit


----------



## schnosi (3. Jan 2010)

hehe..supi, dass es so jetzt klappt. vielen dank euch allen!
@eRaaa: Ich glaube wir sind froh, wenn wir es irgendwie hinbekommen. Da müssen wir nicht noch probieren das schönste Programm zu schreiben 

schönen abend noch


----------

