Implemented 2017 Day 25

Author: SimonBaars

src/main/java/com/sbaars/adventofcode/year17/days/Day25.java

@@ -2,77 +2,135 @@
 
 import com.sbaars.adventofcode.year17.Day2017;
 import java.util.*;
-import java.util.regex.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 public class Day25 extends Day2017 {
-    private enum Direction { LEFT, RIGHT }
-    
-    private static class Rule {
-        final int writeValue;
-        final Direction moveDirection;
-        final char nextState;
-        
-        Rule(int writeValue, Direction moveDirection, char nextState) {
-            this.writeValue = writeValue;
-            this.moveDirection = moveDirection;
-            this.nextState = nextState;
-        }
-    }
-    
-    private final Map<Character, Map<Integer, Rule>> states = new HashMap<>();
-    private final char initialState;
-    private final int steps;
-    
+    private record StateRule(int writeValue, int moveDirection, char nextState) {}
+    private record State(StateRule zeroRule, StateRule oneRule) {}
+
     public Day25() {
         super(25);
-        List<String> input = dayStream().toList();
-        initialState = input.get(0).charAt(15);
-        steps = Integer.parseInt(input.get(1).replaceAll("\\D+", ""));
+    }
+
+    public static void main(String[] args) {
+        new Day25().printParts();
+    }
+
+    private Map<Character, State> parseStates() {
+        String[] lines = dayStrings();
+        Map<Character, State> states = new HashMap<>();
 
-        for (int i = 3; i < input.size(); i++) {
-            if (input.get(i).startsWith("In state")) {
-                char state = input.get(i).charAt(9);
-                Map<Integer, Rule> stateRules = new HashMap<>();
-                
+        Pattern statePattern = Pattern.compile("In state ([A-Z]):");
+        Pattern valuePattern = Pattern.compile("If the current value is ([01]):");
+        Pattern writePattern = Pattern.compile("- Write the value ([01]).");
+        Pattern movePattern = Pattern.compile("- Move one slot to the (right|left).");
+        Pattern nextPattern = Pattern.compile("- Continue with state ([A-Z]).");
+
+        int i = 2; // Skip first two lines
+        while (i < lines.length) {
+            if (lines[i].trim().isEmpty()) {
+                i++;
+                continue;
+            }
+
+            Matcher stateMatcher = statePattern.matcher(lines[i]);
+            if (stateMatcher.find()) {
+                char stateName = stateMatcher.group(1).charAt(0);
+                StateRule[] rules = new StateRule[2];
+
                 for (int value = 0; value <= 1; value++) {
-                    i += 2;
-                    int writeValue = Character.getNumericValue(input.get(i).charAt(input.get(i).length() - 2));
                     i++;
-                    Direction direction = input.get(i).contains("right") ? Direction.RIGHT : Direction.LEFT;
+                    Matcher valueMatcher = valuePattern.matcher(lines[i]);
+                    if (!valueMatcher.find() || Integer.parseInt(valueMatcher.group(1)) != value) {
+                        throw new IllegalStateException("Invalid value line: " + lines[i]);
+                    }
+
+                    i++;
+                    Matcher writeMatcher = writePattern.matcher(lines[i]);
+                    if (!writeMatcher.find()) {
+                        throw new IllegalStateException("Invalid write line: " + lines[i]);
+                    }
+                    int writeValue = Integer.parseInt(writeMatcher.group(1));
+
                     i++;
-                    char nextState = input.get(i).charAt(input.get(i).length() - 2);
-                    stateRules.put(value, new Rule(writeValue, direction, nextState));
+                    Matcher moveMatcher = movePattern.matcher(lines[i]);
+                    if (!moveMatcher.find()) {
+                        throw new IllegalStateException("Invalid move line: " + lines[i]);
+                    }
+                    int moveDirection = moveMatcher.group(1).equals("right") ? 1 : -1;
+
+                    i++;
+                    Matcher nextMatcher = nextPattern.matcher(lines[i]);
+                    if (!nextMatcher.find()) {
+                        throw new IllegalStateException("Invalid next state line: " + lines[i]);
+                    }
+                    char nextState = nextMatcher.group(1).charAt(0);
+
+                    rules[value] = new StateRule(writeValue, moveDirection, nextState);
                 }
-                
-                states.put(state, stateRules);
+
+                states.put(stateName, new State(rules[0], rules[1]));
+                i++;
+            } else {
+                i++;
             }
         }
+
+        return states;
     }
-    
-    public static void main(String[] args) {
-        new Day25().printParts();
+
+    private int getSteps() {
+        String firstLine = dayStrings()[1];
+        Pattern stepsPattern = Pattern.compile("Perform a diagnostic checksum after (\\d+) steps.");
+        Matcher stepsMatcher = stepsPattern.matcher(firstLine);
+        if (!stepsMatcher.find()) {
+            throw new IllegalStateException("Invalid steps line: " + firstLine);
+        }
+        return Integer.parseInt(stepsMatcher.group(1));
     }
-    
+
+    private char getInitialState() {
+        String firstLine = dayStrings()[0];
+        Pattern statePattern = Pattern.compile("Begin in state ([A-Z]).");
+        Matcher stateMatcher = statePattern.matcher(firstLine);
+        if (!stateMatcher.find()) {
+            throw new IllegalStateException("Invalid initial state line: " + firstLine);
+        }
+        return stateMatcher.group(1).charAt(0);
+    }
+
     @Override
     public Object part1() {
-        Map<Integer, Integer> tape = new HashMap<>();
+        Map<Character, State> states = parseStates();
+        int steps = getSteps();
+        char currentState = getInitialState();
+
+        // Use a TreeSet to store positions of 1s (tape is infinite with 0s by default)
+        Set<Integer> tape = new TreeSet<>();
         int cursor = 0;
-        char currentState = initialState;
-        
+
         for (int i = 0; i < steps; i++) {
-            int currentValue = tape.getOrDefault(cursor, 0);
-            Rule rule = states.get(currentState).get(currentValue);
-            
-            tape.put(cursor, rule.writeValue);
-            cursor += (rule.moveDirection == Direction.RIGHT) ? 1 : -1;
-            currentState = rule.nextState;
+            State state = states.get(currentState);
+            boolean currentValue = tape.contains(cursor);
+            StateRule rule = currentValue ? state.oneRule() : state.zeroRule();
+
+            if (rule.writeValue() == 1) {
+                tape.add(cursor);
+            } else {
+                tape.remove(cursor);
+            }
+
+            cursor += rule.moveDirection();
+            currentState = rule.nextState();
         }
-        
-        return tape.values().stream().mapToInt(Integer::intValue).sum();
+
+        return tape.size();
     }
-    
+
     @Override
     public Object part2() {
+        // Part 2 is automatically solved by collecting all stars
         return "Merry Christmas!";
     }
 }