Nate Dileas

AOC 2021 - Day 8

2021-12-09T18:00:00+00:00

You barely reach the safety of the cave when the whale smashes into the cave mouth, collapsing it. Sensors indicate another exit to this cave at a much greater depth, so you have no choice but to press on.

⊕ Time to fall into a rage, then a depression, then mania, fake my way aboard another submarine, whip the crew into a bloodthirsty frenzy and scour the ocean in the name of revenge. Or, you know, weep a few manly tears and retire quietly to the country. Coin flip, really.

I had a lot of fun with this one. I’d classify it as “logic puzzle”. The problem:

There are many 7-segment displays that are malfunctioning; the inputs have been randomly assigned to the outputs. Our task was to figure out the mapping. Below is an example of the input for a single display; to the left of the pipe are the input patterns for the 10 unique digits. To the right are the numbers we have to decode.

Example test input:

acedgfb cdfbe gcdfa fbcad dab cefabd cdfgeb eafb cagedb ab | cdfeb fcadb cdfeb cdbaf


Output digit mapping:

  0:      1:      2:      3:      4:
 aaaa    ....    aaaa    aaaa    ....
b    c  .    c  .    c  .    c  b    c
b    c  .    c  .    c  .    c  b    c
 ....    ....    dddd    dddd    dddd
e    f  .    f  e    .  .    f  .    f
e    f  .    f  e    .  .    f  .    f
 gggg    ....    gggg    gggg    ....

  5:      6:      7:      8:      9:
 aaaa    aaaa    aaaa    aaaa    aaaa
b    .  b    .  .    c  b    c  b    c
b    .  b    .  .    c  b    c  b    c
 dddd    dddd    ....    dddd    dddd
.    f  e    f  .    f  e    f  .    f
.    f  e    f  .    f  e    f  .    f
 gggg    gggg    ....    gggg    gggg

There’s some features of the input that make this possible to solve. One, some output digits have a unique length (1,4,7, and 8). This is part one of the problem; simply count the number of 1s,4s,7s, and 8s in the output section. Part two is to decode and sum all the output numbers. Part one holds a clue to part two; there’s more usable information to be found by looking at the output patterns. I decided to treat this as a logic puzzle, and wrote ‘Wrote’ in this case means illegibly scribbling slightly similar tables 3 times before I got anything useful out of it. down the table below.

	a	b	c	d	e	f	g	Sum
0	x	x	x		x	x	x	6
1			x			x		2
2	x		x	x	x		x	5
3	x		x	x		x	x	5
4		x		x		x		4
5	x	x		x		x	x	5
6	x	x		x	x	x	x	6
7	x		x			x		3
8	x	x	x	x	x	x	x	7
9	x	x	x	x		x	x	6
Sum	8	6	8	7	4	9	7

The sum across the X direction shows the unique info hand-fed to us in part 1. The sum in the Y direction is new info; the characters that map to b, e, and f occur 6, 4, and 9 times in the input, respectively. Now, all we need is a way of telling apart a and c, and d and g. We know from looking at the output mapping that a is in seven and not in one. We also know that g is in eight, but not in four. Since we know which input strings are one, seven, eight, and one, we have all the information we need to make a full mapping table from input to output characters.

Code

AOC 2021 - Day 7

2021-12-07T19:00:00+00:00

The crab submarines all need to be aligned before they'll have enough power to blast a large enough hole for your submarine to get through. However, it doesn't look like they'll be aligned before the whale catches you! Maybe you can help?

⊕ I miss the bingo squid.

Times for today: about 5 minutes. This one was easy; I just had to good the closed-form solution to triangle numbers for part 2. The naive solution would probably have worked just fine though. Generators are the best; they’re one of my favorite python tools, but I almost never use them in production code. They’re perfect for stuff like this though.

Code

def find_min_fuel(crabs):
    return min(sum(abs(c-i) for c in crabs) for i in range(max(crabs)))


def find_min_fuelv2(crabs):
    return min(sum((abs(c-i)*(abs(c-i) + 1)) / 2 for c in crabs) for i in range(max(crabs)))

AOC 2021 - Day 6

2021-12-06T18:00:00+00:00

Although you know nothing about this specific species of lanternfish, you make some guesses about their attributes. Surely, each lanternfish creates a new lanternfish once every 7 days.

⊕ Ah, rationality.

