2016 on Advent of Code - Too Many Machines

2016 day 22: Grid Computing

Mon, 13 Nov 2023 17:32:00 +0100

We have a cluster of storage nodes organised in a grid and we need to move data from one specific node to an access node. First thing, data structures. I decided to have a dataclass for each node, storing position in a grid and used/available/total disk space. Then a list of nodes (we don’t need a 2D structure as every node knows its position), input parsing with regexps.

Part 1

Calculate how many pairs of nodes can be used for moving data, regardless of position in a grid, we’re only interested in used/available space. Easy, just some elementary maths.

Part 2

On the other hand, part 2 was very hard. I couldn’t even code a universal solution. A usual BFS brute force wouldn’t work as the problem space is too big. Instead I combined the strong points of the computer: looking up data and doing simple maths - and strong points of human: pattern recognition. First, I printed the grid.

There is only one empty node. Which means we need to move the “hole” next to the node we’re interested in. In my case, it happens to be last but one node on the last row. So I would simply move it up (1 step for each row), except there are also a few nodes much larger than the rest, that can’t be copied. They form a “wall” which we need to pass to the left and then go back to the right.

Finally, we need to move the data using the empty node, then move the empty node (by going down, to the side and up again). So, moving the data by one column takes 5 steps. Complete formula is (emptyx+1-wallbegin)+emptyy+wallsize+(width-1)*5 which at least makes the solution viable for other setups where the wall is in one row, extends to the right edge and the hole is down and to the right relative to the first node of the wall.

#!/usr/bin/python3

import re
from dataclasses import dataclass

INPUTFILE="22-input.txt"

@dataclass(frozen=True)
class Node:
    x: int
    y: int
    size: int
    used: int
    available: int

rx1=re.compile(r"x(\d+)-y(\d+)\s+(\d+)T\s+(\d+)T\s+(\d+)T")

grid=[]

with open(INPUTFILE) as f:
    for i, line in enumerate(f):
        if i<=1:
            continue
        m=rx1.search(line)
        grid.append(Node( *map(int,m.groups() )))

viable=0

print(grid[2])

for nodeA in grid:
    if nodeA.used==0:
        continue
    for nodeB in grid:
        if nodeA!=nodeB and nodeA.used<=nodeB.available:
            viable+=1

print(f"Part 1: {viable}")

# print grid
width=max( node.x for node in grid )
height=max( node.y for node in grid )

gridmap=[[0 for _ in range(width+1)] for _ in range(height+1)]
for node in grid:
    gridmap[node.y][node.x]="█" if node.used>90 else "."
    if node.used==0:
        gridmap[node.y][node.x]="#"
        emptyx,emptyy=node.x, node.y
# show start and end node
gridmap[0][width]="S"
gridmap[0][0]="E"

wallbegin=min(node.x for node in grid if node.used>90)
wallsize=width+1-wallbegin

for row in gridmap:
    for d in row:
        print(d,end="")
    print("")

print(f"Width {width} height {height} empty node {emptyx, emptyy} wall size {wallsize}")

part2=(emptyx+1-wallbegin)+emptyy+wallsize+(width-1)*5
print(f"Part 2: {part2}")

2016 day 23: Safe Cracking

Mon, 13 Nov 2023 17:32:00 +0100

We’re cracking an electronic lock by emulating a simple computer. The assembunny code is similar to day 12, so it’s a good starting point. For part 1, we need to add one instruction, TGL, which modifies a specific instruction.

Part 2 is annoying, in a similar way to the previous puzzle: I can’t code a universal solution. The code for part 1 works, but is too slow: instruction suggests we should implement a multiply instruction. In the input file there are two blocks that increment register many times, there’s an inner loop with jnz -2 and outer loop with jnz -5. The end result is very fast (few milliseconds, while unoptimized code didn’t find the solution in 30 minutes) but also very fragile - it would fail with another input file, where jnz -5 is preceded by some other instructions. But coding a real optimizer is well outside the scope of a puzzle.

#!/usr/bin/python3


INPUTFILE="23-input.txt"

class Computer:
    register: dict = {}
    pointer: int = 0
    instructions: list[str]

    def __init__(self, filename: str) -> None:
        with open(filename) as f:
            self.instructions = f.read().splitlines()
        self.reset()
        self.optimize()

    def reset(self) -> None:
        self.register["a"]=0
        self.register["b"]=0
        self.register["c"]=0
        self.register["d"]=0
        self.pointer=0

    def optimize(self) -> None:
        for i,instr in enumerate(self.instructions):
            cmd=instr.split()
            if cmd[0]=="jnz" and cmd[2]=="-5":
                jmpreg=cmd[1] # register to check for jnz
                cmd1=self.instructions[i-5].split() # inner loop
                cmd2=self.instructions[i-1].split() # counter for jump
                cmd3=self.instructions[i-4].split() # target register
                jmpreset=cmd1[2] # register reset

                targetreg1=cmd1[1]
                targetreg2=cmd2[1]
                targetval=cmd3[1]
                newcmd=f"mul {targetreg1} {targetreg2} {targetval}"
                self.instructions[i-5]=newcmd
                self.instructions[i-4]="nop"
                self.instructions[i-3]="nop"
                self.instructions[i-2]="nop"
                self.instructions[i-1]=f"cpy 0 {jmpreset}"  
                self.instructions[i]=f"cpy 0 {jmpreg}"  


    def __repr__(self) -> str:
        return f"Registers: {self.register} pointer {self.pointer} current instruction {self.instructions[self.pointer]}"

    def get(self, arg: str) -> int:
        try:
            return int(arg)
        except ValueError:
            return self.register[arg]

    def toggle(self, arg: str, debug=False) -> None:
        offset=self.get(arg)-1
        try:
            oldinstr=self.instructions[self.pointer+offset]
        except IndexError:
            if debug:
                print(f"Toggle: index {self.pointer+offset} out of range")
            return
        cmd=oldinstr.split()
        match cmd:
            case ("inc", arg):
                newinstr=f"dec {arg}"
            case (_, arg):
                newinstr=f"inc {arg}"
            case ("jnz", arg1, arg2):
                newinstr=f"cpy {arg1} {arg2}"
            case (_, arg1, arg2):
                newinstr=f"jnz {arg1} {arg2}"
            case _:
                newinstr=oldinstr
        self.instructions[self.pointer+offset]=newinstr
        self.optimize()
        if debug:
            print(f"toggle instruction at {arg} {offset} from {oldinstr} to {newinstr}")
            #print(self.instructions)

    def run(self, debug=False) -> None:
        while self.pointer<len(self.instructions):
            cmd=self.instructions[self.pointer].split()
            if (debug): print(self)
            self.pointer+=1  # will have to decrease by 1 for jumps
            match cmd:
                case ["nop"]:
                    pass
                case ("cpy", arg, target):
                    self.register[target]=self.get(arg)
                case ("inc", arg):
                    self.register[arg]+=1
                case ("mul", arg1, arg2, arg3):
                    self.register[arg3]+=self.get(arg1)*self.get(arg2)
                case ("tgl", arg):
                    self.toggle(arg, debug=debug)
                case ("dec", arg):
                    self.register[arg]-=1
                case ("jnz", testval, offset):
                    self.pointer += self.get(offset) -1 if self.get(testval)!=0 else 0
                case _: raise ValueError(cmd)
        


computer=Computer(INPUTFILE)
computer.register["a"]=7
computer.run(debug=False)
print("Part 1, register A: ",computer.register["a"])

computer=Computer(INPUTFILE)
computer.register["a"]=12
computer.run(debug=False)
print("Part 2, register A: ",computer.register["a"])

2016 day 01: No Time for a Taxicab

Sat, 27 May 2023 17:32:00 +0200

Title is a reference to a Taxicab Metric, but you don’t even need to know what’s that. As usual, first days of Advent of Code are simple.

We’re moving on a 2D grid. We need to keep track of visited points, a set is an obvious structure for it. I used an immutable dataclass for point, though a simple tuple of 2 ints would do.

#!/usr/bin/python3

from dataclasses import dataclass

INPUTFILE="01-input.txt"


#immutable data class
@dataclass(frozen=True)
class Point:
    x: int
    y: int

# read input file
with open(INPUTFILE) as f:
    line=f.readline().strip()
    directions=line.split(", ")


current=Point(0,0)
visited=set()
visited.add(current)
direction=0 # 0=N, 1=E, 2=S, 3=W
part2done=False
for i in directions:
    move=int(i[1:])
    if i[0]=="R":
        direction=(direction+1)%4
    else:
        direction=(direction-1)%4
    #print(direction)
    newx=current.x
    newy=current.y
    for j in range(move):
        if direction==0:
            newy+=1
        elif direction==1:
            newx+=1
        elif direction==2:
            newy-=1
        elif direction==3:
            newx-=1
        current=Point(newx, newy)
        #print(current)
        if (not part2done) and (current in visited):
            print("Visited twice: ", current)
            #calculate distance
            print("Distance (part 2): ", abs(current.x)+abs(current.y))
            part2done=True
        # add current to visited
        visited.add(current)



