aoc 2024 day 14

Author: jacobsandersen

src/main/java/dev/jacobandersen/codechallenges/challenge/adventofcode/year2024/Year2024.java

@@ -34,6 +34,7 @@ public static List<Day> getDays() {
  new Day11(),
  new Day12(),
  new Day13()
+// Day 6 part 2 is slow due to slow update algorithm
 // new Day14()
  );
  }

src/main/java/dev/jacobandersen/codechallenges/challenge/adventofcode/year2024/day14/Day14.java

@@ -1,20 +1,108 @@
 package dev.jacobandersen.codechallenges.challenge.adventofcode.year2024.day14;
 
 import dev.jacobandersen.codechallenges.challenge.adventofcode.Day;
+import dev.jacobandersen.codechallenges.util.Grid;
+import dev.jacobandersen.codechallenges.util.Pair;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
 
 public class Day14 extends Day {
+ private static final int ROWS = 103, COLS = 101;
+
  public Day14() {
  super(2024, 14, "Restroom Redoubt");
  }
 
+ public record Robot(Pair<Integer, Integer> position, Pair<Integer, Integer> velocity) {}
+
+ public List<Robot> loadRobots() {
+ return getInputLinesNoBlanks().stream().map(line -> {
+ final String[] parts = line.split(" ");
+ final String pos = parts[0].substring(2), vel = parts[1].substring(2);
+ return new Robot(Pair.fromStringPair(pos, Integer::parseInt).reverse(), Pair.fromStringPair(vel, Integer::parseInt).reverse());
+ }).toList();
+ }
+
+ public Grid<List<Robot>> loadInitialState() {
+ final Grid<List<Robot>> patrolArea = Grid.emptyGrid(ROWS, COLS, ArrayList::new);
+
+ loadRobots().forEach(robot -> {
+ List<Robot> lst = patrolArea.get(robot.position);
+ lst.add(robot);
+
+ patrolArea.set(robot.position, lst);
+ });
+
+ return patrolArea;
+ }
+
+ public Grid<List<Robot>> tickRobots(Grid<List<Robot>> in) {
+ final Grid<List<Robot>> updatedGrid = Grid.emptyGrid(ROWS, COLS, ArrayList::new);
+
+ in.forEach(robots -> {
+ List<Robot> lst = robots.value();
+ Iterator<Robot> itr = lst.iterator();
+ while (itr.hasNext()) {
+ final Robot robot = itr.next();
+ final Pair<Integer, Integer> currentPos = robot.position();
+ final Pair<Integer, Integer> velocity = robot.velocity();
+ final Pair<Integer, Integer> newPosition = updatedGrid.locateWrappedPosition(currentPos.first() + velocity.first(), currentPos.second() + velocity.second());
+ final List<Robot> currentRobots = updatedGrid.get(newPosition);
+ currentRobots.add(new Robot(newPosition, velocity));
+ updatedGrid.set(newPosition, currentRobots);
+ itr.remove();
+ }
+ });
+
+ return updatedGrid;
+ }
+
  @Override
  public String partOne() {
- getInputLinesNoBlanks().forEach(System.out::println);
- return "";
+ Grid<List<Robot>> room = loadInitialState();
+
+ for (int i = 0; i < 100; i++) {
+ room = tickRobots(room);
+ }
+
+ return String.valueOf(
+ room.getQuadrants().stream()
+ .mapToInt(quad ->
+ quad.map(ctx -> ctx.value().size())
+ .getBackingList().stream()
+ .flatMap(Collection::stream)
+ .reduce(0, Integer::sum)
+ )
+ .reduce(1, (a, b) -> a * b)
+ );
  }
 
  @Override
  public String partTwo() {
- return "";
+ Grid<List<Robot>> room = loadInitialState();
+
+ int seconds = 0;
+ while (true) {
+ seconds++;
+
+ room = tickRobots(room);
+
+ Grid<Integer> asRobotCounts = room.map(ctx -> ctx.value().size());
+ boolean hasSharedPositions = asRobotCounts.getBackingList().stream().flatMap(Collection::stream).anyMatch(x -> x >= 2);
+
+ if (hasSharedPositions) continue;
+
+ for (List<Integer> integers : asRobotCounts.getBackingList()) {
+ integers.forEach(System.out::print);
+ System.out.println();
+ }
+
+ break;
+ }
+
+ return String.valueOf(seconds);
  }
 }

src/main/java/dev/jacobandersen/codechallenges/util/Grid.java