Times for today: Embarrassing. I stalled out in the middle and went and did other stuff for a bit. I got about half of the way to the fundamental insight; that each fish is not unique. This problem is something like sequences or exponential modeling. I eventually gave up and looked at a few solutions on the reddit, then wrote one of my own. Can’t win ‘em all.

Code

def model_lanterfish_clever(start, niter=80):
    fish = [start.count(i) for i in range(9)]

    for i in range(niter):
        n = fish.pop(0)
        fish.append(n)
        fish[6] += n

    return sum(fish)

AOC 2021 - Day 5

2021-12-05T11:00:00+00:00

Because of the limits of the hydrothermal vent mapping system, the lines in your list will only ever be horizontal, vertical, or a diagonal line at exactly 45 degrees. In other words:

⊕ This submarine has subsystems for depth, piloting, bingo, hydrothermal vents detection, and probably christmas lights – everything a deep sea explorer needs.

Times for today: 00:23:15, 00:32:09. I stayed up till midnight and had fun doing it. I was in the top 3000; not bad for not trying too hard. I’d classify this problem as array operations; had to parse some line descriptions and keep track of intersection points. I was happy with how I solved this one.

Code

import itertools as it
import numpy as np

INPUT = """
0,9 -> 5,9
8,0 -> 0,8
9,4 -> 3,4
2,2 -> 2,1
7,0 -> 7,4
6,4 -> 2,0
0,9 -> 2,9
3,4 -> 1,4
0,0 -> 8,8
5,5 -> 8,2
"""
INPUT = open('input.txt').read()


def makemap(input):
    points = {}
    for line in filter(None, input.splitlines()):
        p1, p2 = line.split(' -> ')
        x1, y1 = map(int, p1.split(','))
        x2, y2 = map(int, p2.split(','))

        # print(x1, y1, x2, y2)

        if x1 == x2:
            for y in range(min(y1, y2), max(y1, y2)+1):
                points.setdefault((x1, y), 0)
                # print(x1, y)
                points[(x1, y)] += 1
        elif y1 == y2:
            for x in range(min(x1, x2), max(x1, x2)+1):
                # print(x, y1)
                points.setdefault((x, y1), 0)
                points[(x, y1)] += 1

    return sum(1 for v in points.values() if v >= 2)


def makemap_diag(input):
    points = {}
    for line in filter(None, input.splitlines()):
        p1, p2 = line.split(' -> ')
        x1, y1 = map(int, p1.split(','))
        x2, y2 = map(int, p2.split(','))

        # print(x1, y1, x2, y2)

        if x1 == x2:
            for y in range(min(y1, y2), max(y1, y2)+1):
                points.setdefault((x1, y), 0)
                # print(x1, y)
                points[(x1, y)] += 1
        elif y1 == y2:
            for x in range(min(x1, x2), max(x1, x2)+1):
                # print(x, y1)
                points.setdefault((x, y1), 0)
                points[(x, y1)] += 1
        else:
            xstep = int((x2 - x1) / abs(x2 - x1))
            ystep = int((y2 - y1) / abs(y2 - y1))
            for i, x in enumerate(range(x1, x2+xstep, xstep)):
                y = y1+(i*ystep)
                # print((x, y))
                points.setdefault((x, y), 0)
                points[(x, y)] += 1

    return sum(1 for v in points.values() if v >= 2)


if __name__ == '__main__':
    print('part 1: ', makemap(INPUT))
    print('part 2: ', makemap_diag(INPUT))

AOC 2021 - Day 4

2021-12-04T11:00:00+00:00

You're already almost 1.5km (almost a mile) below the surface of the ocean, already so deep that you can't see any sunlight. What you can see, however, is a giant squid that has attached itself to the outside of your submarine.

Maybe it wants to play bingo?

⊕ Watery grave = 95%

Times for today: 10:42, 14:08. I recorded my screen and intend to do a little analysis of where I spent my time. I used screen2gif and ffmpeg (but had a hiccup when I filled up my temp drive in the middle.) I’m generally happy with my code, although I could definitely have named things better in a couple places. I always reach for l, i, j, ii, etc too often, although this time I managed to not confuse myself too badly.

I’d classify this problem as “game modelling” and “array operations”, both of which I’m familiar with and enjoy.

Screencap analysis (played back at 2x real time, all times in video time):

