advent of code 2021 on about me

day 12

Sun, 12 Dec 2021 00:00:00 +0000

you can find the description here and you can find the code here

as long as there are no upper-cased direct loops (ie, A - B), simple dfs works for both cases:

for part 1:

def dfs1(g, node, visited):
    if node == "end":
        return 1
    res = 0
    for nn in g[node]:    
        if nn.isupper() or nn not in visited:
            visited.add(nn) 
            res += dfs1(g, nn, visited)
            visited.discard(nn)    
    return res

for part 2:

def dfs2(g, node, visited, used):
    if node == "end":        
        return 1
    res = 0
    for nn in g[node]:
        if nn.isupper():    
            res += dfs2(g, nn, visited, used)    
        elif nn in visited and nn != "start" and not used:
            res += dfs2(g, nn, visited, True)
        elif nn not in visited:
            visited.add(nn)
            res += dfs2(g, nn, visited, used)
            visited.discard(nn)
    return res

day 11

Sat, 11 Dec 2021 00:00:00 +0000

you can find the description here and you can find the code here

the only thing we have to be careful about in this problem is avoid counting octopuses more than once

but otherwise, just simulate the steps

here’s the step function i used, that returns the number of flashes that happened during each time period

# mutates grid
def step(grid):
    n, m = len(grid), len(grid[0])
    s = []
    for r, c in product(range(n), range(m)):   
        grid[r][c] += 1        
        if grid[r][c] == 10: 
            s.extend(neighbors(grid, r, c))
    while s:
        r, c = s.pop()    
        grid[r][c] += 1   
        if grid[r][c] == 10:
            s.extend(neighbors(grid, r, c))    

    flashes = 0
    for r, c in product(range(n), range(m)):
        if grid[r][c] > 9:
            grid[r][c] = 0    
            flashes += 1
    return flashes

day 10

Fri, 10 Dec 2021 00:00:00 +0000

you can find the description here and you can find the code here

using a stack, you can figure out exactly where does the string become invalid, if at all

m = {"{":"}", "(":")", "[":"]", "<":">"}
def parse(l):
    s = []
    for c in l:
        if c in m:
            s.append(c)    
        elif s and m[s[-1]] == c:
            s.pop()
        else:
            return s, c
    return s, None

if the stack is not empty at the end, it means it is incomplete and that the only way to complete it would be to reverse the stack and append it to the original string

day 9

Thu, 09 Dec 2021 00:00:00 +0000

you can find the description here and you can find the code here

for part one, simply count the number of cells in which all neighbors are strictly greater.

for part two, floodfill until you have previously visited or until you find a height 9

def floodfill(grid, r, c):
    if grid[r][c] is None or grid[r][c] == 9: 
        return 0    
    s, grid[r][c] = 1, None
    for nr, nc in neighbors(grid, r, c):
        s += floodfill(grid, nr, nc)    
    return s

day 8

Wed, 08 Dec 2021 00:00:00 +0000

you can find the description here and you can find the code here

for the first part, simply count the number of words in the output section that have lengths 2, 3, 4 or 7

for the second part, i couldn’t think of a better solution than just try permutations until the wires make sense

day 7

Tue, 07 Dec 2021 00:00:00 +0000

you can find the description here and you can find the code here

def cost(l, n, f):
    return sum(f(e, n) for e in l)

for the first part, the solution is the median.

def median(l):
    return l[len(l) >> 1]

def part1(l):
    m = median(l)
    return cost(l, m, lambda x, y: abs(x - y))

for the second part, the solution is the average.

def part2(l):
    avg = sum(l) / len(l)
    f = lambda x, y: gauss(abs(x - y))
    return min(cost(l, ceil(avg), f), cost(l, floor(avg), f))

day 6

Mon, 06 Dec 2021 00:00:00 +0000

you can find the description here and you can find the code here

this was very fun!

my first solution consisted on a simple simulation on a double ended queue. this solution is linear on the number of days and it handles both parts without a problem.

# mutates q
def step(q):
    n, last = q[0], q.pop()    
    q[-1] += n
    q.append(last)
    q.rotate(-1)

however, it ocurred to me while working, that i could simply simulate a single step of this as a matrix multiplication. and well, if you have repeated matrix multiplication, you have matrix exponentation. and if you have matrix exponentiation you have fast matrix exponentiation.

day 5

Sun, 05 Dec 2021 00:00:00 +0000

you can find the description here and you can find the code here

nothing interesting for this problem. just walk from p1 to p2 and add all the points you walk to a counter. for part one, simply filter those who are diagonal (start[1] == end[1] or start[0] == end[0])

for part two, don’t filter.

def span(p1, p2):
    sx, sy = p1 
    ex, ey = p2
    dx = delta(sx, ex)
    dy = delta(sy, ey)
    while p1 != p2:
        yield p1    
        p1 = (p1[0] + dx, p1[1] + dy)
    yield p1

def count_points(segments):
    c = Counter()
    for p1, p2 in segments:
        for p in span(p1, p2):
            c[p] += 1
    return c

day 4

Sat, 04 Dec 2021 00:00:00 +0000

you can find the description here and you can find the code here

ok. this was fun!

for both parts, i just simulated all boards with a class. only interesting thing is i kept track of all numbers contained in a board and added a rows and cols array, containing how many remaining numbers until a bingo in each row/col. this made it very easy to know if marking a number in a board yields a bingo.

day 3

Fri, 03 Dec 2021 00:00:00 +0000

you can find the description here and you can find the code here

to solve each part, we basically need a function that can give us the number of bits turned on for a certain digit index:

def count_by_index(nums, i):
    total = len(nums)
    res = ones = 0
    for n in nums:            
        if (n >> i) & 1:
            ones += 1    
    return ones, total - ones

you can get the gamma rate by simply iterating over each possible index and assigning that index to be the digit of the most common digit of all numbers for that index.

day 2

Thu, 02 Dec 2021 00:00:00 +0000

you can find the description here and you can find the code here

for part one, it is a very straight forward simulation.

(defn step-part1 [x y cmd i]
  (cond
    (= cmd "forward") [(+ x i) y]
    (= cmd "up") [x (- y i)]
    :else [x (+ y i)]))

part two is very similar but we also need to keep track of the aim

(defn step-part2 [x y aim cmd i]
  (cond
    (= cmd "forward") [(+ x i) (- y (* aim i)) aim]
    (= cmd "up") [x y (+ aim i)]
    :else [x y (- aim i)]))

day 1

Wed, 01 Dec 2021 00:00:00 +0000

you can find the description here and you can find the code here

well my solution uses a very simple (fixed size) sliding window technique, with the first part being a size 1 window and the second part a size 3 window.

def solve(l: [int], k: int):
    s = sum(l[:k])    
    res = 0
    for i in range(k, len(l)):
        ss = s - l[i - k] + l[i]
        res += s < ss
        s = ss
    return res