2024-16 * ** Gleam

Author: Janiczek

src/aoc_2024/day_12.gleam

@@ -1,9 +1,7 @@
 import extra
 import gleam/int
-import gleam/io
 import gleam/list
 import gleam/set.{type Set}
-import gleam/string
 import grid.{type Grid, type XY}
 
 pub fn parse(input: String) -> Grid(String) {

src/aoc_2024/day_14.gleam

@@ -112,25 +112,8 @@ fn step_pt2(seconds: Int, robots: List(Robot)) {
  True -> {
  io.println_error("------------------------")
  io.debug(#(seconds, "seconds"))
- show(robots)
  step_pt2(seconds + 1, step(robots))
  }
  False -> step_pt2(seconds + 1, step(robots))
  }
 }
-
-fn show(robots: List(Robot)) {
- robots
- |> list.map(fn(robot) { #(robot.p, "#") })
- |> grid.from_list
- |> grid.with_dims(Dims(
- width: room.0,
- height: room.1,
- min_x: 0,
- min_y: 0,
- max_x: room.0 - 1,
- max_y: room.1 - 1,
- ))
- |> grid.to_string(fun: fn(item) { #(item, Error(Nil)) }, empty: ".")
- |> io.println_error
-}

src/aoc_2024/day_15.gleam

@@ -1,4 +1,3 @@
-import extra
 import gleam/bool
 import gleam/int
 import gleam/io
@@ -63,11 +62,9 @@ pub fn pt_1(input: Input) {
 pub fn pt_2(input: Input) {
  let wider_grid = widen(input.grid)
  let wider_robot = grid.xy_mul(input.robot, #(2, 1))
- let #(final_grid, final_robot) =
+ let #(final_grid, _) =
  input.moves
  |> list.fold(from: #(wider_grid, wider_robot), with: wider_step)
- //io.println_error("============== FINAL =============")
- //show2(final_grid, final_robot)
  final_grid
  |> grid.filter(fn(_, e) { e == BoxLeft })
  |> grid.keys
@@ -141,7 +138,6 @@ fn widen(grid: Grid(Entity)) -> Grid(Entity2) {
 
 fn wider_step(state: #(Grid(Entity2), XY), dir: Dir) -> #(Grid(Entity2), XY) {
  let #(grid, robot) = state
- //show2(grid, robot)
  let next_xy = grid.step(robot, dir, 1)
  case grid.get(grid, next_xy) {
  Error(Nil) -> #(grid, next_xy)
@@ -309,33 +305,3 @@ fn left_in_dir(e: Entity2, xy: XY, dir: Dir) -> XY {
  _, _ -> panic as "diagonals? huh?"
  }
 }
-
-fn show2(grid: Grid(Entity2), robot: XY) -> Nil {
- let without_robot =
- grid.to_string(
- grid,
- fn(e) {
- case e {
- Wall2 -> #("#", Error(Nil))
- BoxLeft -> #("[", Error(Nil))
- BoxRight -> #("]", Error(Nil))
- }
- },
- ".",
- )
- let with_robot =
- without_robot
- |> string.split("\n")
- |> list.index_map(fn(s, i) {
- case i == robot.1 {
- True -> s |> extra.string_set(robot.0, "@")
- False -> s
- }
- })
- |> string.join("\n")
- io.println_error(" 0123456789")
- io.println_error(
- with_robot
- |> extra.add_line_numbers,
- )
-}

src/aoc_2024/day_16.gleam

@@ -0,0 +1,301 @@
+import gleam/bool
+import gleam/dict.{type Dict}
+import gleam/int
+import gleam/io
+import gleam/list
+import gleam/option.{None, Some}
+import gleam/order
+import gleam/result
+import gleam/set.{type Set}
+import gleamy/priority_queue.{type Queue}
+import grid.{type Dir, type Grid, type XY}
+
+pub type Input {
+ Input(grid: Grid(Nil), reindeer: XY, exit: XY)
+}
+
+pub fn parse(input: String) -> Input {
+ let grid: Grid(Nil) =
+ input
+ |> grid.from_string
+ |> grid.filter_map(fn(_, c) {
+ case c {
+ "#" -> Ok(Nil)
+ _ -> Error(Nil)
+ }
+ })
+
+ Input(
+ grid: grid,
+ reindeer: #(grid.dims.min_x + 1, grid.dims.max_y - 1),
+ exit: #(grid.dims.max_x - 1, grid.dims.min_y + 1),
+ )
+}
+
+pub fn pt_1(input: Input) {
+ pt_1_aux(
+ input,
+ todos: priority_queue.from_list(
+ [
+ Todo(
+ current_xy: input.reindeer,
+ current_dir: grid.Right,
+ positions: set.new(),
+ cost: 0,
+ ),
+ ],
+ compare_todo,
+ ),
+ seen: dict.new(),
+ )
+}
+
+type Step {
+ RotateCW
+ RotateCCW
+ Forward
+}
+
+type Todo {
+ Todo(current_xy: XY, current_dir: Dir, positions: Set(#(XY, Dir)), cost: Int)
+}
+
+fn compare_todo(a: Todo, b: Todo) {
+ int.compare(a.cost, b.cost)
+}
+
+fn pt_1_neighbours(grid: Grid(Nil), xy: XY, dir: Dir) -> List(Step) {
+ case grid.get(grid, grid.step(xy, dir, 1)) {
+ Ok(Nil) -> [RotateCW, RotateCCW]
+ Error(Nil) -> [RotateCW, RotateCCW, Forward]
+ }
+}
+
+fn apply_step(step: Step, xy: XY, dir: Dir) -> #(XY, Dir) {
+ case step {
+ RotateCW -> #(xy, grid.rotate_cw(dir))
+ RotateCCW -> #(xy, grid.rotate_ccw(dir))
+ Forward -> #(grid.step(xy, dir, 1), dir)
+ }
+}
+
+fn pt_1_aux(
+ input: Input,
+ todos todos: Queue(Todo),
+ seen seen: Dict(#(XY, Dir), Int),
+) -> Result(Int, Nil) {
+ use #(todo_, rest_of_todos) <- result.try(priority_queue.pop(todos))
+ use <- bool.guard(
+ when: todo_.current_xy == input.exit,
+ return: Ok(todo_.cost),
+ )
+ let new_seen =
+ dict.insert(seen, #(todo_.current_xy, todo_.current_dir), todo_.cost)
+ let new_neighbours: List(Step) =
+ pt_1_neighbours(input.grid, todo_.current_xy, todo_.current_dir)
+ |> list.filter(fn(neighbour) {
+ let neighbour_applied =
+ apply_step(neighbour, todo_.current_xy, todo_.current_dir)
+ case dict.get(seen, neighbour_applied) {
+ Error(Nil) -> True
+ Ok(previously_best_cost) ->
+ previously_best_cost > todo_.cost + find_cost(neighbour)
+ }
+ })
+ let added_todos =
+ new_neighbours
+ |> list.map(fn(neighbour) {
+ let neighbour_applied =
+ apply_step(neighbour, todo_.current_xy, todo_.current_dir)
+ Todo(
+ current_xy: neighbour_applied.0,
+ current_dir: neighbour_applied.1,
+ positions: set.insert(todo_.positions, neighbour_applied),
+ cost: todo_.cost + find_cost(neighbour),
+ )
+ })
+ let new_todos =
+ list.fold(over: added_todos, from: rest_of_todos, with: priority_queue.push)
+ pt_1_aux(input, todos: new_todos, seen: new_seen)
+}
+
+fn find_cost(step: Step) -> Int {
+ case step {
+ RotateCCW -> 1000
+ RotateCW -> 1000
+ Forward -> 1
+ }
+}
+
+pub fn pt_2(input: Input) {
+ let steps =
+ pt_2_aux(
+ input,
+ todos: priority_queue.from_list(
+ [
+ Todo(
+ current_xy: input.reindeer,
+ current_dir: grid.Right,
+ positions: set.new(),
+ cost: 0,
+ ),
+ ],
+ compare_todo,
+ ),
+ seen: dict.new(),
+ best: 109_496,
+ )
+ io.println_error(
+ grid.to_string(input.grid, fn(xy, c) {
+ case set.contains(steps, xy), c {
+ True, Error(Nil) -> #("O", Error(Nil))
+ True, Ok(Nil) -> panic as "walked over a wall?"
+ False, Error(Nil) -> #(".", Error(Nil))
+ False, Ok(Nil) -> #("#", Error(Nil))
+ }
+ }),
+ )
+
+ set.size(steps)
+}
+
+fn pt_2_final(exit: XY, seen: Dict(#(XY, Dir), #(Int, Set(XY)))) -> Set(XY) {
+ case
+ seen
+ |> dict.filter(fn(k, _) { k.0 == exit })
+ |> dict.values
+ |> list.group(by: fn(kv) { kv.0 })
+ |> dict.to_list
+ |> list.sort(fn(a, b) { int.compare(a.0, b.0) })
+ |> list.first
+ {
+ Ok(best) ->
+ best.1
+ |> list.flat_map(fn(x) {
+ x.1
+ |> set.to_list
+ })
+ |> set.from_list
+ Error(Nil) -> panic as "no solution?"
+ }
+}
+
+fn pt_2_aux(
+ input: Input,
+ todos todos: Queue(Todo),
+ seen seen: Dict(#(XY, Dir), #(Int, Set(XY))),
+ best best: Int,
+) -> Set(XY) {
+ case priority_queue.pop(todos) {
+ Error(Nil) -> pt_2_final(input.exit, seen)
+ Ok(#(todo_, rest_of_todos)) -> {
+ case todo_.cost > best {
+ True -> pt_2_aux(input, todos: rest_of_todos, seen: seen, best: best)
+ False -> {
+ case todo_.current_xy == input.exit {
+ True -> {
+ let new_seen =
+ dict.upsert(
+ seen,
+ #(todo_.current_xy, todo_.current_dir),
+ with: fn(existing) {
+ case existing {
+ None -> #(
+ todo_.cost,
+ set.map(todo_.positions, fn(x) { x.0 }),
+ )
+ Some(existing_) ->
+ case int.compare(todo_.cost, existing_.0) {
+ order.Lt -> #(
+ todo_.cost,
+ set.map(todo_.positions, fn(x) { x.0 }),
+ )
+ order.Eq -> #(
+ todo_.cost,
+ set.union(
+ existing_.1,
+ set.map(todo_.positions, fn(x) { x.0 }),
+ ),
+ )
+ order.Gt -> existing_
+ }
+ }
+ },
+ )
+ io.debug(#(
+ "found",
+ todo_.cost,
+ set.size(pt_2_final(input.exit, new_seen)),
+ ))
+ let new_best = int.min(best, todo_.cost)
+ pt_2_aux(
+ input,
+ todos: rest_of_todos,
+ // |> list.filter(fn(t) { t.cost <= new_best }),
+ seen: new_seen,
+ best: new_best,
+ )
+ }
+ False -> {
+ case dict.get(seen, #(todo_.current_xy, todo_.current_dir)) {
+ Ok(seen_) if seen_.0 < todo_.cost ->
+ pt_2_aux(input, todos: rest_of_todos, seen: seen, best: best)
+ _ -> {
+ let new_neighbours: List(Step) =
+ pt_1_neighbours(
+ input.grid,
+ todo_.current_xy,
+ todo_.current_dir,
+ )
+ let added_todos =
+ new_neighbours
+ |> list.map(fn(neighbour) {
+ let neighbour_applied =
+ apply_step(
+ neighbour,
+ todo_.current_xy,
+ todo_.current_dir,
+ )
+ Todo(
+ current_xy: neighbour_applied.0,
+ current_dir: neighbour_applied.1,
+ positions: set.insert(
+ todo_.positions,
+ neighbour_applied,
+ ),
+ cost: todo_.cost + find_cost(neighbour),
+ )
+ })
+ let new_todos =
+ list.fold(
+ over: added_todos,
+ from: rest_of_todos,
+ with: priority_queue.push,
+ )
+ pt_2_aux(
+ input,
+ todos: new_todos,
+ seen: dict.upsert(
+ seen,
+ #(todo_.current_xy, todo_.current_dir),
+ with: fn(existing) {
+ case existing {
+ None -> #(todo_.cost, set.new())
+ Some(existing_) -> #(
+ todo_.cost,
+ set.union(existing_.1, set.new()),
+ )
+ }
+ },
+ ),
+ best: best,
+ )
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+}