AoC 2016 Day 22 - java - refactor

Author: pareronia

src/main/java/AoC2016_22.java

@@ -1,5 +1,6 @@
 import static com.github.pareronia.aoc.AssertUtils.assertFalse;
 import static com.github.pareronia.aoc.AssertUtils.assertTrue;
+import static com.github.pareronia.aoc.StringOps.splitLines;
 import static java.util.Comparator.comparing;
 import static java.util.stream.Collectors.joining;
 import static java.util.stream.Collectors.summingInt;
@@ -13,101 +14,52 @@
 import java.util.List;
 import java.util.Set;
 import java.util.function.Function;
-import java.util.regex.Pattern;
 import java.util.stream.Stream;
 
 import com.github.pareronia.aoc.geometry.Direction;
 import com.github.pareronia.aoc.geometry.Point;
 import com.github.pareronia.aoc.geometry.Position;
-import com.github.pareronia.aocd.Aocd;
-import com.github.pareronia.aocd.Puzzle;
+import com.github.pareronia.aoc.solution.Sample;
+import com.github.pareronia.aoc.solution.Samples;
+import com.github.pareronia.aoc.solution.SolutionBase;
 
-public class AoC2016_22 extends AoCBase {
+public class AoC2016_22
+            extends SolutionBase<AoC2016_22.Cluster, Integer, Integer> {
 
-    private static final Pattern REGEX = Pattern.compile(
-            "^\\/dev\\/grid\\/node-x([0-9]+)-y([0-9]+)\\s+[0-9]+T" +
-            "\\s+([0-9]+)T\\s+([0-9]+)T\\s+[0-9]+%$");
-
-    private final List<Node> nodes;
-
-    private AoC2016_22(final List<String> input, final boolean debug) {
+    private AoC2016_22(final boolean debug) {
         super(debug);
-        this.nodes = input.stream()
-                .skip(2)
-                .flatMap(s -> REGEX.matcher(s).results())
-                .map(m -> {
-                    final Integer x = Integer.valueOf(m.group(1));
-                    final Integer y = Integer.valueOf(m.group(2));
-                    final Integer used = Integer.valueOf(m.group(3));
-                    final Integer available = Integer.valueOf(m.group(4));
-                    return new Node(x, y, used, available);
-                })
-                .collect(toList());
     }
 
-    public static AoC2016_22 create(final List<String> input) {
-        return new AoC2016_22(input, false);
+    public static AoC2016_22 create() {
+        return new AoC2016_22(false);
     }
 
-    public static AoC2016_22 createDebug(final List<String> input) {
-        return new AoC2016_22(input, true);
-    }
-    
-    private Set<Node> getUnusableNodes() {
-        final Integer maxAvailable = this.nodes.stream()
-                .max(comparing(Node::available))
-                .map(Node::available).orElseThrow();
-        return this.nodes.stream()
-                .filter(n -> n.used() > maxAvailable)
-                .collect(toSet());
-    }
-    
-    private Node getEmptyNode() {
-        final List<Node> emptyNodes = nodes.stream()
-                .filter(n -> n.used() == 0)
-                .collect(toList());
-        assertTrue(emptyNodes.size() == 1, () -> "Expected 1 empty node");
-        return emptyNodes.get(0);
-    }
-    
-    private Integer getMaxX() {
-        return this.nodes.stream()
-                .max(comparing(Node::x))
-                .map(Node::x).orElseThrow();
-    }
-    
-    private Integer getMaxY() {
-        return this.nodes.stream()
-                .max(comparing(Node::y))
-                .map(Node::y).orElseThrow();
+    public static AoC2016_22 createDebug() {
+        return new AoC2016_22(true);
     }
-    
-    private Node getGoalNode() {
-        return nodes.stream()
-                .filter(n -> n.x() == getMaxX() && n.y() == 0)
-                .findFirst().orElseThrow();
-    }
-    
-    private Node getAccessibleNode() {
-        return nodes.stream()
-                .filter(n -> n.x() == 0 && n.y() == 0)
-                .findFirst().orElseThrow();
+
+    @Override
+    protected Cluster parseInput(final List<String> inputs) {
+        return new Cluster(inputs.stream()
+                .skip(2)
+                .map(Node::fromInput)
+                .collect(toList()));
     }
 
     @Override
-    public Integer solvePart1() {
-        return (int) this.nodes.stream()
+    public Integer solvePart1(final Cluster cluster) {
+        return (int) cluster.nodes.stream()
                 .filter(Node::isNotEmpty)
-                .flatMap(a -> this.nodes.stream()
+                .flatMap(a -> cluster.nodes.stream()
                                 .filter(b -> !a.equals(b))
                                 .filter(b -> a.used() <= b.available()))
                 .count();
     }
 
-    private void visualize() {
-        final Integer maxX = getMaxX();
-        final Integer maxY = getMaxY();
-        final List<Node> sorted = this.nodes.stream()
+    private void visualize(final Cluster cluster) {
+        final Integer maxX = cluster.getMaxX();
+        final Integer maxY = cluster.getMaxY();
+        final List<Node> sorted = cluster.nodes.stream()
                 .sorted(comparing(n -> n.x() * maxY + n.y()))
                 .collect(toList());
         final List<List<Node>> grid = Stream.iterate(0, i -> i <= maxX, i -> i + 1)
@@ -116,10 +68,10 @@ private void visualize() {
                                 .takeWhile(n -> n.x() == i)
                                 .collect(toList()))
                 .collect(toList());
-        final Set<Node> unusableNodes = getUnusableNodes();
-        final Node emptyNode = getEmptyNode();
-        final Node goalNode = getGoalNode();
-        final Node accessibleNode = getAccessibleNode();
+        final Set<Node> unusableNodes = cluster.getUnusableNodes();
+        final Node emptyNode = cluster.getEmptyNode();
+        final Node goalNode = cluster.getGoalNode();
+        final Node accessibleNode = cluster.getAccessibleNode();
         for (final List<Node> row : grid) {
             final String line = row.stream()
                     .map(n -> {
@@ -155,16 +107,16 @@ private Function<Path, Boolean> stopAt(
         };
     }
 
-    private Integer solve2() {
-        visualize();
-        final Set<Position> unusableNodes = getUnusableNodes().stream()
+    private Integer solve2(final Cluster cluster) {
+        visualize(cluster);
+        final Set<Position> unusableNodes = cluster.getUnusableNodes().stream()
                 .map(this::toPosition)
                 .collect(toSet());
-        final Position emptyNode = toPosition(getEmptyNode());
-        final Position accessibleNode = toPosition(getAccessibleNode());
-        final Integer maxX = getMaxX();
-        final Integer maxY = getMaxY();
-        final Position goalNode = toPosition(getGoalNode());
+        final Position emptyNode = toPosition(cluster.getEmptyNode());
+        final Position accessibleNode = toPosition(cluster.getAccessibleNode());
+        final Integer maxX = cluster.getMaxX();
+        final Integer maxY = cluster.getMaxY();
+        final Position goalNode = toPosition(cluster.getGoalNode());
         log("Unusable: "+ unusableNodes);
         log("Empty: " + emptyNode);
         log("Accessible: " + accessibleNode);
@@ -191,9 +143,9 @@ private Integer solve2() {
         return length + 1;
     }
 
-    private Integer solve2Cheat() {
-        visualize();
-        final Set<Node> unusableNodes = getUnusableNodes();
+    private Integer solve2Cheat(final Cluster cluster) {
+        visualize(cluster);
+        final Set<Node> unusableNodes = cluster.getUnusableNodes();
         log(unusableNodes);
         final Set<Integer> holeYs = unusableNodes.stream()
                 .map(Node::y)
@@ -206,52 +158,53 @@ private Integer solve2Cheat() {
         assertFalse(unusableNodes.stream()
                     .max(comparing(Node::x))
                     .map(Node::x)
-                    .orElseThrow() != getMaxX(),
+                    .orElseThrow() != cluster.getMaxX(),
                 () -> "Expected unusable row to touch side");
         final Integer holeX = unusableNodes.stream()
                 .min(comparing(Node::x))
                 .map(Node::x)
                 .orElseThrow();
         final Position hole = Position.of(holeX - 1, holeY);
-        final Position emptyNode = toPosition(getEmptyNode());
+        final Position emptyNode = toPosition(cluster.getEmptyNode());
         final int part1 = emptyNode.manhattanDistance(hole);
-        final Position goalNode = toPosition(getGoalNode());
+        final Position goalNode = toPosition(cluster.getGoalNode());
         final int part2 = hole.manhattanDistance(
                     Position.of(goalNode.getX() - 1, goalNode.getY()));
         final int part3 = 5 * (goalNode.getX() - 1);
         return part1 + part2 + part3 + 1;
     }
 
     @Override
-    public Integer solvePart2() {
-        return solve2Cheat();
+    public Integer solvePart2(final Cluster cluster) {
+        return solve2Cheat(cluster);
     }
-    
-    public static void main(final String[] args) throws Exception {
-        assert AoC2016_22.createDebug(TEST).solvePart1() == 7;
-        assert AoC2016_22.createDebug(TEST).solve2() == 7;
 
-        final Puzzle puzzle = Aocd.puzzle(2016, 22);
-        final List<String> inputData = puzzle.getInputData();
-        puzzle.check(
-            () -> lap("Part 1", AoC2016_22.createDebug(inputData)::solvePart1),
-            () -> lap("Part 2", AoC2016_22.createDebug(inputData)::solvePart2)
-        );
+    @Override
+    @Samples({
+        @Sample(method = "part1", input = TEST, expected = "7")
+    })
+    public void samples() {
+        final AoC2016_22 test = AoC2016_22.createDebug();
+        assert test.solve2(test.parseInput(splitLines(TEST))) == 7;
+    }
+
+    public static void main(final String[] args) throws Exception {
+        AoC2016_22.createDebug().run();
     }
 
-    private static final List<String> TEST = splitLines(
-            "root@ebhq-gridcenter# df -h\r\n" +
-            "Filesystem            Size  Used  Avail  Use%\r\n" +
-            "/dev/grid/node-x0-y0   10T    8T     2T   80%\r\n" +
-            "/dev/grid/node-x0-y1   11T    6T     5T   54%\r\n" +
-            "/dev/grid/node-x0-y2   32T   28T     4T   87%\r\n" +
-            "/dev/grid/node-x1-y0    9T    7T     2T   77%\r\n" +
-            "/dev/grid/node-x1-y1    8T    0T     8T    0%\r\n" +
-            "/dev/grid/node-x1-y2   11T    7T     4T   63%\r\n" +
-            "/dev/grid/node-x2-y0   10T    6T     4T   60%\r\n" +
-            "/dev/grid/node-x2-y1    9T    8T     1T   88%\r\n" +
-            "/dev/grid/node-x2-y2    9T    6T     3T   66%"
-    );
+    private static final String TEST = """
+            root@ebhq-gridcenter# df -h\r
+            Filesystem            Size  Used  Avail  Use%\r
+            /dev/grid/node-x0-y0   10T    8T     2T   80%\r
+            /dev/grid/node-x0-y1   11T    6T     5T   54%\r
+            /dev/grid/node-x0-y2   32T   28T     4T   87%\r
+            /dev/grid/node-x1-y0    9T    7T     2T   77%\r
+            /dev/grid/node-x1-y1    8T    0T     8T    0%\r
+            /dev/grid/node-x1-y2   11T    7T     4T   63%\r
+            /dev/grid/node-x2-y0   10T    6T     4T   60%\r
+            /dev/grid/node-x2-y1    9T    8T     1T   88%\r
+            /dev/grid/node-x2-y2    9T    6T     3T   66%
+            """;
 
     private static final class PathFinder {
         private final Position start;
@@ -315,8 +268,63 @@ public boolean isAt(final Position position) {
     }
 
     record Node(int x, int y, int used, int available) {
+        public static Node fromInput(final String line) {
+            final String[] splits = line.split("\\s+");
+            final String[] xy = splits[0].split("-");
+            return new Node(
+                Integer.parseInt(xy[1].substring(1)),
+                Integer.parseInt(xy[2].substring(1)),
+                Integer.parseInt(splits[2].substring(0, splits[2].length() - 1)),
+                Integer.parseInt(splits[3].substring(0, splits[3].length() - 1))
+            );
+        }
+        
         public boolean isNotEmpty() {
             return this.used != 0;
         }
     }
+    
+    record Cluster(List<Node> nodes) {
+        
+        public Set<Node> getUnusableNodes() {
+            final Integer maxAvailable = this.nodes.stream()
+                    .max(comparing(Node::available))
+                    .map(Node::available).orElseThrow();
+            return this.nodes.stream()
+                    .filter(n -> n.used() > maxAvailable)
+                    .collect(toSet());
+        }
+        
+        public Node getEmptyNode() {
+            final List<Node> emptyNodes = this.nodes.stream()
+                    .filter(n -> n.used() == 0)
+                    .collect(toList());
+            assertTrue(emptyNodes.size() == 1, () -> "Expected 1 empty node");
+            return emptyNodes.get(0);
+        }
+        
+        public Integer getMaxX() {
+            return this.nodes.stream()
+                    .max(comparing(Node::x))
+                    .map(Node::x).orElseThrow();
+        }
+        
+        public Integer getMaxY() {
+            return this.nodes.stream()
+                    .max(comparing(Node::y))
+                    .map(Node::y).orElseThrow();
+        }
+        
+        public Node getGoalNode() {
+            return this.nodes.stream()
+                    .filter(n -> n.x() == getMaxX() && n.y() == 0)
+                    .findFirst().orElseThrow();
+        }
+        
+        public Node getAccessibleNode() {
+            return this.nodes.stream()
+                    .filter(n -> n.x() == 0 && n.y() == 0)
+                    .findFirst().orElseThrow();
+        }
+    }
 }