Advent of Code 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))

2015 day 15: Science for Hungry People

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

We’re baking cookies. We have 4 ingredients which have 5 numeric properties (capacity, durability, flavor, texture and calories) . Our cookie takes 100 spoons of ingredients, we need to maximise the score (ignoring calories for part 1, getting exactly 500 calories for part 2).

There are many ways to mix the ingredients, from (100, 0, 0, 0) to (0, 0, 0, 100). Specifically, there are 176847 ways. Problem space is small enough for brute force to be useful, large enough that it makes sense to optimise.

The puzzle calls for some combined combinatorics (pun intended). First, generate all combinations with replacement of numbers from 0 to 100 that together add up to 100. Then, generate permutations of those. Why “with replacement”? Because the numbers can repeat, we might have 20 spoons of first ingredient and 20 spoons of the second ingredient. Why permutations? Because the first operation disregards order, eg. if it tries (1, 2, 3, 94) it won’t try (94, 1, 2, 3) because these are the same elements in a different order. We need permutations for that. Both are available in the itertools module.

First version of the code was slow, so I used tqdm module (from PyPI) to add a progress bar. After some fixes, the program finishes in a second, so it’s not really needed, but I left it anyway. Maybe someone wants to run it on a 386?

#!/usr/bin/python3

import re
from itertools import permutations, combinations_with_replacement
from tqdm import tqdm
from dataclasses import dataclass


FILENAME="15-input.txt"
MAXSIZE=100
TARGETCALORIES=500

@dataclass
class Ingredient:
    name: str
    capacity: int
    durability: int
    flavor: int
    texture: int
    calories: int


class Cookie:
    calories: int
    totalscore: int

    def __init__(self, ingr: tuple) -> None:
        global ingredients
        capacity=0
        durability=0
        flavor=0
        texture=0
        self.calories=0
        for num, amount in enumerate(ingr):
            capacity += amount*ingredients[num].capacity
            durability += amount*ingredients[num].durability
            flavor += amount*ingredients[num].flavor
            texture += amount*ingredients[num].texture
            self.calories += amount*ingredients[num].calories
        # any negative becomes 0
        capacity = max(capacity, 0)
        durability = max(durability, 0)
        flavor = max(flavor, 0)
        texture = max(texture, 0)
        self.totalscore=capacity*durability*flavor*texture


# parse input file
ingredients=[]
rx=re.compile( r"(\w+): capacity (\-?\d+), durability (\-?\d+), flavor (\-?\d+), texture (\-?\d+), calories (\-?\d+)" )
with open(FILENAME) as inputfile:
    for line in inputfile:
        name, capacity, durability, flavor, texture, calories = rx.match(line).groups()
        ingredients.append(Ingredient(name, int(capacity), int(durability), int(flavor), int(texture), int(calories)))

# calculate permutations
num_ingredients=len(ingredients)
ingr_combinations=[ i for i in combinations_with_replacement(range(MAXSIZE), num_ingredients) if sum(i)==MAXSIZE ]
print (f"Got {len(ingr_combinations)} combinations, calculating permutations of combinations")
ingr_permutations=set()
for combination in ingr_combinations:
    for i in permutations(combination):
        ingr_permutations.add(i)
print(f"Got {len(ingr_permutations)} permutations of combinations")

# bake cookies
maxscore=0
maxwithtarget=0
for recipe in tqdm(ingr_permutations):
    cookie=Cookie(recipe)
    maxscore=max(maxscore, cookie.totalscore)
    if cookie.calories == TARGETCALORIES and cookie.totalscore > maxwithtarget:
        maxwithtarget=cookie.totalscore

print("Part 1, max score: ", maxscore)
print("Part 2, max score: ", maxwithtarget)

2015 day 17: No Such Thing as Too Much

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

The elves ordered too much eggnog. I need to store it in the containers. Container capacities are given as the puzzle input.

So it’s combinatorics again. Actually easier than the previous ones.

#!/usr/bin/python3

from itertools import combinations


INPUTFILE="17-input.txt"
CAPACITY=150

with open(INPUTFILE) as inputfile:
        containers = [int(x) for x in inputfile.read().splitlines()]

print(containers)

container_combinations=[]
part2reached=False
for num_containers in range(len(containers)+1): # we're tryng combinations of 1, 2... containers until len(containers)
    container_combinations.extend(   i for i in combinations(containers, num_containers) if sum(i)==CAPACITY )
    if not part2reached:
        if container_combinations: # that was the smallest number of containers that worked
            part2reached=True
            part2answer=len(container_combinations)

print("Part 1, number of combinations: ", len(container_combinations))
print("Part 2, number of combinations: ", part2answer)

2015 day 20: Infinite Elves and Infinite Houses

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

Infinite number of elves deliver presents to infinite number of houses - that looks a lot like Hilbert’s Hotel. Luckily, we don’t really have to deal with infinities, we need to find a first house that gets more than a specified number of presents. And there are several ways.

Use brute force

Iterate through all house numbers starting from 1. For each house:
Iterate through elves - numbers from 1 to house number, let’s call that value i
Calculate: house number modulo i, if it’s equal to 0, that house gets 10*i presents

        housenumber=0
        while True:
            numpresents=0
            housenumber+=1
            for i in range(1,housenumber+1):
                if housenumber%i==0:
                    numpresents+=10*i
            if numpresents>=TARGETNUMBER:
                break

Easy to think of, easy to code. The only problem: it would take a long time (my input is an 8-digit number).

There are some possible improvements. We don’t have to start from house number 1. Obviously we need to be somewhere closer to the target number of present, we can start eg. from that number divided by 100. Much faster than starting from 1, but still slow. And, if we start too high we might miss the smallest number.

I actually don’t know how much time it would take. After several minutes I hit Ctrl-C and tried another approach.

Use RAM and smarter force

The brute force solution has 2 loops: external iterates through houses, internal through elves. That means the internal loop runs many times doing the same calculations all over again. And, with each iteration of the external loop, internal loop needs one more iteration, running slower and slower.

Let’s reverse the logic:

Allocate a data structure (eg. in Python list of ints) holding numbers of presents for each house, initial value 0 (that’s a few dozen MB, no problem for a PC)
Iterate through elves, starting from number 1
Iterate through houses, notice that elf number n puts presents in every nth house, starting with house number n (eg. elf number ten starts with house 10, then goes to 20, 30 etc.) - which means we don’t need to start with house 1, increment by 1 and do a modulo operation, instead we can use a proper initial value and step in the loop, massively speeding up the calculation
For every visited house, increase the number of presents by 10*elf number
Finally, iterate through the list of houses and find the index of the first one that meets our criteria.

Use maths

Not the solution I would find by myself, since I’m more into loops and data structures than divisors and such stuff. Just for completeness: each house gets 10 presents if its number is divisible by the elf’s number. So, total number of presents equals 10 times sum of all house number’s divisors (including trivial divisors).

Code

#!/usr/bin/python3

from tqdm import tqdm

TARGETNUMBER=33100000
LIMIT=TARGETNUMBER//10

houses = [0 for _ in range(LIMIT)]
houses2 = [0 for _ in range(LIMIT)]


for elfnumber in tqdm(range(1, LIMIT)):
    numvisit=0
    for housenumber in range(elfnumber, LIMIT, elfnumber):
        houses[housenumber]+=10*elfnumber
        if numvisit<50:
            numvisit+=1
            houses2[housenumber]+=11*elfnumber



# find the smallest house number with the specified number of presents:
for i in range(2, LIMIT):
    if houses[i]>=TARGETNUMBER:
        part1result=i
        break
for i in range(2, LIMIT):
    if houses2[i]>=TARGETNUMBER:
        part2result=i
        break


print(f"Part 1: house number {part1result} got {houses[part1result]} presents")
print(f"Part 2: house number {part2result} got {houses[part2result]} presents")

2015 day 21: RPG Simulator 20XX

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

Easy one for a change: a part of a very simple RPG game. I used Python and some basic OOP to encapsulate data. The player has to use a weapon, can use an armour and up to 2 rings. My design decisions:

weapon, armour and rings are all objects of the same class - GameItem
all 4 equipment slots are obligatory to simplify the design, I just added armour and ring of type “none”

We need to find the lowest cost of equipment that would win the fight. Easy, there are only 1290 combinations so we can just use brute force: generate 1290 players, make them all fight with the boss, create a list of cost for the winning players and find a minimum of that list. These are all very fast operations (integer addition, subtraction and comparison) so it all runs in just some milliseconds.

#!/usr/bin/python3
from dataclasses import dataclass

@dataclass
class GameItem:
    name: str
    cost: int
    damage: int
    armor: int

@dataclass
class Boss:
    totaldamage: int
    totalarmor: int
    hitpoints: int

class Player:
    totalcost: int
    totaldamage: int
    totalarmor: int
    hitpoints: int
    won: bool

    def __init__(self, equip) -> None:
        self.hitpoints=100
        self.totalarmor=self.totaldamage=self.totalcost=0
        for i in equip:
            self.totalcost+=i.cost
            self.totaldamage+=i.damage
            self.totalarmor+=i.armor

    def __repr__(self) -> str:
        return f"Player:  hp: {self.hitpoints}  cost: {self.totalcost} armor: {self.totalarmor} damage: {self.totaldamage}"

    def fight(self, boss):
        while True:
            # player attacks
            damage_done=self.totaldamage-boss.totalarmor
            damage_done = max(damage_done, 1)
            boss.hitpoints-=damage_done
            if boss.hitpoints<=0:
                self.won=True
                print("+",end="")
                break
            # boss attacks
            damage_done=boss.totaldamage-self.totalarmor
            damage_done = max(damage_done, 1)
            self.hitpoints-=damage_done
            if self.hitpoints<=0:
                self.won=False
                print("-",end="")
                break


weapons=(
       GameItem("Dagger", 8, 4, 0),
       GameItem("Shortsword", 10, 5, 0),
       GameItem("Warhammer", 25, 6, 0),
       GameItem("Longsword", 40, 7, 0),
       GameItem("Greataxe ", 74, 8,0)
)

armors=(
       GameItem("None", 0, 0, 0),
       GameItem("Leather", 13, 0, 1),
       GameItem("Chainmail", 31, 0, 2),
       GameItem("Splintmail", 53, 0, 3),
       GameItem("Bandedmail", 75, 0, 4),
       GameItem("Platemail", 102, 0, 5)
)

rings=(
       GameItem("None", 0, 0, 0),
       GameItem("Damage +1", 25, 1, 0),
       GameItem("Damage +2", 50, 2, 0),
       GameItem("Damage +3", 100, 3, 0),
       GameItem("Defense +1", 20, 0, 1),
       GameItem("Defense +2", 40,0, 2),
       GameItem("Defense +3", 80, 0, 3)
)



