Spiel SQUARES

[Guest]

Hallo allerseits,
ich habe folgende Aufgabe gestellt gekriegt:

Implementieren Sie eine Klasse Squares.java. Squares ist ein Spiel, welches auf einem 8x8 großen Feld mit zwei Spielern gespielt wird. Beide setzen abwechselnd einen Spielstein (X bzw. O). Ziel des Spieles ist es, mit jeweils vier eigenen Spielsteinen die Ecken eines Quadrates zu belegen. Für ein fertiges Quadrat bekommt man den Flächeninhalt als Punkte. Vervollständigt man mit einem Zug mehrere Quadrate, bekommt man für jedes Quadrat die Punkte. Das Spiel ist beendet, wenn entweder das Feld komplett belegt ist oder sobald von einem Spieler mindestens 500 Punkte erreicht wurden.
Arbeiten sie mit einem 2-dimensionalen char-Array. Um einen Stein zu setzen, lesen Sie für den jeweiligen Spieler den Zeilen- und Spaltenindex ein. Ist der Stein gesetzt, überprüfen Sie den Rest der Zeile nach rechts auf einen weiteren gleichen Spielstein. Ist dieser gefunden, berechnen Sie die Indizes der möglichen Quadratecken links und rechts unten und testen, ob sich dort ebenfalls die passenden Spielsteine befinden. Danach prüfen Sie das Quadrat nach oben, berechnen also die Indizes für die linke und rechte obere Ecke. Das wird für die gesamte Zeile nach rechts durchgeführt. Danach erfolgt der gleiche Vorgang analog nach links. Ist ein Quadrat gefunden, werden jeweils die Punkte (Flächeninhalt des Quadrates) gutgeschrieben.

Wäre in folgendem Beipiel Spieler X am Zug und würde er seinen Stein in Zeile 5 und Spalte 4 setzen, würde er 25 (16+9) Punkte bekommen.

| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
---+---+---+---+---+---+---+---+---+
1 | | | | O | O | | O | O |
---+---+---+---+---+---+---+---+---+
2 | X | | | X | O | | O | O |
---+---+---+---+---+---+---+---+---+
3 | | X | | X | O | | | O |
---+---+---+---+---+---+---+---+---+
4 | | | | | | | | |
---+---+---+---+---+---+---+---+---+
5 | X | X | | | | | | X |
---+---+---+---+---+---+---+---+---+
6 | | | | | | | | |
---+---+---+---+---+---+---+---+---+
7 | | | | X | | | | X |
---+---+---+---+---+---+---+---+---+
8 | | | | | | | | |
---+---+---+---+---+---+---+---+---+


Leider ist die Tabelle ein wenig verrutscht aber ich hoffe ihr versteht worums geht...ich nämlich nicht! Zwar verstehe ich wie das Spiel funktionieren soll aber ich habe keine Ahnung wie ich es als java-Programm schreiben soll! Deshalb brauche ich eure Hilfe!

Danke schonmal im Voraus![/code]

 

[lama]

Hallo,

hier bietet sich ein zweidimensionales Array an. Jeder Spieler hat einen Wert, den er bei seinem Zug in ein Feld schreiben kann, Spieler 1 schreibt z.B. eine 1, Spieler 2 eine 2. Leer ist 0.
Dann musst du nach jedem Zug überprüfen, ob sich ein neues Quadrat bilden lässt.

Den Flächeninhalt kannst du einfach mit Breite² oder Höhe² ausrechnen Reicht dir das als Denkanstoß?

P.S.: Um zu verhindern, dass eine Tabelle verrutscht, kannst du die [*code]-tags benutzen.

 

[Gast]

Ja Danke. die ersten 2. Schritte hab ich schon gemacht. Aber ich habe glaub ich ein ganz einfaches Problem und zwar, wie krieg ich die Tabelle hin und vor allem, wie kann ich zb an der Stelle (Zeile)3,(Spalte)4 ein x bzw o setzen? Ist bestimmt ganz leicht, aber ich hab absolut keine idee!

 

[lama]

int spielfeld[][] = new int[8][8]; // 8*8 großes Spielfeld

// i sind die Spalten, j die Zeilen.
for (int i=0; i < spielfeld.length; i++) {
  System.out.println(); // Zeilenumbruch für nächste Zeile
  for (int j=0; j < spielfeld.length; j++) {
    System.out.print(spielfeld[i][j] + " "); // auf den Bildschirm malen
  }
}

