2024-18 * ** Gleam (A*)

Author: Janiczek

src/aoc_2024/day_18.gleam

@@ -1,10 +1,9 @@
 import extra
 import gleam/dict
-import gleam/io
 import gleam/list
 import gleam/result
 import gleam/string
-import grid.{type XY, Grid}
+import grid.{type Dims, type XY, Grid}
 
 pub fn parse(input: String) -> List(XY) {
  input
@@ -17,39 +16,52 @@ pub fn parse(input: String) -> List(XY) {
  })
 }
 
-pub fn pt_1(input: List(XY)) {
- let size = 71
- // let size = 7
+// example: size 7, take 12
+const size = 71
+
+pub fn pt_1(input: List(XY)) -> Int {
  let board = grid.dims_of_size(width: size, height: size)
+ let taken = 1024
+ let assert Ok(cost) = attempt(input, board, taken)
+ cost
+}
+
+pub fn pt_2(input: List(XY)) {
+ let board = grid.dims_of_size(width: size, height: size)
+ pt_2_loop(input, board, 1025)
+}
+
+fn pt_2_loop(input: List(XY), board: Dims, taken: Int) -> XY {
+ case attempt(input, board, taken) {
+ Ok(_) -> pt_2_loop(input, board, taken + 1)
+ Error(last) -> last
+ }
+}
+
+fn attempt(input: List(XY), board: Dims, taken: Int) -> Result(Int, XY) {
  let first_kb =
  input
- |> list.take(1024)
- // |> list.take(12)
+ |> list.take(taken)
  |> list.filter(grid.in_dims(board, _))
  |> list.map(fn(xy) { #(xy, Nil) })
  let grid = Grid(dims: board, data: dict.new()) |> grid.set_all(first_kb)
- io.println_error(
- grid.to_string_simple(grid, fn(_, c) {
- case c {
- Ok(Nil) -> "#"
- Error(Nil) -> "."
- }
- }),
- )
- let assert Ok(path) =
- grid.shortest_path(
+ let found_cost =
+ grid.astar(
  from: #(0, 0),
- to: #(grid.dims.max_x, grid.dims.max_y),
+ to: #(size - 1, size - 1),
  neighbours: fn(xy) {
  grid.neighbours(grid, xy, grid.orthogonal_dirs)
- |> list.filter(fn(kv) { grid.in_grid(grid, kv.0) })
  |> list.filter(fn(kv) { kv.1 |> result.is_error })
  |> list.map(fn(kv) { kv.0 })
  },
+ cost: grid.manhattan_distance,
+ print_progress: fn(_, _, _) { Nil },
  )
- path.1
-}
-
-pub fn pt_2(input: List(XY)) {
- todo as "part 2 not implemented"
+ case found_cost {
+ Error(Nil) -> {
+ let assert Ok(last) = input |> list.drop(taken - 1) |> list.first
+ Error(last)
+ }
+ Ok(cost) -> Ok(cost)
+ }
 }

src/grid.gleam

@@ -348,7 +348,7 @@ pub fn shortest_path(
  seen: dict.new(),
  todos: priority_queue.from_list(
  [ShortestPathTodo(origin, [], 0)],
- compare_todo,
+ compare_shortest_path_todo,
  ),
  neighbours: neighbours,
  )
@@ -402,7 +402,7 @@ fn shortest_path_aux(
  }
 }
 
-fn compare_todo(a: ShortestPathTodo, b: ShortestPathTodo) {
+fn compare_shortest_path_todo(a: ShortestPathTodo, b: ShortestPathTodo) {
  int.compare(a.steps_count, b.steps_count)
 }
 
@@ -691,3 +691,69 @@ pub fn dims_of_size(width width: Int, height height: Int) -> Dims {
  max_y: height - 1,
  )
 }
+
+pub fn manhattan_distance(a: XY, b: XY) -> Int {
+ int.absolute_value(a.0 - b.0) + int.absolute_value(a.1 - b.1)
+}
+
+pub type AstarTodo {
+ AstarTodo(xy: XY, cost: Int)
+}
+
+fn compare_astar_todo(a: AstarTodo, b: AstarTodo) {
+ int.compare(a.cost, b.cost)
+}
+
+pub fn astar(
+ from from: XY,
+ to to: XY,
+ cost cost: fn(XY, XY) -> Int,
+ neighbours neighbours: fn(XY) -> List(XY),
+ print_progress print_progress: fn(XY, List(XY), Queue(AstarTodo)) -> Nil,
+) -> Result(Int, Nil) {
+ let frontier =
+ priority_queue.new(compare_astar_todo)
+ |> priority_queue.push(AstarTodo(from, 0))
+ let cost_so_far: Dict(XY, Int) = dict.from_list([#(from, 0)])
+ astar_aux(to, cost, neighbours, frontier, cost_so_far, print_progress)
+}
+
+fn astar_aux(
+ to goal: XY,
+ cost cost: fn(XY, XY) -> Int,
+ neighbours neighbours: fn(XY) -> List(XY),
+ frontier frontier: Queue(AstarTodo),
+ cost_so_far cost_so_far: Dict(XY, Int),
+ print_progress print_progress: fn(XY, List(XY), Queue(AstarTodo)) -> Nil,
+) -> Result(Int, Nil) {
+ use #(current, rest) <- result.try(priority_queue.pop(frontier))
+ use <- bool.guard(when: current.xy == goal, return: Ok(current.cost))
+ let nexts = neighbours(current.xy)
+ print_progress(current.xy, nexts, frontier)
+ let #(new_frontier, new_cost_so_far) =
+ list.fold(over: nexts, from: #(rest, cost_so_far), with: fn(acc, next) {
+ let #(acc_frontier, acc_cost_so_far) = acc
+ let assert Ok(current_cost) = dict.get(acc_cost_so_far, current.xy)
+ let new_next_cost = current_cost + cost(current.xy, next)
+ case dict.get(acc_cost_so_far, next) {
+ Ok(old_next_cost) if old_next_cost <= new_next_cost -> acc
+ _ -> {
+ let new_cost_so_far =
+ dict.insert(acc_cost_so_far, next, new_next_cost)
+ let priority = new_next_cost + manhattan_distance(next, goal)
+ let new_frontier =
+ acc_frontier
+ |> priority_queue.push(AstarTodo(xy: next, cost: priority))
+ #(new_frontier, new_cost_so_far)
+ }
+ }
+ })
+ astar_aux(
+ goal,
+ cost,
+ neighbours,
+ new_frontier,
+ new_cost_so_far,
+ print_progress,
+ )
+}