players=[]
for w in weapons:
    for a in armors:
        for l in rings:
            for r in rings:
                if (l.name==r.name) and (l.name!="None" and r.name!="None"): # you can't have 2 of the same rings
                    continue
                players.append(Player( (w,a,l,r) ))


for p in players:
    boss=Boss(totaldamage=9, totalarmor=2, hitpoints=103)
    p.fight(boss)
 

winning=[ p.totalcost for p in players if p.won ]
losing=[ p.totalcost for p in players if not p.won ]
print(f"\n\nGenerated {len(players)} players of which {len(winning)} won.")
print("Part 1, lowest cost of winning: ", min(winning))
print("Part 2, highest cost of losing: ", max(losing))

2015 day 23: Opening the Turing Lock

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

We’re emulating a simple computer, with 2 registers and 6 instructions. Hardware-emulating puzzles are always the most fun. And so was this one, except for one trick in the instruction. There’s an instruction jie - “jump if even”, and next one is jio, which I automatically read as “jump if odd”, although the instruction explained it’s “jump if one”. Either I’m dumb or that trick is dumb, you decide.

Other than that, it’s simple. Match/case to run the right command and some string parsing. Initial version had 6 more methods, one for each command, but since they were 2-6 lines and even that could be shortened, I moved all of that directly into match/case. To be fair, I could even remove the whole class without affecting the readability too much.

I later learned that Python’s match is way more powerful and the code could be shorter and more readable (see 2016 day 12 for comparison), but let’s leave it this way.

#!/usr/bin/python3

class Computer:
    register: dict = {}
    pointer: int
    instructions: list

    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.pointer=0


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


    def run(self, debug=False) -> None:
        while self.pointer<len(self.instructions):
            if (debug): print(self)
            cmd = self.instructions[self.pointer][:3]
            arg = self.instructions[self.pointer][4:]
            self.pointer+=1  # will have to decrease by 1 for jumps
            match cmd:
                case "hlf": 
                    self.register[arg]=self.register[arg]//2
                case "tpl": 
                    self.register[arg]*=3
                case "inc": 
                    self.register[arg]+=1
                case "jmp": 
                    self.pointer+=int(arg)-1
                case "jie": 
                    register,offset=arg.split(",")
                    self.pointer += int(offset) -1 if self.register[register]%2==0 else 0
                case "jio": 
                    register,offset=arg.split(",")
                    self.pointer += int(offset) -1 if self.register[register]==1 else 0
                case _: raise ValueError
        


computer=Computer("23-input.txt")
computer.run()
print("Part 1, register B: ",computer.register["b"])
computer.reset()
computer.register["a"]=1
computer.run()
print("Part 1, register B: ",computer.register["b"])

2015 day 24: It Hangs in the Balance

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

Part 1

Up to this point I wrote these documents months after writing the code. This one is different - I’m writing and coding simultaneously. I’ll use this opportunity to show my approach to AoC puzzles. I usually go step by step, starting with the input data. Then I think of the data structures. Then how to get a step closer towards solution. The code is often quite verbose in the beginning (eg. standard loops instead of list comprehension), later I simplify it.

First, I need to read the input data. I prepared 2 files, 24-input.txt is my input for the puzzle, 24-small.txt is sample data from the problem description.

INPUTFILE="24-small.txt"

packages=[]
with open(INPUTFILE) as f:
    for line in f:
        packages.append(int(line))

Now, the instruction says we need to divide packages using the following conditions:

each container weighs the same,
first container has the smallest possible number of packages,
if there are several ways to satisfy the second condition, choose one with the smallest QE.

So, target weight is 1/3 of the total weight. Let’s hope it divides evenly. Let’s also check the number of packages and the total weight.

weight=sum(packages)//3
print(f"Number of packages:  {len(packages)} total weight {sum(packages)} container weight {weight}")

An obvious solution: brute force! Generate all (permutations? combinations? with or without replacement? I’ll have to check, AS USUAL) and find the best one. But wait, we only really care about the first container, that greatly reduces the problem space.

OK, so let’s check if we can satisfy the weight requirement using only one element. Then two element (permutations? combinations? I checked, order doesn’t matter and there’s no replacement, so it’s combinations). Then 3-element combinations, and so on.

has_right_weight=[]
for i in range(1,len(packages)):
    has_right_weight.extend(  x for x in combinations(packages,i) if sum(x)==target_weight )

But we need to have the smallest possible number of packages. So if we find that n-element combination satisfies the requirement, no need to check further. The moment that something appears in our list, break:

    if has_right_weight:
        break

Let’s check with the small dataset - only one 2-element combination, like the instruction says. With the full data - many 6-element combinations. So now we need to find one with the lowest “quantum entanglement”, defined as product of the elements. Python 3.10 has a math.prod function, which saves me from an effort of writing one myself.

qe= [ math.prod(x) for x in has_right_weight ]
print(f"Part 1: {min(qe)}")

Part 2

So now we have to divide packages between 4 containers instead of 3. The solution is obvious: I need to put the code into a function, taking the number of containers as a parameter, then call it twice.

While I’m at it, let’s shorten the code. Unusually for me, I used list comprehension instead of for loops in most places because it was obvious for me. The only exception is input processing.

The result code is this:

#!/usr/bin/python3

import math
from itertools import combinations

INPUTFILE="24-input.txt"


def calculate_min_qe(num_containers: int):
    target_weight=sum(packages)//num_containers
    has_right_weight=[]

    for i in range(1,len(packages)):
        has_right_weight.extend(  x for x in combinations(packages,i) if sum(x)==target_weight )
        if has_right_weight:
            break

    qe= [ math.prod(x) for x in has_right_weight ]
    return min(qe)


packages=[]
with open(INPUTFILE) as f:
    packages.extend(int(line) for line in f)

print(f"Part 1: {calculate_min_qe(3)}")
print(f"Part 2: {calculate_min_qe(4)}")

2015 day 16: Aunt Sue

Fri, 12 May 2023 17:32:00 +0200

Apparently, I have 500 aunts named Sue, some of which have a small herd of pomeranians and samoyeds. Plus cats, children, cars etc. I got a present from one of them, using my Crime Scene Analyser I need to find out which one it was.

I like the story. The puzzle itself is not that interesting, just some basic input file processing with regexps (split() would also work) and few comparisons.

#!/usr/bin/python3

import re

INPUTFILE="16-input.txt"


aunt_sender= {
"children": 3,
"cats": 7,
"samoyeds": 2,
"pomeranians": 3,
"akitas": 0,
"vizslas": 0,
"goldfish": 5,
"trees": 3,
"cars": 2,
"perfumes": 1
}



# read file into list
aunts=[]
rx=re.compile( r"Sue (\d+): (\w+): (\d+), (\w+): (\d+), (\w+): (\d+)" )
with open(INPUTFILE) as inputfile:
    for line in inputfile:
        number, item1, item1value, item2, item2value, item3, item3value  = rx.match(line).groups()
        aunts.append( ( (item1, int(item1value)), (item2, int(item2value)), (item3, int(item3value) )) )

# part 1
for i,aunt in enumerate(aunts):
    itemsmatched=0

    for item in aunt:
        if item[1] == aunt_sender[item[0]]:
            itemsmatched+=1
        else:
            break # no need to check other items
    if itemsmatched==3:
        print(f"Part 1: aunt {i+1} matches") 
        break


# part 2
for i,aunt in enumerate(aunts):
    itemsmatched=0

    for item in aunt:
        if item[0] in ["cats", "trees"]:
            if item[1] > aunt_sender[item[0]]:    
                itemsmatched+=1
        elif item[0] in ["pomeranians", "goldfish"]:
            if item[1] < aunt_sender[item[0]]:    
                itemsmatched+=1
        elif item[1] == aunt_sender[item[0]]:
            itemsmatched+=1
    if itemsmatched==3:
        print(f"Part 2: aunt {i+1} matches") 
        break

2015 day 18: Like a GIF For Your Yard

Fri, 12 May 2023 17:32:00 +0200

Animated lights, or Conway’s Game of Life. As usual, we only need to provide a number for an answer, but I couldn’t resist making a visualisation with Pygame.

State of each light depends on the state of its neighbours. But we can’t just go through an array calculating and changing a state of each light, because that would affect the outcome for the neighbouring lights. My solution is to have 2 arrays of lights, one source and the other target, alternate them every other step. How does it affect the problem size? We have 10 thousand cells and Python’s bool is really an integer, so it’s quite wasteful, 8 bytes on a 64-bit system, so we have 2 arrays of 80 kB. It would be a huge concern on a microcontroller with eg. 64KB of RAM, but on a PC that’s nothing.

#!/usr/bin/python3


import pygame


# constants
INPUTFILE="18-input.txt"
WIDTH=100
HEIGHT=100
LIGHTSIZE=8 # on the screen each light will be 8x8 pixels
FPS=50 # how many animation frames / calculation steps per second
ROUNDS=100

VARIANT=True # set to False for Part1, True for Part2

cwhite=(255,255,255)
cblack=(0,0,0)

# global variables
lights1=[]
lights2=[]


########## FUNCTIONS - VISUALIZATION ##########

def print_lights(lights): # for debug
    for y in range(len(lights)):
        for x in range(len(lights[0])):
            try:
                if lights[y][x]:
                    print("#",end="")
                else:
                    print(".",end="")
            except IndexError:
                print("index error: ",x,y)
        print()

