`start`

to `end`

such that nodes named with lowercase letters are visited once, and nodes with uppercase letters can be visited any number of times.

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:Start with a circular buffer containing`[0]`

and`current_position = 0`

. For`n`

from`1`

up to`2017`

:

- Step forward
`steps`

(puzzle input)- Input the next value for
`n`

, set`current_position`

to`n`

, increment`n`

- Repeat

What is the value after 2017?

It’s a bit weird to describe, but the given example helps (assume `steps = 3`

):

```
(0)
0 (1)
0 (2) 1
0 2 (3) 1
0 2 (4) 3 1
0 (5) 2 4 3 1
0 5 2 4 3 (6) 1
0 5 (7) 2 4 3 6 1
0 5 7 2 4 3 (8) 6 1
0 (9) 5 7 2 4 3 8 6 1
```

Part 1:Running on the string`a...p`

apply a series of the following commands:

`sX`

rotates the string right by`X`

positions`xX/Y`

swaps positions`X`

and`Y`

`pA/B`

swaps the letters`A`

and`B`

no matter their positions

Part 1:Input will be a list of the following form:

- The first floor contains a hydrogen-compatible microchip and a lithium-compatible microchip.
- The second floor contains a hydrogen generator.
- The third floor contains a lithium generator.
- The fourth floor contains nothing relevant.

You have an elevator that can move exactly 1 or 2 items. You can only leave a microchip on a floor with a non-matching generator if a matching generator is also present.

Move all items to the top (4th) floor.

Inspired half by a post on the Code Golf StackExchange and half by the corresponding website allrgb.com, today’s post tasks us with making images like this:

So what’s so interesting about that picture?

Today’s task comes from the Code Golf StackExchange. The idea behind code golf is to write a program with as few characters as possible, often rendering the code nigh on unreadable. Luckily, the same StackExchange also host popularity contests, one of which is the inspiration behind today’s post:

You are given two true color images, the Source and the Palette. They do not necessarily have the same dimensions but it is guaranteed that their areas are the same, i.e. they have the same number of pixels. Your task is to create an algorithm that makes the most accurate looking copy of the Source by only using the pixels in the Palette. Each pixel in the Palette must be used exactly once in a unique position in this copy. The copy must have the same dimensions as the Source. – American Gothic in the palette of Mona Lisa: Rearrange the pixels

Last Thursday I wrote a post about generating Perlin/simplex noise in Racket. Later that day, I posted to the Racket mailing list asking how I could make it faster. What resulted was a whole sequence of responses (primarily about Typed Racket) and a bit of a rabbit hole that I’m still trying to wrap my head around.