Add day 22 solution

Author: SvenWoltmann

src/main/java/eu/happycoders/adventofcode2022/day22/BoardMap.java

@@ -0,0 +1,91 @@
+package eu.happycoders.adventofcode2022.day22;
+
+import java.util.Arrays;
+
+/**
+ * Advent of Code 2022 – Object-Oriented Solutions in Java.
+ *
+ * <p>A map of the board with its open tiles and walls.
+ *
+ * <p>This board uses 0-based coordinates, that makes all position calculation much easier.
+ *
+ * @author <a href="mailto:sven@happycoders.eu">Sven Woltmann</a>
+ */
+class BoardMap {
+
+  private final int width;
+  private final int height;
+
+  // With a board size of 150 x 200 = 30000,
+  // we don't need to optimize for size and can easily use an enum to store a tile.
+  private final Tile[][] tiles;
+
+  BoardMap(int width, int height) {
+    this.width = width;
+    this.height = height;
+    this.tiles = new Tile[height][width];
+  }
+
+  int width() {
+    return width;
+  }
+
+  int height() {
+    return height;
+  }
+
+  // Internally, we work with 0-based coordinates, that makes all position calculation much easier.
+  void setTile(Position position, Tile tile) {
+    tiles[position.row()][position.column()] = tile;
+  }
+
+  // Internally, we work with 0-based coordinates, that makes all position calculation much easier.
+  Tile getTile(Position position) {
+    return tiles[position.row()][position.column()];
+  }
+
+  Position findStartPosition() {
+    // "leftmost open tile of the top row of tiles"
+    for (int column = 0; column < width; column++) {
+      Position position = new Position(column, 0);
+      if (getTile(position) == Tile.OPEN) {
+        return position;
+      }
+    }
+    throw new IllegalStateException();
+  }
+
+  @Override
+  public boolean equals(Object object) {
+    if (this == object) {
+      return true;
+    }
+
+    if (object == null || getClass() != object.getClass()) {
+      return false;
+    }
+
+    BoardMap that = (BoardMap) object;
+    return Arrays.deepEquals(tiles, that.tiles);
+  }
+
+  @Override
+  public int hashCode() {
+    return Arrays.deepHashCode(tiles);
+  }
+
+  @Override
+  public String toString() {
+    StringBuilder result = new StringBuilder();
+
+    for (int row = 0; row < height; row++) {
+      for (int column = 0; column < width; column++) {
+        Tile tile = tiles[row][column];
+        result.append(tile == null ? ' ' : tile.symbol());
+      }
+      result.append('\n');
+    }
+
+    return result.toString();
+  }
+}

src/main/java/eu/happycoders/adventofcode2022/day22/CubeFaceCoordinates.java

@@ -0,0 +1,42 @@
+package eu.happycoders.adventofcode2022.day22;
+
+/**
+ * Advent of Code 2022 – Object-Oriented Solutions in Java.
+ *
+ * <p>Coordinates on a cube face.
+ *
+ * @author <a href="mailto:sven@happycoders.eu">Sven Woltmann</a>
+ */
+record CubeFaceCoordinates(int faceId, int sideLength, Position position) {
+
+  CubeFaceCoordinates transportTo(WormholeCoordinates target, Direction sourceDirection) {
+    int numberClockwiseTurns = (target.side().ordinal() - sourceDirection.ordinal() + 6) % 4;
+
+    Position newPosition = turnPositionOnCubeFace(numberClockwiseTurns);
+
+    newPosition = mirrorPositionOnCubeFace(newPosition, target);
+
+    return new CubeFaceCoordinates(target.cubeFaceId(), sideLength, newPosition);
+  }
+
+  private Position turnPositionOnCubeFace(int numberClockwiseTurns) {
+    return switch (numberClockwiseTurns) {
+      case 0 -> new Position(position.column(), position.row());
+      case 1 -> new Position(flip(position.row()), position.column());
+      case 2 -> new Position(flip(position.column()), flip(position.row()));
+      case 3 -> new Position(position.row(), flip(position.column()));
+      default -> throw new IllegalStateException();
+    };
+  }
+
+  private Position mirrorPositionOnCubeFace(Position newPosition, WormholeCoordinates target) {
+    return switch (target.side()) {
+      case LEFT, RIGHT -> new Position(flip(newPosition.column()), newPosition.row());
+      case UP, DOWN -> new Position(newPosition.column(), flip(newPosition.row()));
+    };
+  }
+
+  private int flip(int newPosition) {
+    return sideLength - 1 - newPosition;
+  }
+}

src/main/java/eu/happycoders/adventofcode2022/day22/CubeLogic.java