def write_below(message):
    global font, screen
    """ prints a message at the bottom of the window """
    text = font.render(message, True, (200,200,200), (0,0,0))
    textRect = text.get_rect()
    textRect.center = ((WIDTH*LIGHTSIZE) // 2, (HEIGHT*LIGHTSIZE)+20)
    screen.blit(text, textRect)

def redraw_screen(lights):
    global screen
    screen.fill(cblack) # Fill the background with black
    for y in range(HEIGHT):
        for x in range(WIDTH):
            if lights[y][x]:
                #print(f"{x}x{y} ", end="")
                pygame.draw.rect(screen, cwhite, pygame.Rect(x*LIGHTSIZE,y*LIGHTSIZE,LIGHTSIZE,LIGHTSIZE))

########## FUNCTIONS - OTHER  ###########

def corners_on(lights):
    lights[0][0], lights[HEIGHT-1][0], lights[0][WIDTH-1], lights[HEIGHT-1][WIDTH-1] = True, True, True, True

def update_lights(source, target):
    for y in range(HEIGHT):
        for x in range(WIDTH):
            num_neighbours=get_neighbours(source, x, y)
            if source[y][x]:
                if num_neighbours==2 or num_neighbours==3:
                    target[y][x]=True
                else:
                    target[y][x]=False
            else:
                if num_neighbours==3:
                    target[y][x]=True
                else:
                    target[y][x]=False
    if VARIANT:
        corners_on(target)
        

def get_neighbours(lights, x, y):
    num_neighbours=0
    for deltax in (-1, 0, 1):
        for deltay in (-1, 0, 1):
            if deltax==0 and deltay==0: 
                continue
            if (x+deltax<0) or (x+deltax>=WIDTH):
                continue
            if (y+deltay<0) or (y+deltay>=WIDTH):
                continue
            if lights[y+deltay][x+deltax]:
                #print("neighbour on: ", x+deltax, y+deltay)
                num_neighbours+=1
    return num_neighbours

########## INITIALIZATION  ###########

# read input
with open(INPUTFILE) as inputfile:
    for line in inputfile:
        lights1.append( [ x=='#' for x in line.strip() ] ) # saves True for every # or False otherwise
        lights2.append( [ x=='#' for x in line.strip() ] ) 
if VARIANT:
        corners_on(lights1)
        corners_on(lights2)
#print_lights(lights1)

# initialize pygame
pygame.init()
screen=pygame.display.set_mode((WIDTH*LIGHTSIZE, HEIGHT*LIGHTSIZE+40)) # extra height for text message
pygame.display.set_caption('Day 18: Like a GIF For Your Yard')
clock = pygame.time.Clock()
font = pygame.font.Font(None, 20)
running=True
done=False

##########  MAIN LOOP   ###########
while running:
    if not done:
        for i in range(ROUNDS):
            for event in pygame.event.get():
                if event.type == pygame.QUIT: 
                    running=False
            if not running: break             
            if (i%2==0):
                source, target = lights1, lights2
            else:
                source, target = lights2, lights1
            update_lights(source, target)
            redraw_screen(target)
            lit=sum(map(sum, target))
            write_below(f"Round: {i+1}, lights on: {lit}")
            pygame.display.flip()
            clock.tick(FPS) # delay here
        done=True # don't start iterating again, just wait for quit event
    else:
        for event in pygame.event.get():
            if event.type == pygame.QUIT: running=False
        clock.tick(FPS) # or here

##########  ENDGAME  ###########

pygame.quit()
print ("Lights on: ", lit)
#print_lights(target)

2015 day 19: Medicine for Rudolph

Fri, 12 May 2023 17:32:00 +0200

Part 1

We need a medicine for Rudolph. We’ve got a starting molecule and a list of possible replacements. First part was too easy: calculate how many molecules can be made with a single replacement. Tricky bits are:

when creating new molecule, I added them to the set and checked the set’s length, that way I filtered out duplicate results,
I had to use a tricky way to replace first, second…, nth occurrence.

Part 2

Then the second part: how many steps we need to reach the target molecule from a single electron? I admit I had to check how other people did it. It was obvious for me I should check the other way around: from the molecule to the electron. And a proper parser should help. I could write them when I was at the uni, but I happily forgot them and hope to never need them again. I’m OK with regexps and such, but I run away screaming when I hear about CNF, context-free grammar and so on.

Some people had luck with a randomised brute-force search: try to apply all the replacement rules, if a dead-end was reached, shuffle the rules and try again. They said they reached a single electron in only a few shuffles. I allowed for 200 thousand and only got some short molecules that couldn’t be reduced any further.

I also tried some order in my replacements. I noticed there are different types of rules: some duplicate the element, some generate a group containing Rn, Ar and something in between. Some generate an element from an electron. I tried running them in different orders, trying to eliminate longer pieces first. Reached a dead end every time.

In desperation, I based my solution on the analysis by CdiTheKing: https://www.reddit.com/r/adventofcode/comments/3xflz8/comment/cy4h7ji/?utm_source=share&utm_medium=web2x&context=3

It feels like cheating because I barely understand the reasoning and couldn’t reach it myself. But I don’t want to spend more time on the puzzle that’s no fun.

Code

#!/usr/bin/python3

import re

INPUTFILE="19-input.txt"


replacements=[]
with open(INPUTFILE) as inputfile:
    done_replacements=False
    for line in inputfile:
        line=line.strip()
        if line=='':
            done_replacements=True
            continue
        elif done_replacements:
            molecule=line
            break
        else:
            replacements.append( line.split(" => ") )

print("molecule: ", molecule)
#print("replacements: ", replacements)

# part 1
newmolecules=set()
for to_find,to_replace in replacements:
    for m in re.finditer(to_find, molecule): # gives list of positions where to_find string can be found in molecule
        index=m.start()
        #print(f"Replacing {to_find} with {to_replace} on position {index}")
        newmolecule=molecule[:index] + to_replace + molecule[index+len(to_find):]
        newmolecules.add(newmolecule) # need to add to a set, not just count, to skip duplicates
    
print("Part 1, number of molecules: ", len(newmolecules))

# part 2

num_capitals=sum(1 for char in molecule if char.isupper())
rx1=re.compile( r"Y" )
rx2=re.compile( r"Rn" )
rx3=re.compile( r"Ar" )
num_y =len(rx1.findall(molecule))
num_rn=len(rx2.findall(molecule))
num_ar=len(rx3.findall(molecule))
#print(f" atoms {num_capitals} y {num_y}  rn {num_rn} ar {num_ar}"  )
print("Part 2, min number of transforms: ", num_capitals-num_rn-num_ar-2*num_y-1)

2015 day 09: All in a Single Night

Tue, 09 May 2023 17:32:00 +0200

We are given a list of distances between several cities. Santa needs to visit all of them exactly once using shortest (part 1) and longest (part 2) route possible.

What a gentle introduction to graph theory! Every computer science graduate will instantly recognise it as a Travelling Salesman Problem. It’s a well known problem with many real-world applications - not only the obvious one of finding a shortest route between cities, but also about placing data in the compute cluster, and optimal use of pretty much everything, from storage shelves to industrial robots. It’s also deceptively hard. Brute-force approach of trying all possible routes is O(n!) meaning it scales with the factorial of the number of nodes so it’s out of the question for bigger datasets. Luckily, we only have 7 cities, 7! is only 5040. There’s no need to implement any clever algorithm.

So, it’s Python again with no special libraries (C++ with the usual STL containers would also work):

read input file, parse lines (just two split(), nothing fancy)
we need 3 data structures: set of cities, dict of distances between cities (both initialised from the input data) and list of route lengths, initially empty (note that we only need to store the distance, not the route)
iterate through all permutations of cities
for each permutation, get the distances from the dict, sum them up, store in the list of route lengths
and just get the smallest/largest number from the list

New language feature: itertools

Many puzzles in AoC involve combinatorics. In this case we need to generate all permutations of cities - or arrange them in every possible order. Module itertools contains mostly functions for looping and iterating over data, but also combinatoric functions: permutations, combinations, combinations_with_replacement and product.

They are very simple to use. We have a set of cities (any iterable data structure would do):

{'AlphaCentauri', 'Norrath', 'Straylight', 'Arbre', 'Faerun', 'Tambi', 'Snowdin', 'Tristram'}

and permutations(cities) will generate an iterable object containing:

('AlphaCentauri', 'Norrath', 'Straylight', 'Arbre', 'Faerun', 'Tambi', 'Snowdin', 'Tristram')
('AlphaCentauri', 'Norrath', 'Straylight', 'Arbre', 'Faerun', 'Tambi', 'Tristram', 'Snowdin')
('AlphaCentauri', 'Norrath', 'Straylight', 'Arbre', 'Faerun', 'Snowdin', 'Tambi', 'Tristram')
...
('Tristram', 'Snowdin', 'Tambi', 'Faerun', 'Arbre', 'Norrath', 'Straylight', 'AlphaCentauri')
('Tristram', 'Snowdin', 'Tambi', 'Faerun', 'Arbre', 'Straylight', 'AlphaCentauri', 'Norrath')
('Tristram', 'Snowdin', 'Tambi', 'Faerun', 'Arbre', 'Straylight', 'Norrath', 'AlphaCentauri')

Possible optimisations

No need to store the length of every route, we only need to store it if it’s shorter/longer than the previous ones.
Every route has the same length in both directions, while the code generates all permutations. So, for the example data we check Dublin -> London -> Belfast and Belfast -> London -> Dublin. We could cut the problem size in half by filtering out those.

Those improvements would only save a few hundred bytes of RAM and have negligible effect on time (and I’m not even sure which way - there’s less computation but some extra comparisons) so I skipped the premature optimisations.

Code

#!/usr/bin/python3

from itertools import permutations


FILENAME="09-input.txt"

def read_input(filename):
    distances={}
    cityset=set()
    with open(filename) as inputfile:
        for line in inputfile:
            cities, distance=line.split('=')
            distance=int(distance)
            city1, city2 = cities.split("to")
            city1=city1.strip()
            city2=city2.strip()
            cityset.add(city1)
            cityset.add(city2)
            distances[(city1,city2)] = distance
            distances[(city2,city1)] = distance
    return distances, cityset


distances, cities=read_input(FILENAME)

routelengths=[]
for route in permutations(cities):
    current_dist = sum(
        distances[(route[i], route[i + 1])] for i in range(len(route) - 1)
    )
    routelengths.append(current_dist)

print("Shortest route: ", min(routelengths))
print("Longest route: ", max(routelengths))

2015 day 12: JSAbacusFramework.io

Tue, 09 May 2023 17:32:00 +0200

For part 1, we need to sum all numbers in the JSON file. We don’t really need to parse JSON, just extract all the numbers and sum them. A simple regular expression will do for extracting and classic map/reduce for the sum. I usually prefer longer code for readability’s sake, but this just asks for putting all the contents of the main loop in one line: result+=sum( map(int, rx.findall(line) ) ).

How does it work? rx.findall(line) gives a list of all numbers in the line, using the following regexp: \-?\d+ meaning 0 or 1 minus sign followed by 1 or more digits. Then map(int, rx.findall(line) ) runs int() on every element of the list to create the list of integers. And then, just sum the list.

For part 2, we need to ignore JSON objects (but not lists) that contain a value “red”. So now we actually have to parse the JSON. I used a recursive function that iterates through the data, checks types, adds integers, skips dictionaries if any value is “red”, recurse into lists and dictionaries.

Note that explicit type checking is usually frowned upon by Python programmers, but I believe it’s the right tool for this job.

#!/usr/bin/python3

import re
import json

INPUTFILE="12-input.txt"

def parse_data(dict_or_list):
    retval=0
    if isinstance(dict_or_list, dict):
        for v in dict_or_list.values():
            if v=="red":
                return 0
            if isinstance(v, int):
                retval+=v
            elif isinstance(v, (dict, list)):
                retval+=parse_data(v)
    if isinstance(dict_or_list, list):
        for v in dict_or_list:
            if isinstance(v, int):
                retval+=v
            elif isinstance(v, (dict, list)):
                retval+=parse_data(v)
    return retval



# part 1

result=0
rx=re.compile( r'\-?\d+' )
with open(INPUTFILE) as inputfile:
    for line in inputfile:
        result+=sum( map(int, rx.findall(line) ) )
print("Part 1, sum: ", result)


# part 2

with open(INPUTFILE) as inputfile:
    data=json.load(inputfile)

result2=parse_data(data)
print("Part 2, sum: ", result2)

2015 day 13: Knights of the Dinner Table

Tue, 09 May 2023 17:32:00 +0200

We need to find optimal seating arrangement for the family. Everyone has their happiness increased or decreased based on who they sit next to. We need to maximise total happiness.

Although it doesn’t look like that, it’s a similar puzzle to day 9, Travelling Santa Problem. So similar that most of my code was actually a copy-paste. Again, it would require some sophisticated algorithms for larger dataset, but we only have 8 people so we might as well do brute-force.

Spoilers below: There are 2 key differences between day 9 (distance finding) and this puzzle:

on day 9, you had to sum up distance from A to B, then B to C etc., here you have to sum up happiness from A to B and from B to A, B to C and C to B etc.
the table is round, so you have to also add happiness between last person and first person - the easiest way is to add the first person again at the end.

Possible optimisations: similar to day 9, you can skip sitting arrangements that are the reverse of another sitting arrangement, but I didn’t bother as the program was fast enough. Though I can clearly see how it grows with the size of the dataset: on an old laptop it took 0.2s for the first part and 1.4s for the second part with one extra person.

#!/usr/bin/python3

from itertools import permutations



FILENAME="13-input.txt"


def calculate_happiness():
    global edges, people
    happiness=[]
    for people_permut in permutations(people):
        sitting_arrangement=list(people_permut)
        sitting_arrangement.append(sitting_arrangement[0])
        #print(sitting_arrangement)
        current_happiness=0
        for i in range(len(sitting_arrangement)-1):
            current_happiness+=edges[( sitting_arrangement[i], sitting_arrangement[i+1] )]
            current_happiness+=edges[( sitting_arrangement[i+1], sitting_arrangement[i] )]
        happiness.append(current_happiness)
    return happiness

# parse input
edges={}
people=set()
with open(FILENAME) as inputfile:
    for line in inputfile:
        person, _, direction, howmuch, _, _, _, _, _, _, otherperson = line.strip().split()
        otherperson=otherperson.strip('.')
        if direction=='gain':
            value=int(howmuch)
        elif direction=='lose':
            value=-int(howmuch)
        else:
            raise ValueError
        people.add(person)
        edges[(person, otherperson)]=value

happiness=calculate_happiness()
print("Part 1: ", max(happiness))

# add another person
for person in people:
    edges[person, "me"]=0
    edges["me", person]=0
people.add("me")

happiness=calculate_happiness()
print("Part 2: ", max(happiness))

2015 day 08: Matchsticks

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

Santa needs to keep a digital version of the presents list. We need to help by encoding some special characters (or specifically, just find the difference in length), in the same way as many programming languages do:

strings start and end with a quotation mark, those are not counted (eg. “this” has length of 4, "" is 0)
quotation marks inside the strings need to be quoted with a backslash, so " has length 1
special characters can be escaped with a hexadecimal notation, so every block similar to this: \x56 has a length of one.

I decided to use C. The code doesn’t do much more than incrementing a few counters. It’s one of a few cases where I can code in C as fast as in Python, so I used this opportunity to brush up my C skills.

/*  
The only escape sequences used are:
 \\ (which represents a single backslash), 
 \" (which represents a lone double-quote character), 
 \x plus two hexadecimal characters (which represents a single character

For example, given the four strings above, the total number 
of characters of string code (2 + 5 + 10 + 6 = 23) minus the total 
number of characters in memory for string values 
(0 + 3 + 7 + 1 = 11) is 23 - 11 = 12. */

#include <stdio.h>
#include <stdbool.h>

const char* FILENAME="08-input.txt";
const int MAXSTR=200; // max line length

int main() {
    FILE* fileptr;
    int byte_counter=0;
    int char_counter=0;
    int encoded_counter=0;
    int line_counter=0;
    char line[MAXSTR];
    fileptr = fopen(FILENAME, "r");
    if (!fileptr) {
        printf("file: %s can't be opened\n", FILENAME);
        return 1;
    }
    // read file line by line
    bool saw_first_quotation=false;
    
    while ( fgets(line, MAXSTR, fileptr) != NULL ) {
        ++line_counter;
        int byte_current=0;
        int char_current=0;
        int encoded_current=4;   // each line grows by at least 4 chars
        //printf("Parsing line %d: %s",line_counter, line);
        for (int i=0;i<MAXSTR;++i) { // parse characters of the line
            ++byte_current;
            //putchar('.');
            if (line[i]=='"') {
                if (saw_first_quotation)  { 
                    // this must me end-quote, reset the quation flag and go to next line
                    saw_first_quotation=false;
                    break;
                }
                else
                    saw_first_quotation=true;
            }
            else if (line[i]=='\\') {
                ++encoded_current;
                // need to check the next character
                ++i;
                ++byte_current;
                if (line[i]=='\\' || line[i]=='"') {
                    ++char_current;
                    ++encoded_current;
                }
                else if (line[i]=='x') {
                    // 2-digit hex code, need to skip 2 more bytes
                    byte_current+=2;
                    i+=2;
                    ++char_current;
                }
                
            }
            else // ordinary character
                ++char_current;
        } // end for / parse characters of the line
        encoded_current+=byte_current;
        //printf ("bytes: %d, characters: %d, encoded: %d \n", byte_current, char_current, encoded_current);
        byte_counter+=byte_current;
        char_counter+=char_current;
        encoded_counter+=encoded_current;
    } // end while / parse file
    printf("Number of lines: %d\n",line_counter);
    printf("Number of bytes: %d\n",byte_counter);
    printf("Number of characters: %d\n",char_counter);
    printf("Number of encoded: %d\n",encoded_counter);
    printf("Part 1: difference: %d\n", byte_counter-char_counter);
    printf("Part 2: difference: %d\n", encoded_counter-byte_counter);
}

2015 day 07: Some Assembly Required

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

We’ve got a list of wires that feed signals to other wires through logic gates. We need to know the state of the wire a, but for that we need to know the state of the wire lx first. And lx references 2 other wires and so on, until we get to the wires that have their state directly in the input file. I see two ways to do it:

try to get wire a and do recursion, until you get to the wires with known values
or iterate over the list of instructions, at each iteration do all calculations that are possible (the data is already available) and remove those instructions, until the instruction queue is empty

I thought it would be cool to see how we get to the result, so I used the second approach and displayed the state of the wires in columns, with a delay at every step.

Parsing input

This puzzle gave me some trouble with input parsing. First I borrowed the solution from https://aoc.just2good.co.uk/2015/7 and used the Parsimonious library because I wanted to get to the visualisation quickly. It worked, but I wanted to have my own parser, no cheating. So I rewrote it using only string splitting and comparisons. It also worked, but it was long and there was some code repetition. Next, I used match/case. Much better! There’s still some repetition, but “good enough” beats “perfect”.

Python feature: exceptions

I used one Python feature that I haven’t used in 2015 puzzles yet: exceptions. Exceptions are used in many programming languages, usually to handle error conditions. But here I’m using them for flow control, like this:

try value=int(arg)
    # handle the case when arg can be converted to int
except ValueError:
    # handle the case when it can't

It’s not an error that the value can’t be converted, it’s a completely normal case (in fact, the “exceptional” case happens more often than the “standard” case). C++ or Java developers would shudder at such design, but in Python culture it’s considered OK. Maybe the reason is exceptions make programs slower in many languages, in Python there’s not much difference (it’s slow anyway…)

Python feature: match/case

Structural pattern matching was a new feature of Python 3.10. At a first glance, it’s similar to switch/case instructions you might already know from other languages such as C:

match argument:
    case "something":
        do_something()
    case "whatever":
        some_other_stuff()
    case _:
        raise ValueError

Nothing wrong in using it this way, it’s slightly shorter and more readable than a long chain of if/else instructions. But that’s only about 1% of what it can do, I’ve yet to learn all the possibilities. So far I know how to:

match strings (obviously),
assign variables while checking,
check type of the matched argument,
if the argument is a tuple, check how many elements it contains.

All of that while being more readable than the code written without this feature. In fact, probably more readable than my attempt to explain it. Here’s the relevant part of the code:

    match splitinstr:=instr.split():
        case (arg1, "AND"|"OR", arg2): return process_andor(splitinstr[1], arg1, arg2, wire_values, targetwire)
        case (arg1, "LSHIFT"|"RSHIFT", arg2): return process_shift(splitinstr[1], arg1, int(arg2), wire_values, targetwire)
        case ("NOT", arg1): return process_not(arg1, wire_values, targetwire)
        case _:  return process_assingment(splitinstr[0], wire_values, targetwire)

Variable instr contains one instruction from the input file, the part before the -> delimiter, eg. “e OR f -> g”, “NOT dm -> dn”. I then split it, assign the tuple to splitinstr and check the cases.

First two cases are 3-element tuples. If the middle element contains LSHIFT or RSHIFT, it calls process_shift function, “AND” or “OR” call process_andor. In both cases, first and third element are assigned to arg1 and arg2 respectively. Next, a 2-element tuple, first a string “NOT” and then any value of any type, that gets assigned to arg1. Finally, the default case. If it wasn’t any of the 5 logical operations, it must be assignment. It’s a puzzle with known input, for the real production code I would check the input more carefully.

Visualisation

Curses library forces a specific program structure. Everything that uses curses needs to be placed in one function (by convention, called main) which takes stdscr as an argument, and stdscr is the main curses window that covers the entire screen. This function is then called with curses.wrapper(main). Or specifically, that’s not the only way to run curses program, but it’s the most convenient.

Curses allow you to build quite sophisticated text-mode user interfaces, but I only use it for one thing: print text in a specific place on the screen. I start at the top left corner: outx=0 outy=0 then I move right by the colum width: outx+=COLWIDTH which I found experimentally, large enough to fit the longest instruction and keep some space from the next column. If I’m too close to the screen’s edge, I move to the next row and back to the left, the library provides screen width in curses.COLS:

        if (outx>=curses.COLS-COLWIDTH):
            outx=0
            outy+=1

I also highlighted some values using a different output format. Curses allow changing foreground and background colour and also setting attributes such as bold or blink. I simply used curses.color_pair(1) - colour pairs can be user defined but have a default value, and I didn’t care what colours are used as long as they are different than the default.

Code

#!/usr/bin/python3


from collections import defaultdict
import curses
import re




INPUTFILE="07-input.txt"
COLWIDTH=20  
DELAY=300 # 300ms delay to see how signals are calculated
#DELAY=0 # or no delay to get the answer sooner




def display_wires(stdscr, wires, iteration, instructions):
    """ prints the state of all logic gates in multiple columns using curses """
    stdscr.clear()
    outx=0
    outy=0
    for wire,value in instructions.items():
        # try to get the signal value for the wire
        # if we don't have it, print instruction for the wire
        outformat=curses.A_NORMAL
        try:
            outstring = f"{wire}: {str(wires[wire])}"
            outformat=curses.color_pair(1) # higlight the wires that have the signal
        except KeyError:
            outstring = f"{wire}: {value}"


        stdscr.addstr(outy, outx, outstring, outformat)
        #stdscr.addstr(outstring, outformat)
        outx+=COLWIDTH
        if (outx>=curses.COLS-COLWIDTH):
            outx=0
            outy+=1
    # print summary below
    outstring = f"Iteration: {str(iteration)}"
    try:
        a_val=str(wires['a'])
        ending="     PRESS ANY KEY TO CONTINUE"
    except KeyError:
        a_val=instructions['a']
        ending=""
    outstring += f"  current state of a: {a_val}{ending}"
    stdscr.addstr(outy+3, 5, outstring, curses.color_pair(1) )
    stdscr.refresh()



def execute(line : str, wire_values: dict) -> bool:
    # returns true if instruction executed, false otherwise
    instr,targetwire=line.split(" -> ")
    #print(f"{targetwire}: instruction {instr}")

    match splitinstr:=instr.split():
        case (arg1, "AND"|"OR", arg2): return process_andor(splitinstr[1], arg1, arg2, wire_values, targetwire)
        case (arg1, "LSHIFT"|"RSHIFT", arg2): return process_shift(splitinstr[1], arg1, int(arg2), wire_values, targetwire)
        case ("NOT", arg1): return process_not(arg1, wire_values, targetwire)
        case _:  return process_assingment(splitinstr[0], wire_values, targetwire)


def process_not(sourcewire: str, wire_values: dict, targetwire: str) -> bool:
    if sourcewire in wire_values:
        # The ~ operator in Python may return a signed -ve value.
        # We don't want this, so we & with a 16 bit mask of all 1s to convert to +ve representation
        wire_values[targetwire] = ~wire_values[sourcewire] & 0xFFFF
        return True
    else:
        return False


def process_assingment(instr: str, wire_values: dict, targetwire: str) -> bool:
    try: # simplest case first: 123 -> x
        val=int(instr)
        wire_values[targetwire]=val
        return True
    except ValueError: # not a number - another gate then
        if instr in wire_values:
            wire_values[targetwire]=wire_values[instr]
            return True
        else:
            return False

def process_shift(operation: str, sourcewire: str, arg2: int, wire_values: dict, targetwire: str) -> bool:
    if sourcewire not in wire_values:
        return False
    if operation=="LSHIFT":
        wire_values[targetwire] = wire_values[sourcewire] << arg2
    else:
        wire_values[targetwire] = wire_values[sourcewire] >> arg2
    return True


def process_andor(operation: str, arg1: str, arg2: str, wire_values: dict, targetwire: str) -> bool:
    if arg2 not in wire_values:
        return False
    try: # special case - 1st argument is a value not wire
        value=int(arg1)
        wire_values[targetwire] = value & wire_values[arg2] if operation=="AND" else value | wire_values[arg2]
        return True
    except ValueError:
        # normal case - it's a wire
        if arg1 not in wire_values:
            return False
        wire_values[targetwire] = wire_values[arg1] & wire_values[arg2] if operation=="AND" else wire_values[arg1] | wire_values[arg2]
        return True


def process_instructions(data, stdscr, wireinstr):
    wire_values = {}
    iteration=0
    while data:
        iteration+=1
        for line in data[:]:
            if execute(line, wire_values):
                # if the instruction worked, remove it from the queue
                #print(f"removing: {line}")
                data.remove(line)
        #print(f"Iteration {iteration} instructions left {len(instructions)}")
        display_wires(stdscr, wire_values, iteration, wireinstr)
        curses.napms(DELAY) # delay so we can see how the values are changing
    return wire_values


def main(stdscr):
    # read input file
    with open(INPUTFILE) as inputfile:
        data=inputfile.read().splitlines()

    # dictionary of instructions, only needed for visualization
    wireinstr={}
    for line in data:
        instr,wire=line.split(" -> ")
        instr=instr.strip()
        wire=wire.strip()
        wireinstr[wire]=instr

    # some more initialization
    curses.init_pair(1, curses.COLOR_RED, curses.COLOR_WHITE)
    


    # part 1
    results = process_instructions(data.copy(), stdscr, wireinstr)  # main loop goes here
    part1result=results['a']
    stdscr.getch()
    
    # part 2
    wire_b_instr = list(filter(re.compile(r"-> b$").search, data)) # return only rows that match
    wire_b_instr_index = data.index(wire_b_instr[0])  # the position of this instruction in the list
    data[wire_b_instr_index] = f"{part1result} -> b"  # replace the instruction with this new one
    results = process_instructions(data.copy(), stdscr, wireinstr)  # main loop goes here
    part2result=results['a']
    stdscr.getch()

    return part1result,part2result


# wrapper to simplify init/cleanup of curses
part1result,part2result=curses.wrapper(main)

# print results again to the normal output
print("Part 1: Value of input a is ", part1result)
print("Part 2: Value of input a is ", part2result)

2015 day 06: Probably a Fire Hazard

Fri, 05 May 2023 17:32:00 +0200

Part 1

We’ve got 1 million lights in a 1000x1000 grid and instructions to turn on/turn off/toggle some lights. The puzzle only requires to count how many lights are on, but I couldn’t resist the temptation to add visualisation. I used Pygame library, or rather a very small subset of it: drawing rectangles, drawing single pixels, waiting for event (just one - quit) and delay.

Light grid is stored in a 2D array, initialised with zeroes using nested comprehensions: lights = [[0 for _ in range(WIDTH)] for _ in range(HEIGHT)]. Another notable thing is how I counted the lights: lit=sum(map(sum,lights)). The inner function map(sum,lights) returns a list containing sums of each row, and the outer sum just sums it.

Input processing is very simple this time, splitting on space or comma was all that was needed: elems=re.split(r'\s|,', cmd). Then I call a command rect_on or rect_off which sets some elements to 0 or 1 using nested loops and also calls a pygame function to draw rectangle; rect_toggle is similar but needs to work on single pixels. Some might say that using loops here is non-pythonic and I should have used list comprehension. In my opinion comprehension for 2D arrays is not very readable. It’s faster, but I needed to slow down the code for visualisation anyway.

New Python feature: walrus operator

Walrus operator := was introduced in Python 3.7. A common source of frustration for C programmers is mistaking comparison with assignment: if (i=5) assigns the value and is probably not what the developer intended. However, if ( i=some_function() ) is likely valid, it both assigns the value and checks if it’s true. Python, like many modern languages, initially solved the problem by separating those operations. Which means I would have to do:

line = inputfile.readline().rstrip()
if (line):

instead of if (line := inputfile.readline().rstrip()):. Walrus operator allows you to combine those two again, and since it’s neither = nor ==, it can’t be easily mistaken. In this case there’s not much difference. But walrus operator makes the code not only shorter but more readable when placed in a loop statement or list comprehension. Example without and with walrus operator:

x=get_value()
while(x):
    do_something(x)
    x=get_value()

...

while(x:=get_value)
    do_something(x)

Code

#!/usr/bin/python3

import re
import pygame


# constants
INPUTFILE="06-input.txt"
WIDTH=1000
HEIGHT=1000
FPS=25 # how many animation frames / calculation steps per second

cwhite=(255,255,255)
cblack=(0,0,0)

# global variables
lights=[]



############ PARSE FILE

def run_cmd(cmd):
    elems=re.split(r'\s|,', cmd)
    if elems[0]=='toggle': rect_toggle( int(elems[1]), int(elems[2]), int(elems[4]), int(elems[5]) )
    elif elems[1]=='on'  : rect_on    ( int(elems[2]), int(elems[3]), int(elems[5]), int(elems[6]) )
    elif elems[1]=='off' : rect_off   ( int(elems[2]), int(elems[3]), int(elems[5]), int(elems[6]) )
    else: raise(ValueError)



########## FUNCTIONS ################

def rect_on(x1, y1, x2, y2):
    for i in range(x1, x2+1):
        for j in range(y1, y2+1):
            lights[i][j]=1
    pygame.draw.rect(screen, cwhite, pygame.Rect(x1,y1,x2-x1,y2-y1))
    

def rect_off(x1, y1, x2, y2):
    for i in range(x1, x2+1):
        for j in range(y1, y2+1):
            lights[i][j]=0
    pygame.draw.rect(screen, cblack, pygame.Rect(x1,y1,x2-x1,y2-y1))

def pixel_toggle(x,y):
    if lights[x][y]:
        lights[x][y]=0
        screen.set_at((x,y), cblack)
    else:
        lights[x][y]=1
        screen.set_at((x,y), cwhite)

def rect_toggle(x1, y1, x2, y2):
    for i in range(x1, x2+1):
        for j in range(y1, y2+1):
            pixel_toggle(i,j)


# initialize pygame
pygame.init()
screen=pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption('Day 6: Probably a Fire Hazard')
clock = pygame.time.Clock()
screen.fill((0, 0, 0)) # Fill the background with black
running=True



# initialize the rest
lights = [[0 for _ in range(WIDTH)] for _ in range(HEIGHT)]
with open(INPUTFILE) as inputfile:
    while running:
        for event in pygame.event.get():
            if event.type == pygame.QUIT: running=False

        if (line := inputfile.readline().rstrip()):
            run_cmd(line)
        pygame.display.flip()
        clock.tick(FPS) # wait here


    #end event loop, cleanup here
    pygame.quit()
    lit=sum(map(sum,lights))
    print(f"Lights on: {lit}, off: {WIDTH*HEIGHT-lit}")

Part 2

It turns out the lights have many levels of brightness, “on” really means “increase by 1”, off - “decrease by one” and toggle - “increase by 2”. Of course it does.

Unusually, I decided to put part 2 into a separate file. I also changed the visualisation, instead of updating screen after each instruction, I do it only once, at the end of the program. Updating at every step would really slow down the calculation as there are many cases of controlling individual pixels and this is slow in Pygame.

#!/usr/bin/python3

import re
import pygame


# constants
INPUTFILE="06-input.txt"
WIDTH=1000
HEIGHT=1000
FPS=500 # how many animation frames / calculation steps per second

cwhite=(255,255,255)
cgrey1=(180,180,180)
cgrey2=(220,220,220)
cblack=(0,0,0)

# global variables
lights=[]



############ PARSE FILE

def run_cmd(cmd):
    elems=re.split(r'\s|,', cmd)
    if elems[0]=='toggle': rect_toggle( int(elems[1]), int(elems[2]), int(elems[4]), int(elems[5]) )
    elif elems[1]=='on'  : rect_on    ( int(elems[2]), int(elems[3]), int(elems[5]), int(elems[6]) )
    elif elems[1]=='off' : rect_off   ( int(elems[2]), int(elems[3]), int(elems[5]), int(elems[6]) )
    else: raise(ValueError)



########## FUNCTIONS ################

def rect_on(x1, y1, x2, y2):
    for i in range(x1, x2+1):
        for j in range(y1, y2+1):
            lights[i][j]+=1
    

def rect_off(x1, y1, x2, y2):
    for i in range(x1, x2+1):
        for j in range(y1, y2+1):
            lights[i][j]-=1
            lights[i][j] = max(lights[i][j], 0)


def rect_toggle(x1, y1, x2, y2):
    for i in range(x1, x2+1):
        for j in range(y1, y2+1):
            lights[i][j]+=2

# initialize pygame
pygame.init()
screen=pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption('Day 6: Probably a Fire Hazard')
clock = pygame.time.Clock()
screen.fill((0, 0, 0)) # Fill the background with black
running=True



# initialize the rest
lights = [[0 for _ in range(WIDTH)] for _ in range(HEIGHT)]
with open(INPUTFILE) as inputfile:
    for line in inputfile:
        run_cmd(line)

while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT: running=False
    for i in range(WIDTH):
        for j in range(HEIGHT):
            if lights[i][j]==0:
                screen.set_at((i,j), cblack)
            elif lights[i][j]<=10:
                screen.set_at((i,j), cgrey1)
            elif lights[i][j]<=20:
                screen.set_at((i,j), cgrey2)
            else:
                screen.set_at((i,j), cwhite)
    pygame.display.flip()
    clock.tick(FPS) # wait here


#end event loop, cleanup here
pygame.quit()
lit=sum(map(sum,lights))

print(f"Total brightness: {lit}")

2015 day 04: The Ideal Stocking Stuffer

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

Santa is mining AdventCoins for gifts. We need to calculate some MD5 hashes - Python conveniently has a function for this in the standard library - until we find the right one. Just one loop and some string comparisons.

#!/usr/bin/python3

import hashlib


puzzleinput="iwrupvqb"

i=0
foundfirst=False
foundsecond=False
while not (foundfirst and foundsecond):
    nextval=puzzleinput+str(i)
    nexthash=hashlib.md5(nextval.encode()).hexdigest()
    if not foundfirst and nexthash.startswith("00000"):
        print("Found first hash for value ",i)
        foundfirst=True
    if not foundsecond and nexthash.startswith("000000"):
        print("Found second hash for value ",i)
        foundsecond=True
    i+=1

2015 day 05: Doesn't He Have Intern-Elves For This?

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

Santa needs help figuring out which strings in his text file are naughty or nice. There are different rules for part 1 and 2. So the main program just calls the function is_nice1 and is_nice2 for each line of the input:

nice_1=0
nice_2=0
with open(INPUTFILE) as inputfile:
    for line in inputfile:
        if is_nice_1(line.rstrip()):  nice_1+=1
        if is_nice_2(line.rstrip()):  nice_2+=1
    
print("Number of nice lines (version 1): ", nice_1)
print("Number of nice lines (version 2): ", nice_2)

Nice rules

The easiest thing to check is rule 3 of part 1: It does not contain the strings ab, cd, pq, or xy, even if they are part of one of the other requirements. All we need is a list of naughty strings. We can then iterate over it and check the input string:

    for pair in NAUGHTYPAIRS:
        if pair in chstring:
            return False

Then, there are regular expressions. Personally, I don’t like to construct complicated regexps, they are prone to bugs. These are not so bad yet. All are precompiled and checked the same way:

        if not rx1.search(chstring):
            return False

and the regexps are:

rx1=re.compile(r"(\w)\1")
rx2=re.compile(r'(\w)\w\1')
rx3=re.compile(r'(\w\w)\w*\1')

Here’s the meaning:

rx1 - \w means any letter, in parentheses means remember it, \1 mean repeat the first parentheses, so combined it means a pair of letters
rx2 - (\w) and \1 has the same meaning as in rx1 and there’s another letter in between
rx3 - (\w\w) is a 2-letter group, \1 is the same group, repeated and there’s \w* in between, meaning any number of letters (including 0)

A slightly more interesting case is rule 1 of part 1: It contains at least three vowels (aeiou only). Interesting, because it can be solved with a useful Python class called Counter. It can count occurrences of all characters in the string. We then need to check vowelcounter[letter] for letter in VOWELS (wow, Python code is exactly the same as English explanation!) and sum it:

VOWELS=("a", "e", "i", "o", "u")
vowelcounter=Counter(chstring)
vowelcount = sum(vowelcounter[letter] for letter in VOWELS)
if vowelcount<3:
    return False

Full code below

#!/usr/bin/python3

from collections import Counter
import re

INPUTFILE="05-input.txt"


NAUGHTYPAIRS=("ab", "cd", "pq", "xy")
VOWELS=("a", "e", "i", "o", "u")
rx1=re.compile(r"(\w)\1")
rx2=re.compile(r'(\w)\w\1')
rx3=re.compile(r'(\w\w)\w*\1')

def is_nice_1(chstring: str) -> bool:
    for pair in NAUGHTYPAIRS:
        # condition: doesn't contain naughty pair
        if pair in chstring:
            #print ("naughty pair: ",chstring)
            return False
        # condition: at least 3 vowels
        vowelcounter=Counter(chstring)
        vowelcount = sum(vowelcounter[letter] for letter in VOWELS)
        if vowelcount<3:
            #print (f"less than 3 vowels ({vowelcount}): {chstring}")
            return False
        # condition: letter appears 2 times in a row
        if not rx1.search(chstring):
            #print ("no repeated character: ", chstring)
            return False
    #print("nice: ", chstring)
    return True
            
def is_nice_2(chstring: str) ->bool:
    # condition: contains a letter which repeats with another letter between (xyx)
    if not rx2.search(chstring):
        print ("no (xyx): ", chstring)
        return False
    if not rx3.search(chstring):
        print ("no repeated 2-char group: ", chstring)
        return False
    print("nice: ", chstring)
    return True
 
    
nice_1=0
nice_2=0
with open(INPUTFILE) as inputfile:
    for line in inputfile:
        if is_nice_1(line.rstrip()):  nice_1+=1
        if is_nice_2(line.rstrip()):  nice_2+=1
    
print("Number of nice lines (version 1): ", nice_1)
print("Number of nice lines (version 2): ", nice_2)

2015 day 10: Elves Look, Elves Say

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

We’re checking how fast look-and-say sequence grows. I’ve never heard of it and it doesn’t look particularly useful, but apparently it has some uses in number theory and was analysed by the famous John Conway. Wikipedia explains:

To generate a member of the sequence from the previous member, read off the digits of the previous member, counting the number of digits in groups of the same digit. For example:

1 is read off as “one 1” or 11.
11 is read off as “two 1s” or 21.
21 is read off as “one 2, one 1” or 1211.
1211 is read off as “one 1, one 2, two 1s” or 111221.
111221 is read off as “three 1s, two 2s, one 1” or 312211

Easy thing in any language with strings that:

are dynamic length,
can be treated as an array of characters,
are reasonably fast, because they’re going to get really long.

I think the code is self explanatory. We’re iterating through the string and comparing current character to the previous one. If it’s the same - the streak continues. If it’s different - construct the part of the result as “streak length” and “previous character”. When the loop ends, do the same construction again. Special case: string of length 1. Remember to convert integers to strings when needed. And that’s it.

Not the prettiest code as there’s some repetition, but it’s readable and reasonably fast.

#!/usr/bin/python3

SEED=1113222113
PART1_ROUNDS=40
PART2_ROUNDS=50

def look_and_say(number: str) -> str:
    prev_char=number[0]
    streaklen=1
    if len(number)==1: # special case for 1-digit number
        return f'1{prev_char}'
    newnumber=""
    for i in range(1, len(number)):
        next_char=number[i]
        if next_char==prev_char: # streak continues
            streaklen+=1
        else: # streak ended, change character and create new string
            newnumber+=str(streaklen)+prev_char
            prev_char=next_char
            streaklen=1
    newnumber+=str(streaklen)+prev_char
    return newnumber



number=str(SEED)
for i in range(PART2_ROUNDS):
    #print(f"Round {i+1}  {number} becomes ", end="")
    number=look_and_say(number)
    #print(number)
    if i==PART1_ROUNDS-1:
        print("Part 1 result: ", len(number))

print("Part 2 result: ", len(number))

2015 day 11: Corporate Policy

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

Santa needs a new password that meets the “security” requirements. The puzzle is very similar to day 5, finding naughty strings.

New Python features

zip is a function that allows you to iterate on two or more sequences at once. Usually it’s used over two or more lists, dicts, tuples etc. Example:

>>> countries=["Austria", "United Kingdom", "Denmark", "Sweden", "Norway", "Poland", "Germany"]
>>> areacodes=[43, 44, 45, 46, 47, 48, 49]
>>> for country, code in zip(countries,areacodes):
...     print(f"Area code for {country} is {code}")
... 
Area code for Austria is 43
Area code for United Kingdom is 44
Area code for Denmark is 45
Area code for Sweden is 46
Area code for Norway is 47
Area code for Poland is 48
Area code for Germany is 49

Here I used it like this: for ch1, ch2, ch3 in zip (text, text[1:], text[2:]) which means it combines 3 sequences: some string, the same string starting from the second character and the same string starting from the 3rd character. On the first iteration, it returns characters 0, 1, 2; on the second iteration 1, 2, 3 etc. Note that the sequences have different lengths, second and third one are 1 and 2 characters shorter than the first one. It doesn’t matter for the zip function, it just ends when the shortest sequence ends.

ord returns the Unicode (or ASCII, it’s the same in this case) code of a character, chr is an opposite function that returns character for the given code. In C and C++ I could just do arithmetic operations directly on the characters, surprisingly Python typing is sometimes more strict, you can’t just treat character as a number without explicitly converting it first.

Code

#!/usr/bin/python3

import re

FORBIDDEN=['i', 'o', 'l']
rx1=re.compile(r"(\w)\1.*(\w)\2")


password="cqjxjnds"

def increment(text: str) ->str:
    char_array=list(text)
    for i in range(7,-1,-1):
        char_array[i]=chr(ord( char_array[i] ) + 1)
        if char_array[i]>'z':
            char_array[i]='a'
        else:
            break
    return "".join(char_array)

def rule1(text: str) -> bool: # 3 characters in a sequence
    for ch1, ch2, ch3 in zip (text, text[1:], text[2:]):
        if (ord(ch3)-ord(ch2)==1) and (ord(ch2)-ord(ch1)==1):
            return True
    return False

def rule2(text: str) -> bool:  # does not contain forbidden characters
    for char in text:
        if char in FORBIDDEN:
            return False
    return True

def rule3(text: str) -> bool:  # contains at least 2 different pairs
    if pairsearch := rx1.search(text):
        pair1, pair2= pairsearch.groups()
        if pair1 != pair2: # and they are different
                return True
    return False


print ("Old password: ", password)

while(True):
    password=increment(password)
    if rule1(password) and rule2(password) and rule3(password):
        break
print("Part 1: ", password)
while(True):
    password=increment(password)
    if rule1(password) and rule2(password) and rule3(password):
        break
print("Part 2: ", password)

2015 day 14: Reindeer Olympics

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

It’s time for reindeer race. Reindeers spend each round either flying or resting, have different flight speed and flight/rest cycles. We need to find max distance travelled (part 1) and max score, where each reindeer gets one point when he’s at the first position (part 2).

Simple thing, split() for parsing input, addition and comparisons for the main algorithm.

New Python feature: dataclass

Python got many additions in recent years and dataclass is my favourite. It was introduced in Python 3.7 and if you’re stuck with an older version, it’s worth upgrading just for this.

Simply import it: from dataclasses import dataclass and add decorator @dataclass before the class definition. In the class, add type hints for all variables. And then, magically, Python will create the class constructor, __repr method (used when you print your object), __eq method (comparison operator) and several other things. It saves you from typing a lot of boilerplate code. You can then add methods just like to a standard class, even overwrite the automatically generated methods if they’re not suitable.

But wait, there’s more! There are parameters for the decorator, though not needed here I’ll describe them briefly:

@dataclass(order=True) generates methods for comparison operators (<,>, <=, >=), allows you to sort the objects,
@dataclass(frozen=True) makes the object immutable, which among other things causes it to generate a __hash function, meaning the object can be added to a dictionary or set.

Code

#!/usr/bin/python3

from collections import defaultdict
from dataclasses import dataclass

FILENAME="14-input.txt"
TIMELIMIT=2503

@dataclass
class Reindeer:
    # initial data
    name: str
    speed: int
    maxflighttime: int
    resttime: int
    # data that will change
    distance: int = 0
    cycletime: int = 0
    flying: bool = True
    score: int = 0
    
    
    def do_round(self):
        self.cycletime+=1
        if self.flying:
            self.distance+=self.speed
            if self.cycletime>=self.maxflighttime:
                self.flying=False
                self.cycletime=0
        elif self.cycletime>=self.resttime:
            self.flying=True
            self.cycletime=0


# parse input
reindeers=[]
maxdistances=defaultdict()
with open(FILENAME) as inputfile:
    for line in inputfile:
        name, _, _, speed, _, _, maxflighttime, _, _, _, _, _, _, resttime, _= line.split()
        reindeers.append(Reindeer(name, int(speed), int(maxflighttime), int(resttime)))

# do rounds
for _ in range(TIMELIMIT):
    for r in reindeers:
        r.do_round()
        maxdistances[r.name]=r.distance
    for r in reindeers:
        if r.distance==max(maxdistances.values()):
            r.score+=1

# find score
maxscore=0
for r in reindeers:
    print(r.name, r.score)
    maxscore=max(maxscore, r.score)


print("Part 1, max distance: ", max(maxdistances.values()))
print("Part 2, max score: ", maxscore)

2015 day 25: Let It Snow

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

Part 1

Like with the previous day, I’m writing and coding simultaneously.

I skipped reading the input data. That’s just two numbers, so I put them in the code. At this point I don’t need to practise parsing simple text files, right? I also added the other constants from the instruction:

TARGETROW=2981
TARGETCOL=3075

FIRSTCODE=20151125
MULTIPLIER=252533
DIVIDER=33554393

We have a row and column, which number is that? I suppose there is a mathematical formula that can give it, but I couldn’t easily find one. But computers are really fast at simple arithmetic, so let’s just iterate until we find one. We’re starting at the first number which is at row 0, column 0. I’ll also keep track of maximum row and column reached so far and I’ll use the full loop. Perhaps later I’ll be able to simplify. Let’s try first 10 codes to begin.

row=col=maxrow=maxcol=n=1
while n<10
    if (row==maxrow and col==maxcol):
        row+=1
        maxrow+=1
        col=1
    elif (row>1):
        row-=1
        col+=1
        maxcol+=1
    elif (row==1):
        maxrow+=1
        row=maxrow
        col=1

OK, looks like that already covers all cases - and some of them twice! There’s no need to check for maxcol, whenever we get to the 1st row, we are always at the last column. Let’s simplify already. Also, we need to calculate the code, now we’re only moving on the diagonals. Let’s generate first 10 codes and compare with the sample:

row=col=maxrow=n=1
newcode=FIRSTCODE
while n<10:
    if (row>1):
        row-=1
        col+=1
    else:
        maxrow+=1
        row=maxrow
        col=1
    n+=1
    newcode=(newcode*MULTIPLIER)%DIVIDER
    print(f"{n} row {row} col {col} code {newcode}")

It worked! So let’s get the answer already. But there’s one more thing to simplify. We don’t need the maxrow variable - we’re moving on diagonals, so when we’re at row 1, we’re at column equal to max row reached. Also, we don’t need to know n.

Part 2

There’s no part2. And the puzzle is simple, even easier than day 23 and 24. Nice of the author to remember that people need to do other things on Christmas than coding.

But I’m solving it in May. So let’s rewrite the code to C. It’s only a simple loop and arithmetic operations, shouldn’t be hard. One gotcha - when we multiply the code, we get a number too big for a standard int, but unsigned long long works just fine.

Let’s compare the performance:

$ time ./25-snow.py
Part 1: code 9132360

real	0m5,044s
user	0m4,932s
sys	0m0,016s

$ time ./25-snow
Part 1: code 9132360

real	0m0,097s
user	0m0,087s
sys	0m0,000s

That’s over 50 000 times faster!

Source code - Python version

#!/usr/bin/python3

TARGETROW=2981
TARGETCOL=3075

FIRSTCODE=20151125
MULTIPLIER=252533
DIVIDER=33554393

row=col=1
newcode=FIRSTCODE
while True:
    if (row>1):
        row-=1
        col+=1
    else:
        row=col+1
        col=1

    newcode=(newcode*MULTIPLIER)%DIVIDER
    if row==TARGETROW and col==TARGETCOL:
        break

print(f"Part 1: code {newcode}")

Source code - C version

#include <stdio.h>

int main() {
    const int TARGETROW=2981;
    const int TARGETCOL=3075;

    const unsigned long long FIRSTCODE=20151125;
    const unsigned long long MULTIPLIER=252533;
    const unsigned long long DIVIDER=33554393;

    int row=1;
    int col=1;
    unsigned long long newcode=FIRSTCODE;
    while (1) {
        if (row>1) {
            row-=1;
            col+=1;
        }
        else {
            row=col+1;
            col=1;
        }
        newcode=(newcode*MULTIPLIER)%DIVIDER;
        if (row==TARGETROW && col==TARGETCOL)
            break;
     }
    printf("Part 1: code %llu\n", newcode);

}

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}")