@@ -8,7 +8,7 @@
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-public class Grid<T extends Comparable<T>> {
+public class Grid<T> {
  private final int rows;
  private final int cols;
  private final List<List<T>> grid;
@@ -27,7 +27,7 @@ public Grid(int rows, int cols, int currentRow, int currentCol, List<List<T>> gr
  this.grid = grid;
  }
 
- public static <T extends Comparable<T>> Grid<T> create(Stream<String> input, Function<String, List<T>> mapper) {
+ public static <T> Grid<T> create(Stream<String> input, Function<String, List<T>> mapper) {
  final List<List<T>> grid = input.map(mapper).collect(Collectors.toList());
  if (!grid.stream().map(List::size).allMatch(size -> grid.get(0).size() == size)) {
  throw new IllegalArgumentException("Received grid had rows with varying columns - invalid");
@@ -36,6 +36,18 @@ public static <T extends Comparable<T>> Grid<T> create(Stream<String> input, Fun
  return new Grid<>(grid.size(), grid.get(0).size(), grid);
  }
 
+ public static <T> Grid<T> emptyGrid(int rows, int cols, Supplier<T> initializer) {
+ final List<List<T>> grid = new ArrayList<>();
+ for (int i = 0; i < rows; i++) {
+ grid.add(new ArrayList<>());
+ for (int j = 0; j < cols; j++) {
+ grid.get(i).add(initializer.get());
+ }
+ }
+
+ return new Grid<>(rows, cols, grid);
+ }
+
  public int getRows() {
  return rows;
  }
@@ -56,17 +68,44 @@ public Pair<Integer, Integer> getCurrentPos() {
  return Pair.of(getCurrentRow(), getCurrentCol());
  }
 
- public T get() {
- return grid.get(currentRow).get(currentCol);
+ public Grid<T> set(T value) {
+ return set(currentRow, currentCol, value);
  }
 
- public Grid<T> set(T value) {
- grid.get(currentRow).set(currentCol, value);
+ public Grid<T> set(Pair<Integer, Integer> pos, T value) {
+ return set(pos.first(), pos.second(), value);
+ }
+
+ public Grid<T> set(int row, int col, T value) {
+ grid.get(row).set(col, value);
  return this;
  }
 
- public T get(int row, int col) {
- return grid.get(row).get(col);
+ public Pair<Integer, Integer> locateWrappedPosition(int targetRow, int targetCol) {
+ int wrappedRow = targetRow;
+ int wrappedCol = targetCol;
+
+ if (wrappedRow < 0) {
+ wrappedRow = (wrappedRow % rows + rows) % rows;
+ } else if (wrappedRow >= rows) {
+ wrappedRow = wrappedRow % rows;
+ }
+
+ if (wrappedCol < 0) {
+ wrappedCol = (wrappedCol % cols + cols) % cols;
+ } else if (wrappedCol >= cols) {
+ wrappedCol = wrappedCol % cols;
+ }
+
+ return Pair.of(wrappedRow, wrappedCol);
+ }
+
+ public T get() {
+ return get(currentRow, currentCol);
+ }
+
+ public T getOrNull(Pair<Integer, Integer> pos) {
+ return getOrNull(pos.first(), pos.second());
  }
 
  public T getOrNull(int row, int col) {
@@ -77,6 +116,14 @@ public T getOrNull(int row, int col) {
  }
  }
 
+ public T get(Pair<Integer, Integer> pos) {
+ return get(pos.first(), pos.second());
+ }
+
+ public T get(int row, int col) {
+ return grid.get(row).get(col);
+ }
+
  public Grid<T> move(int row, int col) {
  if (row < 0 || row >= rows || col < 0 || col >= cols) {
  throw new IllegalArgumentException("Tried to move current cell beyond boundaries");
@@ -203,10 +250,6 @@ public <R extends Comparable<R>> Grid<R> map(Function<PositionContext<T>, R> map
  return output;
  }
 
- public List<List<T>> getBackingList() {
- return copy().grid;
- }
-
  public Grid<T> copy() {
  List<List<T>> copy = new ArrayList<>(rows);
 
@@ -225,6 +268,31 @@ public boolean contains(Pair<Integer, Integer> position) {
  return position.first() >= 0 && position.first() < rows && position.second() >= 0 && position.second() < cols;
  }
 
+ public List<Grid<T>> getQuadrants() {
+ int midRow = rows / 2, midCol = cols / 2;
+
+ Grid<T> q1 = extractSubgrid(0, midRow, 0, midCol);
+ Grid<T> q2 = extractSubgrid(0, midRow, midCol + 1, cols);
+ Grid<T> q3 = extractSubgrid(midRow + 1, rows, 0, midCol);
+ Grid<T> q4 = extractSubgrid(midRow + 1, rows, midCol + 1, cols);
+
+ return List.of(q1, q2, q3, q4);
+ }
+
+ private Grid<T> extractSubgrid(int startRow, int endRow, int startCol, int endCol) {
+ Grid<T> subgrid = Grid.emptyGrid(endRow - startRow, endCol - startCol, () -> null);
+ for (int i = startRow; i < endRow; i++) {
+ for (int j = startCol; j < endCol; j++) {
+ subgrid.set(i - startRow, j - startCol, get(i, j));
+ }
+ }
+ return subgrid;
+ }
+
+ public List<List<T>> getBackingList() {
+ return grid;
+ }
+
  @Override
  public String toString() {
  StringBuilder builder = new StringBuilder("Grid {\n" +

src/main/java/dev/jacobandersen/codechallenges/util/Pair.java

@@ -1,10 +1,21 @@
 package dev.jacobandersen.codechallenges.util;
 
+import java.util.function.Function;
+
 public record Pair<T, R>(T first, R second) {
  public static <T, R> Pair<T, R> of(T first, R second) {
  return new Pair<>(first, second);
  }
 
+ public static <T> Pair<T, T> fromStringPair(String pair, Function<String, T> mapper) {
+ final String[] parts = pair.split(",");
+ return Pair.of(mapper.apply(parts[0]), mapper.apply(parts[1]));
+ }
+
+ public Pair<R, T> reverse() {
+ return Pair.of(second(), first());
+ }
+
  public Pair<T, R> copy() {
  return Pair.of(first, second);
  }