AoC 2025 Day 7 - java - faster

Author: pareronia

src/main/java/AoC2025_07.java

@@ -1,20 +1,12 @@
-import static java.util.stream.Collectors.toSet;
-
-import com.github.pareronia.aoc.CharGrid;
-import com.github.pareronia.aoc.Grid.Cell;
-import com.github.pareronia.aoc.geometry.Direction;
 import com.github.pareronia.aoc.solution.Sample;
 import com.github.pareronia.aoc.solution.Samples;
 import com.github.pareronia.aoc.solution.SolutionBase;
 
-import java.util.HashMap;
+import java.util.Arrays;
 import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.stream.Stream;
 
 @SuppressWarnings({"PMD.ClassNamingConventions", "PMD.NoPackage"})
-public final class AoC2025_07 extends SolutionBase<CharGrid, Long, Long> {
+public final class AoC2025_07 extends SolutionBase<List<String>, Long, Long> {
 
  public static final char SPLITTER = '^';
  public static final char START = 'S';
@@ -32,68 +24,41 @@ public static AoC2025_07 createDebug() {
  }
 
  @Override
- protected CharGrid parseInput(final List<String> inputs) {
- return CharGrid.from(inputs);
+ protected List<String> parseInput(final List<String> inputs) {
+ return inputs;
  }
 
- @Override
- public Long solvePart1(final CharGrid grid) {
- final Set<Integer> beams = grid.getAllEqualTo(START).map(Cell::getCol).collect(toSet());
- long ans = 0L;
- final Iterable<Cell> splitters = () -> grid.getAllEqualTo(SPLITTER).iterator();
- for (final Cell splitter : splitters) {
- if (beams.contains(splitter.getCol())) {
- ans++;
- beams.remove(splitter.getCol());
- for (final Direction direction : Set.of(Direction.LEFT, Direction.RIGHT)) {
- beams.add(splitter.at(direction).getCol());
+ @SuppressWarnings("PMD.AvoidInstantiatingObjectsInLoops")
+ private Result solve(final List<String> grid) {
+ final int start = grid.getFirst().indexOf(START);
+ long[] beams = new long[grid.getFirst().length()];
+ beams[start] = 1;
+ long splits = 0;
+ for (int r = 1; r < grid.size(); r++) {
+ final char[] row = grid.get(r).toCharArray();
+ final long[] newBeams = new long[row.length];
+ for (int c = 0; c < row.length; c++) {
+ if (row[c] == SPLITTER) {
+ newBeams[c - 1] += beams[c];
+ newBeams[c + 1] += beams[c];
+ splits += (beams[c] > 0 ? 1 : 0);
+ } else {
+ newBeams[c] += beams[c];
  }
  }
+ beams = newBeams;
  }
- return ans;
+ return new Result(splits, Arrays.stream(beams).sum());
  }
 
  @Override
- public Long solvePart2(final CharGrid grid) {
- class DFS {
- private final Cell start;
- private final Set<Cell> splitters;
- private final Map<Cell, Long> cache = new HashMap<>();
-
- DFS() {
- this.start = grid.getAllEqualTo(START).findFirst().orElseThrow();
- this.splitters = grid.getAllEqualTo(SPLITTER).collect(toSet());
- splitters.add(this.start);
- }
-
- long dfs(final Cell cell) {
- final long ans;
- if (this.cache.containsKey(cell)) {
- ans = this.cache.get(cell);
- } else {
- if (cell.equals(this.start)) {
- ans = 1;
- } else {
- ans =
- grid.getCellsN(cell)
- .takeWhile(n -> !this.splitters.contains(n))
- .flatMap(
- n ->
- Stream.of(Direction.LEFT, Direction.RIGHT)
- .map(n::at))
- .filter(this.splitters::contains)
- .mapToLong(this::dfs)
- .sum();
- }
- this.cache.put(cell, ans);
- }
- return ans;
- }
- }
+ public Long solvePart1(final List<String> grid) {
+ return this.solve(grid).splits;
+ }
 
-  final Cell bottomLeft = Cell.at(grid.getMaxRowIndex(), 0);
-  final DFS dfs = new DFS();
- return dfs.dfs(bottomLeft) + grid.getCellsE(bottomLeft).mapToLong(dfs::dfs).sum();
+ @Override
+ public Long solvePart2(final List<String> grid) {
+ return this.solve(grid).beams;
  }
 
  @Samples({
@@ -123,4 +88,6 @@ public static void main(final String[] args) throws Exception {
  .^.^.^.^.^...^.
  ...............
  """;
+
+ private record Result(long splits, long beams) {}
 }