00:00 -> 00:39: I set up my environment and timers and stuff. I made a new directly weirdly; usually I would use the command line for this. Otherwise, this is as usual.
00:39 -> 00:58: I read the problem.
00:58 -> 01:13: I copied the test case and defined the main function
01:14 -> 01:37: Splitting input data into numbers and boards
01:37 -> 01:57: more problem reading and getting the input data. This could have waited for later, probably an unnecessary context switch
01:57 -> 3:00: Defining the main logic of the function; iterate through the numbers, marking them called in each board and checking if there’s a winner. This is where I could have sped up considerably with better typing skills; 2 minutes real time to type 20 LOC?
@2:42: My screen recorder stopped and I took a pause to fix it. My temp dir had run out of space, I really need a new laptop.
3:00 -> 4:10: defining the string to board mapping. I defined the data model in my head while writing the function. I probably could have saved a lot of time by using np.loadtxt or similar.
4:10 -> 4:44: defining marking a number called. This was easy with numpy, I stopped in the middle to make sure the numbers were converted to integers.
4:44 -> 5:09: defining checking if a board has been won. Easy with numpy, especially without diagonals.
5:09 -> 5:21: defining the sum of the unmarked. very easy.
5:21 -> 5:49: testing. fixed 5 small bugs and got the right answer for the test case. (bugs: forgot import, forgot to run with poetry, forgot enumerate, wrong name for variable)
5:49 -> 5:56: ran the real data and got the right answer
5:56 -> 6:07: context switch + reading part 2
6:07 -> 6:25: housekeeping (copying + renaming function, adding invocation) and reading
6:25 -> 7:36: start editing in earnest. I had all the functions I needed, just needed a different logic in the main function to keep track of the last won board. I went down a false trail here with a dict. Also my girlfriend wanted my attention in the middle for a minute; I paused the timer.
7:36 -> 7:48: test with the text case. fix 1 bug (typo)
7:48 -> 7:54: run with the real thing
7:55: submit answer. Success!

I threw together a quick plot of this. Definitely room for improvement in typing!

import itertools as it
import numpy as np

INPUT = """
7,4,9,5,11,17,23,2,0,14,21,24,10,16,13,6,15,25,12,22,18,20,8,19,3,26,1

22 13 17 11  0
 8  2 23  4 24
21  9 14 16  7
 6 10  3 18  5
 1 12 20 15 19

 3 15  0  2 22
 9 18 13 17  5
19  8  7 25 23
20 11 10 24  4
14 21 16 12  6

14 21 17 24  4
10 16 15  9 19
18  8 23 26 20
22 11 13  6  5
 2  0 12  3  7
"""
INPUT = open('input.txt').read()


def make_boards(lines):
    boards = []
    for i in lines:
        board = np.zeros((5, 5), dtype=int)
        called = np.zeros((5, 5), dtype=bool)
        for ii, line in enumerate(i.splitlines()):
            for j, val in enumerate(line.split()):
                board[ii][j] = int(val)

        boards.append((board, called))

    return boards


def marknumber(board, number):
    board, called = board
    called[np.where(board == number)] = True


def checkwin(board):
    board, called = board
    return np.any(np.all(called, axis=0)) or np.any(np.all(called, axis=1))


def get_sum_unmarked(board):
    board, called = board
    return np.sum(board[called == False])


def play_bingo(input):
    stuff = input.split('\n\n')
    numbers = stuff[0]
    boards = make_boards(stuff[1:])

    for n in map(int, numbers.strip().split(',')):
        for board in boards:
            marknumber(board, n)
            haswon = checkwin(board)

            if haswon:
                s = get_sum_unmarked(board)
                return s * n


def play_bingov2(input):
    stuff = input.split('\n\n')
    numbers = stuff[0]
    boards = make_boards(stuff[1:])

    winningscores = []
    skipboards = []
    for n in map(int, numbers.strip().split(',')):
        for i, board in enumerate(boards):
            marknumber(board, n)
            haswon = checkwin(board)

            if haswon and not i in skipboards:
                s = get_sum_unmarked(board)
                winningscores.append(s * n)
                skipboards.append(i)

    return winningscores[-1]


if __name__ == '__main__':
    print('part 1: ', play_bingo(INPUT))
    print('part 2: ', play_bingov2(INPUT))

AOC 2021 - Day 3

2021-12-03T12:00:00+00:00

The submarine has been making some odd creaking noises, so you ask it to produce a diagnostic report just in case.

⊕ Just between you and me, what are the odds I end up in a watery grave?

Times for today: 8:38, 29:57. I wasn’t rushing, I spent some time reading in the middle. My code was embarrassing, so I’m not going to post it here. Suffice it to say, it was a transpose text and count stuff kind of problem. Tomorrow I want to try screen recording myself, since it’s the weekend and I’ll have more time.