# calculate distance
print("Final position: ", current)
print("Distance (part 1): ", abs(current.x)+abs(current.y))

2016 day 02: Bathroom Security

Sat, 27 May 2023 17:32:00 +0200

2D grid with a twist. I wrote a simple solution using way too many elifs. Could be made a bit shorter by using hexadecimal numbers. Or much shorter by using a lookup table. But I didn’t bother, let’s go to the more interesting tasks.

#!/usr/bin/python3

INPUTFILE="02-input.txt"

#part 1
current="5"
code1=[]
with open(INPUTFILE) as f:
    for line in f:
        line=line.strip()
        for i in line:
            if i == "D":
                if current in "123456":
                    current=str(int(current)+3)
            elif i == "L":
                if current not in "147":
                    current=str(int(current)-1)
            elif i == "R":
                if current not in "369":
                    current=str(int(current)+1)
            elif i == "U":
                if current in "456789":
                    current=str(int(current)-3)
        code1.append(current)
print("Part 1 code: ", ''.join(code1))

#part 2
#TODO: make the code shorter using hexadecimals

current="5"
code2=[]
with open(INPUTFILE) as f:
    for line in f:
        line=line.strip()
        for i in line:
            if i == "D":
                if current in "234":
                    current=str(int(current)+4)
                elif current=="1":
                    current="3"
                elif current=="6":
                    current="A"
                elif current=="7":
                    current="B"
                elif current=="8":
                    current="C"
                elif current == "B":
                    current="D"
            elif i == "L":
                if current in "346789":
                    current=str(int(current)-1)
                elif current=="B":
                    current="A"
                elif current=="C":
                    current="B"
            elif i == "R":
                if current in "235678":
                    current=str(int(current)+1)
                elif current=="A":
                    current="B"
                elif current=="B":
                    current="C"
            elif i == "U":
                if current in "678":
                    current=str(int(current)-4)
                elif current=="3":
                    current="1"
                elif current=="A":
                    current="6"
                elif current=="B":
                    current="7"
                elif current=="C":
                    current="8"
                elif current=="D":
                    current="B"

        code2.append(current)
print("Part 2 code: ", ''.join(code2))

2016 day 03: Squares With Three Sides

Sat, 27 May 2023 17:32:00 +0200

We have a list of triangles, or “triangles”, and we need to find which ones are possible. In Euclidean geometry, that is, not something from Cthulhu mythos. Easy. Slight twist for part 2 - the dimensions are given in columns, not in rows.

#!/usr/bin/python3

INPUTFILE="03-input.txt"

#part 1
num_triangles=0
with open(INPUTFILE) as f:
    for line in f:
        sides=[int(i) for i in line.split()]
        sides.sort()
        if sides[0]+sides[1]>sides[2]:
            num_triangles+=1
print("Part 1: ", num_triangles)

#part 2
triangles=[]
num_triangles=0
with open(INPUTFILE) as f:
    lines=[]
    for line in f:
        lines.append([ int(i) for i in line.split() ])
        if len(lines)>=3:
            # process a triangle
            triangles.extend([ lines[0][i], lines[1][i], lines[2][i] ] for i in range(3))
            lines=[]
#print(triangles)
for sides in triangles:
    #print(sides)
    sides.sort()
    if sides[0]+sides[1]>sides[2]:
        num_triangles+=1
print("Part 2: ", num_triangles)

2016 day 04: Security Through Obscurity

Sat, 27 May 2023 17:32:00 +0200

Two tasks. Part 1 was about calculating a checksum using an unusual algorithm. Two slightly interesting things. Counter object, which greatly simplified the code. And a way to sort dict descending by value, then ascending by key: sorted(lettercounter, key=lambda x: (-x[1],x[0])). Get it? Let’s start from the inside. We define a lambda function for key, it returns a tuple. x[1] is the value, - for reversing the sort order. Then x[0] is the key.

Part 2 was a simple cypher - addition, subtraction and modulo are all that’s needed.

#!/usr/bin/python3

import re
from collections import Counter


rx1=re.compile(r"([a-z-]+)([0-9]+)\[([a-z]+)\]")

INPUTFILE="04-input.txt"

def calculate_sum(name):
    name=name.replace("-","")
    lettercounter=Counter(name).most_common()
    sortedcounter=sorted(lettercounter, key=lambda x: (-x[1],x[0]))  # sort descending by value, then ascending by key
    checksum=""
    for l,_ in sortedcounter[:5]:
        checksum+=l
    return checksum

def decrypt_name(name, sector):
    newname=""
    for letter in name:
        if letter=="-":
            newletter=" "
        else:
            lettercode=ord(letter)
            lettercode+=sector%26
            if lettercode>ord("z"):
                lettercode-=26
            newletter=chr(lettercode)
        newname+=newletter
        #print(f"{letter} becomes {newletter}")
    return newname


sum_sector=0
with open(INPUTFILE) as f:
    for line in f:
        if roomsearch := rx1.search(line):
            roomname, roomsector, roomsum=roomsearch.groups()
            newsum=calculate_sum(roomname)
            if roomsum == newsum:
                newname=decrypt_name(roomname,int(roomsector))
                sum_sector+=int(roomsector)
                #print(f"Correct room: {roomname}, sector {roomsector}, checksum {roomsum}, new name {newname}")
                if "northpole" in newname:
                    print("Part 2, ID of northpole storage: ", roomsector)
        else:
            print("Wrong room format (or wrong regexp): ", line)
print("Part 1, sum of sectors: ", sum_sector)

2016 day 05: How About a Nice Game of Chess?

Sat, 27 May 2023 17:32:00 +0200

We’re generating a password by making a lot of md5 hashes and extracting specific characters. Nothing special, there’s a handy md5 function in the hashlib module from the standard library. For part 2, I store the password as an array of characters, not string (one thing that would be easier in C…), convert on printing. Looks a bit messy, but makes it easier to insert characters at a specific position.

#!/usr/bin/python3

import hashlib

doorid="uqwqemis"

i=0
p1password=""
p2password=['-','-','-','-','-','-','-','-']
part1done=False
part2done=False

while True:
    newid=doorid+str(i)
    newhash=hashlib.md5(newid.encode()).hexdigest()
    if i%1000000==0: # print stats so we can see some progress
        print(f"Iteration {i} newid {newid} md5 {newhash}")
    if newhash.startswith("00000"):
        #part1
        if not part1done:
            p1password+=newhash[5]
            print ("Found character for part 1, current password: ", p1password)
            if len(p1password)==8:
                print("Part 1 done")
                part1done=True
        #part2
        if not part2done:
            if newhash[5] in ("0","1","2","3","4","5","6","7"):
                newpos=int(newhash[5])
                if p2password[newpos]=="-":
                    p2password[newpos]=newhash[6]
                    print ("Found character for part 2, current password: ", "".join(p2password))
                    if not "-" in p2password:
                        print("Part 2 done")
                        part2done=True
    if part1done and part2done:
        break
    i+=1 

print("Part 1, password: ", p1password)
print("Part 2, password: ", "".join(p2password))

2016 day 06: Signals and Noise

Sat, 27 May 2023 17:32:00 +0200

We need to find the most common and the least common letter in each column of the input. Counter class again.

#!/usr/bin/python3

from collections import Counter

INPUTFILE="06-input.txt"

inputcols=[]

with open(INPUTFILE) as f:
    for line in f:
        for i,letter in enumerate( line.strip() ): # iterate over letters + get column number
            try:
                inputcols[i]+=letter
            except IndexError: # we don't have a string for this column yet (we're on line 1 of file)
                inputcols.append(letter)


message1=""
message2=""


for col in inputcols:
    lettercount=Counter(col).most_common()
    letter1=lettercount[0][0]
    letter2=lettercount[-1][0]
    message1+=letter1
    message2+=letter2

print("Part 1, message: ", message1)
print("Part 2, message: ", message2)

2016 day 07: Internet Protocol Version 7

Sat, 27 May 2023 17:32:00 +0200

We’re looking at a list of “IPv7” addresses and need to find those that contain specific sequences of repeated characters.

I used two different methods. For part 1 - the obvious way, regular expressions with backreferences. I hate them, though I seem to be getting better at them.

But I couldn’t write the right regexp for part 2. Instead, I found it easier to do some C-style coding in Python: process the string as a character array and use a very simple state machine (with just 2 states: inside and outside the square brackets). I’m looking for all ABA blocks, store them in two sets (actually I just store AB), separately for inside and outside square brackets. Then it’s just checking if the two sets have any elements in common. The important thing is to reverse characters for one of the sets.