2015 day 22: Wizard Simulator 20XX

Wed, 19 Apr 2023 17:32:00 +0200

That was quite annoying. Coding the initial version didn’t take much time. But then I spent hours debugging it. The result I was getting was ALMOST right - that is, of the multiple won games, I was getting the right one, but also another one with slightly lower cost. Turned out I was checking some conditions in the wrong order: in that game, boss died of poison, but only after it killed the player.

Puzzle description seems quite similar to the previous one, but the code is very different. Previously the number of combinations was small and it was easy to generate all of them in advance. This is different, there are millions of possible games and the only way to check is to play them all. I used a lot of dataclasses:

Spell holds both active effects and spells that can be cast, to simplify the code, each spell has all effects (eg. decrease boss HP, increase player HP, increase mana), but most of them have value 0.
Game holds all of the current game’s data: player’s and boss’s HP and other stats, list of active effects. In the beginning I had a separate class for player and boss - which is a more obvious solution - but since they are heavily coupled and each game has exactly one player and one boss, I decided to combine them.
Gamestats records statistics, for debugging and extra fun. It keeps number of games won, lost and pruned, plus for the won games (but only if they are better than other won games) a more detailed report: list of spells and player’s/boss’s HP and the beginning of each player’s round. The code is slow, to see progress and help with debugging, I added a Curses user interface that displays gamestats.

