— Day 19: A Series of Tubes —

See more puzzles

Advent of Code

Session information

sessionInfo()

Brief

Somehow, a network packet got lost and ended up here. It’s trying to follow a routing diagram (your puzzle input), but it’s confused about where to go.

Its starting point is just off the top of the diagram. Lines (drawn with |, -, and +) show the path it needs to take, starting by going down onto the only line connected to the top of the diagram. It needs to follow this path until it reaches the end (located somewhere within the diagram) and stop there.

Sometimes, the lines cross over each other; in these cases, it needs to continue going the same direction, and only turn left or right when there’s no other option. In addition, someone has left letters on the line; these also don’t change its direction, but it can use them to keep track of where it’s been. For example:

     |          
     |  +--+    
     A  |  C    
 F---|----E|--+ 
     |  |  |  D 
     +B-+  +--+ 

Given this diagram, the packet needs to take the following path:

Starting at the only line touching the top of the diagram, it must go down, pass through A, and continue onward to the first +.

Travel right, up, and right, passing through B in the process.

Continue down (collecting C), right, and up (collecting D).

Finally, go all the way left through E and stopping at F.

Following the path to the end, the letters it sees on its path are ABCDEF.

The little packet looks up at you, hoping you can help it find the way. What letters will it see (in the order it would see them) if it follows the path? (The routing diagram is very wide; make sure you view it without line wrapping.)

Let’s go

Packages & functions

library(tidyverse)
library(testthat)
library(aocodeR)

Input

input <- aoc_get_input(day = 19, cookie_path = paste0(rprojroot::find_rstudio_root_file(),
                                                 "/secrets/session_cookie.txt")) %>% 
    strsplit(., "\n") %>% unlist
input %>% head()

[1] "|                                                                                                                             "                                                                           
[2] "     +-+         +---+   +---+   +-----------------------------------------|---+                                             +---+ +-------------------------------------+         +-------------------+ "
[3] "     | |         |   |   |   |   |                                         |   |                                             |   | |                                     |         |                   | "
[4] " +-------------------|-------|-------------+                           +---|-------------------------------+                 |   +---------------------------------+     |         |                   | "
[5] " |   | |         |   |   |   |   |         |                           |   |   |                           |                 |     |                               |     |         |                   | "
[6] " |   | |         |   +---|---|---|---------|---------------------+     |   |   |                           |                 |     |   +---+                       |     |         |                   | "

Functions

library(prodlim)
input_to_m <- function(input){
    m_i <- input %>% strsplit(., numeric()) %>% map(~ pad_row(.x)) %>% do.call("rbind", .)
    m <- matrix(" ", nrow = nrow(m_i) + 2, ncol = ncol(m_i) + 2)
    m[2:(1 + nrow(m_i)), 2:(1 + ncol(m_i))] <- m_i
    m
}
pad_row <- function(x){
    if(length(x) < 201){
        p <- rep(" ", 201 - length(x))
        if(x[1] != " "){x <- c(p, x)}else{
            x <- c(x, p) 
        }
    }
    x
}
start <- function(m) {
  mv$loc <- c(2, which(m[2,] == "|")) 
  mv$move <- c(1, 0)
  mv$trace <- NULL
  mv$end <- F
  mv$moves <- 1
}
move <- function(m, return = "trace") {
    next_loc <- mv$loc + mv$move
    next_val <- m[next_loc[1], next_loc[2]]
    
    while(next_val != " ") {
        if(grepl("[A-Z]", next_val)){
            mv$trace <- paste0(mv$trace, next_val)
        }
        mv$loc <- next_loc
        next_loc <- next_loc + mv$move
        mv$moves <- mv$moves + 1
        next_val <- m[next_loc[1], next_loc[2]]
    }
    scan_next(m)
    if(mv$end){return(mv[[return]])}else{move(m, return)}
}
scan_next <- function(m){
    moves <- matrix(c(0,0,-1,1, -1,1,0,0), ncol = 2)
    scan_locs <- moves[-prodlim::row.match(mv$move * -1, moves),]
    r <- which(m[t(t(scan_locs) + mv$loc)] != " ")
    if(length(r) == 0){mv$end <- T
    }else{
        mv$move <- scan_locs[r,]}
}

deploy

m <- input_to_m(input)
mv <- new.env(parent = emptyenv())
start(m)
move(m)

[1] "DTOUFARJQ"

Success!

---

—- Part 2 —-

Brief

Let’s go

Test

#expect_equal(,)

deploy

m <- input_to_m(input)
mv <- new.env(parent = emptyenv())
start(m)
move(m, return = "moves")

[1] 16642

Success!

---

template based on the workflowr standalone template