2024-08 * ** Gleam

src/aoc_2024/day_7.gleam

@@ -1,7 +1,6 @@
 import extra
 import gleam/int
 import gleam/list
-import gleam/order
 import gleam/string
 
 pub type Row {

src/aoc_2024/day_8.gleam

@@ -0,0 +1,65 @@
+import gleam/dict
+import gleam/list
+import gleam/set
+import grid.{type Dims, type Grid, type XY}
+
+pub fn parse(input: String) -> Grid(String) {
+  grid.from_string(input)
+  |> grid.filter(fn(_, c) { c != "." })
+}
+
+pub fn pt_1(input: Grid(String)) {
+  input
+  |> grid.to_list
+  |> list.group(by: fn(cell) { cell.1 })
+  |> dict.values
+  |> list.map(fn(nodes) { list.map(nodes, fn(node) { node.0 }) })
+  |> list.fold(from: set.new(), with: fn(acc, nodes) {
+    nodes
+    |> list.combination_pairs
+    |> list.flat_map(antinodes_xy_pt1)
+    |> list.filter(fn(xy) { grid.in_grid(input, xy) })
+    |> set.from_list
+    |> set.union(acc)
+  })
+  |> set.size
+}
+
+fn antinodes_xy_pt1(pair: #(XY, XY)) -> List(XY) {
+  let #(a, b) = pair
+  let diff = grid.xy_sub(a, b)
+  [grid.xy_add(a, diff), grid.xy_sub(b, diff)]
+}
+
+pub fn pt_2(input: Grid(String)) {
+  input
+  |> grid.to_list
+  |> list.group(by: fn(cell) { cell.1 })
+  |> dict.values
+  |> list.map(fn(nodes) { list.map(nodes, fn(node) { node.0 }) })
+  |> list.fold(from: set.new(), with: fn(acc, nodes) {
+    nodes
+    |> list.combination_pairs
+    |> list.flat_map(antinodes_xy_pt2(input.dims, _))
+    |> set.from_list
+    |> set.union(acc)
+  })
+  |> set.size
+}
+
+fn antinodes_xy_pt2(dims: Dims, pair: #(XY, XY)) -> List(XY) {
+  let #(a, b) = pair
+  list.append(
+    cast_ray(dims, a, grid.xy_sub(a, b), [a]),
+    cast_ray(dims, b, grid.xy_sub(b, a), [b]),
+  )
+}
+
+/// Also return the start point
+fn cast_ray(dims: Dims, start: XY, d: XY, acc: List(XY)) -> List(XY) {
+  let next = grid.xy_add(start, d)
+  case grid.in_dims(dims, next) {
+    False -> acc
+    True -> cast_ray(dims, next, d, [next, ..acc])
+  }
+}

src/grid.gleam

@@ -12,6 +12,10 @@ pub fn xy_add(a: XY, b: XY) -> XY {
   #(a.0 + b.0, a.1 + b.1)
 }
 
+pub fn xy_sub(a: XY, b: XY) -> XY {
+  #(a.0 - b.0, a.1 - b.1)
+}
+
 pub fn xy_scale(xy: XY, k: Int) -> XY {
   #(xy.0 * k, xy.1 * k)
 }
@@ -97,6 +101,10 @@ pub fn map(grid: Grid(a), fun: fn(XY, a) -> b) -> Grid(b) {
   Grid(dims: grid.dims, data: grid.data |> dict.map_values(fun))
 }
 
+pub fn filter(grid: Grid(a), pred: fn(XY, a) -> Bool) -> Grid(a) {
+  Grid(..grid, data: grid.data |> dict.filter(pred))
+}
+
 pub fn filter_map(grid: Grid(a), fun: fn(XY, a) -> Result(b, Nil)) -> Grid(b) {
   Grid(
     dims: grid.dims,
@@ -123,15 +131,23 @@ pub fn find_exact(grid: Grid(a), needle: a) -> Result(XY, Nil) {
   })
 }
 
+pub fn to_list(grid: Grid(a)) -> List(#(XY, a)) {
+  dict.to_list(grid.data)
+}
+
 pub fn values(grid: Grid(a)) -> List(a) {
   dict.values(grid.data)
 }
 
 pub fn in_grid(grid: Grid(a), xy: XY) -> Bool {
-  xy.0 >= grid.dims.min_x
-  && xy.0 <= grid.dims.max_x
-  && xy.1 >= grid.dims.min_y
-  && xy.1 <= grid.dims.max_y
+  in_dims(grid.dims, xy)
+}
+
+pub fn in_dims(dims: Dims, xy: XY) -> Bool {
+  xy.0 >= dims.min_x
+  && xy.0 <= dims.max_x
+  && xy.1 >= dims.min_y
+  && xy.1 <= dims.max_y
 }
 
 pub fn extend(dims: Dims, xy: XY) -> Dims {