day 6

src/advent_2025.gleam

···
 import day1
 import day2
-import gleam/io
+import day3
+import day4
+import day5
+import day6
 
 pub fn main() {
-  day1.day1main()
-  day2.day2main()
+  // day1.day1main()
+  // day2.day2main()
+  // day3.day3main()
+  // day4.day4main()
+  // day5.day5main()
+  day6.day6main()
 }

src/day3.gleam

···
+import gleam/int
+import gleam/io
+import gleam/list
+import gleam/regexp
+import gleam/result
+import gleam/string
+import herbie as h
+import simplifile
+
+pub fn day3main() {
+  let assert Ok(file) = simplifile.read("./data/day3test")
+  let batteries =
+    file
+    |> string.trim
+    |> string.split("\n")
+    |> list.map(fn(x) {
+      string.to_graphemes(x)
+      |> list.map(h.quickint)
+    })
+
+  part1(batteries)
+  |> echo
+}
+
+fn part1(input: List(List(Int))) -> Int {
+  list.fold(input, 0, fn(acc, x) {
+    let first_digit =
+      x
+      |> list.reverse
+      |> list.drop(1)
+      |> list.reverse
+      |> list.max(int.compare)
+      |> result.unwrap(69)
+
+    let second_digit =
+      x
+      |> list.drop_while(fn(y) { y <= first_digit - 1 })
+      |> list.drop(1)
+      |> list.max(int.compare)
+      |> result.unwrap(69)
+    acc + { first_digit * 10 } + second_digit
+  })
+}

src/day4.gleam

