day7

src/advent_2025.gleam

···
 import day4
 import day5
 import day6
+import day7
 
 pub fn main() {
   // day1.day1main()
···
   // day3.day3main()
   // day4.day4main()
   // day5.day5main()
-  day6.day6main()
+  // day6.day6main()
+  day7.day7main()
 }

src/day6.gleam

···
     list.reverse(line)
     |> list.filter(fn(char) { char != " " })
   })
+  |> echo
   |> list.filter(fn(x) { x != [] })
   |> list.map(fn(num) {
     string.concat(num)
     |> h.quickint
   })
+  |> echo
+}
+
+fn chunk_it_out(input: List(String)) -> List(List(String)) {
+  chunk_recurse(input, [])
+  |> list.reverse
+}
+
+fn chunk_recurse(
+  input: List(String),
+  acc: List(List(String)),
+) -> List(List(String)) {
+  let #(head, rest) = list.split_while(input, fn(x) { x != " " })
+  case input {
+    [] -> acc
+    _ -> chunk_recurse(list.drop(rest, 1), [head, ..acc])
+  }
 }

src/day7.gleam

···
+import gleam/dict
+import gleam/int
+import gleam/list
+import gleam/set
+import gleam/string
+import herbie as h
+import simplifile
+
+pub type Coord {
+  Coord(x: Int, y: Int)
+}
+
+pub fn day7main() {
+  let input = "./data/day7"
+  let grid =
+    part1input(input)
+    |> h.grid_to_coords
+
+  let assert [#(#(start_x, _start_y), _)] =
+    dict.filter(grid, fn(_k, v) { v == "S" })
+    |> dict.to_list
+
+  let splitters = isolate_splitters(grid)
+
+  walk_splitters(splitters, start_x)
+  |> echo
+}
+
+fn walk_splitters(splitters: List(Coord), start: Int) -> Int {
+  let rays =
+    set.new()
+    |> set.insert(start)
+
+  let #(_rays, return) = list.fold(splitters, #(rays, 0), fold_splitters)
+  return
+}
+
+fn fold_splitters(acc: #(set.Set(Int), Int), splitter: Coord) {
+  let #(rays, _count) = acc
+  case set.contains(rays, splitter.x) {
+    False -> acc
+    True -> ray_split(acc, splitter.x)
+  }
+}
+
+fn ray_split(acc: #(set.Set(Int), Int), splitter: Int) -> #(set.Set(Int), Int) {
+  let #(rays, count) = acc
+  let rays =
+    rays
+    |> set.insert(splitter + 1)
+    |> set.insert(splitter - 1)
+    |> set.drop([splitter])
+
+  #(rays, count + 1)
+}
+
+fn isolate_splitters(grid: dict.Dict(#(Int, Int), String)) -> List(Coord) {
+  grid
+  |> dict.filter(fn(_k, v) { v == "^" })
+  |> dict.to_list
+  |> list.map(fn(coord) {
+    let #(#(x, y), _z) = coord
+    Coord(x:, y:)
+  })
+  |> list.sort(fn(a, b) { int.compare(a.y, b.y) })
+}
+
+fn part1input(input: String) -> List(List(String)) {
+  let assert Ok(string_input) = simplifile.read(input)
+  string_input
+  |> string.trim
+  |> string.split("\n")
+  |> list.map(string.to_graphemes)
+}