I made a little visualization of the submarines progress so far. I didn’t mean to give myself vertigo, but here we are. I had to mess with units and stuff to get this to look nice; either the scale is tiny or santa has discovered an ocean trench multiple times deeper than marianna.

red line is the ocean floor, day 1's input, yellow is the path from day 2 part 2. matplotlib.

AOC 2021 - Start

2021-12-02T12:00:00+00:00

It’s a truth universally acknowledged that I hate a finished product, as long as I’m the one doing the finishing. Last year, I stopped writing these blog posts when I got bored. This year, I promise to either finish the month or get bored much more quickly, 50-50. I did eventually finish 2020’s problems with much tearing my clothes, rubbing ashes in my hair, and putting on of sackcloth. As a total aside; I think the fragmentation of literary culture away from the bible has robbed the US population of a useful schelling point, or common reference, for a rich source of metaphor (see moby dick). As always, the jewish community has a good strategy by making every smart person study the same set of books for thousands of years.

Onward and downward!

You're minding your own business on a ship at sea when the overboard alarm goes off! You rush to see if you can help. Apparently, one of the Elves tripped and accidentally sent the sleigh keys flying into the ocean!

Before you know it, you're inside a submarine the Elves keep ready for situations like this. It's covered in Christmas lights (because of course it is), and it even has an experimental antenna that should be able to track the keys if you can boost its signal strength high enough; there's a little meter that indicates the antenna's signal strength by displaying 0-50 stars.

Your instincts tell you that in order to save Christmas, you'll need to get all fifty stars by December 25th.

⊕ I’m firmly convinced the elves are hunting me for sport in increasingly convoluted ways.

Overall Approach

In preparation for this year’s puzzles, I’ve been thinking and trying to systematize my approach. There’s a few common things that I do every time, and formalizing this might help with speed, clarity of thinking, and “reflexes”.

Read the problem
Get the test cases
Get the input data
Map or subdivide the problem to known entities + examples: graph theory, regular expressions, factorization, etc
Then develop potential solution, test it, iterate as needed

For each day, I want to try and categorize the problem and the way I solved it, to try and pick out weak points in my own thinking. I don’t intend to measure times and try to speed up this year, but I do want to do screen recordings and see where I spend my time, and where struggle. My intuition is that I struggle the most on the problem mapping stage, but we’ll see how it works out.

In terms of tools, I’m sticking with python (poetry,pyenv as package+version management) this year. I’ve also devised a template file to cut down on mental overhead, and want to try and make a library out of the functions I develop along the way. We’ll see how long that lasts.

Day 1

For lack of a better category, I’m calling this signal processing. It also follows the “map + reduce lines” pattern, or whatever. This problem was easy (~3 minutes), and I didn’t bother to make it reusable; I can’t see it coming up again.

INPUT = open('input1.txt').read()

if __name__ == '__main__':
	values = [int(i) for i in INPUT.splitlines() if i]
	
	print('part 1: ', sum(values[i+1] > values[i] f
		or i in range(len(values)-1)))

	print('part 2: ', sum(sum(values[i+1:i+4]) > sum(values[i:i+3]) 
		for i in range(len(values)-3)))

Day 2

Now, you need to figure out how to pilot this thing.

...

Based on your calculations, the planned course doesn't seem to make any sense. You find the submarine manual and discover that the process is actually slightly more complicated.

⊕ Based on my calculations, I’ve been trapped in some sort of puzzle world hell, ruled by a sort of red madman with lots of child labor.

Also pretty easy (5:54 but I was sick). I’m categorizing this one as “instruction per line” and “manhattan distance” or “grid movement”. I kind of want to make some visualizations of the movement here. When I’m pressed for time, I tend to name things generically, even when there’s consistent terminology in the question. Something to fix in the future. This type of problem struck me as a way to experiment with the structural pattern matching that’s new in python 3.10; something to try.

INPUT = """
forward 5
down 5
forward 8
up 3
down 8
forward 2"""
INPUT = open('input.txt').read()


def plot_pos(input):
    x = 0
    y = 0

    for line in input.splitlines():
        if not line:
            continue

        if line.startswith('forward'):
            x += int(line.replace('forward ', ''))
        elif line.startswith('down'):
            y -= int(line.replace('down ', ''))
        elif line.startswith('up'):
            y += int(line.replace('up ', ''))

    return x, y


