## Source: Blizzard Basin

## Part 1

Given a map with a series of moving walls (that wrap when the hit the edges of the simulation), calculate the fastest route from the top left to the bottom right.

Given a map with a series of moving walls (that wrap when the hit the edges of the simulation), calculate the fastest route from the top left to the bottom right.

Implement a cellular automaton with the following rules:

- If you have no neighbors, don’t move (
*important, I forgot this one for a while*) - Otherwise:
- Calculate a potential move:
- If you have no neighbors to the north, move north
- If not, check likewise for south, then west, than east

- If no other agent is moving to the same space, move to your potential move
- Otherwise, don’t move

- Calculate a potential move:
- On each frame, rotate the order the directions are checked in (
`NSWE`

,`SWEN`

,`WENS`

,`ENSW`

,`NSWE`

, …)

Given a map and a series of instructions formatted as distance + turn (

`L`

or`R`

), find the final position. Any time you would walk off the edge of the map, wrap to the opposite edge.

Given a series of equations of either the form

`dbpl: 5`

or`cczh: sllz + lgvd`

, determine what the value of the node labeled`root`

is.

Given a series of walls as input, run a falling sand simulation until any new sand falls of the map. Count how many grains of sand we end up with.

Given a grid of numbers, count how many of these numbers have a direct path in any cardinal direction to the edge of the grid.

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:

#..# …. …. #..#

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: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 zero

In 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?

Part 1:Create a 128x128 grid. Generate each row by taking the knot hash of`salt-{index}`

. The bits of the hash represent if a tile in the grid is`free`

(`0`

) or`used`

(`1`

).

Given your salt as input, how many squares are

`used`

?