Add day 18 solution

Author: SvenWoltmann

src/main/java/eu/happycoders/adventofcode2022/day18/Box.java

@@ -0,0 +1,106 @@
+package eu.happycoders.adventofcode2022.day18;
+
+import java.util.ArrayDeque;
+import java.util.List;
+import java.util.Queue;
+
+/**
+ * Advent of Code 2022 – Object-Oriented Solutions in Java.
+ *
+ * <p>A box in which to put the droplet and flood-fill the outside.
+ *
+ * @author <a href="mailto:sven@happycoders.eu">Sven Woltmann</a>
+ */
+class Box {
+
+  private final Droplet droplet;
+  private final int sizeX;
+  private final int sizeY;
+  private final int sizeZ;
+  private final boolean[][][] grid;
+
+  private int externalSurfaceArea;
+
+  Box(Droplet droplet) {
+    this.droplet = droplet;
+
+    int maxX = 0;
+    int maxY = 0;
+    int maxZ = 0;
+
+    List<Cube> allCubes = droplet.getAllCubes();
+    for (Cube cube : allCubes) {
+      if (cube.x() < 0 || cube.y() < 0 || cube.z() < 0) {
+        throw new IllegalArgumentException(
+            "Each cube's x, y, z coordinates must be >= 0; cube = " + cube);
+      }
+      maxX = Math.max(maxX, cube.x());
+      maxY = Math.max(maxY, cube.y());
+      maxZ = Math.max(maxZ, cube.z());
+    }
+
+    // x, y, z is 0-based, therefore add 1.
+    // Add two more, so we have at least one area of free cubes on each side.
+    this.sizeX = maxX + 3;
+    this.sizeY = maxY + 3;
+    this.sizeZ = maxZ + 3;
+
+    this.grid = new boolean[sizeX][sizeY][sizeZ];
+  }
+
+  void floodFill() {
+    // As the cubes may have 0 as X, Y, Z coordinates, our grid starts at (-1, -1, -1).
+    Cube startCube = new Cube(-1, -1, -1);
+    fillGridAt(startCube);
+
+    Queue<Cube> queue = new ArrayDeque<>();
+    queue.add(startCube);
+
+    // Now we take one from the queue, fill all empty neighbors and add them to the queue.
+    // Empty means there's no steam and no lava.
+    // And whenever there's lava, we increase the externalSurfaceArea by 1.
+    while (!queue.isEmpty()) {
+      Cube cube = queue.poll();
+      fillIfEmpty(cube.left(), queue);
+      fillIfEmpty(cube.right(), queue);
+      fillIfEmpty(cube.top(), queue);
+      fillIfEmpty(cube.bottom(), queue);
+      fillIfEmpty(cube.front(), queue);
+      fillIfEmpty(cube.back(), queue);
+    }
+  }
+
+  private void fillIfEmpty(Cube cube, Queue<Cube> queue) {
+    if (!isInGrid(cube) || gridFilledAt(cube)) {
+      return;
+    }
+
+    if (droplet.contains(cube)) {
+      externalSurfaceArea++;
+    } else {
+      fillGridAt(cube);
+      queue.add(cube);
+    }
+  }
+
+  private boolean isInGrid(Cube cube) {
+    return cube.x() + 1 >= 0
+        && cube.x() + 1 < sizeX
+        && cube.y() + 1 >= 0
+        && cube.y() + 1 < sizeY
+        && cube.z() + 1 >= 0
+        && cube.z() + 1 < sizeZ;
+  }
+
+  private boolean gridFilledAt(Cube cube) {
+    return grid[cube.x() + 1][cube.y() + 1][cube.z() + 1];
+  }
+
+  private void fillGridAt(Cube cube) {
+    grid[cube.x() + 1][cube.y() + 1][cube.z() + 1] = true;
+  }
+
+  public int getExternalSurfaceArea() {
+    return externalSurfaceArea;
+  }
+}

src/main/java/eu/happycoders/adventofcode2022/day18/Cube.java

