BFS, baby.
2 things got me.
* S position was not (0,0) in the puzzle input. Such embarrasment to
loose time over something so stupid.
* I asumed the elevation was fixed to to increase AND DECREASE by 1.
From the problem description:
> To avoid needing to get out your climbing gear, the elevation of the
> destination square can be at most one higher than the elevation of
> your current square; that is, if your current elevation is m, you
> could step to elevation n, but not to elevation o. _(This also means
> that the elevation of the destination square can be much lower than
> the elevation of your current square.)_
This means elevation only can _increase_ by one,
but _decrease_ with more.
So my wrong code:
0 <= abs(n - e) <= 1
got fixed with:
n - e <= 1
For pt 2, I reused the loop to find S to collect all "a" positions,
and looped them as starting points. Execution time is not the best,
but it works.
This is how far I got the Dec 2022 run in Elixir.
Had no idea what so ever for pt 2, so I had to
solve it by the solutions thread in the subreddit.
At first, I wondered if circular values would be the
case. It was not.
Apparently, modular arithmetics are what I lack
knowledge about.
Not entirely sure what to call the operator, it is
either a greatest common divisor or a least common
nominator.
What it actually does is to reduce the numbers by
modulo for pt 2, which will keep them low and faster
to compute.
My math is rusty.
Pt 1 was just head and tail. For pt 2 I rewrote the
code to instead build the rope (snake) from head to
tail by always moving the head first and traverse
the body of the snake.
Yes, I think of it as a body of a snake - not knots
on a rope. Child hood memories are to damn colorful
:)
For reference, this is my visually debugging code:
def dbg(seen, snake):
print(snake)
for r in range(-4, 1):
print("".join([v(r, c, snake) for c in range(0, 7)]))
print("")
def v(r, c, snake):
if (r,c) == snake[0]:
return "H"
for i, n in enumerate(snake[1:-1], start=1):
if (r,c) == n:
return str(i)
if (r,c) == snake[-1]:
return "T"
if (r,c) == (0,0):
return "s"
return "."
Funny that I did not mention the problem with
recurring directory names in the first run of this
puzzle in Elixir, back in 2022 and bb708a5e58.
Most likely, the insight flew over my head that
time.
This time, I realized I could just add the size to
the size of each parent. I struggled to find a graph
traversal for it, until I realized I did not need
the graph.
The key rewrite was this:
for p in path:
fs[p] += size
fs["/"] += size
... to this:
p = "/"
fs[p] += size
for dir_name in path:
p += f"/{dir_name}"
fs[p] += size
This solved my issues for 3 hours by acknowledge that
- a directory name "a" can accour on multiple places,
example: /a, /b/a, /c/a
- a directory name "a" can have a parent directory named
"a", example: /a/b/a, /a/c/d/a
And as always, example input is the devil. Look at
the reak input as soon as possible.
