progress.yaml

@@ -44,7 +44,3 @@
   stars: 1
 23:
   stars: 2
-24:
-  stars: 1
-25:
-  stars: 1

res/examples/day24_1.txt

@@ -1,10 +0,0 @@
-x00: 1
-x01: 1
-x02: 1
-y00: 0
-y01: 1
-y02: 0
-
-x00 AND y00 -> z00
-x01 XOR y01 -> z01
-x02 OR y02 -> z02

res/examples/day24_2.txt

@@ -1,47 +0,0 @@
-x00: 1
-x01: 0
-x02: 1
-x03: 1
-x04: 0
-y00: 1
-y01: 1
-y02: 1
-y03: 1
-y04: 1
-
-ntg XOR fgs -> mjb
-y02 OR x01 -> tnw
-kwq OR kpj -> z05
-x00 OR x03 -> fst
-tgd XOR rvg -> z01
-vdt OR tnw -> bfw
-bfw AND frj -> z10
-ffh OR nrd -> bqk
-y00 AND y03 -> djm
-y03 OR y00 -> psh
-bqk OR frj -> z08
-tnw OR fst -> frj
-gnj AND tgd -> z11
-bfw XOR mjb -> z00
-x03 OR x00 -> vdt
-gnj AND wpb -> z02
-x04 AND y00 -> kjc
-djm OR pbm -> qhw
-nrd AND vdt -> hwm
-kjc AND fst -> rvg
-y04 OR y02 -> fgs
-y01 AND x02 -> pbm
-ntg OR kjc -> kwq
-psh XOR fgs -> tgd
-qhw XOR tgd -> z09
-pbm OR djm -> kpj
-x03 XOR y03 -> ffh
-x00 XOR y04 -> ntg
-bfw OR bqk -> z06
-nrd XOR fgs -> wpb
-frj XOR qhw -> z04
-bqk OR frj -> z07
-y03 OR x01 -> nrd
-hwm AND bqk -> z03
-tgd XOR rvg -> z12
-tnw OR pbm -> gnj

res/examples/day25.txt

@@ -1,39 +0,0 @@
-#####
-.####
-.####
-.####
-.#.#.
-.#...
-.....
-
-#####
-##.##
-.#.##
-...##
-...#.
-...#.
-.....
-
-.....
-#....
-#....
-#...#
-#.#.#
-#.###
-#####
-
-.....
-.....
-#.#..
-###..
-###.#
-###.#
-#####
-
-.....
-.....
-.....
-#....
-#.#..
-#.#.#
-#####

src/day23/puzzle2.typ

@@ -33,45 +33,6 @@
   return longest
 }
 
-#let bron-kerbosch2(links, R, P, X) = {
-  if P.len() == 0 and X.len() == 0 {
-    return if R.len() > 2 {
-      R.sorted()
-    } else {
-      none
-    }
-  }
-
-  let pivot = if P.len() != 0 {
-    P.first()
-  } else {
-    X.first()
-  }
-  let pivot-neighbors = links.at(pivot)
-  let longest-len = 0
-  let longest = none
-  let to-visit = P.filter(n => n not in pivot-neighbors)
-  for v in to-visit {
-    let neighbors = links.at(v)
-    let clique = bron-kerbosch2(
-      links,
-      R + (v,),
-      P.filter(n => n in neighbors),
-      X.filter(n => n in neighbors)
-    )
-    if clique != none {
-      let l = clique.len()
-      if longest == none or l > longest-len {
-        longest = clique
-        longest-len = l
-      }
-    }
-    let _ = P.remove(P.position(n => n == v))
-    X.push(v)
-  }
-  return longest
-}
-
 #let solve(input) = {
   let links = input.split("\n")
 
@@ -90,7 +51,7 @@
     links-dict.at(b).push(a)
   }
 