#!/usr/bin/python3

import re

INPUTFILE="07-input.txt"


rx1=re.compile(r"(\w)(\w)\2\1")  # check for reversed pair, eg. abba, but will also catch aaaa
rx2=re.compile(r"\[\w*(\w)(\w)\2\1\w*]") # check for reversed pair in square brackets
rx3=re.compile(r"(\w)\1{3}") # check for "reversed pair" of same characters



def check_tls(line):
    if rx2.search(line):
            return False
    if rx3.search(line):
            return False
    if rx1.search(line):
            return True
    return False


def check_ssl(line):
    in_hyper_block=False
    hyper_matches=set()
    no_hyper_matches=set()
    for i in range(len(line)-2): # we're looking 2 characters ahead from current index
        if line[i]=="[":
            in_hyper_block=True
        elif line[i]=="]": 
            in_hyper_block=False
        elif line[i]==line[i+2] and line[i]!=line[i+1]:   # found aba block
            if in_hyper_block:
                hyper_matches.add(line[i]+line[i+1])
            else:
                no_hyper_matches.add(line[i+1]+line[i]) # reverse block
        if hyper_matches & no_hyper_matches:
            return True
    return False


tlscount=0
sslcount=0
with open(INPUTFILE) as f:
    for line in f:
        line=line.strip()
        if check_tls(line):
            tlscount+=1
        if check_ssl(line):
            sslcount+=1

print("Part 1, TLS addresses: ", tlscount)
print("Part 2, SSL addresses: ", sslcount)

2016 day 08: Two-Factor Authentication

Sat, 27 May 2023 17:32:00 +0200

We have a series of instructions for the screen and need to interpret them. Emulating strange hardware is my favourite part of Advent of Code. But this one was too simple.

I used Numpy. One of the instructions is rotate, Numpy provides a function “roll” that does just that. I also packed most of the code in a class. Both aren’t really needed for a simple task like this.

#!/usr/bin/python3

import numpy as np

WIDTH=50
HEIGHT=6
INPUTFILE="08-input.txt"

class Display:
    height: int
    width: int
    screen: np.array
    def __init__(self, _width:int, _height: int):
        self.height=_height
        self.width=_width
        self.screen=np.zeros((self.height, self.width))  # use screen[y][x] when indexing

    def count_pixels(self):
        return np.count_nonzero(self.screen)

    def display(self):
        for i in range(self.height):
            print('|',end='')
            for j in range(self.width):
                if self.screen[i][j]==0:
                    print(' ', end='')
                else:
                    print('█', end='')
            print('|', i)

    def rotate_col(self, x: int, by: int):
        newcolumn=np.roll(self.screen[:,x], by)
        self.screen[:, x]=newcolumn

    def rotate_row(self, y: int, by: int):
        newrow=np.roll(self.screen[y], by)
        self.screen[y]=newrow

    def draw_rect(self, w: int, h: int):
        self.screen[0:h, 0:w]=1


def do_rect(line: str, display: Display):
    _,coords=line.strip().split(' ')
    w,h=coords.split('x')
    w=int(w)
    h=int(h)
    display.draw_rect(w, h)
    
    

def do_rotate(line: str, display: Display):
    _,axis,coord,_,by=line.strip().split(' ')
    by=int(by)
    _,addr=coord.split('=')
    addr=int(addr)
    #print(f"Rotating {axis} {addr} by {by}")
    if axis=="row":
        display.rotate_row(addr, by)
    else:
        display.rotate_col(addr, by)


d=Display(WIDTH, HEIGHT)

with open(INPUTFILE) as f:
    for line in f:
        if line[0:4]=="rect":
            do_rect(line, d)
        elif line[0:6]=="rotate":
            do_rotate(line, d)
        else:
            print("wrong command")


d.display()

print("Part 1, pixels on: ", d.count_pixels() )

2016 day 10: Balance Bots

Sat, 27 May 2023 17:32:00 +0200

The instruction wasn’t very clear, but here’s the situation. We have 2 types of bot commands:

take microchip: this can always be executed
give microchip to another bot or place it in the output: this can only be executed if the bot has 2 microchips

So here’s my take: I process the input file, execute the first type of instructions immediately and put others in the queue. Then I iterate over the instruction queue until it’s empty: if the bot is ready, the command is executed and removed from the queue.

#!/usr/bin/python3

from collections import defaultdict
from dataclasses import dataclass

INPUTFILE="10-input.txt"

@dataclass
class BotInstruction:
    source: int
    type1: str
    target1: int
    type2: str
    target2: int

    def execute(self) -> bool:
        global bots
        if bots[self.source].check_and_swap():
            print(f"Part 1: {self.source}")
        bots[self.source].give(self.type1, self.target1, self.type2, self.target2)

@dataclass
class OutputBin:
    chip: int = 0

    def add(self, value: int) -> None:
        self.chip=value

@dataclass
class Bot:
    chip1: int = 0
    chip2: int = 0

    def add(self, value: int) -> None:
        if not self.chip1:
            self.chip1=value
        else:
            self.chip2=value

    def is_ready(self) -> bool:
        return self.chip1 > 0 and self.chip2 > 0

    def check_and_swap(self) -> bool:
        if self.chip1>self.chip2:
            self.chip1, self.chip2 = self.chip2, self.chip1
        return self.chip1==17 and self.chip2==61
            

    def give(self, type1: str, target1: int, type2: str, target2: int) -> None:
        global bots
        # print(f"{self.chip1} to {type1} {target1}, {self.chip2} to {type2} {target2} ")
        if type1=="bot":
            bots[target1].add(self.chip1)
        else:
            bins[target1].add(self.chip1)
        if type2=="bot":
            bots[target2].add(self.chip2)
        else:
            bins[target2].add(self.chip2)
        self.chip1=0
        self.chip2=0


# MAIN

bots=defaultdict(Bot)
bins=defaultdict(OutputBin)
instructions=[]

with open(INPUTFILE) as f:
    for line in f:
        if line.startswith("value"):
            _, value, _, _, _, botnum = line.split()
            bots[int(botnum)].add(int(value))
        else:
            _, firstbot, _, _, _, type1, target1, _, _, _, type2, target2 = line.split()        
            instructions.append(BotInstruction(int(firstbot), type1, int(target1), type2, int(target2)) )

while instructions:
    for cmd in instructions.copy():
        if bots[cmd.source].is_ready():
            instructions.remove(cmd)
            cmd.execute()


part2 = bins[0].chip * bins[1].chip * bins[2].chip
print(f"Part 2: {part2}")

2016 day 12: Leonardo's Monorail

Sat, 27 May 2023 17:32:00 +0200

We need to simulate a computer with a very simple CPU architecture: 4 registers, 4 instructions. Easy. Very similar to day 23 from 2015, in fact I copied some code. But at this point I learned how to use match/case more effectively, not only to match strings, but also check arguments and extract them. Another trick I should have discovered sooner: sometimes the argument could be either a number or a register. How do we check for that in the parser? Simple, we don’t, we just run the function that reads the string, tries to convert it to int and if that fails - reads the register.

#!/usr/bin/python3


INPUTFILE="12-input.txt"

class Computer:
    register: dict = {}
    pointer: int = 0
    instructions: list[str]

    def __init__(self, filename: str) -> None:
        with open(filename) as f:
            self.instructions = f.read().splitlines()
        self.reset()

    def reset(self) -> None:
        self.register["a"]=0
        self.register["b"]=0
        self.register["c"]=0
        self.register["d"]=0
        self.pointer=0


    def __repr__(self) -> str:
        return f"Registers: {self.register} pointer {self.pointer} current instruction {self.instructions[self.pointer]}"

    def get(self, arg: str) -> int:
        try:
            return int(arg)
        except ValueError:
            return self.register[arg]

    def run(self, debug=False) -> None:
        while self.pointer<len(self.instructions):
            cmd=self.instructions[self.pointer].split()
            if (debug): print(self)
            self.pointer+=1  # will have to decrease by 1 for jumps
            match cmd:
                case ("cpy", arg, target):
                    self.register[target]=self.get(arg)
                case ("inc", arg):
                    self.register[arg]+=1
                case ("dec", arg):
                    self.register[arg]-=1
                case ("jnz", testval, offset):
                    self.pointer += int(offset) -1 if self.get(testval)!=0 else 0
                case _: raise ValueError
        


computer=Computer("12-input.txt")
computer.run(debug=False)
print("Part 1, register A: ",computer.register["a"])
computer.reset()
computer.register["c"]=1
computer.run(debug=False)
print("Part 2, register A: ",computer.register["a"])

2016 day 14: One Time Pad

Sat, 27 May 2023 17:32:00 +0200