The most important game function, game_round, uses recursion run a new copy with every possible new spell. The same function covers 2 cases: player round and boss round, so it needs to pass one variable during recursion and make sure it alternates between the two.

Some optimisations to speed up the code:

I check the game cost (mana spent) and if it’s already higher than the best game, that branch is pruned.
I also initially set the best game cost to some impossibly high value that I guessed instead of infinity, that way some branches are pruned even before the first won game
Stats are only displayed once every 10 000 games

It still needs about a minute to go through all possible combinations.

#!/usr/bin/python3

from dataclasses import dataclass
from copy import deepcopy, copy
import curses



@dataclass
class Spell:
    name: str
    cost: int
    damage: int
    hpplus: int
    armor: int
    manaplus: int
    duration: int
    number: int



@dataclass
class Gamestats:
    gamerecorder: list
    games_played: int=0
    games_won: int=0
    games_lost: int=0
    games_pruned: int=0
    minimal_cost_game: int=9999 # initialize with impossibly high value

    def clear(self):
        self.gamerecorder=[]
        self.games_played=0
        self.games_won=0
        self.games_lost=0
        self.games_pruned=0
        self.minimal_cost_game=9999

@dataclass
class Game:
    player_hp: int
    mana: int
    armor: int
    mana_spent: int
    player_attack: int
    active_effects: list
    boss_hp: int
    boss_attack: int
    game_record: str


    def check_player_end(self) -> bool:
        global stats
        if self.player_hp<=0: 
            stats.games_played+=1
            stats.games_lost+=1
            return True
        return False

    def check_boss_end(self) -> bool:
        global stats
        if self.boss_hp<=0:
            stats.games_played+=1
            stats.games_won+=1
            if self.mana_spent<stats.minimal_cost_game: # only record better games
                gamedata=f"mana {self.mana} spent: {self.mana_spent} spells: {self.game_record} "
                stats.gamerecorder.append(gamedata)
            stats.minimal_cost_game = min(stats.minimal_cost_game, self.mana_spent)
            return True
        return False

    def check_pruned(self) -> bool:
        global stats
        # if we already spent more than the best game, no need to continue
        if self.mana_spent>stats.minimal_cost_game:
            stats.games_played+=1
            stats.games_pruned+=1
            return True
        return False



    def do_effects(self):
        for spell in copy(self.active_effects):
            self.armor+=spell.armor
            self.player_attack+=spell.damage
            self.mana+=spell.manaplus
            spell.duration-=1
            if spell.duration<=0:
                self.active_effects.remove(spell)
        


    def cast_spell(self, spell: Spell) -> bool:
        self.mana-=spell.cost
        self.mana_spent+=spell.cost
        if spell.number in [1, 2]: # missile or drain - instant effect
            self.boss_hp-=spell.damage
            self.player_hp+=spell.hpplus
            if self.check_boss_end():
                return True
        else: # delayed effect
            self.active_effects.append(copy(spell))
        self.game_record+=f"{spell.name} {self.player_hp}/{self.boss_hp}|"
        return self.check_pruned()



    def reset_effects(self):
        self.armor=0
        self.player_attack=0








