day05 for AoC 2023 (part 1)

Took 1 hour 23 minutes

Author: albertominetti

src/main/java/aminetti/adventofcode2024/day05/Day05.java

@@ -0,0 +1,130 @@
+package aminetti.adventofcode2024.day05;
+
+import aminetti.adventofcode2023.day05.SeedFertilizer;
+import com.google.common.collect.Lists;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.*;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+public class Day05 {
+    private static final Logger LOGGER = LoggerFactory.getLogger(Day05.class);
+    private List<String> input;
+
+    private HashMap<String, List<String>> rules = new HashMap<>();
+    private List<List<String>> allPages = new ArrayList<>();
+
+    public Day05() {
+    }
+
+    public void parseInput(List<String> input) {
+        this.input = input;
+
+
+        var firstInputPart = true;
+        for (String s : input) {
+            if (firstInputPart) {
+                if (s.isEmpty()) {
+                    firstInputPart = false;
+                    continue;
+                }
+                //LOGGER.debug("Line: {}", s);
+                String[] split = s.split("\\|");
+                List<String> currentRule = rules.getOrDefault(split[0], new ArrayList<>());
+                currentRule.add(split[1]);
+                rules.put(split[0], currentRule);
+            } else {
+                String[] split = s.split(",");
+                allPages.add(Arrays.stream(split).toList());
+            }
+
+        }
+    }
+
+    public long solvePart1() {
+        LOGGER.info("Rules: {}", rules);
+        LOGGER.info("All pages: {}", allPages);
+
+        long sum = 0;
+        for (List<String> pageList : allPages) {
+            if (isInOrder(pageList)) {
+                String middlePage = pageList.get(pageList.size() / 2);
+                LOGGER.info("Found ordered page: {}; adding {} to the sum", pageList, middlePage);
+                sum += Long.parseLong(middlePage);
+            }
+        }
+
+
+        return sum;
+    }
+
+    private boolean isInOrder(List<String> pageList) {
+        Map<String, Integer> inEdgeCount = pageList.stream().collect(Collectors.toMap(Function.identity(), (x) -> 0));
+        for (String p : rules.keySet()) {
+            for (String v : rules.get(p)) {
+                if (pageList.contains(v) && pageList.contains(p)) {
+                    inEdgeCount.put(v, inEdgeCount.get(v) + 1);
+                }
+            }
+        }
+        LOGGER.info("The pages {} have this inEdgeCount: {}", pageList, inEdgeCount);
+        List<String> firstElements = inEdgeCount.entrySet().stream()
+                .filter(e -> e.getValue() == 0)
+                .map(Map.Entry::getKey)
+                .collect(Collectors.toList());
+
+        List<List<String>> partialOrder = new ArrayList<>();
+        partialOrder.add(firstElements);
+
+        for (int i = 0; i < partialOrder.size(); i++) {
+            List<String> level = partialOrder.get(i);
+            if (level.isEmpty()) {
+                break;
+            }
+            List<String> nextLevel = new ArrayList<>();
+            partialOrder.add(nextLevel);
+            for (String e : level) {
+                if (!rules.containsKey(e)) {
+                    continue;
+                }
+                for (String v : rules.get(e)) {
+                    if (!pageList.contains(v)) {
+                        continue;
+                    }
+                    Integer inEdgesForV = inEdgeCount.get(v);
+                    inEdgesForV--;
+                    inEdgeCount.put(v, inEdgesForV);
+                    if (inEdgesForV == 0) {
+                        nextLevel.add(v);
+                    }
+                }
+            }
+        }
+
+        int currentLevel = 0;
+        for (String p : pageList) {
+            while (!partialOrder.get(currentLevel).contains(p)) {
+                LOGGER.info("{} is not in level [{}] {}, so switching to the next level", p, currentLevel, partialOrder.get(currentLevel));
+                currentLevel++;
+                if (currentLevel > partialOrder.size() - 1) {
+                    LOGGER.info("{} are NOT ordered", pageList);
+                    LOGGER.info(" current level {} and partialOrder {}", currentLevel, partialOrder);
+
+                    return false;
+                }
+            }
+
+        }
+
+        LOGGER.info("{} are ordered", pageList);
+        return true;
+    }
+
+
+    public long solvePart2() {
+
+        return 0;
+    }
+}

src/test/java/aminetti/adventofcode2024/day05/Day05Test.java

@@ -0,0 +1,73 @@
+package aminetti.adventofcode2024.day05;
+
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+import java.util.List;
+
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.apache.commons.io.IOUtils.readLines;
+import static org.apache.commons.io.IOUtils.resourceToString;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+
+class Day05Test {
+
+    @Test
+    void actualInputPart1() throws IOException {
+        // given
+        List<String> input = readLines(resourceToString("/day05/day05_input.txt", UTF_8));
+
+        // when
+        Day05 solver = new Day05();
+        solver.parseInput(input);
+        long l = solver.solvePart1();
+
+        // then
+        assertThat(l, is(0L));
+    }
+
+    @Test
+    void testInputPart1() throws IOException {
+        // given
+        List<String> input = readLines(resourceToString("/day05/day05_input_test.txt", UTF_8));
+
+        // when
+        Day05 solver = new Day05();
+        solver.parseInput(input);
+        long l = solver.solvePart1();
+
+        // then
+        assertThat(l, is(143L));
+    }
+
+    @Test
+    void actualInputPart2() throws IOException {
+        // given
+        List<String> input = readLines(resourceToString("/day05/day05_input.txt", UTF_8));
+
+        // when
+        Day05 solver = new Day05();
+        solver.parseInput(input);
+        long l = solver.solvePart2();
+
+        // then
+        assertThat(l, is(0L));
+    }
+
+    @Test
+    void testInputPart2() throws IOException {
+        // given
+        List<String> input = readLines(resourceToString("/day05/day05_input_test.txt", UTF_8));
+
+        // when
+        Day05 solver = new Day05();
+        solver.parseInput(input);
+        long l = solver.solvePart2();
+
+        // then
+        assertThat(l, is(0L));
+    }
+
+
+}

src/test/resources/day05/day05_input_test.txt

@@ -0,0 +1,28 @@
+47|53
+97|13
+97|61
+97|47
+75|29
+61|13
+75|53
+29|13
+97|29
+53|29
+61|53
+97|53
+61|29
+47|13
+75|47
+97|75
+47|61
+75|61
+47|29
+75|13
+53|13
+
+75,47,61,53,29
+97,61,53,29,13
+75,29,13
+75,97,47,61,53
+61,13,29
+97,13,75,29,47