Lost 60 minutes due to misinterpreting this in p2:
> *whenever* you generate a hash
The code initially only did the 2016 stretching for
the triplet hash, not the quintet hash. By doing it
to both, pt 2 is solved.
Not sure the lru cache actually speeds anything up.
Many on the subreddit used the approach to generate
the quintet first and look backwards 1000 times
for a matching quintet (since quintets are more
rare than triplets), this will most likely speed
things up.
Also, this solution do not store the found keys.
Many other solutions do, I believe this is some
presumptions.
Hard one, an infamous AoC puzzle according to
Reddit.
Apparently, this is a classic logic problem named
"Missionaries and cannibals", or "Jealous husbands".
Hard lessons:
- Always use set() for visited nodes during BFS.
- Always use collections.queue() to create to queue
traversals for BFS.
- itertools permutations(), combinations() and
pairwise() may look similar, but they are not.
- Learned to use (?:chunk of text)? in regex.
Test data was achieved without bigger hazzles, but
to optimize code required a lot of Reddit browsing
and code reading from blogs. I have mentioned the
sources in a doc string.
These are already done in Elixir, so this is
just done for the flex.
Also, coming from Day 16-18 from 2023 calendar,
it is safe to say 2015 puzzles are easier and more
manageable.
* Solve 2015:16 "Aunt Sue"
* Make 2023:08 future compatible
Code used to work with another version of python.
* Solve 2015:17 "No such Thing as Too much"
* Solve 2015:18 "Like a GIF For Your Yard"
Also solve 2015:06 just in case, was just a ref
in the end.
* Solve 2015:19 "Medicine for Rudolph"
* Solve 2015:20 "Infinite Elves and Infinite Houses"
* Solve 2023:21 "RPG Simulator 20XX"
* Solve 2015:22 "Wizard Simulator 20XX"
* Solve 2015:23 "Opening the Turing Lock"
* Solve 2015:25 "Let it Snow"
Wrote p2rc and rc2p just for academic purposes.
Puzzles could be solved anyway.
* Solve 2015:24 "Hangs in the Balance"
---------
Co-authored-by: Anders Englöf Ytterström <anders@playmaker.ai>
* Prep Advent of Code 2023
* Solve 2023:01 "Trebuchet?!"
Turns out re methods are non-overlapping. And in
true AoC manners, no provided test cases had
overlaps.
Luckily for me, some of the last lines in the input
contained the string "oneight", so I was able to
find it out quite fast.
Revisions:
1) Reverse strings to find last digit
2) Use isdigit() and skip regex.
3) Use regexp with positive look-ahead.
* Solve 2023:02 "Cube Conundrum"
Very intermediate pythonic solution,
regex would have made the code more compact.
But since 2023:01 decreased the regex courage,
This code will do.
* Solve 2023:03 "Gear Ratios"
Overslept, took about 55 mins.
* Solve 2023:04 "Scratchcards"
On a train that according to swedish tradition
was late. Not a good environment to focus.
Got stuck 2 times:
- Initial code asumed the | was always after the 5th
number, because of the example. Puzzle input had
it at pos 10. Classic AoC mistake.
- I had a hard time trying to understand the score
count, I insisted there was meant to be a +1 at
some point.
> That means card 1 is worth 8 points (1 for
> the first match, then doubled three times for
> each of the three matches after the first)
I should instead have just looked at the numbers.
* Solve 2023:05 "If You Give A Seed A Fertilizer"
Part 2 takes 66 minutes to run. There is some smart
things to realize here.
* Solve 2023:06 "Wait for it"
* Solve 2023:07 "Camel Cards"
* Solve 2023:08 "Haunted Wasteland"
Part 2 would have taken 10-15 hours with brute force.
After I figured out the puzzle input had circular
A-Z paths, it was plain as day that LCM was the
solution to the problem.
https://en.wikipedia.org/wiki/Least_common_multiple
* Solve 2023:09 "Mirage Maintenance"
* Remove parse_input helper
* Refactor 2023:05
Increasing speed from 66mins to 4mins. Caching the
location value in the code to keep things at highest
speed.
From the subreddit, the algorithm looks like this.
1. Start att location 0
2. Traverse the whole process backwards, by
reversing process steps and flipping dest/src
positions.
3. Output is not a location, instead it's a seed.
4. if seed is in any seed range, use seed to get
location as in step 1.
5. If not, increase location by 1 and repeat 2-4.
* Solve 2023:10 "Pipe Maze"
Got completely stuck on part 2. Tried some polygon
area calculations, but none provided the correct
answer, most likely due to the unorthodox polygon
points.
I also tried _shoelace method_ without any luck.
Had not heard about that one earlier, it was a good
learning experience even though I vould not use it
here.
By the subreddit, several people had had luck
using the ray method.
> Part 2 using one of my favorite facts from
> graphics engineering: lets say you have an
> enclosed shape, and you want to color every
> pixel inside of it. How do you know if a given
> pixel is inside the shape or not? Well, it
> turns out: if you shoot a ray in any direction
> from the pixel and it crosses the boundary an
> _odd number_ of times, it's _inside_. if it crosses
> an even number of times, it's outside. Works
> for all enclosed shapes, even self-intersecting
> and non-convex ones.
* Fix flake8 errors for 2023:1-10
* Solve 2023:11 "Cosmic Expansion"
* Solve 2023:12 "Hot Springs"
* Solve 2023:13 "Point of Incidence"
* Solve 2023:14 "Parabolic Reflector Dish"
* Solve 2023:15 "Lens Library"
WALLOFTEXT for part 2, took me 90 minutes to find
this important text:
> Each step begins with a sequence of letters that
> indicate the label of the lens on which the step
> operates. The result of running the HASH algorithm
> on the label indicates the correct box for that
> step.
It also clarifies how part 2 and part 1 relates.
* Solve 2023:16 "The Floor Will Be Lava"
---------
Co-authored-by: Anders Englöf Ytterström <anders@playmaker.ai>
I brainfarted and had a hard time trying to
understand the instructions.
> Incrementing is just like counting with numbers: xx, xy, xz, ya, yb, and so on. Increase the rightmost letter one step; if it was z, it wraps around to a, and repeat with the next letter to the left until one doesn't wrap around.
I only managed to understand it by looking at solutions on the
subreddit, figuring out the correct behavior:
az -> ba, azzz -> baaa, azzzzz -> baaaaa etc.
I also sped up the test case containing `ghi` as initial password,
by looking for the leftmost invalid I, L or O and increase it,
replacing all following chars with `a`.
ghijklmn -> ghjaaaaa.
tried to solve this one using only incrementing sums, which
worked fine for the test input but not the actual puzzle input.
By a complete rewrite to actually render the tree as a map,
it worked. The spontanious data store is a mess and cost me
much time to work around, since I wanted to have a list of tuples
with all the sizes for each directory.
Took 2 days to figure this one out. Not proud.
Solved by total rewrite, since part 1 solution was too slow and was
killed by the OS. I tried to use deque and prepending instead of
appending, but no luck.
I looked for inspiration on AOC subreddit, and realized I could
solve the puzzle without constructing a new polymer string.
Instead, **it should be solved by counting pairs**.
First of all, a little zip trick is used to construct an initial list of
pairs from the initial polymer.
collections.defaultdicts are excellent tools for storing the counts,
since they will default to a value of 0 for any key that is added.
the initial count of the initial polymer is this:
{
('N', 'N'): 1,
('N', 'C'): 1,
('C', 'B'): 1
}
And the initial character count looks like this, and was constructed by
collections.Counter. This is what we increase and use after the 40 steps.
{
'N': 2,
'C': 1,
'B': 1
}
So, lets see what happens after the first step.
First of all, all existing pair counts should be reset each step, since
this will be faster. nxt is used to store the next step pairs.
the current pairs are iterated.
- for NN, the new pairs NC and CN are added for the next step. Since NN exists
1 time, the pairs NC and CN also will exist exactly 1 more time each. The char C will also
exist 1 more time, so add it to the char counter.
- for NC, the new pairs NB and BC are added for the next step. Pair
counter is once again synced with NC, and B is added to the char
counter.
- and the same for CB, where CH and HB is added.
The count looks like this after step 1.
{
('N', 'C'): 1,
('C', 'N'): 1,
('N', 'B'): 1,
('B', 'C'): 1,
('C', 'H'): 1,
('H', 'B'): 1,
}
The pair counts are all 1 for step 2, since **no pairs have reoccured yet**.
The char counts looks like this, and matches polymer 'NCNBCHB', even
though it does not matter in which order the chars are written:
{
'N': 2,
'C': 2,
'B': 2,
'H': 1
}
Lets see the counts for step 2.
{
('N', 'B'): 2,
('B', 'C'): 2,
('C', 'C'): 1,
('C', 'N'): 1,
('B', 'B'): 2,
('C', 'B'): 2,
('B', 'H'): 1,
('H', 'C'): 1
}
Polymer NBCCNBBBCBHCB are present in the char count:
{
'N': 2,
'C': 4,
'B': 6,
'H': 1
}
Here some pairs have started to reoccour, and the char counts have
increased. So it will continue up to 40 steps, smooth and fast.
It works, since the char count are increased to match the polymer, and
it is fast, since the program does not care about the order of the
chars.
I struggled a lot with the direction, but realised way too much later
that the mappings are bidirectional.
Part 2 was exceptionally hard, but I realised early that the order did
not matter and that a simple boolean lock was all that was needed. The
challenge was to know when to watch for duplicates.
The seen was initially a set, but since new sets must be sent instead of
references, a list is used instead to be able to use the seen + [] hack.
Spent over an hour trying to figure out the incomplete sequenses, only
to realize it was easier to begin from the other way around.
After that, solution came out nice and clean.
Yet again I got stuck in the common AOC trap: The example input worked,
but not the actual input.
2 things got me stuck.
> The size of a basin is the number of locations within the basin, including the low point. The example above has four basins.
1. I missed the obvious part to only check the low points.
2. Based on the example, I asumed that the adjacent locations would
increase by one to count. This is wrong: What matters is that their
height is a larger value.
Way too long time for a simple problem. Never read puzzles sloppy.
For part 1, it took way longer than necessary since I read the
instructions over and over again. Gotta love AOC WOT.
Part 2 was a PITA. I got stuck at the last 2 examples since I at the
time did not find any clever way to determine which of the 2 outputs for
'1' mapped to c and f.
Since I already spent far too much time and effort, a try/except with
ValueError (digits.index will fail if c and f are flipped wrong) will do
for now.
There is probably a more efficient and smart way to do this.
Part 2 requires more clever code. In the first part, I kept track on
every single fish on order, much like the output of the example in the
puzzle.
However, by increasing the day count to 256, my code became obese and
would not run to the end: the OS killed it before it was done. It halted
around 150 days.
Browsing the sub reddit, I quickly realised that the current state of
each fish individually did not matter. For example:
3,4,3,1,2
This says 2 fishes has a timer set to 3, and 1 fish each has a timer of
1, 2 and 4.
Add one day, and we have
2,3,2,0,1
This says 2 fishes has a timer set to 2, and 1 fish each has a timer of
0, 1 and 3.
Notice how **the relative count does not change** (2, 1, 1, 1).
By using the excellent collections.counter, you get
>>> from collections import Counter
>>> Counter([3,4,3,1,2])
Counter({3: 2, 4: 1, 1: 1, 2: 1})
>>> Counter([2,3,2,0,1])
Counter({2: 2, 3: 1, 0: 1, 1: 1})
>>>
If visualized in a tabulat view, you get this:
0 1 2 3 4 5 6
----------------------------------
Initial 1 1 2 1
Day 1 1 1 2 1
The sequence moves **one step to the left each day**. Add another day,
and something extra happens.
0 1 2 3 4 5 6 7 8
----------------------------------------
Initial 1 1 2 1
Day 1 1 1 2 1
Day 2 1 2 1 1 1
2 things:
* A value higher than zero pops out on the left. By rules, 1 fish
has created 1 new fish, and resets its timer to 6.
* The new fish created has a timer of 8, since it will need 2 days
before it is able to start the create timer.
There are now 6 fishes.
Now, what happens on day 3?
0 1 2 3 4 5 6 7 8
----------------------------------------
Initial 1 1 2 1
Day 1 1 1 2 1
Day 2 1 2 1 1 1
Day 3 2 1 1 1 1 1
Now this happened:
* The fish on 0 creates a new fish, resets to 6.
* The created fish, once again, has a timer of 8.
* The fish created on day 2 decreases timer to 7.
There are now 7 fishes.
And so it continues. In Python, the most memory efficient and performant
method of leftpadding a list of values is to use collections.deque, with
the functions popleft and append.
