Forem: Caleb Weeks

Hello DEV! I'm looking for a new role as a senior software developer either remote or in the Dallas/Fort Worth area. If you have any leads please reach out!

Caleb Weeks — Fri, 19 Dec 2025 16:32:39 +0000

Advent of Code #1 (in F#)

Caleb Weeks — Mon, 01 Dec 2025 15:14:16 +0000

It's that time of the year again! Advent of Code is here! And although it is only 12 days instead of 25 this year, I am super excited as usual. Maybe I'll even be able to finish it this time!

This year, I'm going to try to solve the problems using F#. I have done a little bit of OCaml before, which is pretty similar, but have never used F#. Since I've been using a lot of C# at work, I figured I would try the functional language in the .NET world.

(To anyone who follows me because I used to write a lot about JavaScript, sorry to spam you with random languages... If you are interested in polyglot content with inconsistent publishing schedules and level of effort, then stay tuned :P)

Anyway, back to the problem at hand. I think day 1 was was a touch harder than previous years. It took me over an hour to finish both parts, but most of that was getting to know F# (and my new setup with MacOS + Zed + Arc).

I tried to use the strong points of F# to model the domain. Active Patterns will probably be useful for parsing later on, but they seemed redundant when I tried to use them today. I used a union type for the Left and Right rotations, but looking back, the problem would have been so much easier if I had just replaced all instances of "L" with "-1" and removed all instances of "R".

Part 1 was fairly straightforward with some modular arithmetic. Part 2 was a bit of a twist (there is a pun in there somewhere). I think my solution of multiplying the new_state with the old state to see if it crossed 0 was pretty clever, but maybe there is a better way I didn't think of.

Some quick thoughts on F# so far:

Objects like System.String are shared with other .NET languages, and therefore have the same methods. Collections are not shared and follow the pattern that most functional languages use with a module of helper functions. It is weird to see that mix of patterns in the code.
Compile errors have not been very friendly so far. Perhaps it is because of the nature of type inference. I have had similar issues with OCaml and Julia.
Documentation seems to be split between fsharp.org and learn.microsoft.com. It has been a little confusing to figure out where to look.

open System
open System.IO

let input_string = File.ReadAllLines("input")

type Rotation =
    | Left of int
    | Right of int

let parse_input (input: string array) =
    input
    |> Array.filter (fun line -> line.Length > 0)
    |> Array.map (fun line ->
        if line.StartsWith "L" then Left (int (line.Trim('L')))
        else Right (int (line.Trim('R'))))

let input = parse_input input_string

let part1 (input: Rotation array) =
    input |> Array.fold (fun (sum, state) rotation ->
        let new_state =
            match rotation with
            | Left l -> (state - l) % 100
            | Right r -> (state + r) % 100
        if new_state = 0 then (sum + 1, new_state) else (sum, new_state)
    ) (0, 50)
    |> fst

printfn "%A" (part1 input)

let part2 (input: Rotation array) =
    input |> Array.fold (fun (sum, state) rotation ->
        let new_state =
            match rotation with
            | Left l -> state - l
            | Right r -> state + r
        if new_state = 0 then (sum + 1, new_state)
        elif new_state * state < 0 then (Math.Abs(new_state) / 100 + 1 + sum, new_state % 100)
        else (Math.Abs(new_state) / 100 + sum, new_state % 100)
    ) (0, 50)
    |> fst

printfn "%A" (part2 input)

Fluent API for piping standalone functions in JavaScript

Caleb Weeks — Wed, 08 Oct 2025 13:57:13 +0000

Today (October 8, 2025), there is a post called Working pipe operator today in pure JavaScript on Hacker News. It's a really neat concept that uses type coercion to use the bitwise OR (|) operator. I really like the idea and how similar it looks like the widely used pipe operator (|>).

The one downside of this approach is that each function that you want to pipe needs to be wrapped in an asPipe function. If you're willing to live with this, I came up with another JavaScript hack that uses proxies to call functions as if they are methods on the calling object. The object gets passed in as the first argument of the passed in function.

First, we check if the property is a method on the target object. If it is, we simply call the method. Then we check if there is a function with the same name as the property in the provided functions and call it accordingly. Then we fall back to a regular property getter.

I like the fluent API that feels more like idiomatic JavaScript. There is also a possibility of making this work with TypeScript. I think it should be possible to make the passed-in functions appear as methods on the target object as you type in your editor.

const chainWith = (fns) => (obj) => {
  const isFunction = (fn) => typeof fn === "function";
  const chainify = (obj) => {
    if (typeof obj === "object" && obj !== null) {
      return new Proxy(obj, {
        get: (target, prop) => {
          switch (true) {
            case isFunction(target[prop]):
              return (...args) => chainify(target[prop].apply(target, args));
            case isFunction(fns[prop]):
              return (...args) =>
                chainify(fns[prop].apply(target, [target, ...args]));
            default:
              return target[prop];
          }
        },
      });
    }
    return obj;
  };
  return chainify(obj);
};

const shuffle = (arr) => arr.sort(() => Math.random() - 0.5);
const zipWith = (a, b, fn) => a.slice(0, Math.min(a.length, b.length)).map((x, i) => fn(x, b[i]));
const log = (arr) => {
  console.log(arr);
  return arr;
};

const chain = chainWith({shuffle, zipWith, log});

chain([1, 2, 3, 4, 5, 6, 7, 8, 9])
  .map((i) => i + 10)
  .log() // [ 11, 12, 13, 14, 15, 16, 17, 18, 19 ]
  .shuffle()
  .log() // e.g. [ 16, 15, 11, 19, 12, 13, 18, 14, 17 ]
  .zipWith(["a", "b", "c", "d", "e"], (a, b) => a + b)
  .log() // e.g. [ '16a', '15b', '11c', '19d', '12e' ]
  [0]; // e.g. '16a'

