Advent of Code 2016 Day 12
Part 1
- Thank goodness: no reliance on Day 11
- Assembly code: Round...?
- Writing my working algorithm
Thank goodness: no reliance on Day 11
- I failed to solve any parts of Day 11
- That worried me coming in to Day 12
Thankfully, Day 12 is yet another...
Assembly code: Round...?
- I'm probably remembering incorrectly, but it seems like every year - except 2021 - featured at least one assembly-code-themed puzzle
This feels like an easier one:
- store and update numbers in registers
- jump conditionally
- end when a pointer is out of bounds
- return the value stored in a particular register
I'm off to write the same algorithm for what feels like the third or fourth time...
Writing my working algorithm
Extracting each line's opcodes and operands:
Split the input at each newline character into an array of strings
For each string
Split the string at each space character into an array of two or three strings, saved as op, x and y
If y contains a value (meaning there were three strings)
Construct a three-element array containing the opcode string, and either a string or number for x and y
Else, if y is empty (meaning there were two strings)
Construct a two-element array containing the opcode string, and either a string or number for x
This is the JavaScript I wrote:
input.split('\n').map(line => {
let [op, x, y] = line.split(' ')
if (y) {
return [op, isNaN(x) ? x : +x, isNaN(y) ? y : +y]
} else {
return [op, isNaN(x) ? x : +x]
}
})
More setup:
Set pointer to 0 so it starts reading at the first instruction
Set registers as an object with four keys, a-d, each with 0 as a value
The dictionary of opcode functions:
cpy(x,y) {
registers[y] = (typeof x == 'string') ? registers[x] : x;
pointer++
},
inc(x) {
registers[x]++
pointer++
},
dec(x) {
registers[x]--
pointer++
},
jnz(x,y) {
registers[x] !== 0 ? pointer += y : pointer++
}
The main loop:
Do as long as pointer contains a number that could refer to an index within the bounds of the list of instructions
Invoke the appropriate function in the dictionary of opcodes, passing as arguments the second value in the instruction and the third...even if there is no third value
while (pointer >= 0 && pointer < rules.length) {
opcodes[rules[pointer][0]](
rules[pointer][1], rules[pointer][2]
)
}
Two mistakes I made while writing the code above:
- I forgot to increment
pointer
in the three non-jnz
functions - I wrote
rules[pointer[1]]
instead ofrules[pointer][1]
, confusing the program into expecting some property1
to exist on the number stored inpointer
After correcting those errors, the program ran and generated the correct answer as expected!
Part 2
- Let me guess...a performance test?
- Thankfully, it finishes in a few seconds
Let me guess...a performance test?
- It seems like a simple task: change
c
to start as1
, then re-run - In prior puzzles, changing a register's starting value caused the program to run exponentially longer...seemingly forever!
- Will that be the case here?
Thankfully, it finishes in a few seconds
- Seven seconds, to be exact - not great
- register
a
contains a number over 9 million - in Part 1 it ended containing a number just over 300 thousand - I don't care enough to inspect what causes the long runtime - I tried doing that in prior puzzles and it never helped me solve the puzzle
- I'm just glad it finished in under a minute and generated the correct answer!
I did it!!
- I solved both parts!
- I sadly stumbled over the same mistakes I made in previous attempts: array look-up and pointer incrementing!
- I feel prepared to attempt Part 1 of Day 23!
After solving today's puzzle and returning to the main map, I was delighted to see this animation playing:
Top comments (0)