We need to generate 64 MD5 hashes. The hash is correct if it has 3 of the same characters in a row AND in the next 1000 hashes there’s one that has the same character repeated 5 times. Easy.

It’s clear to see that a naive solution would calculate the same hash many times. There are many clever ways to overcome it, eg. we can start by computing all the hashes and store them in a lookup table, or we can have some sort of a moving window and keep 1000 recent hashes. But Python has a much simpler solution: we can cache results of the function by using just one import statement: from functools import cache and prepending the function with a decorator @cache.

For part 2, we need to use key stretching, each hash is looped 2016 times. Even with caching, it takes about 30 seconds. How long without cache? I tried disabling it, ran the code for 20 minutes with debug enabled and it only got to about 10%.

#!/usr/bin/python3

import hashlib
import re
from functools import cache

SALT="ahsbgdzn"
has3=re.compile(r"(\w)\1\1")

@cache
def gethash(i: int) -> str:
    newid=SALT+str(i)
    return hashlib.md5(newid.encode()).hexdigest()
# execution time: 2.6 vs 0.5

@cache
def getstretchedhash(i: int) -> str:
    newid=SALT+str(i)
    stretchedhash= hashlib.md5(newid.encode()).hexdigest()
    for _ in range(2016):
        stretchedhash=hashlib.md5(stretchedhash.encode()).hexdigest()
    return stretchedhash

def check5(startindex: int, text: str, stretched=False) -> int:
    for i in range(startindex+1,startindex+1000):
        nexthash = getstretchedhash(i) if stretched else gethash(i)
        if text in nexthash:
            return i
    return 0

# part1

def get64hashes(stretched=False, debug=False) -> int:
    i=0
    num_hashes=0
    while True:
        nexthash=getstretchedhash(i) if stretched else gethash(i)
        if m:=has3.search((nexthash)):
            matched=m.group(1)
            if index_of_5:=check5(i,matched*5, stretched):
                num_hashes+=1
                if (debug):
                    print(f"Got new hash number {num_hashes} at index {i}")
                if num_hashes==64:
                    return i
        i+=1

print(f"Part 1: {get64hashes(stretched=False)}")
print(f"Part 2: {get64hashes(stretched=True)}")

2016 day 16: Dragon Checksum

Sat, 27 May 2023 17:32:00 +0200

We need to generate data that would fill a disk of a specific size, then calculate the checksum. Algorithm for generating and for checksum is described, unusual but nothing complicated.

For part 1, disk has a size 272 and for part 2: 35651584. This year, many problems were easy to solve with a simple algorithm for part 1, but part 2 made a problem space much bigger, requiring a clever solution. If that was supposed to be one of them, it didn’t work. Sure, I guess there is a way to calculate the checksum without actually generating and then iterating over 35 million characters. But my program runs in 7 seconds and uses less RAM than the editor I used to write it.

#!/usr/bin/python3

INPUT="00111101111101000"

def dragon(a: str) ->str:
    b="".join("0" if c=="1" else "1" for c in reversed(a))
    return a+"0"+b

def checksum(data: str) -> str:
    csum=""
    for i in range(0,len(data)-1,2):
        csum += "1" if data[i]==data[i+1] else "0"
    return csum if len(csum)%2 else checksum(csum)

def get_checksum_for_disk(initval: str, size: int):
    data=initval
    while len(data)<=size:
        data=dragon(data)
    data=data[:size]
    return checksum(data)

print(f"Part 1: {get_checksum_for_disk(INPUT,272)}")
print(f"Part 2: {get_checksum_for_disk(INPUT,35651584)}")

2016 day 17: Two Steps Forward

Sat, 27 May 2023 17:32:00 +0200

Part 1

Finding a path in a vault. At this point I wrote so many programs to find the shortest path in a 2D grid, I could probably do it in my sleep. There is a slight twist: a set of doors open/closed depends on the hash of the path taken. That means there’s no need to store “already visited states” as I usually do for BFS: even if I enter the same place again, different doors are open so it is a different state. And there’s really no smart way to solve it, bruteforcing the solution is the only way.

So, at each step we get a hash of the current path, we only need the first 4 characters: hashlib.md5(i.encode()).hexdigest()[:4]. Each character describes one door, they also have coordinates relative to the current place (eg. 0,-1 for up). We iterate on those: for (door, direction) in zip(doorhash,DIRECTIONS): If that direction is not out of range and the door is open - yield it, add to the queue.

When we reach the end point, break the loop and check the length of the path.

Part 2

So now we need to find the shortest and longest path. That’s just a simple modification. When we reach the end point, don’t break the loop, instead append the path to the list of possible paths.

In the end, just find the shortest and longest string in the list of paths. Python’s usual min and max functions can do that with just one extra argument key=len - meaning it will run the len() function on each element and use its result as a key for comparison.

Code

#!/usr/bin/python3

import hashlib
from dataclasses import dataclass
from typing import Tuple
from collections import deque

PASSCODE="pslxynzg"
WIDTH=4
HEIGHT=4
DIRECTIONS=( (0,-1), (0,1), (-1,0), (1,0) ) 
DIRNAME={ (0,-1):"U", (0,1):"D", (-1,0):"L", (1,0):"R" }


def gethash(i: str) -> str:
    return hashlib.md5(i.encode()).hexdigest()[:4]

def door_open(char: str) -> bool:
    return char in "bcdef"

@dataclass
class Gamestate:
    x: int = 1
    y: int = 1
    path: str=""

    def get_next_dir(self) -> Tuple[int, int]:
        doorhash=gethash(PASSCODE+self.path)
        for (door, direction) in zip(doorhash,DIRECTIONS):
            (deltax,deltay)=direction           
            if self.x+deltax<1 or self.x+deltax>WIDTH:
                continue
            if self.y+deltay<1 or self.y+deltay>HEIGHT:
                continue
            if door_open(door):
                yield direction


def get_paths(start_point: Gamestate, end_point: Tuple[int, int], pathlist: list) -> None:
    to_check=deque()
    to_check.append(start_point)
    while to_check:
        current_point=to_check.popleft()
        for dir in current_point.get_next_dir():
            newpath=current_point.path+DIRNAME[dir]
            newx=current_point.x+dir[0]
            newy=current_point.y+dir[1]
            if newx==end_point[0] and newy==end_point[1]:
                pathlist.append(newpath)
            else:
                newpoint=Gamestate(newx, newy, newpath)
                to_check.append(newpoint)


start=Gamestate()
end=(4,4)

paths=[]
get_paths(start, end, paths)
print(f"Part 1: { min(paths, key=len)  }")
print(f"Part 2: { len(max(paths, key=len))  }")

2016 day 18: Like A Rogue

Sat, 27 May 2023 17:32:00 +0200

A simple cellular automaton - like Conway’s Life, but in one dimension. Nothing special here. Input data has “^” and “.” characters, I changed them to 1s and 0s for easy calculation.

Instruction says that tile is a trap if one of these conditions is true;

Its left and centre tiles are traps, but its right tile is not.
Its centre and right tiles are traps, but its left tile is not.
Only its left tile is a trap.
Only its right tile is a trap.

After coding all those, turns out it can be simplified to “left is different than right”. Also, when we’re on the edge, we should consider places outside of the corridor as safe. Which means getting the new row based on the old row is as simple as that:

def get_next_row(oldrow: list) -> list:
    newrow=[]
    for i in range(len(oldrow)):
        left=oldrow[i-1] if i>=1 else 1
        right=oldrow[i+1] if i<len(oldrow)-1 else 1
        newrow.append(1 if left==right else 0)
    return newrow

Part 2

For part 2, the corridor has 400000 rows instead of 40. Which means if I wrote the code in a very inefficient way, it would take ages to run. But it takes 8 seconds and it’s quite elegant, so I don’t feel compelled to look for a better solution.

Code

#!/usr/bin/python3


STARTROW="^^.^..^.....^..^..^^...^^.^....^^^.^.^^....^.^^^...^^^^.^^^^.^..^^^^.^^.^.^.^.^.^^...^^..^^^..^.^^^^"
NUMROWS1=40
NUMROWS2=400000


def get_next_row(oldrow: list) -> list:
    newrow=[]
    for i in range(len(oldrow)):
        left=oldrow[i-1] if i>=1 else 1
        right=oldrow[i+1] if i<len(oldrow)-1 else 1
        newrow.append(1 if left==right else 0)
    return newrow


row=[ 1 if x=="." else 0 for x in STARTROW ]
sumsafe=sum(row)
for i in range(NUMROWS2-1):
    row=get_next_row(row)
    sumsafe+=sum(row)
    if i==NUMROWS1-2:
        print(f"Part 1: {sumsafe}")        

print(f"Part 2: {sumsafe}")

