Just some grain rain.

What is Advent of Code?

In this little series, I want to write about the thought processes I have behind solving the puzzles presented in Advent of Code.

During the Advent of Code small coding puzzles are presented with varying levels of difficulty. They're always Christmas-themed text puzzles where you help elves out of some mess to save the holidays. The puzzles are deliberately ambiguous to not bias puzzlers into a certain solution, they always have an example input in the text to explain some details and an input file for each day that comes in the form of a text file you can download. The solution is a simple number or a string you enter, which is checked by the website automatically. After you finish part 1, part 2 unlocks, which is a variation on part 2. This can be a little twist on part 1 or a large twist that changes the problem formulation into a problem that would take brute force solutions to compute longer than the heat death of the universe would take.

Find my solutions here: github.com/JesperDramsch/advent-of-code

These descriptions won't be a perfect narrative, but rather how I think about these problems and where I see different solutions. I apologise for the possibility of rambling!

The example input

When I saw today's example input, I was worried!

498,4 -> 498,6 -> 496,6
503,4 -> 502,4 -> 502,9 -> 494,9

But my parser of "lists of lists" already worked on this and then I just needed to split and convert the coordinates to integers.

The implementation

This hoenstly felt pretty straight-forward.

I implemented a dictionary with the given values, but ignored air. In the same step I also got the maximum depth.

Then I just used a while loop to drop the sand grains down to their position with three if statements checking for the middle, left and right.

Then I just repeated that until the first grain dropped below the maximum depth.

def sand_grain(grid, max_depth):
    loc = complex(500)

    while loc.imag < max_depth + 1:
        if loc + 1j not in grid:
            loc += 1j
        elif loc - 1 + 1j not in grid:
            loc += -1 + 1j
        elif loc + 1 + 1j not in grid:
            loc += 1 + 1j
        else:
            grid.add(loc)
            return grid
    return False

Part Deux

In part 2, I extended this logic with a floor:

def sand_grain(grid, max_depth, floor=None):
    loc = complex(500)

    if floor is not None:
        max_depth = floor

    while loc.imag < max_depth + 1:
        if loc.imag + 1 == floor:
            grid.add(loc)
            return grid
        ...

This allowed me to not assume a width of the stone floor, but simply used an additional logic step.

Refactor

I wasn't happy with the dictionary implementation, the deep if structure and using x,y when complex numbers would work.

The refactor is already live and a little cleaner.

The part 2 is still fairly slow, and there is a way to calculate it as triangles, but we have to subtract the negative space under horizontal parts and that's a bit of work.

Error Log

Well... that worked out alright!

• Not an error, but I did get a wrong intermittent result, when I forgot to change min to max in range(min(b,y), max(b,y) + 1):
• if not grid and start in grid: TypeError: argument of type 'bool' is not iterable want to make it work with the existing function, but messed up one return.
• Wrong answer for example part 2, but that was just a off-by-one error in the floor.