Du verwendest einen veralteten Browser. Es ist möglich, dass diese oder andere Websites nicht korrekt angezeigt werden. Du solltest ein Upgrade durchführen oder ein alternativer Browser verwenden.
Habe folgendes Problem:
Ich habe das array Zustand[][] spielbrett = new Zustand[10][10];
jetzt durchlaufe ich das array und suche nach einem bestimmten Zustand, alle "Steine" die diesen Zustand besitzen möchte ich entfernen und mir die Anzahl der entfernten Elemente zurückgeben lassen!
Wie funktioniert das??
Laufe eine (doppelte) Schleife über alle Elemente ab und prüfe, ob das gerade betrachtete Element den Zustand besitzt. Sollte dem so sein, schmeiß es in ein neues Array rein, welches du zum Schluss zurückgibst.
Wie genau willst du die Steine dann "entfernen" ? Aus nem array rauslöschen ist nicht so einfach, dafür nimmt man eigentlich Listen. Oder willst du die einfach nur auf
Code:
Zustand.LEER
setzen?
Das ganze kann man dann mit ner verschachtelten for schleife lösen.
@EikeB:
Ja das ist mein Problem, ich wollte das ganze ohne Liste probieren; mit Arrays.asList() wäre das ganze kein Problem.
Das ganze ist so, dass die Steine auf dem Spielbrett liegen und eben entfernt werden sollen wenn sie einen gewissen Zustand besitzen, am Ende muss ich dann wissen wie viele Steine ich entfernt habe!
Du kannst aus ´nem Array keine Elemente "löschen", es sei denn, du verkleinerst es und die hinten befindlichen Elemente fallen damit raus. Wie ich bereits sagte: bau dir ein zweites Array und hau da alle noch vorhandenen Steine rein.
Jedes Mal, wenn du einen Stein damit nicht übertragen hast ins neue Array, zählst du dann einfach eine Variable um 1 hoch und hast auch ratzbatz die Zhl der "gelöschten" Elemente.
Zustand[][] einSteine = new Zustand[10][10];
einSteine[x][y] = spielbrett[x][y];
Arrays.asList(einSteine);
Also ich durchlaufe das ganze mit einer for-Schleife und alle Steine die den entsprechenden Zustand haben übertrage ich in das neue array einSteine[x][y]; wie bekomme ich jetzt die Anzahl der Steine?!
Na du definerst eine int. Mit jedem Schleifendurchlauf wird ein Element aus deinem Feld geprüft und übertragen. Soll es "gelöscht" werden, wird es halt nicht in das neue Feld übertragen, stattdessen wird der int um 1 hochgezählt.
EDIT: Wenn du nun aber sowieso Listen verwendest, kannst du zum Schluss auch einfach die Größe der resultierenden Liste von der Ursprungsgröße abziehen...
meiner Meinung nach musst Du es nicht unbedingt mit einer Liste machen. Ich nehme an das Zustand eine von Dir implementierte Klasse ist. Ich nehme auch an, dass Du in der Klasse Zustand einen oder mehrere Statusinformationen setzt. Angenommen Du willst den Stein auf dem Spielbrett anzeigen, dann hast Du den Status 1. Möchtest Du den Stein nicht anzeigen lassen, dass hast du eben den Status 0. Das ganze kann man beliebig weiter spinnen. Zum Beispiel wenn Status 2, dann ist der Stein rot.
public int entferneEingeschlosseneSteine(Zustand farbe) {
// Farbe verschieden von Zustand WEISS und SCHWARZ, also
// IllegalArgumentException
if (farbe == Zustand.LEER) {
throw new IllegalArgumentException("Farbe ist nicht WEISS und nicht SCHWARZ!");
}
boolean[][] markierung = new boolean[10][10];
int entfernteSteine = 0;
for (int x = 0; x < 10; x++) {
for (int y = 0; y < 10; y++) {
markierung[x][y] = false;
/*
* Testen ob dort ein noch nicht markierter Stein der Farbe
* farbe liegt, welcher markiert werden kann, also
* markierung[x][y] == false
*/
if (spielbrett[x][y] == farbe && markierung[x][y] == false) {
markierung[x][y] = true; // wenn true, dann ist das
// Feld/Stein markiert
} else {
markierung[x][y] = false; // sonst eben false, also nicht
// markiert
}
// spielbrett[x][y] ist Nachbar eines LEEREN Feldes
if (spielbrett[x + 1][y] == Zustand.LEER || spielbrett[x-1][y] == Zustand.LEER || spielbrett[x][y+1] == Zustand.LEER || spielbrett[x][y-1] == Zustand.LEER) {
// Stein wird markiert
markierung[x][y] = true;
}
// ein Nachbarstein ist bereits markiert
else if (markierung[x + 1][y] == true
|| markierung[x - 1][y] == true
|| markierung[x][y + 1] == true
|| markierung[x][y - 1] == true) {
// Stein wird markiert
markierung[x][y] = true;
}
// alle Steine false und Farbe farbe, sind vollstaendig
// eingeschlossen
else
markierung[x][y] = false;
// vollstaendig eingeschlossener Stein, also entfernen
if (markierung[x][y] == false & spielbrett[x][y] == farbe) {
entfernteSteine++;
} else
;
}// Ende innere for-Schleife
}// Ende aeussere for-Schleife
return entfernteSteine;
}// Ende Methode entferne
public static void main(String[] args) {
Spielbrett spiel = new Spielbrett();
System.out.println(spiel.entferneEingeschlosseneSteine(Zustand.WEISS));
}
Hab das ganze jetzt mal so geschriebn, bekomme aber folgende Fehlermeldung:
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 10
at de.jpp.minigo.Spielbrett.entferneEingeschlosseneSteine(Spielbrett.java:119)
at de.jpp.minigo.Spielbrett.main(Spielbrett.java:150)
9 ist, steht da in der Klammer natrülich der nicht-existente Index 10. Du müsstest also vorher prüfen, ob x genau 9 ist, oder die Exception in einen cacth-Block schmeißen und dann einfah ignorieren. In deinem Fall dürfte das gehen.
EDIT: Äquivalent natürlich für y
Dein Mehrdimensionaler Array hat in beiden Dimensionen 10 Elemente. D.h. gültige Indices von 0 bis 9. Irgendwo in Deinem Code versuchst Du, auf ein Element mit dem Index 10 zuzugreifen. Das ist außerhalb der definierten Grenzen (out of bounds). Ich tippe mal auf den Teil des Codes, wo du das machst: "x + 1"
Lies doch deine Aufgabenstellung exakt durch. Dort steht recht deutlich wie du vorgehen kannst und IMHO auch vorgehen solltest.
1. Erstelle array markierung ... (OK)
2. Iteriere solange, bis sich nichts mehr ändert.
Dieser Punkt fehlt
Java:
boolean aenderung = true;
while(aenderung){
aenderung = false;
//Nun den Code mit dem du über alle Felder gehst
//Wenn nun ein neues Feld markiert wird
aenderung = true;
}
Danach sind alle steine markiert, die nicht eingeschlossen sind.
3. Nochmals über alle Felder gehen und überprüfen ob sie
a. nicht markiert sind
b. von einer bestimmten Farbe sind
Gegebenenfalls auf Leer setzen und hochzählen