def plot_posv2(input):
    x = 0
    y = 0
    aim = 0

    for line in input.splitlines():
        if not line:
            continue

        if line.startswith('forward'):
            w = int(line.replace('forward ', ''))
            x += w
            y += aim * w
        elif line.startswith('down'):
            aim += int(line.replace('down ', ''))
        elif line.startswith('up'):
            aim -= int(line.replace('up ', ''))

    return x, y

	if __name__ == '__main__':
	    print('part 1: ', plot_pos(INPUT))
	    print('part 2: ', plot_posv2(INPUT))

AOC 2020 - Days 13 and 14

2020-12-15T01:41:00+00:00

Blargh. I haven’t finished part 2 of day 13 yet, but day 14 was fun. It was a bit hacking exercise, which is always a fun way to exercise my brain. I cheated a little bit by using stackoverflow, but just to remind myself of the right way to set and clear a bit. I wouldn’t be surprised if this turned out to be reused later; it had that sort of feel to it.

I don’t have anything pithy to add today, so here’s a nice visualization of the ascii art on the puzzle page. The ordering of the puzzles is really bothering me.

My times are definitely getting worse, especially considering the part 2 failures. But the challenges are getting slightly longer, and I'm getting very ready for a real vacation.

AOC 2020 - Days 10,11,12

2020-12-13T00:47:00+00:00

I had a rough time day 10. I still haven’t finished part 2. Days 11 and 12 were fun, but being tired greatly increased the time necessary to complete them.

Of course, the right number of jolts is 0.

Fortunately...

The test had a back?!

Day 11 was a fun modeling task, sort of reminiscent of Conway’s Game of Life. Day 12 was a common enough task of movement directions. On both of the tasks, I made a small error in typing, and took a long time to find it in part 2. Here’s the code.

Times!

AOC 2020 Day 9 - Hacks on a Plane

2020-12-10T02:17:00+00:00

I like how the puzzles went from “measure the tree-tobaggan collisions” to “dupe the customs officials with a fake passport” to “connect to potentially flight critical hardware and mess with it while in the air”. Santa is apparently instilling a wonderful black hat spirit in the great white north (pole). Maybe he’s the Red Green of hackers.

I do what?

In other news, I did this challenge at peak coffee time, and I did pretty well at 12:15! I did this one by just throwing together script stuff, trying to see if function-izing stuff was slowing me down significantly. I think the data is inconclusive; the varying level I have with the puzzles makes it hard to tell if it’s reverse causality. Also, different puzzles lend themselves to be split up into reusable chunks more or less. This one in particular was two almost entirely separate tasks, which made it a good approach.

I’m thinking of maybe making a module to encapsulate input loading; there’s a lot of common tasks I do for every day’s input. It would probably slow me down more than it would save for timing. But it might help for common formats later in the challenges. I’ll keep mulling it over.

Here are my times so far for the challenges. Honestly, not as bad as I feared. But there’s still many challenges to go. Obligatory code link.

I don't have individual challenge timing data for the first few days, unfortunately. It probably follows the general pattern of longer time on the first puzzle, shorter on the second.

	a	b	c	d	e	f	g	Sum
0	x	x	x		x	x	x	6
1			x			x		2
2	x		x	x	x		x	5
3	x		x	x		x	x	5
4		x		x		x		4
5	x	x		x		x	x	5
6	x	x		x	x	x	x	6
7	x		x			x		3
8	x	x	x	x	x	x	x	7
9	x	x	x	x		x	x	6
Sum	8	6	8	7	4	9	7

	a	b	c	d	e	f	g	Sum
0	x	x	x		x	x	x	6
1			x			x		2
2	x		x	x	x		x	5
3	x		x	x		x	x	5
4		x		x		x		4
5	x	x		x		x	x	5
6	x	x		x	x	x	x	6
7	x		x			x		3
8	x	x	x	x	x	x	x	7
9	x	x	x	x		x	x	6
Sum	8	6	8	7	4	9	7

	a	b	c	d	e	f	g	Sum
0	x	x	x		x	x	x	6
1			x			x		2
2	x		x	x	x		x	5
3	x		x	x		x	x	5
4		x		x		x		4
5	x	x		x		x	x	5
6	x	x		x	x	x	x	6
7	x		x			x		3
8	x	x	x	x	x	x	x	7
9	x	x	x	x		x	x	6
Sum	8	6	8	7	4	9	7