Methode, welche ein Feld eines Springers erhält und alle möglichen Züge zurückgibt

[carl-02]

Moin, für die Prüfungsvorbereitung haben wir folgende Aufgabe bekommen, die wir (so ähnlich) in der Prüfung auf Papier lösen müssen: Schreiben Sie eine Methode nach CCD-Aspekten, welche ein Feld eines Springers (e4 = 54) erhält und alle möglichen Züge zurückgibt.

Nun habe ich mich da mal dran gewagt, aber finde meine Lösung viel zu umfangreich und ich bin mir sicher, dass man das noch vereinfachen kann, stehe aber total auf dem Schlauch. Hat jemand dazu eine Idee? Thema ist Verfahren & Werkzeuge moderner Softwareentwicklung, Stichwort: Clean Code.

Danke schon mal für Eure Hilfe!!

package schach;

import java.util.Map;
import java.util.TreeMap;

public class Main {

    public static Map<String, String> springer(String s, int n1, int n2){
        String schachbrett[][] =
            {
                    {"a1", "a2", "a3", "a4", "a5", "a6", "a7", "a8"},
                    {"b1", "b2", "b3", "b4", "b5", "b6", "b7", "b8"},
                    {"c1", "c2", "c3", "c4", "c5", "c6", "c7", "c8"},
                    {"d1", "d2", "d3", "d4", "d5", "d6", "d7", "d8"},
                    {"e1", "e2", "e3", "e4", "e5", "e6", "e7", "e8"},
                    {"f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8"},
                    {"g1", "g2", "g3", "g4", "g5", "g6", "g7", "g8"},
                    {"h1", "h2", "h3", "h4", "h5", "h6", "h7", "h8"},
                    
            };
        
        int x = n1 - 1;
        int y = n2 - 1;
        
        Map<String, String> zuege = new TreeMap<>();
        
        for(int i = 1; i < 9; i++){
            switch(i){
                case 1: zuege.put((x+1) + "" + (y-2), schachbrett[x+1][y-2]);
                break;
                case 2: zuege.put((x+1) + "" + (y+2), schachbrett[x+1][y+2]);
                break;
                case 3: zuege.put((x-1) + "" + (y-2), schachbrett[x-1][y-2]);
                break;
                case 4: zuege.put((x-1) + "" + (y+2), schachbrett[x-1][y+2]);
                break;
                case 5: zuege.put((x+2) + "" + (y-1), schachbrett[x+2][y-1]);
                break;
                case 6: zuege.put((x+2) + "" + (y+1), schachbrett[x+2][y+1]);
                break;
                case 7: zuege.put((x-2) + "" + (y-1), schachbrett[x-2][y-1]);
                break;
                case 8: zuege.put((x-2) + "" + (y+1), schachbrett[x-2][y+1]);
                break;
                
            }
        }
        return zuege;
        
    }

    public static void main(String[] args) {
        System.out.println(springer("e4", 5, 4));
    }

}

 

[kneitzel]

Also was mir so durch den Kopf geht:

a)Wozu brauchst Du ein 2d Array für das Spielfeld? Du speicherst da nicht wirklich irgendwelche Daten, die Du nicht auch so schon hast,... Aus meiner Sicht reicht doch einfach jeweils die Koordinate inx und y Richtung von 0-7. Und wenn Du da deinen "Inhalt" vom Array brauchst, dann ist es einmal 'a'+x und y+1 zusammen als String ...

b)for Schleife mit switch für jeden Fall?Was passiert denn da? Doch einfach nur dass alle Züge der Reihe nach ausgeführt werden. Also alles bis auf die zuege.put Zeilen löschen und schon hast du es um über die Hälfte gekürzt.

c)Bei den neuen Feldern sehe ich noch nicht die Prüfung, ob Du da auf dem Feld bist. Also da kannst Du schnell IndexOutOfBound Exceptions bekommen.

 

[MoxxiManagarm]

1) Du hast s UND n1+n2. Konzentriere dich auf eins. Ich verstehe es so, dass der Eingabeparameter entweder 54 oder e4 sein kann. Du musst also mit beiden Formaten umgehen können. Du brauchst also erst eine Art Normierung. 0-basiert handelt es in beiden Fällen um die Indexe (4, 3).

2) Wenn du wie bei meinem Vorschlag aus 1) auf Indexe normierst, dann brauchst du wirklich kein solches Array. Du addierst/subtrahierst einfach mit den Indexen und überprüfst, ob das neue theoretische Feld immernoch im Bereich [0, 7] liegt. Nur dann ist es ein gültiger Zug. Für die Ausgabe kannst du den Index einfach wieder zurückverwandeln.

3) Die Schleife ist total überflüssig. Du kannst doch alle 8 puts direkt untereinanderschreiben.

 

[httpdigest]

Mit ein bisschen Integer-Arithmetik kann man (wenn man will) auch die möglichen alternierenden Offsets (-1,-2; +1,-2; -1,+2; +1;+2; ...) für den Springer ermitteln und eine Schleife von 0 bis exclusive 8 verwenden:

int dx = (i%2*2-1)*(i/4+1); // <- -1,+1,-1,+1,-2,+2,-2,+2
int dy = (i/2%2*2-1)*(2-i/4); // <- -2,-2,+2,+2,-1,-1,+1,+1

Dann ist's ganz einfach:

Spoiler

public static Stream<String> movesOfKnight(int px, int py) {
  return range(0, 8)
        // Erzeuge [x, y] Koordinatenpaar
        .mapToObj(x -> new int[] {px + (x%2*2-1) * (x/4+1), py + (x/2%2*2-1)* (2-x/4)})
        // Prüfe, ob y von [x, y] innerhalb des Feldes
        .filter(c -> c[1] >= 0 && c[1] < 8)
        // Erzeuge Koordinatenstring für [x, y]
        .map(c -> Character.toString('a' + c[0]) + (c[1] + 1));
}

Ich verstehe allerdings nicht, warum das Ergebnis denn eine Map sein soll... was soll denn da von wo nach wo mappen?

 

[carl-02]

Vielen Dank für die Hilfe, da habe ich wohl etwas zu viel drauf rumgedacht und es unnötig verkompliziert...