2016 day 19: An Elephant Named Joseph

Sat, 27 May 2023 17:32:00 +0200

Elves passing presents in a (large) circle. For part 1 - to the next elf, part 2 - to the elf sitting opposite. Elf without presents is eliminated.

I tried brute force first - worked for part 1, but was too slow for part 2. So we need to work smarter.

Part 1

I didn’t know the problem described here, but I thought the name must mean something and googled for “Joseph algorithm”. Google was smart enough to find “Josephus algorithm” for me. A standard solution for Josephus algorithm (I’m not pretending I invented it) also worked for part 1.

Part 2

There are generalized Josephus solutions for finding a survivor with a group of size n with a step of k. So, if we modify k at each step to be number_of_remaining_elves//2, that would work, right? Wrong. Well, it should work, probably I made some off-by-1 errors or something like that, but I couldn’t make it right.

Instead, I checked the answer on paper for some low numbers to try and find a pattern.

One elf keeps its present. If there are 2, first one wins. That’s just a special case that needs to be dealt with if n<3. What do we have next? For 3 and 9 we’re getting 3 and 9. These numbers are powers of 3. Coincidence?

So for our number of elves, we need to find the nearest power of 3 that’s smaller than that. Logarithm will give us the exponent (hey, I still remember something from high school maths!) and luckily Python has a function for calculating logarithm with an arbitrary base, not only natural logarithm like many languages. That saved me a terrible burden of replacing a base-3 logarithm with a natural logarithm (just kidding, that would be one extra operation).

base=int(log(n-1,3))
closestpower=3**base

Then, for the next few steps, we’re just getting one element away from the nearest power of 3. After that, something happens. We’re not moving by 1, but by 2? Some more trial and error coding got me at 2*n-3*closestpower and I have to admit I have no idea why, must be something to do with maths, but it works.

Code

#!/usr/bin/python3

from math import log

NUM_ELVES=3001330


def josephus(n: int) -> int:
    l = n - (1 << (n.bit_length() - 1))
    return 2*l + 1

def josephus2(n: int) -> int:
    if n<3:
        return 1
    exponent=int(log(n-1,3))
    closestpower=3**exponent
    if n-closestpower <= closestpower:
        return n-closestpower
    return 2*n-3*closestpower


print(f"Part 1, {josephus(NUM_ELVES)}")
print(f"Part 2, {josephus2(NUM_ELVES)}")

2016 day 20: Firewall Rules

Sat, 27 May 2023 17:32:00 +0200

We have some blocklists and need to find IPs outside of them. IPs are 32-bit numbers here, not the usual 4-octet notation. Good, that’s easier to compare. Blocklists are given in no particular order, sorting them is an obvious first step. They can also overlap.

Once again it’s an exercise in optimization. There are some nice, easy to code ways to do it that would work for smaller spaces and look pythonic. Eg. I could create ranges for blocklists, combine them with itertools.chain, unpack them into one list and just check if ip not combined_blocklist. But such ways would take too much time or memory to check 2^32 addresses. Solution? Code like it’s 1980 and only operations you have are +, - and <. I only got pythonic for input parsing because it only happens once.

#!/usr/bin/python3


INPUTFILE="20-input.txt"
MAXIP=2**32

with open(INPUTFILE) as f:
    data=sorted(f.read().splitlines())
    ipranges=[ ( int(x),int(y) ) for x,y in [line.split("-")  for line in data ] ]

ipranges.sort()
num_valid=0
ip=0
part1done=False

for limit_l,limit_h in ipranges:
    if ip<limit_l: # outside the lower limit, valid IP
        num_valid+=limit_l-ip
        if not part1done:
            print(f"Part 1: {ip}")
            part1done=True
    ip=max(ip, limit_h+1) # skip past the end of the current blocklist
# add IPs from the end of the last blocklist till the max value
num_valid+=MAXIP-ip

print(f"Part 2: {num_valid}")

2016 day 21: Scrambled Letters and Hash

Sat, 27 May 2023 17:32:00 +0200

Part 1

We need to scramble a password according to a list of instructions. Easy. First I parse the list of instructions with my favourite match/case. For every instruction there’s a simple function. There are operations such as swapping letters or rotating the string. All of them can be done with some string slicing and concatenation. Other than some annoying off-by-one errors in indexing, very simple.

Part 2

We need to unscramble a password. That is a bit more complicated. First, we need to iterate over the instruction in the reverse order, that’s easy: for line in reversed(instructions):. Then, some instructions work the same both ways, eg. swapping letters. Others are easily reversed, eg. for rotation I just change direction. Except one instruction, for rotating string based on a position of a letter. I wasn’t able to figure out how to reverse the formula, so I ended up trying all possibilities, getting the numbers and putting them in a lookup table, eg. if we’re rotating on a letter that’s on the 1st position, we need to rotate by 7.

#!/usr/bin/python3

INPUTFILE="21-input.txt"
STARTPASS="abcdefgh"
ENDPASS="fbgdceah"

def swap_positions(text, pos1, pos2):
    char1, char2 = text[pos1], text[pos2]
    tmppass=text[:pos1]+char2+text[pos1+1:]
    text=tmppass[:pos2]+char1+tmppass[pos2+1:]
    return text

def move_positions(text :str, pos1, pos2, inv):
    if inv:
        pos1,pos2=pos2,pos1
    char1=text[pos1]
    tmppass=text[:pos1]+text[pos1+1:]
    return tmppass[:pos2]+char1+tmppass[pos2:]

def swap_letters(text, char1, char2):
    pos1=text.index(char1)
    pos2=text.index(char2)
    tmppass=text[:pos1]+char2+text[pos1+1:]
    text=tmppass[:pos2]+char1+tmppass[pos2+1:]
    return text

def rotate(text, steps, direction, inv):
    if inv:
        direction = "right" if direction=="left" else "left"
    if direction=="right":
        steps=-steps
    return text[steps:]+text[:steps]

def rotate_on_letter(text, char1, inv):
    invrot = [7, 7, 2, 6, 1, 5, 0, 4]
    pos1=text.index(char1)
    if inv:
        steps= -invrot[pos1]
    else:
        steps=pos1 + (2 if pos1>=4 else 1)
    if steps>len(text):
        steps-=len(text)
    return rotate(text, steps, "right", inv)


def reverse(text, pos1, pos2):
    tmppass=text[pos1:pos2+1]
    return text[:pos1]+tmppass[::-1]+text[pos2+1:]

def run_instruction(password, line, inv=False, debug=False):
    if debug: print(password)
    match line.split():
        case ("swap", "position", pos1, "with", "position", pos2):
            return swap_positions(password, int(pos1), int(pos2))
        case ("swap", "letter", l1, "with", "letter", l2):
            return swap_letters(password, l1, l2)
        case ("rotate", direction, numsteps, _):
            return rotate(password, int(numsteps), direction, inv)
        case ("rotate", "based", "on", "position", "of", "letter", letter):
            return rotate_on_letter(password, letter, inv)
        case ("reverse", "positions", pos1, "through", pos2):
            return reverse(password, int(pos1), int(pos2))
        case ("move", "position", pos1, "to", "position", pos2):
            return move_positions(password, int(pos1), int(pos2), inv)
        case _:
            raise ValueError("unknown instruction")
    


with open(INPUTFILE) as f:
    instructions=f.read().splitlines()

password=STARTPASS
for line in instructions:
    password=run_instruction(password,line,False)
print(f"Part 1: {password}")

password=ENDPASS
for line in reversed(instructions):
    password=run_instruction(password,line,inv=True)
print(f"Part 2: {password}")

2016 day 15: Timing is everything

Mon, 22 May 2023 17:32:00 +0200

We have a machine with rotating discs. Each disk has many possible positions, only position 0 will let the ball fall through. Ball takes 1 second to fall between the disks. For part 1, sizes and initial positions are puzzle input. Part 2 just adds one disk.

Brute force

The naive solution is to simulate all the steps until we find the proper alignment. But hold on, is it really naive? Although it had to iterate through 3 million steps, it only took about 2 seconds. I’d say that solution is good enough.

Anyway, here it goes:

def brute_force(sizes: list, positions: list) -> int:
    t=0
    while True:
        if all( (t+startpos+num)%size==0 for num,(startpos,size) in enumerate(zip(positions,sizes)) ):
            return t
        t+=1

Position of each disk is a sum of starting position and time, modulo number of positions. But we don’t want the disks to align on position 0. Remember that the ball takes a second to reach the next disk, so each disk needs to be offset by 1. For the first one we need to solve: t+startpos==0, for the second one, t+startpos==-1 etc. Let’s just move the number to the left side of the equation (relax, that’s only primary school maths, it will get worse in the next solution) so the right side is always 0 and it’s easy to iterate.