Of course, you could just use a simple pipe function like so...

const pipe = (...fns) => (x) => fns.reduce((v, f) => f(v), x);

const pipeline = pipe(
  (x) => x.map((i) => i + 10),
  log, // [ 11, 12, 13, 14, 15, 16, 17, 18, 19 ]
  shuffle,
  log, // e.g. [ 16, 15, 11, 19, 12, 13, 18, 14, 17 ]
  (arr) => zipWith(arr, ["a", "b", "c", "d", "e"], (a, b) => a + b),
  log // e.g. [ '16a', '15b', '11c', '19d', '12e' ]
)

pipeline([1, 2, 3, 4, 5, 6, 7, 8, 9]);

Advent of Code #14 (in Gleam)

Caleb Weeks — Mon, 10 Mar 2025 04:44:02 +0000

Remember how I mentioned that my code might not provide a solution that would work on your input because further analysis might be needed? Today is a prime example of that. Part 1 was simple enough, but part 2 was an Easter egg! Literally. The goal was to find a Christmas tree in the output.

Now that I know what to look for, I could code up something that would find the Easter egg for any input (assuming they all look the same). But since I didn't know what I was looking for, I had to resort to analysis. So I first figured out how often the pattern cycled, then did a binary search by guessing the answer and using the information of whether the answer was higher or lower. From there, I just wrote the output to a file every 200 milliseconds until I thought I saw something that looked like a Christmas tree.

So this code won't get you the final answer, but it's what I used to get mine:

import gleam/int
import gleam/io
import gleam/list
import gleam/string
import gleam/erlang/process
import gleam/set.{type Set}
import gleam/option.{Some}
import gleam/regexp.{Match}
import simplifile as file

const example = "
p=0,4 v=3,-3
p=6,3 v=-1,-3
p=10,3 v=-1,2
p=2,0 v=2,-1
p=0,0 v=1,3
p=3,0 v=-2,-2
p=7,6 v=-1,-3
p=3,0 v=-1,-2
p=9,3 v=2,3
p=7,3 v=-1,2
p=2,4 v=2,-3
p=9,5 v=-3,-3
"

pub fn main() {
  let assert Ok(input) = file.read("input")
  // let assert 12 = part1(example, 11, 7)
  // part1(input, 101, 103) |> int.to_string |> io.println
  part2(input, 101, 103)
}

type Velocity = #(Int, Int)
type Position = #(Int, Int)
type Robot {
  Robot(position: Position, velocity: Velocity)
}

fn assert_parse_int(input: String) -> Int {
  let assert Ok(x) = int.parse(input)
  x
}

fn parse_input(input: String) -> List(Robot) {
  let assert Ok(re) = regexp.from_string("p=(\\d+),(\\d+) v=(-*\\d+),(-*\\d+)")
  regexp.scan(re, input)
  |> list.map(fn(match) {
    let assert Match(_, [Some(x), Some(y), Some(vx), Some(vy)]) = match
    Robot(
      #(assert_parse_int(x), assert_parse_int(y)),
      #(assert_parse_int(vx), assert_parse_int(vy))
    )
  })
}

fn position_after(robot: Robot, seconds: Int, width: Int, height: Int) -> Position {
  let Robot(#(x, y), #(vx, vy)) = robot
  let assert Ok(new_x) = int.modulo(x + vx * seconds, width)
  let assert Ok(new_y) = int.modulo(y + vy * seconds, height)
  #(new_x, new_y)
}

fn in_quadrants(positions: List(Position), width: Int, height: Int) -> Int {
  positions
  |> list.fold(#(0, 0, 0, 0), fn(quadrants, position) {
    let #(tl, tr, bl, br) = quadrants
    let #(x, y) = position
    case position {
      #(x, y) if x < width / 2 && y < height / 2 -> #(tl + 1, tr, bl, br)
      #(x, y) if x > width / 2 && y < height / 2 -> #(tl, tr + 1, bl, br)
      #(x, y) if x < width / 2 && y > height / 2 -> #(tl, tr, bl + 1, br)
      #(x, y) if x > width / 2 && y > height / 2 -> #(tl, tr, bl, br + 1)
      _ -> quadrants
    }
  })
  |> fn(quadrants) {
    let #(tl, tr, bl, br) = quadrants
    tl * tr * bl * br
  }
}

fn part1(input: String, width: Int, height: Int) -> Int {
  input
  |> parse_input()
  |> list.map(fn(robot) { position_after(robot, 100, width, height) })
  |> in_quadrants(width, height)
}

fn print_positions(positions: List(Position), width: Int, height: Int) {
  let positions = set.from_list(positions)
  list.range(0, height)
  |> list.fold("", fn(lines, x) {
    list.range(0, width)
    |> list.fold(lines, fn(tiles, y) {
      case set.contains(positions, #(x, y)) {
        True -> tiles <> "#"
        False -> tiles <> " "
      }
    })
    |> string.append("\n")
  })
}

fn loop(robots: List(Robot), seconds: Int, width: Int, height: Int, pics: Set(String)) {
  io.println(int.to_string(seconds))
  let pic = 
    robots
    |> list.map(fn(robot) { position_after(robot, seconds, width, height) })
    |> print_positions(width, height)
  case set.contains(pics, pic) {
    True -> io.println("PICTURE DUPLICATE")
    False -> Nil
  } 
  file.write("output", pic)
  process.sleep(1000)
  loop(robots, seconds + 1, width, height, set.insert(pics, pic))
}