···
+import gleam/dict.{type Dict}
+import gleam/int
+import gleam/io
+import gleam/list
+import gleam/regexp
+import gleam/result
+import gleam/string
+import herbie as h
+import simplifile
+
+pub fn day4main() {
+  let assert Ok(file) = simplifile.read("./data/day4")
+  let grid =
+    file
+    |> string.trim
+    |> string.split("\n")
+    |> list.map(string.to_graphemes)
+    |> h.grid_to_coords()
+
+  part1(grid)
+  inner(#(grid, 0))
+  outer(#(grid, 0))
+  |> echo
+}
+
+fn outer(grid: #(dict.Dict(#(Int, Int), String), Int)) {
+  let old = grid
+  let new = inner(grid)
+
+  case new.1 == old.1 {
+    True -> grid
+    False -> outer(new)
+  }
+}
+
+fn inner(
+  input: #(dict.Dict(#(Int, Int), String), Int),
+) -> #(dict.Dict(#(Int, Int), String), Int) {
+  let #(grid, acc) = input
+
+  dict.fold(grid, #(dict.new(), acc), fn(acc, k, v) {
+    let newgrid = acc.0
+    let replacements = acc.1
+    case v {
+      "@" -> {
+        let count =
+          h.neighbors_9_flat_vals(k, grid)
+          |> list.count(fn(x) { x == "@" })
+        case count < 5 {
+          True -> #(dict.insert(newgrid, k, "X"), replacements + 1)
+          False -> #(dict.insert(newgrid, k, v), replacements)
+        }
+      }
+      _ -> #(dict.insert(newgrid, k, v), replacements)
+    }
+  })
+}
+
+fn part1(grid: dict.Dict(#(Int, Int), String)) -> Int {
+  dict.filter(grid, fn(k, v) {
+    let count =
+      h.neighbors_9_flat_vals(k, grid)
+      |> list.count(fn(x) { x == "@" })
+    count < 5 && v == "@"
+  })
+  |> dict.values
+  |> list.length
+}

src/day5.gleam

···
+import gleam/int
+import gleam/list
+import gleam/string
+import herbie as h
+import simplifile
+
+pub fn day5main() {
+  let #(ranges, values) = inputs()
+
+  part1(ranges, values)
+  |> echo
+
+  part2(ranges)
+  |> echo
+}
+
+fn part2(ranges: List(#(Int, Int))) -> Int {
+  ranges
+  |> sort_ranges()
+  |> merge_ranges([])
+  |> list.fold(0, fn(acc, x: #(Int, Int)) { x.1 - x.0 + 1 + acc })
+}
+
+fn merge_ranges(
+  ranges: List(#(Int, Int)),
+  acc: List(#(Int, Int)),
+) -> List(#(Int, Int)) {
+  case ranges, acc {
+    [new, ..rest], [] -> merge_ranges(rest, [new])
+    [new, ..rest], [last, ..acc] if last.0 <= new.0 && last.1 >= new.1 ->
+      merge_ranges(rest, [last, ..acc])
+    [new, ..rest], [last, ..acc] if last.1 < new.0 ->
+      merge_ranges(rest, [new, last, ..acc])
+    [new, ..rest], [last, ..acc] if last.0 <= new.0 && last.1 <= new.1 ->
+      merge_ranges(rest, [#(last.0, new.1), ..acc])
+    [], _ -> acc
+    [_, ..], [_, ..] -> panic as "aw beans"
+  }
+}
+
+fn sort_ranges(ranges: List(#(Int, Int))) {
+  ranges
+  |> list.sort(fn(a, b) { int.compare(a.0, b.0) })
+}
+
+fn part1(ranges: List(#(Int, Int)), values: List(Int)) -> Int {
+  list.count(values, fn(value) { part1check(value, ranges) })
+}
+
+fn part1check(value: Int, ranges: List(#(Int, Int))) -> Bool {
+  list.any(ranges, fn(range) { value >= range.0 && value <= range.1 })
+}
+
+fn inputs() -> #(List(#(Int, Int)), List(Int)) {
+  let assert Ok(file) = simplifile.read("./data/day5")
+  let assert [ranges, values] =
+    file
+    |> string.trim
+    |> string.split("\n\n")
+  let ranges =
+    ranges
+    |> string.split("\n")
+    |> list.map(fn(x) {
+      let assert [first, last] = string.split(x, "-") |> list.map(h.quickint)
+      #(first, last)
+    })
+  let values =
+    values
+    |> string.split("\n")
+    |> list.map(h.quickint)
+  #(ranges, values)
+}

src/day6.gleam

···
+import gleam/int
+import gleam/list
+import gleam/string
+import herbie as h
+import simplifile
+
+pub type Column {
+  Column(sign: Sign, digits: List(Int))
+}
+
+pub type Sign {
+  Plus
+  Multiply
+}
+
+pub fn day6main() {
+  let part1 =
+    pt1_inputs()
+    |> add_column
+    |> echo
+
+  let part2 =
+    pt2_inputs()
+    |> add_column
+    |> echo
+}
+
+fn pt1_inputs() -> List(Column) {
+  let assert Ok(file) = simplifile.read("./data/day6test")
+  file
+  |> string.trim
+  |> string.split("\n")
+  |> list.map(fn(line) {
+    string.split(line, " ") |> list.filter(fn(char) { char != "" })
+  })
+  |> list.transpose()
+  |> list.map(build_columns)
+}
+
+fn build_columns(input: List(String)) -> Column {
+  let assert [sign, ..digits] =
+    input
+    |> list.reverse
+
+  let sign = symbol_type(sign)
+
+  let digits =
+    digits
+    |> list.map(h.quickint)
+  Column(sign:, digits:)
+}
+
+fn symbol_type(sign: String) -> Sign {
+  case sign {
+    "+" -> Plus
+    _ -> Multiply
+  }
+}
+
+fn add_column(maths: List(Column)) -> Int {
+  list.fold(maths, 0, column_fold)
+}
+
+fn column_fold(acc: Int, input: Column) -> Int {
+  let #(operand, accumulator) = case input.sign {
+    Plus -> #(int.add, 0)
+    Multiply -> #(int.multiply, 1)
+  }
+  list.fold(input.digits, accumulator, operand) + acc
+}
+
+fn pt2_inputs() -> List(Column) {
+  let assert Ok(file) = simplifile.read("./data/day6test")
+  let assert [raw_symbols, ..digits] =
+    file
+    |> string.trim
+    |> string.split("\n")
+    |> list.map(string.to_graphemes)
+    |> list.reverse
+
+  let symbols =
+    raw_symbols
+    |> list.filter(fn(char) { char != " " })
+
+  let column_count = list.length(symbols)
+  let chunksize = list.length(h.quickfirst(digits)) / column_count
+
+  digits
+  |> group_by_sign
+  |> list.sized_chunk(into: chunksize)
+  |> list.map2(symbols, fn(digits, sign) {
+    let sign = symbol_type(sign)
+    Column(sign:, digits:)
+  })
+}
+
+fn group_by_sign(digits: List(List(String))) -> List(Int) {
+  digits
+  |> list.transpose
+  |> list.map(fn(line) {
+    list.reverse(line)
+    |> list.filter(fn(char) { char != " " })
+  })
+  |> list.filter(fn(x) { x != [] })
+  |> list.map(fn(num) {
+    string.concat(num)
+    |> h.quickint
+  })
+}

src/herbie.gleam

···
 }
 
 pub fn neighbors_9_flat_vals(
-  coordgrid: dict.Dict(Coord, a),
   start: Coord,
-) -> List(List(a)) {
+  coordgrid: dict.Dict(Coord, a),
+) -> List(a) {
   list.flat_map([-1, 0, 1], fn(x) {
-    list.map([-1, 0, 1], fn(y) {
+    list.flat_map([-1, 0, 1], fn(y) {
       case dict.get(coordgrid, #(start.0 + x, start.1 + y)) {
         Ok(val) -> [val]
         _ -> []
···
 }
 
 pub fn neighbors_9_grid(
-  coordgrid: dict.Dict(Coord, a),
   start: Coord,
+  coordgrid: dict.Dict(Coord, a),
 ) -> dict.Dict(#(Int, Int), a) {
   list.flat_map([-1, 0, 1], fn(x) {
     list.flat_map([-1, 0, 1], fn(y) {