@@ -0,0 +1,54 @@
+package eu.happycoders.adventofcode2022.day22;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Advent of Code 2022 – Object-Oriented Solutions in Java.
+ *
+ * <p>The logic for mapping the 3D cube to the 2D board map and vice-versa.
+ *
+ * @author <a href="mailto:sven@happycoders.eu">Sven Woltmann</a>
+ */
+class CubeLogic {
+
+  private final int cubeFaceLength;
+  private final Map<WormholeCoordinates, WormholeCoordinates> wormholeMap;
+
+  CubeLogic(int cubeFaceLength, List<Wormhole> wormholes) {
+    this.cubeFaceLength = cubeFaceLength;
+
+    this.wormholeMap = new HashMap<>();
+    for (Wormhole wormhole : wormholes) {
+      this.wormholeMap.put(wormhole.start(), wormhole.end());
+      this.wormholeMap.put(wormhole.end(), wormhole.start());
+    }
+  }
+
+  CubeFaceCoordinates toCubeFaceCoordinates(Position position, BoardMap boardMap) {
+    int cubeFacesColumn = position.column() / cubeFaceLength;
+    int cubeFacesRow = position.row() / cubeFaceLength;
+    int horizontalCubes = boardMap.width() / cubeFaceLength;
+    int cubeFaceId = cubeFacesRow * horizontalCubes + cubeFacesColumn;
+    return new CubeFaceCoordinates(
+        cubeFaceId,
+        cubeFaceLength,
+        new Position(
+            position.column() - cubeFacesColumn * cubeFaceLength,
+            position.row() - cubeFacesRow * cubeFaceLength));
+  }
+
+  WormholeCoordinates findTransport(WormholeCoordinates startCoordinates) {
+    return wormholeMap.get(startCoordinates);
+  }
+
+  Position toBoardMapCoordinates(CubeFaceCoordinates cubeFaceCoordinates, BoardMap boardMap) {
+    int horizontalCubes = boardMap.width() / cubeFaceLength;
+    int offsetColumn = (cubeFaceCoordinates.faceId() % horizontalCubes) * cubeFaceLength;
+    int offsetRow = (cubeFaceCoordinates.faceId() / horizontalCubes) * cubeFaceLength;
+    int newColumn = offsetColumn + cubeFaceCoordinates.position().column();
+    int newRow = offsetRow + cubeFaceCoordinates.position().row();
+    return new Position(newColumn, newRow);
+  }
+}

src/main/java/eu/happycoders/adventofcode2022/day22/Day22Solver.java

@@ -0,0 +1,26 @@
+package eu.happycoders.adventofcode2022.day22;
+
+/**
+ * Advent of Code 2022 – Object-Oriented Solutions in Java.
+ *
+ * <p>Puzzle solver for day 22.
+ *
+ * @author <a href="mailto:sven@happycoders.eu">Sven Woltmann</a>
+ */
+class Day22Solver {
+
+  static int solveTask1(String input) {
+    PuzzleInput puzzleInput = PuzzleInputParser.parse(input);
+    InstructionExecutor instructionExecutor = new InstructionExecutor(puzzleInput.boardMap(), null);
+    instructionExecutor.execute(puzzleInput.instructions());
+    return instructionExecutor.calculateFinalPassword();
+  }
+
+  static int solveTask2(String input, CubeLogic cubeLogic) {
+    PuzzleInput puzzleInput = PuzzleInputParser.parse(input);
+    InstructionExecutor instructionExecutor =
+        new InstructionExecutor(puzzleInput.boardMap(), cubeLogic);
+    instructionExecutor.execute(puzzleInput.instructions());
+    return instructionExecutor.calculateFinalPassword();
+  }
+}

src/main/java/eu/happycoders/adventofcode2022/day22/Direction.java

@@ -0,0 +1,45 @@
+package eu.happycoders.adventofcode2022.day22;
+
+/**
+ * Advent of Code 2022 – Object-Oriented Solutions in Java.
+ *
+ * <p>The direction into which you face/walk.
+ *
+ * @author <a href="mailto:sven@happycoders.eu">Sven Woltmann</a>
+ */
+enum Direction {
+  RIGHT(0),
+  DOWN(1),
+  LEFT(2),
+  UP(3);
+
+  private final int number;
+
+  Direction(int number) {
+    this.number = number;
+  }
+
+  int number() {
+    return number;
+  }
+
+  Direction clockwise() {
+    int ordinal = (this.ordinal() + 1) % 4;
+    return Direction.values()[ordinal];
+  }
+
+  Direction counterClockwise() {
+    // +3 instead of -1 so that the result of the remainder operation doesn't get negative
+    int ordinal = (this.ordinal() + 3) % 4;
+    return Direction.values()[ordinal];
+  }
+
+  Direction flip() {
+    return switch (this) {
+      case RIGHT -> LEFT;
+      case DOWN -> UP;
+      case LEFT -> RIGHT;
+      case UP -> DOWN;
+    };
+  }
+}

src/main/java/eu/happycoders/adventofcode2022/day22/GoForward.java

@@ -0,0 +1,15 @@
+package eu.happycoders.adventofcode2022.day22;
+
+/**
+ * Advent of Code 2022 – Object-Oriented Solutions in Java.
+ *
+ * <p>The instruction to go forward a certain amount of tiles.
+ *
+ * @author <a href="mailto:sven@happycoders.eu">Sven Woltmann</a>
+ */
+record GoForward(int numberOfTiles) implements Instruction {
+
+  static GoForward tiles(int numberOfTiles) {
+    return new GoForward(numberOfTiles);
+  }
+}

src/main/java/eu/happycoders/adventofcode2022/day22/Instruction.java

@@ -0,0 +1,10 @@
+package eu.happycoders.adventofcode2022.day22;
+
+/**
+ * Advent of Code 2022 – Object-Oriented Solutions in Java.
+ *
+ * <p>Interface for instructions.
+ *
+ * @author <a href="mailto:sven@happycoders.eu">Sven Woltmann</a>
+ */
+sealed interface Instruction permits GoForward, TurnClockwise, TurnCounterClockwise {}