## DEV Community # A Maze of Twisty Trampolines, All Alike

## Part 1

1. This seems very familiar...
2. Writing my working algorithm

### This seems very familiar...

• Jumps? Been there, done that!
• Terminate when outside the list boundary? Ditto!
• Increment the current instruction's value by 1 before jumping? That's a fun twist!

### Writing my working algorithm

``````Split the input at each newline character into an array of strings
Coerce each string to a number
Set pointer to 0
Set steps to 0
Do as long as pointer references an index within the bounds of the array of jumps
Save the number of the current jump instruction
Increment that number by 1
Update pointer to the sum of pointer and the prior number of the current jump instruction
Increment steps by 1
Return steps
``````

In JavaScript, I wrote this concise program:

``````let jumps = input.split('\n').map(Number)
const part1 = () => {
let pointer = 0, steps = 0
while (pointer >= 0 && pointer < jumps.length) {
pointer += jumps[pointer]++
steps++
}
return steps
}
``````

Running on both the example input and my puzzle input generated the expected and correct answers!

## Part 2

1. The twist is...not that difficult
2. Updating my working algorithm

### The twist is...not that difficult

It seems like I'll now need a condition when updating the value at pointer before updating pointer.

### Updating my working algorithm

``````Split the input at each newline character into an array of strings
Coerce each string to a number
Set pointer to 0
Set steps to 0
Do as long as pointer references an index within the bounds of the array of jumps
Save the number of the current jump instruction
If that number is 3 or more
Decrement that number by 1
Else
Increment that number by 1
Update pointer to the sum of pointer and the prior number of the current jump instruction
Increment steps by 1
Return steps
``````

Running on the example input generated the wrong answer!

What's happening?

Oh...I see:

• I mistakenly put my statement that generated the list of jumps outside each of my `part1` and `part2` functions
• So, my `part2` function was operating on a pre-processed list of jumps
• Silly me...but also not the first time that's happened

After moving that statement into each function and re-running:

• Running on both the example input and my puzzle input generated the expected and correct answers!

In JavaScript, I wrote this nearly identical, concise program:

``````const part2 = () => {
let jumps = input.split('\n').map(Number)
let pointer = 0, steps = 0
while (pointer >= 0 && pointer < jumps.length) {
pointer += jumps[pointer] >= 3 ? jumps[pointer]-- : jumps[pointer]++
steps++
}
return steps
}
``````

## I did it!!

• I solved both parts!
• I implemented my Part 1 algorithm exactly as outlined in pseudocode in this article, which made writing it feel super easy!
• I was surprisingly disappointed - and perhaps grateful? - by the lack of difficulty of Part 2 relative to Part 1!
• I'm now two stars away from matching my personal best star score for a given year!