Day 8 part 2

Author: timocp

src/adventofcode2024.gleam

@@ -51,6 +51,7 @@ fn run(d: Int) -> Nil {
       5 -> day5.part2(input) |> int.to_string
       6 -> day6.part2(input) |> int.to_string
       7 -> day7.part2(input) |> int.to_string
+      8 -> day8.part2(input) |> int.to_string
       _ -> "(not implemented)"
     }
   })

src/day8.gleam

@@ -6,31 +6,35 @@ import grid.{type Pos}
 import parse
 
 pub fn part1(input: String) -> Int {
-  let #(antennas, width, height) = parse_input(input)
+  let #(map, in_bounds) = parse_input(input)
 
-  antennas
-  |> dict.keys
-  |> list.flat_map(fn(label) { antinodes_for(antennas, label, width, height) })
+  map
+  |> dict.values
+  |> list.flat_map(fn(antennas) { antinodes_for(antennas, in_bounds) })
   |> list.unique
   |> list.length
 }
 
-fn antinodes_for(
-  antennas: Dict(String, List(Pos)),
-  label: String,
-  width: Int,
-  height: Int,
-) -> List(Pos) {
+pub fn part2(input: String) -> Int {
+  let #(map, in_bounds) = parse_input(input)
+
+  map
+  |> dict.values
+  |> list.flat_map(fn(antennas) { harmonic_antinodes_for(antennas, in_bounds) })
+  |> list.unique
+  |> list.length
+}
+
+type BoundFn =
+  fn(Pos) -> Bool
+
+fn antinodes_for(antennas: List(Pos), in_bounds: BoundFn) -> List(Pos) {
   antennas
-  |> dict.get(label)
-  |> result.unwrap([])
   |> list.combination_pairs
   |> list.flat_map(fn(pair) {
     [individual_antinode(pair.0, pair.1), individual_antinode(pair.1, pair.0)]
   })
-  |> list.filter(fn(pos) {
-    pos.0 >= 0 && pos.0 < width && pos.1 >= 0 && pos.1 < height
-  })
+  |> list.filter(in_bounds)
 }
 
 fn individual_antinode(a: Pos, b: Pos) -> Pos {
@@ -39,7 +43,40 @@ fn individual_antinode(a: Pos, b: Pos) -> Pos {
   #(a.0 + dx, a.1 + dy)
 }
 
-fn parse_input(input: String) -> #(Dict(String, List(Pos)), Int, Int) {
+fn harmonic_antinodes_for(antennas: List(Pos), in_bounds: BoundFn) -> List(Pos) {
+  antennas
+  |> list.combination_pairs
+  |> list.flat_map(fn(pair) {
+    [
+      find_harmonic_antinodes(pair.0, pair.1, in_bounds),
+      find_harmonic_antinodes(pair.1, pair.0, in_bounds),
+    ]
+  })
+  |> list.flatten
+}
+
+fn find_harmonic_antinodes(a: Pos, b: Pos, in_bounds: BoundFn) -> List(Pos) {
+  let dx = a.0 - b.0
+  let dy = a.1 - b.1
+
+  next_harmonic_antinode(a, dx, dy, in_bounds, [a])
+}
+
+fn next_harmonic_antinode(
+  a: Pos,
+  dx: Int,
+  dy: Int,
+  in_bounds: BoundFn,
+  nodes: List(Pos),
+) -> List(Pos) {
+  let node = #(a.0 + dx, a.1 + dy)
+  case in_bounds(node) {
+    True -> next_harmonic_antinode(node, dx, dy, in_bounds, [node, ..nodes])
+    False -> nodes
+  }
+}
+
+fn parse_input(input: String) -> #(Dict(String, List(Pos)), BoundFn) {
   let lines = parse.lines(input)
 
   let pos_to_char =
@@ -56,6 +93,10 @@ fn parse_input(input: String) -> #(Dict(String, List(Pos)), Int, Int) {
   let width = lines |> list.first |> result.unwrap("") |> string.length
   let height = lines |> list.length
 
+  let in_bounds = fn(p: Pos) {
+    p.0 >= 0 && p.0 < width && p.1 >= 0 && p.1 < height
+  }
+
   #(
     pos_to_char
       |> dict.values
@@ -74,7 +115,6 @@ fn parse_input(input: String) -> #(Dict(String, List(Pos)), Int, Int) {
         )
       })
       |> dict.from_list,
-    width,
-    height,
+    in_bounds,
   )
 }

test/day8_test.gleam

@@ -21,6 +21,23 @@ const example1 = "............
 ............
 "
 
+const example2 = "T.........
+...T......
+.T........
+..........
+..........
+..........
+..........
+..........
+..........
+..........
+"
+
 pub fn part1_test() {
   day8.part1(example1) |> should.equal(14)
 }
+
+pub fn part2_test() {
+  day8.part2(example1) |> should.equal(34)
+  day8.part2(example2) |> should.equal(9)
+}