Du schreibst einen Wert so in das Feld:
spielfeld[j] = neuerWert;

Standardmäßig ist ein int-Array mit 0 belegt, siehst du auch wenn du den Codeschnipsel oben ausführst

EDIT: Ich seh gerade, 8x8 groß, habs angepasst.

 

[Gast]

Oh danke das hilft mir jetzt schon deutlich weiter. Ich werds mal probieren und mich wieder melden wenn ich wieder aufm schlauch stehe!
Danke nochmal!

 

[Guest]

Ich habs probiert aber irgendwie passiert da nix wenn ich das ausführen will. Wie schaffe ich es denn eine sichtbare Tabelle zu schreiben? Und wo und wie muss ich das spielfeld[j]=neuer Wert anordnen. Wie man merkt ich hab nicht so den Durchblick! Ich hab das folgender Maßen probiert, d<s ist sicherlich grob falsch aber ich weiß es nicht besser!

char [][] spielfeld= new char [8] [8];
         int a;
         a= IO.readInt ("neuer Wert");

           for (int i=0; i<spielfeld.length; i++) {
               System.out.println();
               for (int j=0; j<spielfeld.length;j++) {
                   System.out.print(speilfeld[i][j] + " "=;
                   spielfeld[i][j]=a;
               }
          }

So kann das "Programm" auch nicht ausgeführt werden, weil er für a einen char-Wert erwartet. Aber wie komme ich denn an den "neuen Wert" und was für ein wert ist das? Das es so nicht funktioniert ist mir klar weil ich ja das a auch nicht verändere aber ich wollte halt ertmal nur gucken ob er mir den Wert den ich ihm eingebe ausgibt an der Stelle an der ich ihn haben will. Aber das tut er natürlich nicht. Wenn ich erstmal das a und das Ausgeben von a weglasse, und das Programm ausführe, dann passiert auch nichts! :bahnhof:
Ich hoffe ihr könnt mir helfen!

Danke schonmal!

 

[lama]

Hallo!

Du willst einen char-Wert in das Array schreiben, also musst du den Wert auch mit einzelnen Hochkommas einklammern 'a' statt a. Die Methode, die ich dir aufgeschrieben hatte, ist dafür da, das Spielfeld auf den Bildschirm zu malen.

Willst du einen Wert neu reinschreiben solltest du den Benutzer fragen, an welche Position er schreiben will

Hier ist ein Code, der genau das macht, aber da gibt es noch viel zu verbessern.

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class Test {
	/** Variablen für Feld und Benutzereingabe. */
	static char[][] spielfeld = new char[8][8];
	static BufferedReader in = new BufferedReader(
					new InputStreamReader(System.in));
	
	
	/** Hier malen wir nur auf den Bildschirm. */
	public static void maleSpielfeld() {
		for (int i=0; i < spielfeld.length; i++) {
			System.out.println();
			for (int j=0; j < spielfeld.length; j++) {
				System.out.print(spielfeld[i][j]+" ");
			}
		}
		System.out.println();
	}
	
	/** Benutzer soll solange was eingeben bis die Eingabe stimmt. */
	public static int benutzerEingabe(String s) {
		while (true) {
			try {
				System.out.print(s);
				return Integer.parseInt(in.readLine());
				// Es sollte noch geprüft werden ob die Eingabe
				// außerhalb des Arrays liegt...
			}
			catch (IOException e) {}
			catch (NumberFormatException e) {}
		
			System.out.println("Falsche Eingabe! Nochmal!");
		}
	}
	
	
	public static void main(String[] args) {
		boolean spieler1 = true;
		
		// Spielfeld mit Nullen füllen vorm ersten Zug.
		for (int i=0; i < spielfeld.length; i++) {
			for (int k = 0; k < spielfeld.length; k++) {
				spielfeld[i][k] = '0';
			}
		}
		
		// Achtung Endlosschleife.
		while (true) {
			maleSpielfeld();
			System.out.println("Ist Spieler 1 dran? "+spieler1);
			int x = benutzerEingabe("x: ");
			int y = benutzerEingabe("y: ");
			
			// Wenn Spieler 1 dran ist, male 'a' an die Position,
			// ansonsten 'b'.
			spielfeld[y][x]= (spieler1) ? 'a' : 'b';
			// Wechsele den Spieler.
			spieler1= (spieler1) ? false : true;
		}
		
	}
}

Es wird noch nicht überprüft, ob ein bereits besetzter Platz überschrieben wird. Auch ist keine Punkteberechnung mit drin. Ich denke, den Rest schaffst du allein

 

[Guest]

Wow danke, ich glaube das löst erstmal mein Problem. Aber ich habe noch ein paar kleine Fragen dazu, weil ich einige der Aufforderungen nicht kenne weil wir andere benutzen! ZB:

static BufferedReader in = new BufferedReader(
new InputStreamReader(System.in));

Liest du hier schon etwas ein, und wenn ja, was? Das ist mir nicht ganz klar.

/** Benutzer soll solange was eingeben bis die Eingabe stimmt. */
public static int benutzerEingabe(String s) {

Oder liest du hier etwas ein? Und was? die Spalten oer die Zeilen zahl? Und was ist dann das oben?

return Integer.parseInt(in.readLine());
// Es sollte noch geprüft werden ob die Eingabe
// außerhalb des Arrays liegt...

Ist "return Integer.parseInt(in.readline())" das womit man prüft ob die Eingabe außerhalb des Arrays liegt? Ich kenne diesen Befehl leider nicht und weiß nicht wozu er verwendet wird. Ich glaube auch nicht dass ich ihn anwenden kann also müsste ich das ja umschreiben oder etwas nehmen, was wir benutzen, deshalb wäre es nett wenn du mir die Funktion davon erklären könntest.

catch (IOException e) {}
catch (NumberFormatException e) {}

Den catch befehl kenne ich leider auch nicht!

public static void main(String[] args) {
boolean spieler1 = true;

Muss man hier nochmal "public static void main (String[] argv" hinschreiben. Wir haben das bis jetzt immer nur einmal an den Anfang geschrieben!

Ja aber sonst versteh ich alles! :wink: *freu*

Ganz lieben Dank für deine Hilfe!

 

[lama]

static BufferedReader in = new BufferedReader(
new InputStreamReader(System.in));

Liest du hier schon etwas ein, und wenn ja, was? Das ist mir nicht ganz klar.

Hier lese ich noch nichts ein. Das ist die Variable, die ich benutze, um später etwas einzulesen Das brauche ich auch nur, weil ich deine IO-Klasse nicht hab ; ) Ich wollte dir hier lauffähigen Code hinstellen, damit du direkt damit rumspielen kannst.

/** Benutzer soll solange was eingeben bis die Eingabe stimmt. */
public static int benutzerEingabe(String s) {

Oder liest du hier etwas ein? Und was? die Spalten oer die Zeilen zahl? Und was ist dann das oben?

Das ist eine Methode, sie wird später in main() aufgerufen. In der Methode kann man eine Integer-Zahl über die Tastatur einlesen. Wofür diese Zahl dann benutzt wird, entscheidet sich später beim Methodenaufruf.

return Integer.parseInt(in.readLine());
// Es sollte noch geprüft werden ob die Eingabe
// außerhalb des Arrays liegt...

Das hier ist die Zeile, die die Benutzereingabe in einen Integer (Ganzzahl) umwandelt. Alles, was über die Tastaur eingelesen wird, ist erstmal ein String. Hier wandele ich den in einen Integer um
Man muss noch prüfen, ob die Zahl, die der Benutzer eingegeben hat < 0 oder > Array-Größe-1 ist, weil man ansonsten probiert einen Wert außerhalb des Arrays zu füllen --> Fehler mit Programmabbruch.

catch (IOException e) {}
catch (NumberFormatException e) {}

Den catch befehl kenne ich leider auch nicht!

Das ist nur dafür da, dass das Programm nicht mit einer Fehlermeldung abgebrochen wird, wenn der Benutzer statt einer Zahl eine Fließkommazahl oder einen Buchstaben eintippt Wie gesagt, die ganze Methode kannste streichen und dafür deine IO-Klasse benutzen wenn du magst.

public static void main(String[] args) {
boolean spieler1 = true;

Muss man hier nochmal "public static void main (String[] argv" hinschreiben. Wir haben das bis jetzt immer nur einmal an den Anfang geschrieben!

Verstehe, ihr hattet also noch keine Methoden... das macht die Sache schwerer. main() ist das, was ausgeführt wird, wenn das Programm gestartet wird. So eine Methode braucht jedes lauffähige Programm (außer Applets). Den Code, den ich geschrieben habe, fügst du also nicht in deinen Code ein, sondern du nimmst ihn als komplettes Programm/Datei. Dann hast du auch nur einmal die main()

Ja aber sonst versteh ich alles! :wink: *freu*

Ganz lieben Dank für deine Hilfe!

Super und bitte!

 

[Gast]

Juhuuu es klappt! :smile: DANKE!

Ich werde mich jatzt weiter durcharbeiten, bis ich das genauso hab wie wir das machen sollen und deshalb zwischendurch immer noch ein paar kleine Frgen stellen. :wink:

Also hier meine erste Frage:
Wie bekomme ich es hin, dass bei der Ausführung nicht geschrieben wird: "Ist Spieler 1 dran? true", sondern "Spieler 1 ist dran" Bzw "Spieler 2 ist dran"??

 

[Gast]

Geht das überhaupt mit boolean? Oder muss ich dafür einen anderen Datentypen verwenden?

Also ih vermute dass es mit boolean geht, nur weiß ich nicht wie!?

Danke

 

[Guest]

Und ich habenoch ein Problem:
Ich muss das 8x8 Feld so darstellen:

  | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
---+---+---+---+---+---+---+---+---+
  1 |   |   |   | O | O |   | O | O |
---+---+---+---+---+---+---+---+---+
  2 | X |   |   | X | O |   | O | O |
---+---+---+---+---+---+---+---+---+
  3 |   | X |   | X | O |   |   | O |
---+---+---+---+---+---+---+---+---+
  4 |   |   |   |   |   |   |   |   |
---+---+---+---+---+---+---+---+---+
  5 | X | X |   |   |   |   |   | X |
---+---+---+---+---+---+---+---+---+
  6 |   |   |   |   |   |   |   |   |
---+---+---+---+---+---+---+---+---+
 7 |   |   |   | X |   |   |   | X |
---+---+---+---+---+---+---+---+---+
  8 |   |   |   |   |   |   |   |   |
---+---+---+---+---+---+---+---+---+

Naja, die vertikalen Balken sollten jeweils unter den Kreuzen sein.

Ich habe schon einiges probiert und meine bisher beste Lösung ist:

for i=0; i<spielfeld.length; i++) {
  IO.println( " ");
  IO.println("--");
  for (int j=0; j<spielfeld.length;j++) {
    IO.print(spielfeld[i][j]+" |");
  }
} IO.println ();

Aber dann sieht es ausgeführt nur so aus:

--
| | | | | | | |
--
| | | | | | | |
--
| | | | | | | |
usw.

Was mache ich falsch, wo fehlt was? Oder ist vielleicht mein ganzer Ansatz falsch? Also dass ich das gar nicht in die for schleife einbauen muss?

Danke im Voraus

 

[lama]

Geht das überhaupt mit boolean? Oder muss ich dafür einen anderen Datentypen verwenden?

Also ih vermute dass es mit boolean geht, nur weiß ich nicht wie!?

Ja, das geht mit boolean. Frag doch einfach ab ob spieler1 true ist. Wenn ja, dann schreibst du halt: "Spieler 1 ist dran" auf den Bildschirm, ansonsten Spieler 2.

Zum malen: Ja, das muss in die for-Schleife, ist aber im Aufbau gar nicht so simpel. Spiel etwas damit herum und schau, was es bewirkt. Ich würde aber erstmal dafür sorgen, dass technisch alles richtig läuft. Mit der Optik kannst du dich dann danach beschäftigen.

 

[Nick10126]

doch in die for schleife musst du das schon einbauen.. probier einfach ein bisschen rum. wenn ich dir nun meinen code schicke, lernste ja nix draus

ähm wegen der Anzeige des Benutzers.. Kannste ja einfach ne if schleife machen ..

If spieler 1 = true
print "spieler1"
else "spieler 2"

das ist natürlich jetzt nur so geschrieben. will dir den spaß am coden nicht nehmen

mein Problem ist noch die Punkteberechnung. Aber ich hab mich grad drangesetzt..

 

[Gast]

hat jemand ne idee wie das mit der punkteberechnung geht? oder zumindest nen ansatz??

 

[Guest]

Hey!
Ich habe jetzt noch eine Frage:
Wie schaff ich es, dass ich, wenn der spieler einen Wert eingegeben hat, das ganze Array auf ein quadrat überprüfe. Ich habe mir überlegt, dass ich erstmal die Zeile durchsuche, in der der Wert eingegeben wurde, und gucke, ob da ein weiteres x bzw o zu finden ist. wenn ja guck ich, ob dann in den Spalten, in denen die beiden x bzw o sind noch weitere x bzw o sind, die evtl ein Quadrat bilden können.
Wir haben in der Vorlesung gelernt, dass man Arrays nach bestimmten Werten durhsuchen kann. Und zwar wollte ich es mit eine linearen Suche probieren. Also ungefähr so:

for (int i=spielfeld[spalte][zeile];    )

Aber das kann man ja gar nicht machen, weil dann ja dem int wert i ein char wert zugeordnet wird. und würde man i zu einem char wert machen, gäbe das ja auch ein Problem, wenn nämlcih i++ gemacht wird, zählt er ja nicht im Array weiter, weil es ja ein char wert ist.
Also ich weiß echt nicht wie ich das machen soll, so gehts auf jeden Fall (glaube ich) nicht.

Außerdem weiß ich nicht, wie ich feststellen soll, dass 4 x bzw 4 o wirklich ein quadrat bilden, weil so ja nur getestet wird, ob sich in der Spalte bzw Zeile überhaupt irgendein x bzw o befindet.
Also ich bin wirklich absolut ratlos und verzweifelt! :bahnhof: :cry:
Bitte bitte helft mir!

Danke schonmal für jeden Tipp - ich kann ihn wirklich gebrauchen!

 

[Gast]

studenten helfen sich ja gerne hier ist mein ansatz, liefert eine super tabelle und auch 2 spieler die x und o setzten können

char [] [] feld = new char [9][9];

do {
int punkte1=0, punkte2=0, i, j, k;
int p1=0 ,p2=0;


for(int spieler=1; punkte1 < 500 && punkte2 < 500 ;spieler++){


char pl1='X';
char pl2='O';
p1=0;
p2=0;
IO.println(" | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |");
IO.println("---+---+---+---+---+---+---+---+---+");
for (i=1;i< feld.length;i++){

IO.print(+i, 3);
IO.print("|");

for(j=0; j < feld.length ;j++){

IO.print(" ");
IO.print(feld [j]);
if(j<=7) IO.print(" |");

}

IO.println ();
IO.println("---+---+---+---+---+---+---+---+---+");
}

IO.println ();

if((spieler%=2)!=0){
do{
i=IO.readInt("Spieler 1, Bitte Zeile eingeben: ");
IO.println ();
j=IO.readInt("Spieler 1, Bitte Spalte eingeben: ");
j-=1;
feld [j]=pl1;
p1=1;
if(i>10&&j>10&&i<0&&j<0) IO.println("Passende zahl eingeben");

}
while(i>10&&j>10&&i<0&&j<0);
}

if((spieler%=2)==0){
do{
i=IO.readInt("Spieler 2, Bitte Zeile eingeben: ");
IO.println ();
j=IO.readInt("Spieler 2, Bitte Spalte eingeben: ");
j-=1;
feld [j]=pl2;
p2=2;
if(i>10&&j>10&&i<0&&j<0) IO.println("Passende zahl eingeben");
}

while(i>10&&j>10&&i<0&&j<0);
IO.println("moep");

}

IO.println ();
IO.println ();
}

 

[Gast]

sehr hilfreich wäre nun die berechnung der punkte, da steh ich aufm schlauch

 

[Schreibi]

Hey!
Ich habe jetzt noch eine Frage:
Wie schaff ich es, dass ich, wenn der spieler einen Wert eingegeben hat, das ganze Array auf ein quadrat überprüfe.

also ich hab das so gelöst, dass ich einfach erstma eine richtung im array durchlaufe und schau ob da ein x (bzw. o) ist...dann errechne ich den abstand der beiden (einfach voneinander abziehen) und überprüfe die möglichen eckpunkte bei dem abstand

for (a=0; a < Eingabey*2; a++) {    //erste for-Schleife ueberprueft ob
    if (quadrat [a][1+(Eingabex*4)] == 111) { //ein quadrat oberhalb der
        s = 1+(Eingabey-(a/2));                 //eingegebenen Stelle liegt
        if ((4*Eingabex+1+(4*(s-1))) <= 36      //nich ausserhalb des Arrays
                && quadrat [a][4*(s-1)+1+(Eingabex*4)] == 111) {
            if (quadrat [Eingabey*2][4*(s-1)+1+(Eingabex*4)] == 111) {
                Punkte1 = Punkte1+(s*s);  //falls Quadrat  neue Punktzahl
            }
        }
        if ((4*Eingabex+1-(4*(s-1))) >= 1
                && quadrat[a][1+(Eingabex*4)-(4*(s-1))] == 111) {
            if (quadrat [Eingabey*2][1+(Eingabex*4)-(4*(s-1))] == 111) {
                Punkte1 = Punkte1+(s*s);
            }
        }
    }
}

das is ma jetzt nur ein kleiner codeschnipsel...will dir ja nich den spaß am programmiern nehmen
so in der art hab ichs dann noch für den bereich unter der eingabe und für spieler 2 gemacht.
das is sicher auch nich der beste oder einfachste weg aba der auf den ich gekommen bin^^

 

[Guest]

Hallo, ich bins mal wieder.

Ich habe wieder ein Problem:
Mein Code zur Ausgabe von x bzw o and der Stelle Spielfeld[spalte][zeile] ist folgender:

int punkte1=0;
int punkte2=0;

boolean spieler1=true;
for(spieler1=true; punkte1!=500&&punkte2!=500; spieler1=false)
  if (spieler1=true) System.out.println("Spieler1 ist dran");
  else IO.println("Spieler2 ist dran");

    int spalte=IO.readINT ("Welche Spalte? ");
    int zeile = IO.readInt("Welche Zeile? ");
    spalte-=1;

    spielfeld [spalte][zeile]=(spieler1)? 'x' : 'o';
}

Jetzt mein Problem: Es funktioniert Er schreibt zwar beim ersten Mal hin: "Spieler 1 ist dran" und ließt die Werte ein, aber er git and der Stelle dann weder ein x noch ein o aus, und schreibt danach auch wieder "Spieler 1 ist dran" anstatt Spieler2. Wo liegt mein Fehler? ich glaube ich hab irgendwas mit boolean falsch verstanden, aber ich weiß nicht was.

Ich wär also für jeden Verbesserungsvorschlag dankbar!

 

[Guest]

Frage an Schreibi:
Was ist deine Eingabey bzw Eingabex? Sind das deine Spalten bzw. Zeilen?
a ist doch eine Hilfsvariable, oder?
Ist "quadrat" ein eigenes Array im Spielfled-Array?
Warum

if (quadrat [a][1+(Eingabex*4)] == 111)

Warum 111?

if ((4*Eingabex+1+(4*(s-1))) <= 36

Warum 36? Wie kommst du darauf?

Tut mir Leid aber ich hab noch nicht so ganz den Durchblick, ich hoffe du kannst mir helfen!
Danke

 

[Guest]

Frage an Schreibi:
Was ist deine Eingabey bzw Eingabex? Sind das deine Spalten bzw. Zeilen?
a ist doch einee Hilfsvariable, oder?
Ist "quadrat" ein eigenes Array im Spielfled-Array?

Eingabey und x sind meine zeilen und spalten und a is ein hilfsvariable richtig.
quadrat is mein spielfeldarray.

Warum 111?

111 is der ascii-code wert für 'o' (kleines o)

if ((4*Eingabex+1+(4*(s-1))) <= 36

Warum 36? Wie kommst du darauf?

also ich habe nur ein einziges array benutzt in das ich den ganzen tabellenmist, also die striche und zahlen, als auch die 'o' und 'x' reinschreibe. das array hat 36 Spalten und 18 zeilen (so viele zeichen wie auf dem Übungsblatt).
das bedeutet aber auch das nur jede 4. spalte ein 'o' enthalten kann, weshalb ich 4*eingabe rechnen muss...insgesamt schau ich also nur nach ob die mögliche ecke (in dem fall unten rechts glaube ich ) auch überhaupt im array liegt

Tut mir Leid aber ich hab noch nicht so ganz den Durchblick, ich hoffe du kannst mir helfen!
Danke

kein problem[/quote]

 

[Schreibi]

oh sry der text von grad kam natürlich von mir...nur vergessen einzuloggen