-  let clique = bron-kerbosch2(links-dict, (), links-dict.keys(), ())
+  let clique = bron-kerbosch(links-dict, (), links-dict.keys(), ())
 
   return clique.join(",")
 }

src/day24/puzzle1.typ

@@ -1,78 +0,0 @@
-#import "/src/utils.typ": *
-
-#let solve(input) = {
-  let (inputs, gates) = input.split("\n\n")
-  let ids = ()
-  inputs = inputs.split("\n").map(i => {
-    let (id, value) = i.split(": ")
-    return (id: id, value: value == "1")
-  })
-  ids += inputs.map(i => i.id)
-  gates = gates.split("\n").map(g => {
-    let (gate, output) = g.split(" -> ")
-    let (i1, op, i2) = gate.split(" ")
-    return (
-      in1: i1,
-      in2: i2,
-      op: op,
-      out: output
-    )
-  })
-  let gates-by-id = (:)
-  for gate in gates {
-    gates-by-id.insert(gate.out, gate)
-  }
-
-  ids += gates.map(g => g.out)
-  ids = ids.dedup()
-  let dbg = (inputs, gates)
-
-  let values = (:)
-  for input in inputs {
-    values.insert(input.id, input.value)
-  }
-
-  let stack = ids.filter(id => id.starts-with("z"))
-  let output = (0,) * stack.len()
-  while stack.len() != 0 {
-    let v = stack.pop()
-    if v in values {
-      if v.starts-with("z") {
-        let i = int(v.slice(1))
-        output.at(i) = int(values.at(v))
-      }
-    } else {
-      stack.push(v)
-      let gate = gates-by-id.at(v)
-      if gate.in1 in values and gate.in2 in values {
-        let v1 = values.at(gate.in1)
-        let v2 = values.at(gate.in2)
-        let value = if gate.op == "AND" {
-          v1 and v2
-        } else if gate.op == "OR" {
-          v1 or v2
-        } else if gate.op == "XOR" {
-          (v1 or v2) and not (v1 and v2)
-        }
-        values.insert(v, value)
-      } else {
-        stack.push(gate.in1)
-        stack.push(gate.in2)
-      }
-    }
-  }
-
-  let result = output.rev()
-                     .fold(0, (a, b) => a.bit-lshift(1).bit-or(b))
-
-  return result
-}
-
-#show-puzzle(
-  24, 1,
-  solve,
-  example: (
-    "1": 4,
-    "2": 2024
-  )
-)

src/day25/puzzle1.typ

@@ -1,61 +0,0 @@
-#import "/src/utils.typ": *
-
-#let parse-schematic(schematic) = {
-  let lines = schematic.split("\n")
-  let is-key = "." in schematic.first()
-
-  let n-cols = lines.first().len()
-  let n-rows = lines.len()
-  let heights = ()
-
-  for x in range(n-cols) {
-    let y = if is-key {n-rows - 2} else {1}
-    let h = 0
-    for i in range(n-rows) {
-      if lines.at(y).at(x) == "." {
-        break
-      }
-      h += 1
-      y += if is-key {-1} else {1}
-    }
-    heights.push(h)
-  }
-
-  return (if is-key {"key"} else {"lock"}, heights)
-}
-
-#let fits(lock, key) = {
-  let tmp = lock.zip(key).map(p => p.sum())
-  return calc.max(..tmp) <= 5
-}
-
-#let solve(input) = {
-  let schematics = input.split("\n\n")
-
-  let locks = ()
-  let keys = ()
-  for schematic in schematics {
-    let (type, heights) = parse-schematic(schematic)
-    if type == "key" {
-      keys.push(heights)
-    } else {
-      locks.push(heights)
-    }
-  }
-  let total = 0
-  for key in keys {
-    for lock in locks {
-      if fits(lock, key) {
-        total += 1
-      }
-    }
-  }
-
-  return total
-}
-
-#show-puzzle(
-  25, 1,
-  solve,
-  example: 3
-)