As I did with last year / yesterday, I’ve written up a series of posts for the Advent of Code 2017 problems. Again, I didn’t manage to write them up as I did them, but this time around I least I finished mostly on time.

As I did with last year / yesterday, I’ve written up a series of posts for the Advent of Code 2017 problems. Again, I didn’t manage to write them up as I did them, but this time around I least I finished mostly on time.

As I did last year, I’m going to solve the Advent of Code problems again this year.

Or that was the plan. It turns out that instead I put down my blog for almost a year and a half and never quite got around to doing these problems. So I’m actually backdating these posts from the early days of 2018 to where they would have been had I solved them on time. They’re still interesting problems, so give them a read.

Part 1:Implement a Turing machine defined as such:`Begin in state A. Perform a diagnostic checksum after 6 steps. In state A: If the current value is 0: - Write the value 1. - Move one slot to the right. - Continue with state B. If the current value is 1: - Write the value 0. - Move one slot to the left. - Continue with state B. ...`

What is the final number of

`1s`

on the tape?

Part 1:Given a series of reversible components of the form`3/4`

(can connect a`3`

on one end to a`4`

on the other), form a bridge of components. The bridge’s strength is equal to the sum of component values. So`0/3, 3/7, and 7/4`

has a strength of`0+3 + 3+7 + 7+4 = 24`

.What is the strongest possible bridge?

Part 1:Create a variation of the previous DuetVM with only the following four instructions:

`set X Y`

sets register`X`

to`Y`

`sub X Y`

set register`X`

to`X - Y`

`mul X Y`

sets register`X`

to`X * Y`

`jnz X Y`

jumps with an offset of the value of`Y`

, iff`X`

is not equal to zeroIf you run the given program, how many times is

`mul`

invoked?

Part 1:Implement a cellular automaton on an infinite grid of`.`

and`#`

pixels such that:

- Start at
`(0, 0)`

, facing`Up`

- Repeat:

- If the cursor is on
`.`

swap it to`#`

and turn`Left`

- If the cursor is on
`#`

swap it to`.`

and turn`Right`

- Either way, after turning, move forward once
After 10,000 iterations, how many pixels were turned from

`.`

to`#`

?

Part 1:Start with an input image made of`.`

and`#`

pixels. For`n`

iterations, break the image into blocks:

- If the current size is even, break the image into 2x2 chunks and replace each with a 3x3 chunk
- If the current size is odd, break the image into 3x3 chunks and replace each with a 4x4 chunk
The replacement rules will be specified in the following format (example is a 3x3 -> 4x4 rule):

`.#./..#/### => #..#/..../..../#..#`

In that example, replace this:

`.#. ..# ###`

With this:

`#..# .... .... #..#`

Any rotation or reflection of a chunk can be used to match the input of a replacement rule.

After

`n = 18`

iterations, how many`#`

pixels are there?

Part 1:Given the initial position, velocity, and acceleration of a large number of particles, which particle will stay the closet to the origin as the simulation runs to infinity?

Part 1:Take a network diagram of the following form:`| | +--+ A | C F---|--|-E---+ | | | D +B-+ +--+`

Starting at the single node at the top and following the lines, what order would the nodes be visited in?

Part 1:Create a virtual machine with the following instruction set:

`snd X`

plays a sound with a frequency equal to the value of`X`

`set X Y`

sets register`X`

to`Y`

`add X Y`

set register`X`

to`X + Y`

`mul X Y`

sets register`X`

to`X * Y`

`mod X Y`

sets register`X`

to`X mod Y`

`rcv X`

recovers the frequency of the last sound played, if`X`

is not zero`jgz X Y`

jumps with an offset of the value of`Y`

, iff`X`

is greater than zeroIn most cases,

`X`

and`Y`

can be either an integer value or a register.What is the value recovered by

`rcv`

the first time`X`

is non-zero?