2025

Day 1 Day 2 Day 3 Day 4 Day 5 Day 6 Day 7 Day 8 Day 9 Day 10 Day 11 Day 12

R

— R Day 11 Part 1 —

solve_day11_part1 <- function(input) {
  first_key <- "you"
  last_key <- "out"

  devices <- stringi::stri_extract_all_regex(input, r"{.+?(?=:)}")
  outputs <- stringi::stri_extract_all_regex(input, r"{(?<= )\w+}")
  n_devices <- length(input)

  # visited <- new.env(parent = emptyenv(), size = n_devices)
  queue <- vector("list", n_devices)
  queue_last <- queue_first <- 1L
  queue[[queue_last]] <- first_key

  path_count <- 0L

  while (queue_first <= length(queue)) {
    device <- queue[[queue_first]]
    pos <- which(devices == device)

    if (identical(device, "out")) {
      path_count <- path_count + 1L
    } else {
      next_devices <- outputs[[pos]]
      next_in_queue <- queue_last + seq_along(next_devices)
      queue[next_in_queue] <- next_devices
      queue_last <- queue_last + length(next_devices)
    }

    queue_first <- queue_first + 1L
  }

  path_count
}

aoc_source(day = 11, part = 1)

input = aoc_read(day = 11)

aoc_run(solve_day11_part1(input))

Elapsed: 0.026 seconds
Memory:  17414 KB

— R Day 11 Part 2 —

solve_day11_part2 <- function(input) {
  lookup <- stringi::stri_extract_all_regex(input, r"{(?<= )\w+}")
  names(lookup) <- stringi::stri_extract_all_regex(input, r"{.+?(?=:)}")
  n_devices <- length(input)

  prod(
    count_paths("svr", "fft", lookup),
    count_paths("fft", "dac", lookup),
    count_paths("dac", "out", lookup)
  )
}

count_paths <- function(from, to, lookup) {
  if (from == to) return(1L)
  if (from == "out") return(0L)

  next_nodes <- lookup[[from]]

  dfs <- vapply(
    next_nodes,
    \(node) count_paths(node, to, lookup),
    integer(1)
  )

  sum(dfs)
}

# the golden ticket
count_paths <- memoise::memoise(count_paths)

aoc_source(day = 11, part = 2)

input = aoc_read(day = 11)

aoc_run(solve_day11_part2(input))

Elapsed: 0.008 seconds
Memory:  32573 KB

Python

— Python Day 11 Part 1 —

def solve_day11_part1(text):
    first = "you"
    last = "out"

    keys = [line[:3] for line in text]
    outs = [line[4:].split() for line in text]
    devices = dict(zip(keys, outs))

    return(search(first, last, devices))

def search(first, last, devices):
    if first == last:
        return(1)

    next_devices = devices[first]
    paths = [search(next, last, devices) for next in next_devices]

    return(sum(paths))

aoc_source(day = 11, part = 1)

input = aoc_read(day = 11)

result = aoc_run("solve_day11_part1(input)")

Elapsed: < 0.001 seconds
Memory:  265 KB

— Python Day 11 Part 2 —

def solve_day11_part2(text):
    keys = [line[:3] for line in text]
    outs = [line[4:].split() for line in text]
    devices = dict(zip(keys, outs))

    svr = search("svr", "fft", devices)
    fft = search("fft", "dac", devices)
    dac = search("dac", "out", devices)

    return(svr * fft * dac)

def search(first, last, devices):
    curr_layer = {first:1}
    last_count = 0

    while len(curr_layer) > 0:
        next_layer = {}

        for dev in curr_layer:
            curr_count = curr_layer[dev]
            if dev == last:
                last_count += curr_count
                continue

            if dev == "out":
                continue

            next_devs = devices[dev]

            for next_dev in next_devs:
                if next_dev in next_layer:
                    next_layer[next_dev] += curr_count
                else:
                    next_layer[next_dev] = curr_count

        curr_layer = next_layer


    return(last_count)

aoc_source(day = 11, part = 2)

input = aoc_read(day = 11)

result = aoc_run("solve_day11_part2(input)")

Elapsed: < 0.001 seconds
Memory:  287 KB