@@ -0,0 +1,35 @@
+package eu.happycoders.adventofcode2022.day18;
+
+/**
+ * Advent of Code 2022 – Object-Oriented Solutions in Java.
+ *
+ * <p>A single cube consisting of X, Y, and Z coordinates.
+ *
+ * @author <a href="mailto:sven@happycoders.eu">Sven Woltmann</a>
+ */
+@SuppressWarnings("PMD.ShortVariable") // x, y, and z are OK!
+record Cube(int x, int y, int z) {
+  Cube left() {
+    return new Cube(x - 1, y, z);
+  }
+
+  Cube right() {
+    return new Cube(x + 1, y, z);
+  }
+
+  Cube back() {
+    return new Cube(x, y - 1, z);
+  }
+
+  Cube front() {
+    return new Cube(x, y + 1, z);
+  }
+
+  Cube top() {
+    return new Cube(x, y, z + 1);
+  }
+
+  Cube bottom() {
+    return new Cube(x, y, z - 1);
+  }
+}

src/main/java/eu/happycoders/adventofcode2022/day18/CubesParser.java

@@ -0,0 +1,35 @@
+package eu.happycoders.adventofcode2022.day18;
+
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Advent of Code 2022 – Object-Oriented Solutions in Java.
+ *
+ * <p>Parses the input string into a list of cubes.
+ *
+ * @author <a href="mailto:sven@happycoders.eu">Sven Woltmann</a>
+ */
+class CubesParser {
+
+  private static final Pattern PATTERN = Pattern.compile("(\\d+),(\\d+),(\\d+)");
+
+  static List<Cube> parse(String input) {
+    return input.lines().map(CubesParser::parseCube).toList();
+  }
+
+  @SuppressWarnings("PMD.ShortVariable") // x, y, and z are OK!
+  private static Cube parseCube(String input) {
+    Matcher matcher = PATTERN.matcher(input);
+    if (!matcher.matches()) {
+      throw new IllegalArgumentException(input);
+    }
+
+    int x = Integer.parseInt(matcher.group(1));
+    int y = Integer.parseInt(matcher.group(2));
+    int z = Integer.parseInt(matcher.group(3));
+
+    return new Cube(x, y, z);
+  }
+}

src/main/java/eu/happycoders/adventofcode2022/day18/Day18Solver.java

@@ -0,0 +1,27 @@
+package eu.happycoders.adventofcode2022.day18;
+
+import java.util.List;
+
+/**
+ * Advent of Code 2022 – Object-Oriented Solutions in Java.
+ *
+ * <p>Puzzle solver for day 18.
+ *
+ * @author <a href="mailto:sven@happycoders.eu">Sven Woltmann</a>
+ */
+class Day18Solver {
+
+  static int solveTask1(String input) {
+    List<Cube> cubes = CubesParser.parse(input);
+    Droplet droplet = new Droplet(cubes);
+    return droplet.getSurfaceArea();
+  }
+
+  static int solveTask2(String input) {
+    List<Cube> cubes = CubesParser.parse(input);
+    Droplet droplet = new Droplet(cubes);
+    Box box = new Box(droplet);
+    box.floodFill();
+    return box.getExternalSurfaceArea();
+  }
+}

src/main/java/eu/happycoders/adventofcode2022/day18/Droplet.java

@@ -0,0 +1,60 @@
+package eu.happycoders.adventofcode2022.day18;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * Advent of Code 2022 – Object-Oriented Solutions in Java.
+ *
+ * <p>A lava droplet consisting of cubes.
+ *
+ * @author <a href="mailto:sven@happycoders.eu">Sven Woltmann</a>
+ */
+class Droplet {
+
+  private final Set<Cube> cubes;
+
+  Droplet(List<Cube> cubes) {
+    this.cubes = new HashSet<>(cubes);
+  }
+
+  List<Cube> getAllCubes() {
+    return List.copyOf(cubes);
+  }
+
+  boolean contains(Cube cube) {
+    return cubes.contains(cube);
+  }
+
+  int getSurfaceArea() {
+    int result = 0;
+    for (Cube coordinate : cubes) {
+      result += countNonConnectedSides(coordinate);
+    }
+    return result;
+  }
+
+  private int countNonConnectedSides(Cube coordinate) {
+    int connected = 0;
+    if (cubes.contains(coordinate.left())) {
+      connected++;
+    }
+    if (cubes.contains(coordinate.right())) {
+      connected++;
+    }
+    if (cubes.contains(coordinate.front())) {
+      connected++;
+    }
+    if (cubes.contains(coordinate.back())) {
+      connected++;
+    }
+    if (cubes.contains(coordinate.top())) {
+      connected++;
+    }
+    if (cubes.contains(coordinate.bottom())) {
+      connected++;
+    }
+    return 6 - connected;
+  }
+}