spells = [
    Spell("Missile", 53, 4, 0, 0, 0, 0, 1),
    Spell("Drain", 73, 2, 2, 0, 0, 0, 2),
    Spell("Shield", 113, 0, 0, 7, 0, 6, 3),
    Spell("Poison", 173, 3, 0, 0, 0, 6, 4),
    Spell("Recharge", 229, 0, 0, 0, 101, 5, 5),
]



# each round:
# player: (spell effects, test hp, test mana), player casts new spell, optionally (missile and drain) spell has effect, test hp
# boss: (spell effects, test hp, boss attacks, test hp)


def display_stats(stdscr: curses.window, stats: Gamestats):
    try:
        outx=0
        outy=2
        outformat=curses.A_NORMAL
        outstring=f"Games played: {stats.games_played:,}"
        stdscr.addstr(outy, outx, outstring, outformat)
        outy+=1
        outstring=f"Won:          {stats.games_won:,}"
        stdscr.addstr(outy, outx, outstring, outformat)
        outy+=1
        outstring=f"Lost:         {stats.games_lost:,}"
        stdscr.addstr(outy, outx, outstring, outformat)
        outy+=1
        outstring=f"Pruned:       {stats.games_pruned:,}"
        stdscr.addstr(outy, outx, outstring, outformat)
        outy+=1
        outformat=curses.A_BOLD
        outstring = f"Lowest cost {stats.minimal_cost_game}"
        stdscr.addstr(outy, outx, outstring, outformat)
        outformat=curses.A_NORMAL
        outy+=1
        for i in stats.gamerecorder:
            outy+=1
            stdscr.addstr(outy, outx, i, outformat)

        stdscr.refresh()
    except Exception:
        pass

