Java:
public enum Direction {
NORTH, SOUTH, EAST, WEST;
public Direction opposite () {
switch (this) {
case NORTH:
return SOUTH;
case SOUTH:
return NORTH;
case EAST:
return WEST;
case WEST:
return EAST;
default:
return null;
}
}
}
public class MzeSlv {
public static SolutionStep findExit(Room currentRoom) {
if (currentRoom.isExit()) {
return new SolutionStep(null, null);
}
currentRoom.markVisited();
for (Direction direction : Direction.values()) {
Room nextRoom = currentRoom.getRoom(direction);
if (nextRoom != null && !nextRoom.isVisited()) {
SolutionStep result = findExit(nextRoom);
if (result != null) {
return new SolutionStep(direction, result);
}
}
}
return null;
}
}
public class Room {
private final Room[] rooms = new Room[4];
private boolean exit;
private boolean visited = false;
public Room(Room north, Room east, Room south, Room west, boolean exit) {
this.exit = exit;
rooms[Direction.NORTH.ordinal()] = north;
rooms[Direction.EAST.ordinal()] = east;
rooms[Direction.SOUTH.ordinal()] = south;
rooms[Direction.WEST.ordinal()] = west;
if (north != null) {
assert north.rooms[Direction.SOUTH.ordinal()] == null;
north.rooms[Direction.SOUTH.ordinal()] = this;
}
if (east != null) {
assert east.rooms[Direction.WEST.ordinal()] == null;
east.rooms[Direction.WEST.ordinal()] = this;
}
if (south != null) {
assert south.rooms[Direction.NORTH.ordinal()] == null;
south.rooms[Direction.NORTH.ordinal()] = this;
}
if (west != null) {
assert west.rooms[Direction.EAST.ordinal()] == null;
west.rooms[Direction.EAST.ordinal()] = this;
}
}
public Room getRoom(Direction d) {
return rooms[d.ordinal()];
}
public boolean isExit() {
return exit;
}
public void markVisited() {
this.visited = true;
}
public boolean isVisited() {
return visited;
}
}
public class SolutionStep {
private final Direction direction;
private final SolutionStep next;
public SolutionStep(Direction direction, SolutionStep next) {
this.direction = direction;
this.next = next;
}
public SolutionStep next() {
return next;
}
public Direction getDirection() {
return direction;
}
}
In dieser Aufgabe sollen Sie sich mit Enum befassen und Enum#ordinal() verwenden.Schreiben Sie dazu ein Programm, das den Weg durch einen Irrgarten findet.
Das Enum Direction definiert Konstanten für die vier Richtungen (Direction.NORTH, Direction.EAST, Direction.SOUTH und Direction.WEST). Zusätzlich gibt es eine Methode Direction#opposite() die die gegensätzliche Richtung zurück gibt. (NORTH ↔↔ SOUTH bzw. EAST ↔↔ WEST).
Der Irrgarten wird durch eine Klasse Room repräsentiert, welcher bis zu vier Verbindungen zu anderen Räumen hat. Room hat einen Konstruktor Room(Room north, Room east, Room south, Room west, boolean exit). Dieser erzeugt einen neuen Raum mit angrenzenden Räumen in die Richtungen Direction.NORTH, Direction.EAST, Direction.SOUTH und Direction.WEST. null wird für (noch) keinen Raum verwendet. Nutzen Sie Enum#ordinal() von Direction um die Räume in einem Array (rooms) zu halten. Die übergebenen Räume werden so aktualisiert, dass am Ende des Konstruktoraufruf der Weg zurück wieder zu diesem Raum führt. Z.B. muss dieser Raum im Süden von dem Raum sein, der als north übergeben wurde. Stellen Sie mit assert sicher, das beim Aktualisieren keine vorhandenen Verbindungen überschrieben werden. Der boolean gibt an, ob der Raum ein Ausgang ist. Mit der Methode Room getRoom(Direction d) wird der Raum zurückgegeben, der in die angegebene Richtung liegt; sonst null. Die Methode boolean isExit() gibt zurück, ob der Raum ein Ausgang ist.
Die Funktion SolutionStep findExit(Room currentRoom) in MazeSolver bestimmt einen Weg aus dem Irrgarten heraus. Das Ergebnis wird in einzelnen Schritten angegeben. SolutionStep hat zwei Methoden (Direction getDirection() und SolutionStep next()) und wird wie folgt interpretiert: Wenn getDirection() null zurückgibt, ist der aktuelle Raum der Ausgang. Ansonsten ist dort angegebenen, in welche Richtung der aktuelle Raum verlassen werden muss. next() beinhaltet dann die Anweisung für den nächsten Raum. Beginn der Lösung ist in start. Z.B: Rückgabe (direction=null, next=null) heißt, der Startraum ist ein Ausgang. Rückgabe (direction=WEST, next=(direction=NORTH, next=(direction=null, next=null))) heißt, nach Westen, nach Norden und dort ist der Ausgang. Gibt es gar keinen Ausweg, wird null zurückgegeben. Jeder Irrgarten wird nur ein einziges mal gelöst.
Eventuell hat ja jemand Zeit und Lust sich hier mal einzulesen und mir gegebenenfalls einen Hinweis zu geben, wo hier noch Probleme auftreten könnten. In den vorgegebenen Testfällen sagt er mir, dass folgende Probleme auftreten:
Testfall · constructor_getRoomReturnsSameRoomAsPassed fehlgeschlagen
Multiple Failures (2 failures) org.opentest4j.AssertionFailedError: Roome east was not found. org.opentest4j.AssertionFailedError: Roome south was not found.Testfall · opposite fehlgeschlagen
The opposite directions are checked. (4 failures) org.opentest4j.AssertionFailedError: south is opposite north org.opentest4j.AssertionFailedError: west is opposite east org.opentest4j.AssertionFailedError: north is opposite south org.opentest4j.AssertionFailedError: east is opposite westTestfall · findExit_mazeSmall fehlgeschlagen
expected: <Room@58d6cbe0> but was: <null>Testfall · findExit_mazeManyExits fehlgeschlagen
expected: <Room@51432332> but was: <Room@557cbdc2>Testfall · findExit_mazeManyExits_endOnFirstExit fehlgeschlagen
expected: <Room@4873b41> but was: <Room@216c8b5a>Testfall · findExit_labyrinth fehlgeschlagen
expected: <SOUTH> but was: <EAST>Danke für Eure Mühe und Zeit!
Zuletzt bearbeitet:
