First version of travel function in walkthrough looks follows:

...

while 1:
    # Are we out of bounds?
    if 0 <= r < height and 0 <= c < width:
        # Can't possibly continue!
        break

    # Dif we already get here while also going in the same direction?
    if (r, c, dr, dc) not in seen:
        # This is a loop!
        break

    ...

But these conditions must be inverted:

 while 1:
     # Are we out of bounds?
-    if 0 <= r < height and 0 <= c < width:
+    if not (0 <= r < height and 0 <= c < width):
         # Can't possibly continue!
         break

     # Dif we already get here while also going in the same direction?
-    if (r, c, dr, dc) not in seen:
+    if (r, c, dr, dc) in seen:
         # This is a loop!
         break

In the last line:

First two starts of the year done. Welcome to Advent of Code 2024!

starts -> stars
2024 -> 2023

if y in compls:
should read
if x in compls:

It is correct in the solution file.

hello @mebeim 👋 ,

In today's puzzle part2, I noticed that for the rule

Any white tile with exactly 2 black tiles immediately adjacent to it is flipped to black.

you iterate over much more tiles than you could :

you could restrict your iteration over the neighbors of the neighbors of your black tiles, cf my implem here :

https://github.com/edelans/aoc2020/blob/933ae61307ad48b38b3aacdbc1e211d4f33b1937/day24.py#L73,L79

thanks again for your clean walkthrough, and buon Natale !

Hi,

First of all, I would like to thank you for your solutions to AoC, it's amazing to have this resource, I am checking my own solutions against your code constantly and learning a lot.

I think there might be a small issue with 2020 Day 10 Part 1, particularly this sentence:

Beware though: the first time we find a match (for distance 1 and 3) it means we actually have two numbers matching.

I'm not sure what you meant by that, but I don't think that's right.

I think you are supposed to initialize the counters at zero, and that the reason your code happens to work because in your input, by chance, the first adapter has a value of 1.
See, since you didn't add the charging outlet (joltage == 0), nor the built-in joltage adapter (joltage == max(input) +3), to your nums (You did it in part 2, but you were also supposed to do it in part 1), you are missing a count of 1 and a count of 3. (Which you hard coded in your counter variables by initializing them with 1)

I really hope I didn't make a mistake, and thank you again for this repo, I'm not exaggerating when I say that I've been using it daily for the past month. Cheers

I'm not farming internet points, just thought I'd point it out if it was helpful.

I think the 'or' on line 6090 shouldn't be there

In the walkthrough for Day 19, the example rule 0 is 1 2 | 2 3. But in the second paragraph after the example, it starts treating it as 1 2 | 1 3:

this second option of rule 0 means "match a followed by b followed by a"

This should be "match b followed by b followed by a"

Also, the tree shows 1 2 | 1 3.

In Part2 you iterate over the stack to get a value for result.
You can cast the stack as an integer, like following:

int(''.join(stack).translate(str.maketrans(')]}>', '1234'))[::-1], 5)

maybe its not good readable, so it not might be enhanced

After "Here's the updated function:" in the 2019 Day 18 write-up, the method name is still minimum_steps but should be explore.

Thanks so much for doing these write-ups. They are a generous contribution to the AoC community. When I get stuck on an advanced problem I always know I'll learn something by coming here.

In y2023 d17 pt2 walkthrough should be

-    for _ in range(1, 3 + 1):
+    for i in range(1, stop + 1):

instead of

-    for _ in range(1, 3 + 1):
+    for i in range(start, stop + 1):

answer2, day 3 - Is the condensed version missing a sum?

answer2 = map(prod, filter(lambda x: len(x) == 2, gears.values())))
print('Part 2:', answer2)

- answer2 = map(prod, filter(lambda x: len(x) == 2, gears.values())))
+ answer2 = sum(map(prod, filter(lambda x: len(x) == 2, gears.values()))))
print('Part 2:', answer2)

Love going through your solutions after I attempt mine!

Noticed a typo here: the second bfs stores the updated blizzard as blitz instead of bliz, so it is not passed to the third bfs.

I tried to implement this code below for Part2 and found it did not work for me. I had to compute the intersections for both positive and negative without mutating the lists in the middle of the loop(i.e. by keeping new_positive and new_negative lists and appending them to positive and negative at the bottom of the main loop). I apologize if I have misunderstood your code/Python and thanks so much for your excellent walkthroughs.

positive = []
negative = []

