Advent of Code #13 (in Gleam)

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) }) }

Mar 10, 2025 - 06:08

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)
  })
}