Robert Mion

Posted on

# Wait For It

## Advent of Code 2023 Day 6

### Part 1

#### Seeing the bell curve in the bullet points

``````Btn.
----------------------------------------|
7 -                     .               |
6                   -   .               |
5                       .       X       |
4                       .             X |
3                       .             X |
2                       .       X       |
1                   -   .               |
0 -                     .               |
0  1  2  3  4  5  6  7. 8  9 10 11 12 | Dist.
``````

Cool!

#### Verifying second race stats

In the second race, you could hold the button for at least 4 milliseconds and at most 11 milliseconds and beat the record

``````Time:      15
Distance:  40
``````
• Hold for 4 time units
• Go 4 distance units per time unit
``````Time: 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
Dist: 0  0  0  0  4  8 12 16 20 24 28 32 36 40 44
``````

I feel like I'm starting to see how I could programmatically calculate this.

#### Thinking algorithmically

``````Set winners to 0
For all times i from 1 to N - 1 where N is the race time
Calculate the product of i and N - i
Compare to distance target
If greater, increment winners by 1
``````

Using `Time: 7` as example:

``````For i from 1 to 7
1 * 6 = 6
6 < 7
LOSE

2 * 5 = 10
10 > 7
WIN

3 * 4 = 12
12 > 7
WIN

4 * 3 = 12
12 > 7
WIN

5 * 2 = 10
10 > 7
WIN

6 * 1 = 6
6 < 7
LOSE

Winners: 4
``````

If all bell curves are symmetrical, then this algorithm could stop as soon as `i` is greater than `N - i`, and just double that winner count at that point.

Time to write this program!

#### My working JavaScript algorithm

``````times.reduce((product, time, index) => {
let winners = 0
for (let i = 1; i < time; i++) {
winners += (i * (time - i)) > distances[index] ? 1 : 0
}
return product *= winners
}, 1)
``````

It generates the correct answer for the example input.

And it generates the correct answer for my puzzle input!

### Part 2

#### A nod to kerning? Hahahaha!

It may come in handy to halve my algorithm's operations for this performance test, since my puzzle input requires checking nearly 50 million times.

First, I'll just try it brute-force, evaluating every permutation of `i`.

#### My working JavaScript algorithm

``````time = parseInt(times.join(''))
distance = parseInt(distances.join(''))
let winners = 0
for (let i = 1; i < time; i++) {
winners += (i * (time - i)) > distance ? 1 : 0
}
return winners
``````

It completed in milliseconds, even on my puzzle input.

And it generated the correct answer!

That was a breath of fresh air compared to Day 5!

Fun with bell curves. Who knew?