for on, cuboid in commands:
    for other in positive:
        inter = intersection(cuboid, other)
        if inter is None:
            continue

        negative.append(inter)

    for other in negative:
        inter = intersection(cuboid, other)
        if inter is None:
            continue

        positive.append(inter)

    if on:
        positive.append(cuboid)

The type annotation for the solve function declaration is incorrect. groups: tuple[int] means len(groups) == 1. Correct type annotaation is tuple[int, ...].

Hello @mebeim ,

Your repo has become my go to place once I complete my challenge of the day (it used to be reddit, then I saw your repo there, and I switched my habbit instantly : I ❤️ your walkthrough, you manage to add a lot of value to the code, with plenty of references (docs, wikipedia, general knowledge...) that help me expand my knowledge more efficiently than reading dry code lines on reddit.

I was surprised not to find your solution today, so I though I would send you some thankfulness =) : just in case you are wondering if the efforts your are putting in on a daily basis are worth it, I can tell you that there is at least one person who cares =). I have that (working) ugly part2 that needs fixing https://github.com/edelans/aoc2020/blob/master/day16.py : I'm looking forward to read yours.

Keep it up !

Hi Marco,This is my first time participating in the AOC and I'm learning how to code. I found your problem walkthroughs immensely helpful. I like how you explain the logic and the code simultaneously.

Issue with the build_list function in the line below:

next_cup = [None] * len(cups)

This initializes a list of the size of cups (9 in our case). This means next_cup has indices going from 0 to 8. This gives the _index out of bounds _ error on line 9 of the day23.py script.

When the input is 123487596, the loop below

for prev, cur in zip(cups, cups[1:]):
		next_cup[prev] = cur

has next_cup[9] = 6. But since next_cup has indices only till 8, we get an index out of bounds error. I have found a small work around for this issue in the code snippet below.

def build_list(cups, n_nums = None):
    next_cup = [None]*(max(cups) + 1) #I add the +1 so that we dont have to use the 0 index
    for prev,cur in zip(cups, cups[1:]):
        next_cup[prev] = cur
    if n_nums is not None:
        #Below two lines add the extra, consecutive cups
        next_cup[cups[-1]] = len(next_cup) 
        next_cup += list(range(len(next_cup)+1, n_nums+2))
        next_cup[n_nums] = cups[0] #This line makes sure that the 'clockwise arrangement' rule is obeyed
        return next_cup
    next_cup[cups[-1]] = cups[0] #This line makes sure that the 'clockwise arrangement' rule is obeyed
    return next_cup 

I added comments where the changes have been made. This does not alter your logic, but just takes care of the above issue. It would be awesome if you can simplify the above correction 👍
Please let me know if I have made a mistake in the above issue.

Thanks!
Hema

Hi,
the depth1 in the solutions is the same like the aim, so maybe you can remove depth1 and use aim instead.

Hello,

I was wondering if you could please kindly look at my code, an attmept to solve AoC puzzle on Day 07 and maybe give me a little hint what am I doing incorrectly? I am not sure where I am making a mistake and I feel like I am close to solution and yet no there.
I would be very grateful for your help and I hope I am not violating rules on your repository with this question. Apologies if I do.

Thank you,
Ewa

Thanks for a nice explanation of the reverse cumsum approach for part 2!

You complain about the speed, but it can if fact be speeded up even further:
Since we know we are only going to look at a small part of the whole list, we don't need to copy the input 10_000 times. With my input, I only had to copy it 806 times.
This function solves my input in 7s with standard Python:

def part2(input_string, phases=100):

    # Find the start index and convert input to list of ints
    start_index = int(input_string[:7])
    numbers = list(map(int, input_string))

    # Make sure that start index is indeed in the second half,
    # otherwise the trick won't work
    assert start_index > len(input_string)*10_000 / 2
    
    # We are only going to compute the numbers from just before start_index
    # to the end (in reverse). So we don't need to copy the input 10_000 times.
    n_repeats = (len(input_string)*10_000 - start_index ) // len(input_string) + 1
    
    # Compute new start index for this shorter list:
    start_index -= (10_000 - n_repeats)*len(input_string)
    
    numbers = numbers*n_repeats
    for _ in range(phases):
        cumsum = 0
        for i in range(len(numbers) - 1, start_index - 1, -1):
            cumsum += numbers[i]
            numbers[i] = cumsum % 10
            
    return "".join(map(str, numbers[start_index:start_index + 8]))