I don’t usually like the all function, but here it actually makes the code more readable - we are really checking if all disks are in the right position.

Note that the function calculates the time when the machine aligns. The ball takes 1 second to reach the first disk, so to get the time to release the ball, we need to subtract 1.

Chinese Remainder Theorem

Even though the solution was fast, I wasn’t satisfied with it. Sure, for all practical purposes it was OK, but AoC is about learning and having fun. I wanted something better.

It was obvious there was no need to check all steps one by one. I made the following thought experiment: let’s choose the largest disk, say it has 17 positions. Find when it’s properly aligned. Then from this point, increment time by 17 instead of one and check if other disks aligned. At some point one of them is aligned, say it has 3 positions. Next time they are both aligned the same way, is 3*17=51 seconds later, so that’s the new value of step. Then we find the third disk and so on. All our disk sizes are prime numbers.

I didn’t code this solution, because at this point something rang a bell. I graduated in computer science, meaning at some point I learned a bit about advanced mathematics: number theory, matrices, differential equations, you name it. I then forgot much of it as it was 20 years ago and most of this stuff is not needed for the daily work (except once in a blue moon it unexpectedly helps to solve a programming problem). But modulo arithmetic appears in a lot of places, prime numbers are a known feature in cryptography. I remember I learned something about solving a system of equations in modulo arithmetic with prime numbers. After a few minutes of searching I found Chinese Remainder Theorem. Yep, that was it.

I’m not going to repeat what others wrote, Wikipedia has a theoretical background: https://en.wikipedia.org/wiki/Chinese_remainder_theorem and Rosetta Code has example code: https://rosettacode.org/wiki/Chinese_remainder_theorem. The hard part was calculating the right residues, it took some trial and error to get rid of inevitable off-by-one and “add or subtract” errors.

Code

#!/usr/bin/python3

from functools import reduce

INPUTFILE="15-input.txt"

def chinese_remainder(divisors: list, residues: list) -> int:
    csum = 0
    prod = reduce(lambda acc, b: acc*b, divisors)
    for divisor_i, a_i in zip(divisors, residues):
        p = prod // divisor_i
        csum += a_i * modular_inverse(p, divisor_i) * p
    return csum % prod
  

def modular_inverse(a: int, b: int) -> int:
    b0 = b
    x0, x1 = 0, 1
    if b == 1: return 1
    while a > 1:
        q = a // b
        a, b = b, a%b
        x0, x1 = x1 - q * x0, x0
    if x1 < 0: x1 += b0
    return x1

def get_residues(positions: list, sizes: list) -> list:
    residues=[]
    for i, (position, size) in enumerate(zip(positions, sizes)):
        newposition=(size-position-i)%size
        residues.append(newposition)
    return residues

def brute_force(sizes: list, positions: list) -> int:
    t=0
    while True:
        if all( (t+startpos+num)%size==0 for num,(startpos,size) in enumerate(zip(positions,sizes)) ):
            return t
        t+=1

# parse input
sizes=[]
positions=[]
with open(INPUTFILE) as f:
    for line in f:
        splitline=line.rstrip().split()
        size=int(splitline[3])
        position=int(splitline[11][:-1]) # skip last character - dot
        sizes.append(size)
        positions.append(position)


residues=get_residues(positions, sizes)
print(f"Disc sizes: {sizes}")
print(f"Disc positions: {positions}")
print(f"Residues: {residues}")

part1crt=chinese_remainder(sizes, residues)-1
part1force=brute_force(sizes,positions)-1

print(f"Part 1, Chinese Remainder Theorem: {part1crt}")
print(f"Part 1, brute force: {part1force}")

#part 2
sizes.append(11)
positions.append(0)
residues=get_residues(positions, sizes)
part2crt=chinese_remainder(sizes, residues)-1
part2force=brute_force(sizes,positions)-1
print(f"Part 2, Chinese Remainder Theorem: {part2crt}")
print(f"Part 2, brute force: {part2force}")

2016 day 13: A Maze of Twisty Little Cubicles

Sat, 20 May 2023 17:32:00 +0200

Finding distance on a 2D grid again: how many steps it takes to move from (1,1) to (31,39) if some paths are blocked by walls?

Finding empty spaces

We need to determine if a given point is a wall or an empty space by doing a simple calculation and then checking bit parity. First, let’s define the data structure for the grid points and create the function that check if the space is empty. Python 3.10 has a handy function bit_count.

@dataclass(frozen=True)
class Point:
    x: int
    y: int

def is_empty(point: Point) -> bool:
    v = point.x**2 + 3*point.x + 2*point.x*point.y + point.y + point.y**2 + FAVNUM
    return v.bit_count() %2==0

Let’s check with the sample data:

print("  0123456789")
for y in range(7):
    print(y,end="|")
    for x in range(10):
        if is_empty(Point(x,y)):
            print(" ", end="")
        else:
            print("█", end="")
    print("|")

Breadth First Search

A classic BFS algorithm should work. We need a queue of points to check, we need to record the points already checked and we need a starting point. Here it goes:

start_point=Point(1,1)
visited=set()
to_check=deque()
to_check.append(start_point)
visited.add(start_point)

We then iterate over the queue until it’s empty or we find the solution. Pop the point to check and then get the neighbours: for p in get_next_points(current_point):. Now we just have to write the get_next_points function.

Getting next points

We can move left, right, up or down from the current point - that’s -1 or +1. We can’t go diagonally and also we don’t want to return the current point. So, x can be -1 or 1 while y is 0, or vice versa. The easiest way to write it is:

    for deltax in [-1, 0, 1]:
        for deltay in [-1, 0, 1]:
            if abs(deltax)==abs(deltay):
                continue

The instruction says: “The cube maze starts at 0,0 and seems to extend infinitely toward positive x and y”. But I added a sanity check. If either x or y gets too large, I skip the point, just like I skip the negatives. We also need to skip walls: if not is_empty(newpoint): continue

Recording distance

starting point has a distance of 0 from the starting point (obviously)
all other points are initialized with infinity (in practice, a value much larger than expected will do)
new point gets a distance 1 larger than the previous point, but here’s an important thing: only if it’s smaller than the previously recorded distance (we can get to a point more than once and we’re only interested in the shortest path)

I used a dict of Points to keep distances and wrapped them in a class for convenience. I later added a function that prints the map.

class Map:
    distance: dict={}

    def __init__(self):
        for x in range(MAXX):
            for y in range(MAXY):
                self.distance[Point(x, y)] = MAXDISTANCE
        self.distance[Point(1,1)]=0

We need some answers

For part 1, we need to reach a specific point. Then we can stop the calculations: if p==target: return floormap.distance[p]

For part 2, we need to know how many points can be reached in 50 steps or less. Since we recorded all the distances, we can just find them in one line using dict comprehension: sum(v <= 50 for v in floormap.distance.values())

Code

#!/usr/bin/python3

from dataclasses import dataclass
from collections import deque
from os import get_terminal_size

FAVNUM=1350
#FAVNUM=10

MAXX=MAXY=200
MAXDISTANCE=9999

@dataclass(frozen=True)
class Point:
    x: int
    y: int