def top_message(stdscr: curses.window, message: str):
    outformat=curses.A_REVERSE
    stdscr.addstr(0, 0, message, outformat)
    stdscr.refresh()

def game_round(game: Game, stdscr: curses.window, part2, player_round=True):
    global spells, stats
    if stats.games_played%10000==0: # display stats every 10000 games
        display_stats(stdscr, stats)

    if player_round and part2:
        game.player_hp-=1
        if game.check_player_end():
            return

    game.do_effects()
    game.boss_hp-=game.player_attack # only does something if poison is active
    if game.check_boss_end(): # check if poison killed the bos
        return

    if player_round:
        game.reset_effects()
        # try to cast spell
        could_not_cast=True
        for spell in spells:
            already_active = any(effect.number==spell.number for effect in game.active_effects)
            if not already_active and game.mana>=spell.cost:
                could_not_cast=False
                newgame=deepcopy(game)
                if (newgame.cast_spell(spell)): # boss died
                    return
                game_round(newgame, stdscr, player_round=False, part2=part2)
        if could_not_cast: 
            game.player_hp=0
            game.check_player_end() # record lost game
            return
    else: # boss round
        # boss attacks
        attack = max(game.boss_attack-game.armor, 1)
        game.player_hp-=attack 
        game.reset_effects()
        if game.check_player_end():
            return
        game_round(game, stdscr, player_round=True, part2=part2)


