2015 on Advent of Code - Too Many Machines

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);

}

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