AoC 2015 Day 6 - java - faster

pareronia · pareronia · commit 80aca71a5dea · 2025-01-11T16:40:08.000+01:00
diff --git a/src/main/java/AoC2015_06.java b/src/main/java/AoC2015_06.java
@@ -1,12 +1,12 @@
 import static java.util.stream.Collectors.toList;
 
+import java.util.Arrays;
 import java.util.List;
-import java.util.function.Function;
-import java.util.stream.IntStream;
-import java.util.stream.Stream;
+import java.util.function.IntFunction;
 
 import com.github.pareronia.aoc.Grid.Cell;
-import com.github.pareronia.aoc.IntGrid;
+import com.github.pareronia.aoc.StringOps;
+import com.github.pareronia.aoc.StringOps.StringSplit;
 import com.github.pareronia.aoc.solution.Sample;
 import com.github.pareronia.aoc.solution.Samples;
 import com.github.pareronia.aoc.solution.SolutionBase;
@@ -32,19 +32,80 @@ protected List<Instruction> parseInput(final List<String> inputs) {
         return inputs.stream().map(Instruction::fromInput).collect(toList());
     }
 
+    private int solve(final List<Instruction> instructions, final Mode mode) {
+        final int[] lights = new int[1_000_000];
+        for (final Instruction instruction : instructions) {
+            instruction.action.apply(
+                    lights, instruction.start, instruction.end, mode);
+        }
+        return Arrays.stream(lights).sum();
+    }
+
     @Override
-    public Integer solvePart1(final List<Instruction> input) {
-        final Grid lights = new Grid(c -> 1, c -> 0, c -> c == 1 ? 0 : 1);
-        lights.processInstructions(input);
-        return (int) lights.getAllLightValues().filter(l -> l == 1).count();
+    public Integer solvePart1(final List<Instruction> instructions) {
+        return solve(instructions, Mode.MODE_1);
     }
 
     @Override
-    public Integer solvePart2(final List<Instruction> input) {
-        final Grid lights = new Grid(c -> c + 1, c -> Math.max(c - 1, 0), c -> c + 2);
-        lights.processInstructions(input);
-        return lights.getAllLightValues().sum();
+    public Integer solvePart2(final List<Instruction> instructions) {
+        return solve(instructions, Mode.MODE_2);
     }
+    
+    enum Mode { MODE_1, MODE_2 }
+
+    record Instruction(Action action, Cell start, Cell end) {
+        public static Instruction fromInput(final String input) {
+            final String s = input.replace("turn ", "turn_");
+            final StringSplit splits = StringOps.splitOnce(s, " through ");
+            final StringSplit actionAndStartSplits
+                    = StringOps.splitOnce(splits.left(), " ");
+            return new Instruction(
+                Action.fromString(actionAndStartSplits.left()),
+                Cell.fromString(actionAndStartSplits.right()),
+                Cell.fromString(splits.right()));
+        }
+        
+        enum Action {
+            TURN_ON, TURN_OFF, TOGGLE;
+
+            public static Action fromString(final String s) {
+                return switch (s) {
+                    case "turn_on" -> TURN_ON;
+                    case "turn_off" -> TURN_OFF;
+                    default -> TOGGLE;
+                };
+            }
+
+            public void apply(
+                    final int[] grid,
+                    final Cell start,
+                    final Cell end,
+                    final Mode mode
+            ) {
+                final IntFunction<Integer> f = switch (this) {
+                    case TURN_ON -> switch (mode) {
+                            case MODE_1: yield v -> 1;
+                            case MODE_2: yield v -> v + 1;
+                        };
+                    case TURN_OFF -> switch (mode) {
+                            case MODE_1: yield v -> 0;
+                            case MODE_2: yield v -> Math.max(v - 1, 0);
+                        };
+                    case TOGGLE -> switch (mode) {
+                            case MODE_1: yield v -> v == 1 ? 0 : 1;
+                            case MODE_2: yield v -> v + 2;
+                        };
+                };
+                final int rStart = start.getRow() * 1_000;
+                final int rEnd = end.getRow() * 1_000;
+                for (int r = rStart; r <= rEnd; r += 1_000) {
+                    for (int idx = r + start.getCol(); idx <= r + end.getCol(); idx++) {
+                        grid[idx] = f.apply(grid[idx]);
+                    }
+                }
+            } //apply
+        } // Action
+    } // Instruction
 
     @Override
     @Samples({
@@ -66,61 +127,4 @@ public static void main(final String[] args) throws Exception {
     private static final String TEST3 = "turn off 499,499 through 500,500";
     private static final String TEST4 = "turn on 0,0 through 0,0";
     private static final String TEST5 = "toggle 0,0 through 999,999";
-    
-    private static final class Grid {
-        private final IntGrid lights = new IntGrid(new int[1_000][1_000]);
-        private final Function<Integer, Integer> turnOn;
-        private final Function<Integer, Integer> turnOff;
-        private final Function<Integer, Integer> toggle;
-        
-        protected Grid(
-                final Function<Integer, Integer> turnOn,
-                final Function<Integer, Integer> turnOff,
-                final Function<Integer, Integer> toggle
-        ) {
-            this.turnOn = turnOn;
-            this.turnOff = turnOff;
-            this.toggle = toggle;
-        }
-
-        public IntStream getAllLightValues() {
-            return Stream.of(this.lights.getValues()).flatMapToInt(IntStream::of);
-        }
-        
-        public void processInstructions(final List<Instruction> instructions) {
-            for (final Instruction instruction : instructions) {
-                final Function<Integer, Integer> action =
-                        instruction.action == Instruction.Action.TURN_ON
-                            ? this.turnOn
-                            : instruction.action == Instruction.Action.TURN_OFF
-                            ? this.turnOff
-                            : this.toggle;
-                for (int rr = instruction.start.getRow(); rr <= instruction.end.getRow(); rr++) {
-                    for (int cc = instruction.start.getCol(); cc <= instruction.end.getCol(); cc++) {
-                        this.lights.setValue(Cell.at(rr, cc), action.apply(this.lights.getValue(Cell.at(rr, cc))));
-                    }
-                }
-            }
-        }
-    }
-
-    record Instruction(Action action, Cell start, Cell end) {
-        
-        enum Action { TURN_ON, TURN_OFF, TOGGLE }
-        
-        public static Instruction fromInput(final String input) {
-            final String s = input.replace("turn ", "turn_");
-            final String[] splits = s.split(" through ");
-            final String[] actionAndStartSplits = splits[0].split(" ");
-            final Cell start = Cell.fromString(actionAndStartSplits[1]);
-            final Cell end = Cell.fromString(splits[1]);
-            if ("turn_on".equals(actionAndStartSplits[0])) {
-                return new Instruction(Action.TURN_ON, start, end);
-            } else if ("turn_off".equals(actionAndStartSplits[0])) {
-                return new Instruction(Action.TURN_OFF, start, end);
-            } else {
-                return new Instruction(Action.TOGGLE, start, end);
-            }
-        }
-    }
 }