fn part2(input: String, width: Int, height: Int) -> Int {
  loop(parse_input(input), 6667, width, height, set.new())
  // Duplicate at 10403
  // 5201 too low
  // Searched to 6620
  // Searched above 10000

}

Advent of Code #13 (in Gleam)

Caleb Weeks — Mon, 10 Mar 2025 04:36:32 +0000

This was yet another problem that my boss helped me out with for part 2. I honestly don't know if I would have ever figured out the trick. I used an iterative approach to part 1 that clearly wouldn't work for part 2. Again, the wording of the problem doesn't make it obvious that you can just solve it as a system of equations, but that's what makes these puzzles fun!

I kept the iterative approach for part 1 in the code because I actually kind of like how it was done. But obviously the solution for part 2 could be applied much more effectively.

import gleam/int
import gleam/io
import gleam/list
import gleam/string
import gleam/option.{type Option, Some, None}
import gleam/regexp.{Match}
import simplifile as file

const example = "
Button A: X+94, Y+34
Button B: X+22, Y+67
Prize: X=8400, Y=5400

Button A: X+26, Y+66
Button B: X+67, Y+21
Prize: X=12748, Y=12176

Button A: X+17, Y+86
Button B: X+84, Y+37
Prize: X=7870, Y=6450

Button A: X+69, Y+23
Button B: X+27, Y+71
Prize: X=18641, Y=10279
"

const template = "
Button A: X\\+(\\d+), Y\\+(\\d+)
Button B: X\\+(\\d+), Y\\+(\\d+)
Prize: X=(\\d+), Y=(\\d+)
"

pub fn main() {
  let assert Ok(input) = file.read("input")
  let assert 480 = part1(example)
  part1(input) |> int.to_string |> io.println
  part2(input) |> int.to_string |> io.println
}

type Position = #(Int, Int)
type ClawMachine {
  ClawMachine(a: Position, b: Position, prize: Position)
}

fn assert_parse_int(input: String) -> Int {
  let assert Ok(x) = int.parse(input)
  x
}

fn cost(claw_machine: ClawMachine, a: Int, b: Int) -> Option(Int) {
  let ClawMachine(button_a, button_b, prize) = claw_machine
  let #(a_x, a_y) = button_a
  let #(b_x, b_y) = button_b
  let position = #(a * a_x + b * b_x, a * a_y + b * b_y)
  case position == prize {
    True -> Some(a * 3 + b)
    False -> None
  }
}

fn parse_input(input: String) -> List(ClawMachine) {
  let assert Ok(re) = template |> string.trim() |> regexp.from_string()
  regexp.scan(re, input)
  |> list.map(fn(match) {
    let assert Match(_, [Some(a_x), Some(a_y), Some(b_x), Some(b_y), Some(prize_x), Some(prize_y)]) = match
    ClawMachine(
      #(assert_parse_int(a_x), assert_parse_int(a_y)),
      #(assert_parse_int(b_x), assert_parse_int(b_y)),
      #(assert_parse_int(prize_x), assert_parse_int(prize_y))
    )
  })
}

fn play(claw_machine: ClawMachine) -> Int {
  list.range(0, 100)
  |> list.fold(500, fn(min, a) {
    list.range(0, 100)
    |> list.fold(min, fn(min, b) {
      let a_b = 
        case cost(claw_machine, a, b) {
          Some(cost) -> int.min(min, cost)
          None -> min
        }
      case cost(claw_machine, b, a) {
        Some(cost) -> int.min(min, cost)
        None -> min
      }
    })
  })
  |> fn(min) {
    case min == 500 {
      True -> 0
      False -> min
    }
  }
}

fn part1(input: String) -> Int {
  input
  |> parse_input()
  |> list.fold(0, fn(sum, claw_machine) {
    sum + play(claw_machine)
  })
}