class Map:
    distance: dict={}

    def __init__(self):
        for x in range(MAXX):
            for y in range(MAXY):
                self.distance[Point(x, y)] = MAXDISTANCE
        self.distance[Point(1,1)]=0

    def print(self):
        width = min(get_terminal_size()[0]//3,MAXX)
        height = min(get_terminal_size()[1]-3,MAXX)
        for y in range(height):
            for x in range(width):
                p=Point(x,y)
                if is_empty(p):
                    d=self.distance[p]
                    if d<MAXDISTANCE:
                        print(f"{d:02d}", end=" ")
                    else:
                        print("   ", end="")
                else:
                    print("███", end="")
            print("")

            



def is_empty(point: Point) -> bool:
    v = point.x**2 + 3*point.x + 2*point.x*point.y + point.y + point.y**2 + FAVNUM
    return v.bit_count() %2==0


def get_next_points(p: Point) -> Point:
    global floormap
    for deltax in [-1, 0, 1]:
        for deltay in [-1, 0, 1]:
            if abs(deltax)==abs(deltay): # don't go diagonal
                continue
            newx=p.x+deltax
            newy=p.y+deltay
            if newx<0 or newy<0 or newx>=MAXX or newy>=MAXY:
                continue
            newpoint=Point(newx, newy)
            if not is_empty(newpoint):
                continue
            newdistance=floormap.distance[p]+1
            floormap.distance[newpoint]=min(floormap.distance[newpoint],newdistance)
            yield newpoint

def calculate_distances(target: Point) -> int:
    global floormap
    start_point=Point(1,1)
    visited=set()
    to_check=deque()
    to_check.append(start_point)
    visited.add(start_point)
    while to_check:
        current_point=to_check.popleft()
        for p in get_next_points(current_point):
            if p in visited:
                continue
            if p==target:
                return floormap.distance[p]
            to_check.append(p)
            visited.add(p)


floormap=Map()
part1answer=calculate_distances(Point(31,39))
print(f"Part 1: {part1answer}")
part2answer = sum(v <= 50 for v in floormap.distance.values())
print(f"Part 2: {part2answer}")
#floormap.print()

2016 day 11: Radioisotope Thermoelectric Generators

Wed, 17 May 2023 17:32:00 +0200

Puzzle description is long and quite convoluted. We need to move some Radioisotope Thermoelectric Generators and microchips to the fourth floor. Generators emit radiation which will damage the microchip on the same floor, unless the chip is connected to a corresponding generator. Elevator can take one or two devices (won’t go empty).

It’s one of the tough ones. I tried to solve it myself, got stuck and searched for solutions. Then I combined some parts of https://eddmann.com/posts/advent-of-code-2016-day-11-radioisotope-thermoelectric-generators/ with what I wrote before (or what I decided to do in a different way).

First thoughts

we have to check many possible ways to solve the problem,
instruction suggests we probably shouldn’t check all ways because that would make the problem too large,
the tricky part is the data structure, how do we model the problem?
enough thinking, let’s do some exploratory coding

Input

Parsing input file is easy. Each line is one floor, so for i,line in enumerate(f): gives a floor number (starting from 0, as it should - I can just add 1 while printing) and a line. Then we need to capture a word before " generator" and “-compatible”, easy with regexps:

rx1=re.compile(r"(\w+) generator")
rx2=re.compile(r"(\w+)-compatible")

Now I can store the data in many ways. Should I have a data structure that describes a floor with all possible devices? Or a dict of generators and a dict of microchips with element as the key, floor as the value? Or a list of generators and a list of microchips on each floor? At first I went with the last approach. It makes it easy to check for valid state (see below). But it makes it harder to find the next state. We can move:

1 or 2 microchips,
1 or 2 generators,
1 of each type of object.

It’s easier if they are in the same data structure. I can combine the lists together eg. with itertools.chain, but then I would have two objects called “promethium” with no way to tell which one is a generator and which one is a microchip. So, let’s keep them all in one list. But that means I need to also store the type, not just the name. Dataclasses to the rescue:

@dataclass
class Device:
    name: str
    type: str

Also, while we’re at it, let’s change the list to set. Lists are faster for iterating, sets are faster for most other operations. Sets can only store hashable objects, but that only requires changing @dataclass to @dataclass(frozen=True). And the input parsing code looks like this:

floors=[]
with open(INPUTFILE) as f:
    for i,line in enumerate(f):
        floors.append(set())
        for rtg in rx1.findall(line):
            floors[i].add( Device(rtg, "generator") )
        for chip in rx2.findall(line):
            floors[i].add( Device(chip, "microchip") )

current_floor=0
max_floor=i+1

For a fully OOP solution, I should also create a Floor class containing a set of devices plus some functions operating on it. But I decided that a list of sets is good enough.

What’s a valid state?

If there’s no generator on the floor, there’s no radiation, so all chips are safe,
If there are no microchips on the floor, the radiation won’t harm anything,
If there are both chips and generators on the floor, every chip needs to have a corresponding generator

First condition is easy to check. Second condition will be checked implicitly by the third condition (we’re iterating over microchips, if there are none, there’s nothing to iterate on). But the third one is tricky. Now, it was easy when I had a separate list of chips and generators:

    for e in microchips:
        if e not in generators:
            return False

Or even shorter, though less readable: return all(e in generators for e in microchips) Function “all” returns True if all elements in the iterable are True, in this case, if we can find a generator for every chip. I don’t usually use it because for me this syntax is less readable (maybe I’m just not used to it). There’s also another function “any” which returns True if at least one element is True.

But now we need to filter the list to find microchips-only and generators-only iterables. We also need to extract first element of the tuple. So the for loop becomes this monstrosity:

    for device in filter(lambda x: x.type=="microchip", floor):
        if device.name not in [ dev.name for dev in filter(lambda x: x.type=="generator", floor)]:
            return False
    return True

That is horrible! How it would look with all?

    return all(
        device.name
        in [dev.name for dev in filter(lambda x: x.type == "generator", floor)]
        for device in filter(lambda x: x.type == "microchip", floor)
    )

For me, it looks even worse and it’s not faster, so I left the loop.

Wrapping the gamestate together

Since we have to create many possible states, store them, give them as an argument to the function or return them from the function, it makes sense to store them in an object. I also added a print function for debugging.

@dataclass
class Gamestate:
    elevator: int
    floors: list
    moves: int = 0

    def print(self) -> None:
        global maxfloor
        for i in range(maxfloor):
            print(f"Floor {i+1}: {self.floors[i]}  is valid? {is_valid_floor(self.floors[i])}")

Finding the next steps

We can move the devices up or down. The elevator can’t go below the first floor or above the last floor, so we can immediately skip this direction and only check the other one.

We can move 2 devices from the current floor: combinations(state.devices(), 2). We can also move 1 device at a time: combinations(state.devices(), 1). How do we iterate over both at a time? There’s a handy function in itertool called chain that combines iterators.

Next, we need to copy the gamestate. In the new object, we have to modify two floors: remove object from one and add them to the other one. We have sets, which have functions just for this. Finally, we need to check if those two floors are still valid.

Checking the end condition

We need to move all devices to the highest floor. How to check that? Easiest way: check if all other floors are empty. Let’s add one function to the Gamestate class:

    def is_done(self) -> bool:
        global maxfloor
        for i in range(maxfloor-1):
            if len(self.floors[i]):
                return False
        return True

Do not go back

What if we take a device up one level, then in the next step down one level, then up again etc.? That’s an infinite loop, and since we’re checking all possible moves, we would unavoidably hit it. We need to store the states that were already checked and skip them.

But there’s more. It’s not really important which generator or microchip is moved. A unique state can be described by number of generators and microchips on each floor plus the elevator position. I decided to encode a state in a string and make it readable to help debugging. I added this function to the Gamestate class:

    def get_seen_state(self) -> str:
        retval=f"elevator:{self.elevator} "
        for i,floor in enumerate(self.floors):
            count_chips = sum(1 for _ in filter(lambda x: x.type=="microchip", floor))
            count_rtgs = sum(1 for _ in filter(lambda x: x.type=="generator", floor))
            retval+=f"floor{i}:m{count_chips}g{count_rtgs} "
        return retval

New Python features: filter and lambda

Filter is a function that selects elements from an iterable object (list, set, tuple etc.). It takes two arguments, first is a function that returns True or False, second is an iterable. We can use a fully fledged function here, but lambda is a more popular choice for simple functions.

Lambda is a small, anonymous function. The syntax might look a bit awkward in the beginning (believe me, it’s MUCH better than lambda in C++), it looks like this: lambda arguments: expression. Only one expression and it’s automatically returned. The above code: filter(lambda x: x[1]=="c", floor) without lambda could be written like this:

def check_if_chip(x):
    return x.type=="microchip"

filter(check_if_chip, floor)

or even more explicit:

def check_if_chip(x):
    if x.type=="microchip"
        return True
    else:
        return False

filter(check_if_chip, floor)

Breadth First Search

We have an initial state, we generate possible next moves, where to go from here? We can follow one path until it finds a solution or a dead end (eg. using a recursive function), then follow another path etc., but that’s not an optimal solution. We’re looking for a minimal number of moves, if it’s (for example) 50, there’s no point in exploring paths that took 51 moves or more. Which means we should use a BFS, or Breadth First Search algorithm:

get all possible second steps from the initial state,
for each possible second step, get a list of possible third steps,
and so on,

Until the solution is found. It is then guaranteed to be the shortest solution. For the BFS, we need a queue - a data structure that operates on a First In - First Out basis. Python has a deque, double-ended queue which can also function as a stack. We start by adding the initial simulation state to the queue: queue = deque([state]). Then, in a loop, we get the oldest element from the queue: state = queue.popleft(), generate all possible next steps for it and add them to the queue: queue.append(next_state). And of course, at every iteration we check if we reached the end.

Part 2

Second part is the same algorithm, we’re just adding 4 more devices to the data structure. All it did was increasing calculation time from 5s to 37s.

Code

#!/usr/bin/python3

from collections import deque
import re
from dataclasses import dataclass
from itertools import chain, combinations
from copy import deepcopy


INPUTFILE="11-input.txt"

rx1=re.compile(r"(\w+) generator")
rx2=re.compile(r"(\w+)-compatible")




def is_valid_floor(floor: set) -> bool:
    # floor is valid if there's no generator...
    if not [e for e in floor if e.type=="generator" ]:
        return True
    # ...or for every chip there's a relevant generator
    for device in filter(lambda x: x.type=="microchip", floor):
        if device.name not in [ dev.name for dev in filter(lambda x: x.type=="generator", floor)]:
            return False
    return True


@dataclass(frozen=True)
class Device:
    name: str
    type: str

@dataclass
class Gamestate:
    elevator: int
    floors: list
    moves: int = 0

 
    def is_done(self) -> bool:
        global max_floor
        for i in range(max_floor-1):
            if len(self.floors[i]):
                return False
        return True

    def get_seen_state(self) -> str:
        retval=f"elevator:{self.elevator} "
        for i,floor in enumerate(self.floors):
            count_chips = sum(1 for _ in filter(lambda x: x.type=="microchip", floor))
            count_rtgs = sum(1 for _ in filter(lambda x: x.type=="generator", floor))
            retval+=f"floor{i}:m{count_chips}g{count_rtgs} "
        return retval

    def print(self) -> None:
        global max_floor
        print(f"--- elevator: {self.elevator+1}   moves: {self.moves}  -----")
        for i in range(max_floor):
            print(f"Floor {i+1}: {self.floors[i]}  is valid? {is_valid_floor(self.floors[i])}")


def get_next_move(state: Gamestate) -> Gamestate:
    global max_floor
    current_floor=state.elevator
    devices_to_move=chain( combinations(state.floors[current_floor], 2), combinations(state.floors[current_floor], 1)  )
    for devs in devices_to_move:
        for i in [-1, 1]:
            next_floor=current_floor+i
            if next_floor<0 or next_floor>=max_floor:
                continue

            newstate=deepcopy(state)
            newstate.elevator=next_floor
            newstate.moves+=1
            newstate.floors[current_floor]=newstate.floors[current_floor].difference(devs)
            newstate.floors[next_floor]=newstate.floors[next_floor].union(devs)

            if (is_valid_floor(newstate.floors[current_floor]) and is_valid_floor(newstate.floors[next_floor])):
                yield newstate


def count_moves(state: Gamestate) -> int:
    seen = set()
    queue = deque([state])

    while queue:
        state = queue.popleft()
        if state.is_done():
            return state.moves
        
        for next_state in get_next_move(state):
            if (key := next_state.get_seen_state()) not in seen:
                seen.add(key)
                # next_state.print()
                queue.append(next_state)




# parse input
floors=[]
with open(INPUTFILE) as f:
    for i,line in enumerate(f):
        floors.append(set())
        for rtg in rx1.findall(line):
            floors[i].add( Device(rtg, "generator") )
        for chip in rx2.findall(line):
            floors[i].add( Device(chip, "microchip") )

current_floor=0
max_floor=i+1

gamestate=Gamestate(current_floor, floors)
#gamestate.print()
print("Part 1: ") #47
print(count_moves(gamestate))
print("Part 2: ") #71
# reset and add devices
current_floor=0
floors[0]=floors[0].union([ Device("elerium", "generator"), Device("elerium", "microchip"), 
                            Device("dilithium", "generator"), Device("dilithium", "microchip") ])
gamestate=Gamestate(current_floor, floors)
print(count_moves(gamestate))

2016 day 09: Explosives in Cyberspace

Thu, 04 May 2023 17:32:00 +0200

Part 1

We have a compression algorithm: our input data contains markers such as (10x2) meaning take the next 10 characters and repeat them 2 times. “Compressed data” can also contain markers, but they should be skipped. We need to get the length of uncompressed file, skipping any whitespace.

Two things to consider: do we really decompress the data or just calculate the length? It’s quite possible to calculate without reconstructing the string, eg. marker (15x3) adds 14 characters (3*15 minus the original 15 minus the length of the marker 6). It is however possible that part 2 will require actually decompressing the data. I decided to take my chances and not decompress.

Second consideration: how to parse the data? Two solutions come to mind immediately. First way, use regular expressions to find possible markers (easy) and - based on their position in the input - decide whether they are real markers or they are inside the data block of another marker. Second way, a state machine approach: parse the input character by character and do a different thing depending on the current state: starting with the state “no special block”, after opening bracket switch to state “length”, after “x” - “repeat”, after closing bracket - “data”, and after specified number of characters back to “no special block”. This will automatically deal with markers inside data blocks, but is generally more complicated. Let’s try the regexp solution.

First, let’s prepare two input files: 09-input.txt contains my puzzle input and 09-small.txt contains test strings from the instruction. Now let’s read the file, call function to get uncompressed length of each line (stub for now) and sum up everything.

INPUTFILE="09-small.txt"

def get_uncompressed_length(string: str, debug: bool=False) -> int:
    return 1

with open(INPUTFILE) as f:
    totallength=0
    for line in f:
        line="".join(line.split())
        print(line)
        length=get_uncompressed_length(line)
        print (f"Uncompressed line length: {length}")
        totallength+=length

    print(f"Part 1: {totallength}")

That works. Just one explanation, line="".join(line.split()) removes all whitespace from the line. Now to find the markers. Here’s the regexp: rx1=re.compile( r"\((\d+)x(\d+)\)" ). Completely clear, as usual with regular expressions, right? Well, maybe not.

it starts with \( which is an opening bracket and ends with a closing bracket \) - brackets need to be escaped by backslash because they have a special meaning
then there’s (\d+) - \d is a digit, + means it can be repeated (but there’s at least one), brackets mean to remember it - it will be available as group(1)
then x is just x
and another group of digits, group(2)

We also need one special case: if the string checked doesn’t contain any markers, just return its length, it won’t change. If it does, first get the position of the beginning of the marker. Everything before that would be copied as-is, so again the length doesn’t change. And then it’s length*repeat. Then, we’ll have to find the next marker, skipping the data block. But for now let’s check if the regular expression is correct.

def get_uncompressed_length(string: str, debug: bool=False) -> int:
    marker=rx1.search(string)
    if not marker:
        return len(string)
    # we got first marker
    retval=marker.start()
    length=int(marker.group(1))
    repeat=int(marker.group(2))
    if (debug):
        print(f"found marker: repeat {length} characters {repeat} times")
    retval+=length*repeat
    return retval

Great, how do we skip past the data block? With string slicing and iteration.

def get_uncompressed_length(string: str, debug: bool=False) -> int:
    retval=0
    while string:
        marker=rx1.search(string)
        if not marker:
            retval+=len(string)
            break
        else:
            # we got the marker
            retval+=marker.start()
            length=int(marker.group(1))
            repeat=int(marker.group(2))
            if (debug):
                print(f"found marker: repeat {length} characters {repeat} times")
            retval+=length*repeat
            newposition=marker.end()+length
            string=string[newposition:]
            if (debug):
                print(f"    searching new string {string}")
    return retval

It worked! Let’s try with the full data. Also worked!

Part 2

So now we also have to consider the markers inside the data blocks. And the instruction hints that it’s better to calculate the size than actually uncompress, as the computer probably doesn’t have enough memory. Looks like I made the right decision.

So, all we have to do is a slight modification to the get_uncompressed_length function. We need to actually decompress the data block and call the get_uncompressed_length on it recursively. I’m not uncompressing the whole file at once, so hopefully I have enough RAM. As it turned out, my laptop took several minutes to calculate, but RAM usage was minimal.

Why is it so slow? Let’s check: python3 -m cProfile ./09-explosives.py shows that a lot of time is spent on various regexp functions. The usual tradeoff: “state machine” approach would run much faster, if written in C - probably less than a second, but also take longer to code.

Source code

#!/usr/bin/python3

import re

INPUTFILE="09-input.txt"

rx1=re.compile( r"\((\d+)x(\d+)\)" )
 

def get_uncompressed_length(string: str, debug: bool=False, part2: bool=False) -> int:
    retval=0
    while string:
        marker=rx1.search(string)
        if not marker:
            retval+=len(string)
            break
        else:
            # we got the marker
            retval+=marker.start()
            length=int(marker.group(1))
            repeat=int(marker.group(2))
            if (debug):
                print(f"Checking {string}")
                print(f"    found marker: repeat {length} characters {repeat} times")
            if (part2):
                data_begin=marker.end()
                data_end=data_begin+length
                newdata=string[data_begin:data_end]*repeat
                retval+=get_uncompressed_length(newdata, debug=debug, part2=True)
            else:
                retval+=length*repeat
            newposition=marker.end()+length
            string=string[newposition:]
            if (debug):
                print(f"    searching new string {string}")
    return retval

with open(INPUTFILE) as f:
    part1length=0
    part2length=0
    for line in f:
        line="".join(line.split())
        part1length+=get_uncompressed_length(line, part2=False)
        part2length+=get_uncompressed_length(line, part2=True)

    print(f"Part 1: {part1length}")
    print(f"Part 2: {part2length}")