def main(stdscr: curses.window):
    global stats
    game=Game(boss_attack=10, boss_hp=71, player_hp=50, mana=500, mana_spent=0, armor=0, player_attack=0, active_effects=[], game_record="")
    game_round(game, stdscr, part2=False)
    part1result=stats.minimal_cost_game
    top_message(stdscr, "Part 1 done, press any key to continue")
    stdscr.getch() # wait for keypress
    stdscr.clear()
    game=Game(boss_attack=10, boss_hp=71, player_hp=50, mana=500, mana_spent=0, armor=0, player_attack=0, active_effects=[], game_record="")
    stats.clear()
    game_round(game, stdscr, part2=True)
    top_message(stdscr, "Part 2 done, press any key to continue")
    stdscr.getch() # wait for keypress
    part2result=stats.minimal_cost_game
    
    return part1result,part2result


if (__name__=="__main__"):
    stats=Gamestats(gamerecorder=[])
    # wrapper to simplify init/cleanup of curses
    part1result,part2result=curses.wrapper(main)
    # print results again to the normal output
    print("Part 1:  ", part1result)
    print("Part 2:  ", part2result)

2015 day 3: Perfectly Spherical Houses in a Vacuum

Sat, 15 Apr 2023 17:33:00 +0200

Santa is delivering presents to an infinite two-dimensional grid of houses. He’s got a list of instructions telling him to go south, north, east or west. The instructions can take him to some houses more than once, we need to count how many unique houses were visited.

Python has just the data structure for this: a set. All I need is to put coordinates of every visited house, set will only add it if it’s not already present and silently ignore it otherwise. At the end, I just need to check the size of the set. I wrote some quick and dirty code for this.

For part 2, Santa got a mechanical helper. Santa and Robo-Santa start at the same position, every odd instruction (1, 2, 3…) is for Santa, every even one (2, 4, 6…) for the robot. How many houses would be visited?

I decided to rewrite the code and solve a more general problem: not only for 1 and 2 Santas, but for an arbitrary number of Santas. For that I created a class Santa with 3 attributes: current coordinates and a set of visited houses. Then, a function called santatour creates a list of Santa objects: santas = [ Santa() for i in range(numsantas)]. Then I used an instruction counter and modulo arithmetic: s=counter%numsantas, if numsantas equals 2, gives 0 for instruction 0, 2, 4… and 1 for 1, 3, 5. If just one Santa, it always gives 0. If numsantas equals 3, it goes 0, 1, 2, 0, 1, 2… etc.

I could just record all visits in one set of visited houses, but again I wanted to solve a more generic problem. Each santa held its own record, so I needed to get a union. A union of 2 sets contains all elements that belong to any of the sets, in Python you can use a union function or | operator: totalvisited=totalvisited|santas[i].visited

#!/usr/bin/python3

INPUTFILE="03-input.txt"



class Santa:
    x: int
    y: int
    visited: 'set[int,int]'
    
    def __init__(self, x=0, y=0):
        self.x=0
        self.y=0
        self.visited=set()
        self.record_visit()

    def record_visit(self):
        #print("Recording visit in ", self.x, self.y)
        self.visited.add( (self.x, self.y) )


def santatour(numsantas: int=1):
    counter=0 # instruction counter
    santas = [ Santa() for i in range(numsantas)]
    with open(INPUTFILE) as inputfile:
        while True:
            s=counter%numsantas
            c=inputfile.read(1)
            #print(f"Counter {counter} instruction {c} santa {s}")
            if not c:
                break
            if   c=='<': santas[s].x-=1
            elif c=='>': santas[s].x+=1
            elif c=='^': santas[s].y+=1
            elif c=='v': santas[s].y-=1
            else:
                print("Error: unkown direction ",c)
            santas[s].record_visit()
            counter+=1
    print ("Houses visited by each Santa")
    totalvisitsnum=0
    totalvisited=set()
    for i in range(numsantas):
        visits=len(santas[i].visited)
        totalvisited=totalvisited|santas[i].visited
        print(f"  Santa {i}  houses {visits}")
        #print(santas[i])
    print("Total: ", len(totalvisited))

print("Part 1:")
santatour(1)

print("\n\nPart 2:")
santatour(2)

2015 day 2: I Was Told There Would Be No Math

Sat, 15 Apr 2023 17:32:00 +0200

We need to calculate how much wrapping paper (part 1) and ribbon (part 2) we need for the presents. We are given the list of dimensions to calculate the area/perimeter, we also need to add some extra paper/ribbon, we even get the equations.

Simple thing again. This time I went with Python because I wanted to solve it fast and move to more interesting puzzles.

#!/usr/bin/python3

INPUTFILE="02-input.txt"

totalpaper=0
totalribbon=0

with open(INPUTFILE) as inputfile:
    for line in inputfile:
        x,y,z=line.rstrip().split('x')
        dimensions=[int(x), int(y), int(z)]
        dimensions.sort()
        #print(dimensions[0], dimensions[1], dimensions[2])
        totalpaper += 3*dimensions[0]*dimensions[1] + 2*dimensions[1]*dimensions[2] + 2*dimensions[2]*dimensions[0]
        totalribbon+= 2*dimensions[0]+2*dimensions[1] + dimensions[0]*dimensions[1]*dimensions[2]

print("Total paper needed:  ",totalpaper)
print("Total ribbon needed: ",totalribbon)

2015 day 1: Not Quite Lisp

Sat, 15 Apr 2023 17:31:00 +0200

Santa is trying to deliver presents in a large apartment building. He starts on the ground floor - floor 0 - and needs to travel up and down. The instructions are a list of brackets, “(” means go up and “)” means go down. We need to find:

For part 1: what is the last floor?
For part 2: at which instruction Santa will enter the basement for the first time?

That’s clearly just a warm-up. All the operations are: reading one character/byte at time, comparison, incrementing/decrementing. I could solve it in any programming language I know and possibly in some languages I don’t know. So I used C while I still could.

#include <stdio.h>
#include <stdbool.h>

const char* FILENAME="01-input.txt";

int main() {
    FILE* fileptr;
    char direction;
    int current_floor=0;
    int instr_counter=0;
    fileptr = fopen(FILENAME, "r");
    if (!fileptr) {
        printf("file: %s can't be opened\n", FILENAME);
        return 1;
    }

    bool above_ground=true;
    while ( (direction=getc(fileptr)) != EOF ) {
        ++instr_counter;
        if (direction=='(')
            ++current_floor;
        else if (direction==')')
            --current_floor;
        else {
            printf("Wrong direction: %c\n",direction);
            return 2;
        }
        if (above_ground && current_floor<0) { // entering basement first time
            above_ground=false;
            printf("Answer for part 2 (step when basement entered): %d\n", instr_counter);
        }
    }
    printf("Answer for part 1 (last floor): %d\n", current_floor);
}