fn solve_equation(claw_machine: ClawMachine) -> Int {
  let ClawMachine(#(ax, ay), #(bx, by), #(px, py)) = claw_machine
  let b_rem = {py * ax - ay * px} % {ax * by - ay * bx}
  case b_rem == 0 {
    True -> {
      let b = {py * ax - ay * px} / {ax * by - ay * bx}
      let a_rem = {px - bx * b} % ax
      case a_rem == 0 {
        True -> {
          let a = {px - bx * b} / ax
          a * 3 + b
        }
        False -> 0
      }
    }
    False -> 0
  }
}

fn part2(input: String) -> Int {
  input
  |> parse_input()
  |> list.fold(0, fn(sum, claw_machine) {
    let ClawMachine(_, _, #(px, py)) = claw_machine
    let corrected = ClawMachine(..claw_machine, prize: #(px + 10000000000000, py + 10000000000000))
    sum + solve_equation(corrected)
  })
}

Advent of Code #12 (in Gleam)

Caleb Weeks — Mon, 10 Mar 2025 04:31:16 +0000

My boss gave me another clue for part 2 of today's problem. I was planning on determining the number of sides by walking the perimeter and counting the turns, but I honestly didn't know how to account for sides formed by internal sections. He gave me the clue that the number of corners is the same as the number of sides.

It's much easier to figure out if something is a corner. For exterior corners, we just need two adjacent cells to be from different regions. And for interior corners, we need a diagonal cell to be from a different region while the two adjacent cells to the diagonal are from the same region.

The only other trick which took me a bit to get was realizing that I had to use a "flood" algorithm to get the regions. It wasn't as easy as just finding all the cells with the same letter because the letters are reused for different regions.

import gleam/int
import gleam/io
import gleam/list
import gleam/string
import gleam/pair
import gleam/set.{type Set}
import gleam/option.{Some, None}
import gleam/dict.{type Dict}
import simplifile as file

const example = "
RRRRIICCFF
RRRRIICCCF
VVRRRCCFFF
VVRCCCJFFF
VVVVCJJCFE
VVIVCCJJEE
VVIIICJJEE
MIIIIIJJEE
MIIISIJEEE
MMMISSJEEE
"

pub fn main() {
  let assert Ok(input) = file.read("input")
  let assert 1930 = part1(example)
  let assert 1206 = part2(example)
  part1(input) |> int.to_string |> io.println
  part2(input) |> int.to_string |> io.println
}

type Coord = #(Int, Int)
type Garden = Dict(Coord, String)
type Cost = Dict(Coord, #(Int, Int))

fn parse_input(input: String) -> Garden  {
  input
  |> string.trim
  |> string.split("\n")
  |> list.index_fold(dict.new(), fn(garden, line, x) {
    line
    |> string.to_graphemes
    |> list.index_fold(garden, fn(acc, plot, y) {
      dict.insert(acc, #(x, y), plot)
    })
  })
}

fn fences(garden: Garden, coord: Coord) -> Int {
  let assert Ok(plot) = dict.get(garden, coord)
  let #(x, y) = coord
  [#(x - 1, y), #(x + 1, y), #(x, y - 1), #(x, y + 1)]
  |> list.fold(0, fn(acc, c) {
    case dict.get(garden, c) {
      Ok(neighbor) if neighbor == plot -> acc
      _ -> acc + 1
    }
  })
}

fn explore_region(garden: Garden, coord: Coord, visited: Set(Coord)) -> Set(Coord) {
  let assert Ok(plot) = dict.get(garden, coord)
  let visited = set.insert(visited, coord)
  let #(x, y) = coord
  [#(x - 1, y), #(x + 1, y), #(x, y - 1), #(x, y + 1)]
  |> list.filter(fn(c) { 
    case dict.get(garden, c) {
      Ok(neighbor) if neighbor == plot -> !set.contains(visited, c) 
      _ -> False
    }
  })
  |> list.fold(visited, fn(acc, c) {
    set.union(acc, explore_region(garden, c, acc))
  })
}

fn plot_dimensions(garden: Garden) {
  dict.fold(garden, #(dict.new(), set.new()), fn(acc, coord, _) {
    let #(regions, visited) = acc
    case set.contains(visited, coord) {
      True -> #(regions, visited)
      False -> {
        let region = explore_region(garden, coord, set.new())
        let dimensions =
          set.fold(region, #(0, 0), fn(acc, c) {
            let #(area, perimeter) = acc
            #(area + 1, perimeter + fences(garden, c))
          })
        #(dict.insert(regions, coord, dimensions), set.union(visited, region))
      }
    }
  })
  |> pair.first
}

fn part1(input: String) -> Int {
  input
  |> parse_input()
  |> plot_dimensions()
  |> dict.values()
  |> list.fold(0, fn(acc, dimensions) {
    let #(area, perimeter) = dimensions
    acc + area * perimeter
  })
}

fn corners(region: Set(Coord), coord: Coord) -> Int {
  let #(x, y) = coord
  let top = set.contains(region, #(x - 1, y))
  let bottom = set.contains(region, #(x + 1, y))
  let left = set.contains(region, #(x, y - 1))
  let right = set.contains(region, #(x, y + 1))
  let top_left = set.contains(region, #(x - 1, y - 1))
  let top_right = set.contains(region, #(x - 1, y + 1))
  let bottom_left = set.contains(region, #(x + 1, y - 1))
  let bottom_right = set.contains(region, #(x + 1, y + 1))
  let adjacent = [#(top, right), #(bottom, right), #(bottom, left), #(top, left)]
  let exterior = 
    list.fold(adjacent, 0, fn(count, pair) {
      case pair {
        #(False, False) -> count + 1
        _ -> count
      }
    })
  let interior =
    adjacent
    |> list.zip([top_right, bottom_right, bottom_left, top_left])
    |> list.fold(0, fn(count, pair) {
      case pair {
        #(#(True, True), False) -> count + 1
        _ -> count
      }
    })
  exterior + interior
}

fn plot_shapes(garden: Garden) {
  dict.fold(garden, #(dict.new(), set.new()), fn(acc, coord, plot) {
    let #(regions, visited) = acc
    case set.contains(visited, coord) {
      True -> #(regions, visited)
      False -> {
        let region = explore_region(garden, coord, set.new())
        let dimensions =
          set.fold(region, #(0, 0), fn(acc, c) {
            let #(area, sides) = acc
            #(area + 1, sides + corners(region, c))
          })
        #(dict.insert(regions, coord, dimensions), set.union(visited, region))
      }
    }
  })
  |> pair.first
}

fn part2(input: String) -> Int {
  input
  |> parse_input()
  |> plot_shapes()
  |> dict.values()
  |> list.fold(0, fn(acc, dimensions) {
    let #(area, side) = dimensions
    acc + area * side
  })
}

Advent of Code #11 (in Gleam)

Caleb Weeks — Mon, 10 Mar 2025 04:18:02 +0000

One thing I love about Advent of Code is that as the problems get progressively harder, they require clever tricks or optimizations to come up with the solution. Learning these tricks add useful tools to your collection which you may find helpful in your other programming endeavors. I did not figure out the trick to today's problem on my own. My boss suggested a strategy he was going to try, and even though I beat him to the punch, it was ultimately his hint that got me there.

The wording of the puzzle is deceptive in that it makes you think order needs to be preserved. But the order has no bearing on the final answer, so you can rearrange the items as you see fit. This allows for an optimization where you only keep track of the count of each item. So after making that change to my solution, my code works pretty much the same for both part 1 and part 2:

import gleam/int
import gleam/io
import gleam/list
import gleam/string
import gleam/option.{Some, None}
import gleam/dict.{type Dict}
import simplifile as file

const example = "
125 17
"

pub fn main() {
  let assert Ok(input) = file.read("input")
  let assert 55312 = part1(example)
  part1(input) |> int.to_string |> io.println
  part2(input) |> int.to_string |> io.println
}

type Stones = Dict(String, Int)

fn add_multiple_stones(stones: Stones, stone: String, times: Int) -> Stones {
  dict.upsert(stones, stone, fn(opt) {
    case opt {
      Some(count) -> count + times
      None -> times
    }
  })
}

fn add_stone() { fn(stones, stone) { add_multiple_stones(stones, stone, 1) } }
fn add_stones(times: Int) { fn(stones, stone) { add_multiple_stones(stones, stone, times) } }

fn remove_stones(stones: Stones, stone: String, times: Int) -> Stones {
  dict.upsert(stones, stone, fn(opt) {
    case opt {
      Some(count) -> count - times
      None -> 0
    }
  })
}

fn parse_input(input: String) -> Stones {
  input
  |> string.trim
  |> string.split(" ")
  |> list.fold(dict.new(), add_stone())
}

fn rules(stone: String) -> List(String) {
  case stone {
    "0" -> ["1"]
    s -> case string.length(s) % 2 == 0 {
      True -> {
        let half = string.length(s) / 2
        let assert Ok(first) = string.slice(s, 0, half) |> int.parse()
        let assert Ok(second) = string.slice(s, half, string.length(s)) |> int.parse()
        [int.to_string(first), int.to_string(second)]
      }
      False -> {
        let assert Ok(int) = int.parse(s)
        [int.to_string(int * 2024)]
      }
    }
  }
}

fn blink(stones: Stones, times: Int, max: Int) -> Stones {
  case times < max {
    True -> {
      stones
      |> dict.fold(stones, fn(acc, stone, count) {
        stone
        |> rules()
        |> list.fold(acc, add_stones(count))
        |> remove_stones(stone, count)
      })
      |> blink(times + 1, max)
    }
    False -> stones
  }
}

fn part1(input: String) -> Int {
  input
  |> parse_input()
  |> blink(0, 25)
  |> dict.values()
  |> list.fold(0, int.add)
}

fn part2(input: String) -> Int {
  input
  |> parse_input()
  |> blink(0, 75)
  |> dict.values()
  |> list.fold(0, int.add)
}

Advent of Code #10 (in Gleam)

Caleb Weeks — Mon, 10 Mar 2025 04:07:29 +0000

When posting my solutions to Advent of Code, I try to make it so that if you were to take my code and run it with your input file, you should get the right answers. This doesn't always work out for several reasons. It could be that the input file requires some analysis that is specific to my input file or easier to inspect visually than programmatically. Or I am using code to iterate on some analysis which I track separately, like monitoring the output for patterns.

For day 10, however, it was simply that I was lazy for part 2 and ended up modifying the code for part 1 to quickly come up with a solution. Unfortunately, this means that my code as presented doesn't work for part 1 anymore (or part 2 for that matter, because I think I messed with it trying to get it back to solve part 1). I can't be bothered to fix it now, so here it is in its current broken state:

import gleam/dict.{type Dict}
import gleam/int
import gleam/io
import gleam/list
import gleam/set.{type Set}
import gleam/string
import simplifile as file

const example = "
89010123
78121874
87430965
96549874
45678903
32019012
01329801
10456732
"

pub fn main() {
  let assert Ok(input) = file.read("input")
  // let assert 36 = part1(example)
  let assert 81 = part2(example)
  // part1(input) |> int.to_string |> io.println
  // part2(input) |> int.to_string |> io.println
}

type Coord =
  #(Int, Int)

type Map =
  Dict(Coord, Int)

fn parse_input(input: String) -> Map {
  input
  |> string.trim
  |> string.split("\n")
  |> list.index_fold(dict.new(), fn(map, line, x) {
    line
    |> string.to_graphemes
    |> list.index_fold(map, fn(map, char, y) {
      let assert Ok(height) = int.parse(char)
      dict.insert(map, #(x, y), height)
    })
  })
}

fn next_available(map: Map, coord: Coord, current_height: Int) -> List(Coord) {
  let #(x, y) = coord
  [#(x - 1, y), #(x + 1, y), #(x, y - 1), #(x, y + 1)]
  |> list.filter(fn(coord) {
    case dict.get(map, coord) {
      Ok(height) -> height == current_height + 1
      Error(_) -> False
    }
  })
}

fn walk(
  map: Map,
  routes: List(Coord),
  coord: Coord,
  current_height: Int,
) -> List(Coord) {
  case current_height {
    9 -> [coord]
    _ ->
      map
      |> next_available(coord, current_height)
      |> list.fold(routes, fn(acc, next) {
        walk(map, acc, next, current_height + 1)
      })
  }
}

// fn part1(input: String) -> Int {
//   let map = parse_input(input)
//   map
//   |> dict.filter(fn(_, height) { height == 0 })
//   |> dict.fold(0, fn(count, coord, _) {
//     count + { walk(map, set.new(), coord, 0) |> set.size }
//   })
// }

fn part2(input: String) -> Int {
  let map = parse_input(input)
  map
  |> dict.filter(fn(_, height) { height == 0 })
  |> dict.fold(0, fn(count, coord, _) {
    io.debug(walk(map, [], coord, 0))
    0
  })
  81
}

Advent of Code #9 (in Gleam)

Caleb Weeks — Mon, 10 Mar 2025 03:47:25 +0000

I'm finally getting around to posting my solutions to Advent of Code from last year. The first week, I posted my solutions each day, but I got caught up with other things. So I probably don't really remember my thought process around my solution anymore, but I'll try to add some useful commentary.

Day 9 was pretty fun. I think I actually stopped posting on this day because I felt like my code needed some cleanup first. Whether or not I actually did that cleanup, I don't remember. Looking at it again with fresh eyes, though, it is a little confusing. There is a lot of list manipulation with plenty of list reversals thrown in. The main reason for this approach is to make use of pattern matching to take the first few items off a list. But sometimes I want the first part of the end of the list or the last part of the beginning. So there's a lot of snipping and snapping going on.

I think I liked my approach overall, but the list manipulation is certainly hard to follow. Here it is in all of its glory:

import gleam/int
import gleam/io
import gleam/list
import gleam/string
import gleam/order.{Gt, Eq, Lt}
import simplifile as file

const example = "
2333133121414131402
"

pub fn main() {
  let assert Ok(input) = file.read("input")
  let assert 1928 = part1(example)
  let assert 2858 = part2(example)
  part1(input) |> int.to_string |> io.println
  part2(input) |> int.to_string |> io.println
}

type Block {
  Free(size: Int)
  File(size: Int, id: Int)
}
type Disk = List(Block)

fn parse_input(input: String) -> #(Disk, Int) {
  let #(disk, _, total_free) = 
    input
    |> string.trim
    |> string.to_graphemes
    |> list.index_fold(#([], 0, 0), fn(acc, char, i) {
      let #(blocks, id, total_free) = acc
      let assert Ok(size) = int.parse(char)
      case i % 2 {
        0 -> #([File(size, id), ..blocks], id + 1, total_free)
        _ if size > 0 -> #([Free(size), ..blocks], id, total_free + size)
        _ -> acc
      }
    })
  #(disk, total_free)
}

fn move_file(file: Block, front: Disk) -> Disk {
  let assert File(size, id) = file
  let assert #(files, [Free(available), ..rest]) = list.split_while(front, is_file)
  case int.compare(size, available) {
    Gt -> list.flatten([files, [File(available, id)], rest, [File(size - available, id), Free(available)]])
    Eq -> list.flatten([files, [file], rest, [Free(size)]])
    Lt -> list.flatten([files, [file, Free(available - size)], rest, [Free(size)]])
  }
}

fn is_file(block: Block) -> Bool {
  case block {
    File(_, _) -> True
    Free(_) -> False
  }
}

fn is_free(block: Block) -> Bool { !is_file(block) }

fn merge_free(disk: Disk) -> Disk {
  case disk {
    [Free(s1), Free(s2), ..rest] -> merge_free([Free(s1 + s2), ..rest])
    _ -> disk
  }
}

fn disk_to_string(disk: Disk) -> String {
  list.fold(disk, "", fn(acc, block) {
    case block {
      Free(size) -> acc <> string.repeat(".", size)
      File(size, id) -> acc <> string.repeat(int.to_string(id), size)
    }
  })
}

fn defragment(disk: Disk, total_free: Int) -> Disk {
  case disk {
    [Free(size), ..] if size == total_free -> disk // done
    [File(_, _) as file, ..front] -> 
      file
      |> move_file(list.reverse(front))
      |> list.reverse
      |> merge_free
      |> defragment(total_free)
    [Free(_) as free, File(_, _) as file, ..front] ->
      file
      |> move_file(list.reverse(front))
      |> list.reverse
      |> list.prepend(free)
      |> merge_free
      |> defragment(total_free)
    _ -> disk
  }
}

fn checksum(disk: Disk) -> Int {
  disk
  |> list.reverse
  |> list.flat_map(fn(block) {
    case block {
      File(size, id) -> list.repeat(id, size)
      Free(size) -> list.repeat(0, size)
    }
  })
  |> list.index_fold(0, fn(sum, id, i) { sum + id * i })
}

fn part1(input: String) -> Int {
  let #(disk, total_free) = parse_input(input)
  disk
  |> defragment(total_free)
  |> checksum()
}

fn move_whole_file(file: Block, front: Disk) -> Disk {
  let assert File(size, id) = file
  let free_space = 
    list.split_while(front, fn(block) {
      case block {
        Free(available) if available >= size -> False
        _ -> True
      }
    })
  case free_space {
    #(files, [Free(available), ..rest]) ->
      list.flatten([files, [File(size, id), Free(available - size)], rest, [Free(size)]])
    _ -> list.append(front, [file])
  }
}

fn part2(input: String) -> Int {
  let #(original_disk, _) = parse_input(input)
  original_disk
  |> list.filter(is_file)
  |> list.fold(original_disk, fn(disk, file) {
    let assert #(back, [_, ..front]) = list.split_while(disk, fn(f) { f != file })
    list.flatten([back, list.reverse(move_whole_file(file, list.reverse(front)))])
  })
  |> checksum()
}

Advent of Code #8 (in Gleam)

Caleb Weeks — Sun, 08 Dec 2024 19:04:28 +0000

I'm not particularly proud of my code for today's solution. I could definitely refactor it to reduce a lot of the duplication, but I have a lot of other things going on, so I'm just going to leave it as is. The only other thing I'll mention is that this problem would really benefit from generator functions, list comprehensions, or lazy evaluated ranges, but without those features, I resorted to recursion. I suppose this is an example of where my brain decided that recursion was easier to wrap my head around than fold_until. Anyway, here's the code:

import gleam/int
import gleam/io
import gleam/list
import gleam/string
import gleam/pair
import gleam/set.{type Set}
import gleam/option.{Some, None}
import gleam/dict.{type Dict}
import simplifile as file

const example = "
............
........0...
.....0......
.......0....
....0.......
......A.....
............
............
........A...
.........A..
............
............
"

pub fn main() {
  let assert Ok(input) = file.read("input")
  let assert 14 = part1(example)
  let assert 34 = part2(example)
  part1(input) |> int.to_string |> io.println
  part2(input) |> int.to_string |> io.println
}

type Bounds = #(Int, Int)
type Coord = #(Int, Int)
type Map = Dict(String, List(Coord))

fn parse_input(input: String) -> #(Bounds, Map) {
  input
  |> string.trim
  |> string.split("\n")
  |> list.index_fold(#(#(0, 0), dict.new()), fn(acc, line, x) {
    line
    |> string.to_graphemes
    |> list.index_fold(acc, fn(acc, char, y) {
      let #(_, map) = acc
      let map = 
        dict.upsert(map, char, fn(val) {
          case char, val {
            ".", _ -> []
            _, Some(positions) -> list.append(positions, [#(x, y)])
            _, None -> [#(x, y)]
          }
        })
      #(#(x, y), map)
    })
  })
}

fn in_bounds(bounds: Bounds, coord: Coord) -> Bool {
  let #(x, y) = coord
  let #(max_x, max_y) = bounds
  x >= 0 && x <= max_x && y >= 0 && y <= max_y
}

fn part1(input: String) -> Int {
  let #(bounds, map) = parse_input(input)
  map
  |> dict.fold(set.new(), fn(antinodes, _, positions) {
    positions
    |> list.combination_pairs
    |> list.fold(antinodes, fn(antinodes, pair) {
      let #(x1, y1) = pair.first(pair)
      let #(x2, y2) = pair.second(pair)
      let a1 = #(2 * x1 - x2, 2 * y1 - y2)
      let a2 = #(2 * x2 - x1, 2 * y2 - y1)
      case in_bounds(bounds, a1), in_bounds(bounds, a2) {
        True, True -> antinodes |> set.insert(a1) |> set.insert(a2)
        True, False -> antinodes |> set.insert(a1)
        False, True -> antinodes |> set.insert(a2)
        False, False -> antinodes
      }
    })
  })
  |> set.size
}

fn get_antinodes(bounds: Bounds, pair: #(Coord, Coord)) -> Set(Coord) {
  set.new()
  |> set.insert(pair.first(pair))
  |> set.insert(pair.second(pair))
  |> direction_1(bounds, pair)
  |> direction_2(bounds, pair)
}

fn direction_1(set: Set(Coord), bounds: Bounds, pair: #(Coord, Coord)) -> Set(Coord) {
  let #(x1, y1) = pair.first(pair)
  let #(x2, y2) = pair.second(pair)
  let d1 = #(2 * x1 - x2, 2 * y1 - y2)
  case in_bounds(bounds, d1) {
    True -> set |> set.insert(d1) |> direction_1(bounds, #(d1, #(x1, y1)))
    False -> set
  }
}

fn direction_2(set: Set(Coord), bounds: Bounds, pair: #(Coord, Coord)) -> Set(Coord) {
  let #(x1, y1) = pair.first(pair)
  let #(x2, y2) = pair.second(pair)
  let d2 = #(2 * x2 - x1, 2 * y2 - y1)
  case in_bounds(bounds, d2) {
    True -> set |> set.insert(d2) |> direction_2(bounds, #(#(x2, y2), d2))
    False -> set
  }
}

fn part2(input: String) -> Int {
  let #(bounds, map) = parse_input(input)
  map
  |> dict.fold(set.new(), fn(antinodes, _, positions) {
    positions
    |> list.combination_pairs
    |> list.fold(antinodes, fn(antinodes, pair) {
      set.union(antinodes, get_antinodes(bounds, pair))
    })
  })
  |> set.size
}

Advent of Code #7 (in Gleam)

Caleb Weeks — Sat, 07 Dec 2024 16:16:34 +0000

I really enjoyed today's puzzle. At first glance, it seems pretty complicated, but if you know how to code up a backtracking algorithm, there isn't too much else to it. I refactored my solution to part 1 to make solving part 2 straightforward. It took a while to run, but I didn't have to implement caching to get it to finish in a reasonable time. Well, that's all I have for today:

import gleam/int
import gleam/io
import gleam/list.{Continue, Stop}
import gleam/string
import gleam/result
import simplifile as file

const example = "
190: 10 19
3267: 81 40 27
83: 17 5
156: 15 6
7290: 6 8 6 15
161011: 16 10 13
192: 17 8 14
21037: 9 7 18 13
292: 11 6 16 20
"

pub fn main() {
  let assert Ok(input) = file.read("input")
  let assert 3749 = part1(example)
  let assert 11387 = part2(example)
  part1(input) |> int.to_string |> io.println
  part2(input) |> int.to_string |> io.println
}

fn parse_input(input: String) -> List(#(Int, List(Int))) {
  input
  |> string.trim
  |> string.split("\n")
  |> list.map(fn(line) {
    let assert [result, params] = string.split(line, ":")
    let assert Ok(result) = int.parse(result)
    let params =
      params
      |> string.trim
      |> string.split(" ")
      |> list.map(fn(param) {
        param
        |> int.parse
        |> result.unwrap(0)
      })
    #(result, params)
  })
}

type EquationResult {
  Solvable
  Unsolvable
}

fn solve_equation(result: Int, params: List(Int), operators: List(fn(Int, Int) -> Int)) -> EquationResult {
  case params {
    [a] if a == result -> Solvable
    [a] -> Unsolvable
    [a, b, ..rest] -> {
      list.fold_until(operators, Unsolvable, fn(solvable, op) {
        case solve_equation(result, [op(a, b), ..rest], operators) {
          Unsolvable -> Continue(solvable)
          Solvable -> Stop(Solvable)
        }
      })
    }
    _ -> Unsolvable
  }
}

fn calibration_result(input: String, operators: List(fn(Int, Int) -> Int)) -> Int {
  input
  |> parse_input
  |> list.fold(0, fn(count, equation) {
    let #(result, params) = equation
    case solve_equation(result, params, operators) {
      Solvable -> count + result 
      Unsolvable -> count
    }
  })
}

fn part1(input: String) -> Int {
  calibration_result(input, [int.multiply, int.add])
}

fn concat(a: Int, b: Int) -> Int {
  int.to_string(a)
  |> string.append(int.to_string(b))
  |> int.parse
  |> result.unwrap(0)
}

fn part2(input: String) -> Int {
  calibration_result(input, [int.multiply, int.add, concat])
}

Advent of Code #6 (in Gleam)

Caleb Weeks — Fri, 06 Dec 2024 19:23:11 +0000

Today was the first day I decided not to stay up to solve the puzzles right as they come out. Where I live, the puzzles come out at midnight, and for the first few days, I'm usually pretty confident that I can knock out a solution in about half an hour to an hour.

This puzzle was definitely a step up, particularly for part 2. It was the first time this year where I submitted a wrong answer and the first time I had to wait more than a second for the code to run. But I haven't had to reach for any advanced techniques yet. My solution is still pretty much the most straightforward approach.

Typically, these sorts of puzzles where you have to check a lot of things will start to benefit from divide and conquer techniques, caching strategies, or analytical approaches. The one 'optimization' I applied is I only tried placing new barriers along the standard route, but this is only a reduction of about 75% of the search space, which isn't really the defining dimension of the problem.

The other thing I did differently in this solution compared to previous solutions is using types and records. This helped me keep track in my head of the different pieces of data, and provides a nicer interface for pattern matching and accessing record fields. Here's my solution:

import gleam/int
import gleam/io
import gleam/list
import gleam/string
import gleam/result
import gleam/option
import gleam/set.{type Set}
import gleam/dict.{type Dict, insert}
import simplifile as file

const example = "
....#.....
.........#
..........
..#.......
.......#..
..........
.#..^.....
........#.
#.........
......#...
"

pub fn main() {
  let assert Ok(input) = file.read("input")
  let assert 41 = part1(example)
  let assert 6 = part2(example)
  part1(input) |> int.to_string |> io.println
  part2(input) |> int.to_string |> io.println
}

type Coord = #(Int, Int)
type Direction {
  Up
  Down
  Left
  Right
}
type Guard {
  Guard(position: Coord, direction: Direction)
}
type Space {
  Blank
  Barrier
}
type Map = Dict(Coord, Space)

fn parse_input(input: String) -> #(Map, Guard) {
  input
  |> string.trim
  |> string.split("\n")
  |> list.index_fold(#(dict.new(), Guard(#(0, 0), Up)), fn(init, line, x) {
    line
    |> string.to_graphemes
    |> list.index_fold(init, fn(init, char, y) {
      let #(map, start) = init
      case char {
        "." -> #(insert(map, #(x, y), Blank), start)
        "#" -> #(insert(map, #(x, y), Barrier), start)
        "^" -> #(insert(map, #(x, y), Blank), Guard(#(x, y), Up))
        "v" -> #(insert(map, #(x, y), Blank), Guard(#(x, y), Down))
        ">" -> #(insert(map, #(x, y), Blank), Guard(#(x, y), Right))
        "<" -> #(insert(map, #(x, y), Blank), Guard(#(x, y), Left))
        _ -> init
      }
    })
  })
}

fn rotate(guard: Guard) -> Guard {
  case guard {
    Guard(position, Up) -> Guard(position, Right)
    Guard(position, Right) -> Guard(position, Down)
    Guard(position, Down) -> Guard(position, Left)
    Guard(position, Left) -> Guard(position, Up)
  }
}

fn move(map: Map, guard: Guard) -> Result(Guard, Nil) {
  let Guard(#(x, y), direction) = guard
  let next_position = case direction {
    Up -> #(x - 1, y)
    Down -> #(x + 1, y)
    Left -> #(x, y - 1)
    Right -> #(x, y + 1)
  }

  map
  |> dict.get(next_position)
  |> result.map(fn(space) {
    case space {
      Blank -> Guard(next_position, direction)
      Barrier -> rotate(guard)
    }
  })
}

fn standard_route(visited: Set(Coord), map: Map, guard: Guard) -> Set(Coord) {
  case move(map, guard) {
    Ok(guard) -> standard_route(set.insert(visited, guard.position), map, guard)
    _ -> visited
  }
}

fn part1(input: String) -> Int {
  let #(map, start) = parse_input(input)
  set.new()
  |> set.insert(start.position)
  |> standard_route(map, start)
  |> set.size
}

type Route {
  Exit
  Loop
}

fn route(visited: Set(Guard), map: Map, guard: Guard) -> Route {
  case move(map, guard) {
    Ok(guard) ->
      case set.contains(visited, guard) {
        True -> Loop
        False -> route(set.insert(visited, guard), map, guard)
      }
    _ -> Exit
  }
}

fn part2(input: String) -> Int {
  let #(map, start) = parse_input(input)

  set.new()
  |> set.delete(start.position)
  |> standard_route(map, start)
  |> set.fold(0, fn(count, coord) {
    let new_map = 
      map
      |> dict.upsert(coord, fn(space) {
        space
        |> option.map(fn(_) { Barrier })
        |> option.unwrap(Blank)
      })
    case route(set.new(), new_map, start) {
      Loop -> count + 1
      Exit -> count
    }
  })
}