[2023] Solution for day 8

Author: kfarnung

2023/day08/README.md

@@ -0,0 +1,77 @@
+# Day 8: Haunted Wasteland
+
+[https://adventofcode.com/2023/day/8](https://adventofcode.com/2023/day/8)
+
+## Description
+
+### Part One
+
+You're still riding a camel across Desert Island when you spot a sandstorm quickly approaching. When you turn to warn the Elf, she disappears before your eyes! To be fair, she had just finished warning you about _ghosts_ a few minutes ago.
+
+One of the camel's pouches is labeled "maps" - sure enough, it's full of documents (your puzzle input) about how to navigate the desert. At least, you're pretty sure that's what they are; one of the documents contains a list of left/right instructions, and the rest of the documents seem to describe some kind of _network_ of labeled nodes.
+
+It seems like you're meant to use the _left/right_ instructions to _navigate the network_. Perhaps if you have the camel follow the same instructions, you can escape the haunted wasteland!
+
+After examining the maps for a bit, two nodes stick out: `AAA` and `ZZZ`. You feel like `AAA` is where you are now, and you have to follow the left/right instructions until you reach `ZZZ`.
+
+This format defines each _node_ of the network individually. For example:
+
+    RL
+    
+    AAA = (BBB, CCC)
+    BBB = (DDD, EEE)
+    CCC = (ZZZ, GGG)
+    DDD = (DDD, DDD)
+    EEE = (EEE, EEE)
+    GGG = (GGG, GGG)
+    ZZZ = (ZZZ, ZZZ)
+    
+
+Starting with `AAA`, you need to _look up the next element_ based on the next left/right instruction in your input. In this example, start with `AAA` and go _right_ (`R`) by choosing the right element of `AAA`, _`CCC`_. Then, `L` means to choose the _left_ element of `CCC`, _`ZZZ`_. By following the left/right instructions, you reach `ZZZ` in _`2`_ steps.
+
+Of course, you might not find `ZZZ` right away. If you run out of left/right instructions, repeat the whole sequence of instructions as necessary: `RL` really means `RLRLRLRLRLRLRLRL...` and so on. For example, here is a situation that takes _`6`_ steps to reach `ZZZ`:
+
+    LLR
+    
+    AAA = (BBB, BBB)
+    BBB = (AAA, ZZZ)
+    ZZZ = (ZZZ, ZZZ)
+    
+
+Starting at `AAA`, follow the left/right instructions. _How many steps are required to reach `ZZZ`?_
+
+### Part Two
+
+The <span title="Duhduhduhduhduh! Dah, duhduhduhduhduh!">sandstorm</span> is upon you and you aren't any closer to escaping the wasteland. You had the camel follow the instructions, but you've barely left your starting position. It's going to take _significantly more steps_ to escape!
+
+What if the map isn't for people - what if the map is for _ghosts_? Are ghosts even bound by the laws of spacetime? Only one way to find out.
+
+After examining the maps a bit longer, your attention is drawn to a curious fact: the number of nodes with names ending in `A` is equal to the number ending in `Z`! If you were a ghost, you'd probably just _start at every node that ends with `A`_ and follow all of the paths at the same time until they all simultaneously end up at nodes that end with `Z`.
+
+For example:
+
+    LR
+    
+    11A = (11B, XXX)
+    11B = (XXX, 11Z)
+    11Z = (11B, XXX)
+    22A = (22B, XXX)
+    22B = (22C, 22C)
+    22C = (22Z, 22Z)
+    22Z = (22B, 22B)
+    XXX = (XXX, XXX)
+    
+
+Here, there are two starting nodes, `11A` and `22A` (because they both end with `A`). As you follow each left/right instruction, use that instruction to _simultaneously_ navigate away from both nodes you're currently on. Repeat this process until _all_ of the nodes you're currently on end with `Z`. (If only some of the nodes you're on end with `Z`, they act like any other node and you continue as normal.) In this example, you would proceed as follows:
+
+*   Step 0: You are at `11A` and `22A`.
+*   Step 1: You choose all of the _left_ paths, leading you to `11B` and `22B`.
+*   Step 2: You choose all of the _right_ paths, leading you to _`11Z`_ and `22C`.
+*   Step 3: You choose all of the _left_ paths, leading you to `11B` and _`22Z`_.
+*   Step 4: You choose all of the _right_ paths, leading you to _`11Z`_ and `22B`.
+*   Step 5: You choose all of the _left_ paths, leading you to `11B` and `22C`.
+*   Step 6: You choose all of the _right_ paths, leading you to _`11Z`_ and _`22Z`_.
+
+So, in this example, you end up entirely on nodes that end in `Z` after _`6`_ steps.
+
+Simultaneously start on every node that ends with `A`. _How many steps does it take before you're only on nodes that end with `Z`?_

2023/day08/build.gradle.kts

@@ -0,0 +1,11 @@
+plugins {
+    id("com.github.kfarnung.adventofcode.aoc2023.java-application-conventions")
+}
+
+dependencies {
+    implementation(project(":utilities"))
+}
+
+application {
+    mainClass.set("com.github.kfarnung.adventofcode.aoc2023.day08.App")
+}

2023/day08/src/main/java/com/github/kfarnung/adventofcode/aoc2023/day08/App.java

@@ -0,0 +1,92 @@
+/*
+ * Solution for Advent of Code 2023 day 8.
+ */
+package com.github.kfarnung.adventofcode.aoc2023.day08;
+
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static com.github.kfarnung.adventofcode.aoc2023.utilities.InputUtils.readLinesFromFile;
+import static com.github.kfarnung.adventofcode.aoc2023.utilities.MathUtils.leastCommonMultiple;
+
+public class App {
+    public static void main(String[] args) {
+        try {
+            List<String> lines = readLinesFromFile(args[0]);
+            System.out.printf("Part 1: %s%n", getPart1(lines));
+            System.out.printf("Part 2: %s%n", getPart2(lines));
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static String getPart1(List<String> lines) {
+        char[] directions = lines.get(0).toCharArray();
+        Map<String, String[]> map = new HashMap<>();
+        for (int i = 2; i < lines.size(); i++) {
+            String[] parts = lines.get(i).split(" = ");
+            String[] values = parts[1].substring(1, parts[1].length() - 1).split(", ");
+            map.put(parts[0], values);
+        }
+
+        long count = 0;
+        int directionsIndex = 0;
+        String current = "AAA";
+        while (!current.equals("ZZZ")) {
+            String[] values = map.get(current);
+            if (directions[directionsIndex] == 'L') {
+                current = values[0];
+            } else {
+                current = values[1];
+            }
+            directionsIndex = (directionsIndex + 1) % directions.length;
+            count++;
+        }
+
+        return Long.toString(count);
+    }
+
+    public static String getPart2(List<String> lines) {
+        char[] directions = lines.get(0).toCharArray();
+        Map<String, String[]> map = new HashMap<>();
+        List<String> currentNodes = new ArrayList<>();
+        for (int i = 2; i < lines.size(); i++) {
+            String[] parts = lines.get(i).split(" = ");
+            String[] values = parts[1].substring(1, parts[1].length() - 1).split(", ");
+            map.put(parts[0], values);
+            if (parts[0].endsWith("A")) {
+                currentNodes.add(parts[0]);
+            }
+        }
+
+        long count = 1;
+        for (String current : currentNodes) {
+            count = leastCommonMultiple(count, findCycle(map, current, directions));
+        }
+
+        return Long.toString(count);
+    }
+
+    private static long findCycle(Map<String, String[]> map, String current, char[] directions) {
+        Map<String, Long> stateMap = new HashMap<>();
+        long count = 0;
+        int directionsIndex = 0;
+        while (!stateMap.containsKey(current + ":" + directionsIndex)) {
+            stateMap.put(current + ":" + directionsIndex, count);
+            String[] values = map.get(current);
+            if (directions[directionsIndex] == 'L') {
+                current = values[0];
+            } else {
+                current = values[1];
+            }
+            directionsIndex = (directionsIndex + 1) % directions.length;
+            count++;
+        }
+
+        return count - stateMap.get(current + ":" + directionsIndex);
+    }
+}

2023/day08/src/test/java/com/github/kfarnung/adventofcode/aoc2023/day08/AppTest.java

@@ -0,0 +1,59 @@
+/*
+ * Test cases for Advent of Code 2023 day 8.
+ */
+package com.github.kfarnung.adventofcode.aoc2023.day08;
+
+import static com.github.kfarnung.adventofcode.aoc2023.utilities.InputUtils.readLinesFromResources;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.io.IOException;
+import java.util.List;
+
+import org.junit.jupiter.api.Test;
+
+class AppTest {
+    private final List<String> input = List.of(
+            "RL",
+            "",
+            "AAA = (BBB, CCC)",
+            "BBB = (DDD, EEE)",
+            "CCC = (ZZZ, GGG)",
+            "DDD = (DDD, DDD)",
+            "EEE = (EEE, EEE)",
+            "GGG = (GGG, GGG)",
+            "ZZZ = (ZZZ, ZZZ)");
+    private final List<String> input2 = List.of(
+            "LLR",
+            "",
+            "AAA = (BBB, BBB)",
+            "BBB = (AAA, ZZZ)",
+            "ZZZ = (ZZZ, ZZZ)");
+    private final List<String> input3 = List.of(
+            "LR",
+            "",
+            "11A = (11B, XXX)",
+            "11B = (XXX, 11Z)",
+            "11Z = (11B, XXX)",
+            "22A = (22B, XXX)",
+            "22B = (22C, 22C)",
+            "22C = (22Z, 22Z)",
+            "22Z = (22B, 22B)",
+            "XXX = (XXX, XXX)");
+
+    @Test
+    void testGetPart1() throws IOException {
+        assertEquals("2", App.getPart1(input));
+        assertEquals("6", App.getPart1(input2));
+
+        List<String> realInput = readLinesFromResources(this, "input.txt");
+        assertEquals("13207", App.getPart1(realInput));
+    }
+
+    @Test
+    void testGetPart2() throws IOException {
+        assertEquals("6", App.getPart2(input3));
+
+        List<String> realInput = readLinesFromResources(this, "input.txt");
+        assertEquals("12324145107121", App.getPart2(realInput));
+    }
+}