The first time I read through the riddle, I was like: “Phew, no way, I’m going to skip this!” I looked at the example and the description, and it didn’t make sense at all. But when I’m stuck like that at the very beginning, the best approach to get a grip is: Visualize! (A concept I didn’t learn from [Daniel Bourke’s course about machine learning](but he perfected it!)

However, I thought it might be a good idea to use Ruby this time — my first time with this language. I won’t bother you with the environment setup. Again, I’m just using a containerized environment, which makes things so much easier.

Solution to the First Part

So, what is this about? It’s about finding siblings on a surface, connecting them with a straight line, and then extending this line to find two symmetric points. The total number of all those points forms the solution to this riddle. The green and red cells represent two categories of siblings on the map, and the blue cells represent the symmetric points (called antinodes) that we need to find. If you connect them (with red lines), you’ll see how all of them pass through two cells of the same color:

Looks difficult, right? Don’t tell me, it took me a while to understand the “gibberish” of the riddle – no offense, riddle master.

But wait until we add row and column numbers to the map and focus on just one group:

Now it seems quite easy: We just need to somehow identify the row and column distance between two siblings and use that to place the corresponding antinode.

Let me just throw my solution into the ring. It’s not the most elegant, but it gets the job done:

• First, I use two loops to find two siblings.
• Then, I calculate the row and column indexes for both siblings.
• From there, I can calculate the row and column indexes for both antinodes.
• Finally, I just check if they are within the boundaries before adding them to a dictionary.

 1from_char_array.each_with_index do |from_char, from_index|
 2    next if from_char == "."
 3
 4    from_char_array[(from_index + 1)..-1].each_with_index do |to_char, to_index|
 5        next unless from_char == to_char
 6
 7        from_row = (from_index / map_height).floor
 8        from_col = from_index - (from_row * map_width)
 9
10        to_row = ((from_index + to_index + 1) / map_height).floor
11        to_col = (from_index + to_index + 1) - (to_row * map_width)
12
13        puts "Found couple of #{from_char} at #{from_row}/#{from_col} and at #{to_row}/#{to_col}"
14
15        first_antinode_row = from_row - (to_row - from_row)
16        second_antinode_row = to_row + (to_row - from_row)
17
18        first_antinode_col = from_col + (from_col - to_col)
19        second_antinode_col = to_col + (to_col - from_col)
20
21        if first_antinode_row.between?(0, map_height - 1) && first_antinode_col.between?(0, map_width - 1)
22            antinodes["#{first_antinode_row}/#{first_antinode_col}"] = "#"
23        end
24        
25        if second_antinode_row.between?(0, map_height - 1) && second_antinode_col.between?(0, map_width - 1)
26            antinodes["#{second_antinode_row}/#{second_antinode_col}"] = "#"
27        end
28        
29    end
30end

If you’re stuck on this one, no worries: I have to admit, although it’s just roughly 20 lines of simple code, it took me a while to initially understand the task and then put everything together, because I was mixing up 0-based indexing, column calculation, and so on.

And because I am already 4 days behind, I didn’t even read the second part and continued to day 9…

What’s up, Ruby?

Rating: 10/12 – underestimated diamond

I was honestly surprised at how easy it is to get something done in Ruby. It seems as simple and straightforward as Python, and if you’re looking for a quick ’n’ dirty scripting language, I’d say Ruby is definitely worth a try.

This is the kind of task I really enjoy: finding algorithms for simple mathematical challenges! Let’s go—this time in… C++! (Phew!)

You’ll find my .devcontainer and Dockerfile on GitHub. Once again, I don’t want to bloat my system with additional compiler setups. It turns out, this is working like a charm.

Solution to the First Part

Well, the idea is quite easy: We got a list of operands and need to find the correct combination of + and * to get a target result. What we basically need to do is: Loop through all given equations, get all possible permutations of + and * for n given operands, and then do the math.

The first tricky thing here is: They are providing a lot of huge numbers. So using 32-bit integers isn’t sufficient. You not only need 64-bit integers, but also unsigned to work with numbers like 175.033.602.122.656.

But they also hid a little pitfall in the list of possible equations: There is one (exactly one!) duplicate entry. Which makes it hard to find. Would it be ten, 42, or 100 duplicate entries, you would somehow stumble over it. But now it took me a while, and I was close to throwing this task away. I started debugging and I wondered why I am only processing 849 equations instead of 850. At first glance, it looks like one of those classic “indexing starts at zero” bugs. But then I did, what you usually do when filling dictionaries: You check if the entry you want to add already exists. And it does.

And while this wouldn’t lead to a valid equation…

11095: 8 5 9 3 231

This line certainly does

11095: 8 1 2 7 95 8 2 7 2 2 99

And so I found the missing value for the final result…

Solution to the Second Part

Well, the second part took me a while because I was somehow trying to build this concatenation part into the current algorithm. We now have three operators, *, +, and || — but the last one should connect two integers.

Eventually, I had my heureka moment: Concatenation could be implemented as a mathematical operation, too.

If the left number is 123 followed by 45, we need to multiply 123 with 10^2 and then just add 45. Easy math.

Side note: I was cheating a little. I now know that 1095 is a duplicated entry, and I know it would lead to a valid result, so I am adding it hard-coded to get the final result.

Whats up, C++?

Rating: 6/12 – painful

Well, C++ is undoubtedly a powerful language, but for a reason it’s not beating all those scripting languages out there. Simple things are complicated because you have to implement them on your own. 5 out of 12 seems to be unfair for such a grown-up programming language, but this is simply my point of view. For me, right now, there’s no reason to use C++. Which absolutely does not mean that this language is not important! Nevertheless, using it felt like an adult pro developer. ;)

This task looks tricky, so I am once again choosing a simple language that I am familiar with: JavaScript ( which, by the way, was developed in just 10 days ).

With no further ado…

Solution to the First Part

There’s not much to explain. As expected, I just need to move the guard through the maze by increasing and decreasing rows and columns. When I hit an obstacle, I change direction. When I hit the border of the maze, I’ve solved the task. Easy peasy…

Solution to the Second Part

The second part is kind of tricky. They want us to find positions of additional obstacles that make the maze unsolvable.

Well, there’s an easy pattern behind it. You will see it if you visualize it:

An infinite loop occurs when you have four obstacles on each edge of a rectangle, like this:

So, all we need to do at every step on our path is to try to draw a rectangle. If it has three existing obstacles, we get one potential solution for an “artificial obstacle.

In case you’re wondering: I didn’t finish the second part. I know the solution approach, but seeing that I am three days behind already, I stopped working on it.

Whats up, JavaScript?

Rating: 9/12 – god ol’ frien’

Fun Fact: I was writing an algorithm to find prime numbers and found out that JavaScript is way faster than Python.

However, I really like JavaScript and often use it when I want to build small proof of concepts. It’s quick, runs everywhere (like in every browser), and is quite straightforward.

Despite the second bump in the journey to endless glory, I hope to see you again tomorrow!

It’s the fifth day of our outrageous adventure, and we are dealing with printer updates. To solve this riddle, we are getting back to the roots and our good ol’ friend Bash!

The good news here is that I don’t need to set up any particular environment because, thankfully, Bash is available on most systems out of the box.

Solution to the First Part

The solution is quite straightforward: We need to read the rules and the updates into an array, loop through all updates, and check if they somehow break the rules. That’s nothing too complicated. The only thing that I am probably doing unconventionally is how I check.

I am using a regular expression that is the opposite of the rule. If it matches, I know the update is invalid:

161.*?(,29)(,|$)

In this example, 29 is the actual rule name, and 61 should come after 29. With .*?, I am ungreedy checking for any characters in between, and the closing group just makes sure that after 29, there’s either another number or the end of the update.

Simple thing.

Solution to the Second Part

The second part looks way easier. They just want us to switch the position of the pages that we identified as erroneous.

Basically, it’s just something like this:

1updates[page_index]=$subsequent_page
2updates[subsequent_page_index]=$page

But… yeah, that’s the first bump in my journey. My code isn’t resulting in the correct answer, and it seems like I am missing a detail. To avoid wasting any more time, I’ll proceed to the next day… sorry folks :(

Whats up, Bash?

Rating: 8/12 – weird operators and syntax

The boss of all scripting languages: Bash. I still don’t understand most of the syntax rules, but thanks to AI, it’s not too hard to get things done in Bash. When working as a sysadmin, I loved automating processes and even building small user interfaces to make life on the command line easier. However, I guess there are better ways for that.

See you next day!

I Made It to Day 4!

And today’s task perfectly fits Excel. Some—if not most—people don’t like Excel and would never consider it a serious tool for data analytics, exploration, or even “engineering.” Well, you’re wrong about Excel. It’s quite powerful if you know how to use it. Let me show you…

The first part of the task is a kind of word riddle where we have to count occurrences of “XMAS” in a huge grid of letters. And actually, that’s pretty easy with Excel. I’d even say it’s easier than using a fully-fledged scripting tool.

Solution to the First Part

The input comes as a couple of lines. To make each character addressable, we first need to split each character into its own column. While I could use “Text to Columns,” the goal is to make this dynamic, so I will utilize a formula:

_LENGTH refers to [C2]

1[D1]=MID(B4;SEQUENCE(1;_LENGTH);1)

If you pull this formula down, you get a matrix like this (referring to the example input):

The following image shows all possible solutions:

We start with the most simple solution, where XMAS is plotted from the center to the right. The surrounding if-condition is temporary, only to make the result visible:

1=IF(CONCAT(G21;H21;I21;J21)="XMAS";"+";"")

It’s quite easy, right? We copy the formula (not the result of the cell!) to a text editor and modify it to get the other seven directions.

Eventually, you end up with eight lines looking like this:

1=IF(CONCAT(G21;H21;I21;J21)="XMAS";"+";"")
2=IF(CONCAT(G21;H22;I23;J24)="XMAS";"+";"")
3=IF(CONCAT(G21;G22;G23;G24)="XMAS";"+";"")
4=IF(CONCAT(G21;F22;E23;D24)="XMAS";"+";"")
5=IF(CONCAT(G21;F22;E23;D24)="XMAS";"+";"")
6=IF(CONCAT(G21;F20;E19;D18)="XMAS";"+";"")
7=IF(CONCAT(G21;G20;G19;G18)="XMAS";"+";"")
8=IF(CONCAT(G21;H20;I19;J18)="XMAS";"+";"")

To count the occurrences of all existing solutions, we could either build some kind of LAMBDA function or use a simple trick: We just cast the TRUE or FALSE result to an integer:

1=--(VERKETTEN(G21;H21;I21;J21)="XMAS")+
2    --(VERKETTEN(G21;H22;I23;J24)="XMAS")+
3    --(VERKETTEN(G21;G22;G23;G24)="XMAS")+
4    --(VERKETTEN(G21;F21;E21;D21)="XMAS")+
5    --(VERKETTEN(G21;F22;E23;D24)="XMAS")+
6    --(VERKETTEN(G21;F20;E19;D18)="XMAS")+
7    --(VERKETTEN(G21;G20;G19;G18)="XMAS")+
8    --(VERKETTEN(G21;H20;I19;J18)="XMAS")

And now apply it to our testing dataset. Copy the cell (not the formula!) next to our matrix. It should refer to the first column in the first row. Then drag it to the right and down to cover the whole area. You should end up with something like this:

The sum of the matrix is 18 — which is exactly the number of XMAS hidden in the test dataset. Now take the actual puzzle input, copy it to your sheet, and apply your magic formula to it. If you want to avoid dragging the formula to the right and down, you could use SEQUENCE again, but we’ll save that for later…

The good thing about the Excel approach is that the second part doesn’t make it more complicated. We stick with our strategy and now just look for all possible variations of X-MAS. There are four:

And our formula changes a little. We know that A has to be in the middle. We concatenate the surrounding four cells and just test for all four possible combinations of S and M, which leads us to something like this:

1=--(OR(CONCAT(F210;G209;G211;E211;E209)="AMSSM";
2    CONCAT(F210;G209;G211;E211;E209)="ASSMM";
3    CONCAT(F210;G209;G211;E211;E209)="ASMMS";
4    CONCAT(F210;G209;G211;E211;E209)="AMMSS"))

It’s even simpler than the previous one! Again, just make it reference your dataset, and you get the correct result!

Whats up, Excel?

Rating: 10/12 – understimated and powerful

I’m not gonna lie: I really love Excel. Since a couple of years, Excel also supports LAMBDA, which allows for more complex calculations and even functional programming. [You can even build an animated ticker in Excel]((shameless self-promotion)!

That said… see you next day!

I had initially planned to solve today’s riddle in BASIC—the first programming language I learned 30 years ago. However, it turns out that deploying a BASIC compiler into a container isn

Today, we need to parse a text to find all occurrences of mul(n, m), calculate the product of n and m, and finally compute the sum of all products. Let’s try to find a neat one-liner for that.

Solution of the first part

Here it is:

1with open("input.txt", "r") as file: print(sum([reduce(mul, ast.literal_eval(match.replace("mul", ""))) for match in re.findall("mul\(\d{1,3},\d{1,3}\)", file.read())]))

What am I doing? Well, let’s read it from the inside out:

First, we get all occurrences of mul(n, m), which is quite easy using regex:

1re.findall("mul\(\d{1,3},\d{1,3}\)

Then, we go through all matching groups using Python’s list comprehension feature:

1[match for match in re.findall("mul\(\d{1,3},\d{1,3}\)", file.read())]

But we’re not just using the plain result, which is a string like mul(4, 2). First, we remove mul to get the parentheses, then we evaluate the string into an actual tuple, like (4, 2):

1ast.literal_eval(match.replace("mul", ""))

Now that we have a list of integers, we can apply multiplication to each item:

1reduce(mul, (4, 2))

Each of the products will be fed into the final list. The sum() method simply adds up all the products in the list. The surrounding with ... as file: simply opens the file to read the content.

Solution of the second part

Well, the second part is a little trickier with three additional rules:

• Only sum up products of mul() if there’s the preceding keyword do().
• Ignore all mul() instructions after the keyword dont().
• All mul() instructions at the beginning, where there’s neither a dont() nor a do(), need to be considered, too.

This sounds easy at first glance, so I tried to figure out a way to simply adjust my regular expression. With no success, but a ton of frustration. However, I figured out a different way that is way more fun and demonstrates the obscure power of list comprehension:

1sum([sum([sum([reduce(mul, ast.literal_eval(match.replace("mul", ""))) for match in re.findall("mul\(\d{1,3},\d{1,3}\)", dos)]) for _j, dos in enumerate(donts.split("do()")[1:])]) for _i, donts in enumerate(file_contents.split("don't()")) if len(donts.split("do()")) > 1])

I guess you have questions? Fair enough. There you go, this is the expanded version:

1sum_of_all = 0
2for _i, donts in enumerate(('do()' + file_contents).split("don't()")):
3    if len(donts.split("do()")) > 1:
4        for _j, dos in enumerate(donts.split("do()")[1:]):
5            for match in re.findall("mul\(\d{1,3},\d{1,3}\)", dos):
6                print(f'string: {match} - list: {ast.literal_eval(match.replace("mul", ""))} -  product: {reduce(mul, ast.literal_eval(match.replace("mul", "")))}')
7                sum_of_all += reduce(mul, ast.literal_eval(match.replace("mul", "")))
8
9print(f'sum: {sum_of_all}')

The idea is that I simply split the whole text by the string dont() in the first for loop. This returns a list of items, where I know that every mul() must be ignored until I encounter a do() in the string.

This leads to the next operation: Instead of parsing the string, I split each of the strings by the keyword do(). If this string contains do(), I get a list of 2 items. If not, I can ignore the whole string in my outer loop.

Otherwise, I take all items except the first one, and now I can apply the logic from above: using the regular expression to get the list of integers, then multiplying and summing up.

There’s a small pitfall: The third rule says that all instructions at the beginning of the string, until the first do() or dont(), need to be considered. The simplest way to handle this is by just adding do() to the initial input string.

In case you’re wondering how to go from the seemingly simple connection of nested loops to this nasty nested list comprehension—you achieve it step by step:

First, we iterate through the raw file content:

1[donts for _i, donts in enumerate(('do()' + file_contents).split("don't()"))]

Then, we replace dont() with the next loop:

1[[dos for _j, dos in enumerate(donts.split("do()")[1:])] for _i, donts in enumerate(('do()' + file_contents).split("don't()"))]

Don’t forget to add a condition to skip results with a length of 1:

1[[dos for _j, dos in enumerate(donts.split("do()")[1:])] for _i, donts in enumerate(('do()' + file_contents).split("don't()")) if len(donts.split("do()")) > 1]

Then, we can replace do() with the following loop:

1[[[match for match in re.findall("mul\(\d{1,3},\d{1,3}\)", dos)] for _j, dos in enumerate(donts.split("do()")[1:])] for _i, donts in enumerate(('do()' + file_contents).split("don't()")) if len(donts.split("do()")) > 1]

Now we are at the point where we handle the matching groups, so we replace match with everything we need to get a product out of the stringified list of integers:

1[[[reduce(mul, ast.literal_eval(match.replace("mul", ""))) for match in re.findall("mul\(\d{1,3},\d{1,3}\)", dos)] for _j, dos in enumerate(donts.split("do()")[1:])] for _i, donts in enumerate(('do()' + file_contents).split("don't()")) if len(donts.split("do()")) > 1]

And eventually, we get the sum of each nested list:

1sum([sum([sum([reduce(mul, ast.literal_eval(match.replace("mul", ""))) for match in re.findall("mul\(\d{1,3},\d{1,3}\)", dos)]) for _j, dos in enumerate(donts.split("do()")[1:])]) for _i, donts in enumerate(('do()' + file_contents).split("don't()")) if len(donts.split("do()")) > 1])

Looks great, doesn’t it?

Whats up, Python?

Rating: 14/12 – nice and friendly, always again

Uncontroversial—one of Python’s best features is list comprehensions, which also work for dictionaries, sets, and tuples, by the way. List comprehensions have so many features; besides the way you can nest them, you can add conditions in two ways. Either when you add an item to the output list…

1[x if x % 2 == 0 else -x for x in range(10)]

…or before:

1[x for x in range(10) if x % 2 == 0]

You can loop through multiple lists (et al):

1[(x, y) for x in range(3) for y in range(2)]

You can not only nest them, but also serialize multiple loops to flatten a nested input:

1nested = [[1, 2], [3, 4], [5, 6]]
2[x for sublist in nested for x in sublist]

And there are probably a couple more that I don’t even know.

See you next day…

This task is about testing if integers in a list are increasing or decreasing. I’ll try Rust, and I assume I need nerves of steel for this exercise.

Setting Up the Development Environment

Rust comes in a container, too. Here’s the Dockerfile:

 1# Dockerfile
 2FROM rust:latest
 3
 4# Install additional tools you might need
 5RUN apt-get update && apt-get install -y \
 6    git \
 7    curl \
 8    wget \
 9    build-essential
10
11# Set the working directory
12WORKDIR /workspace
13
14# Copy project files (if any)
15COPY . .
16
17# Default command
18CMD ["bash"]

And here’s the devcontainer.json to develop inside that container made of steel:

 1{
 2    "name": "Rust Development Container",
 3    "build": {
 4        "dockerfile": "../Dockerfile"
 5    },
 6    "customizations": {
 7        "vscode": {
 8            "extensions": [
 9                "rust-lang.rust-analyzer",
10                "serayuzgur.crates",
11                "tamasfe.even-better-toml"
12            ]
13        }
14    },
15    "remoteUser": "root",
16    "features": {
17        "ghcr.io/devcontainers/features/rust:1": {}
18    }
19}

Rust also requires a Cargo.toml file that defines your project and dependencies:

1# Cargo.toml
2[package]
3name = "rust-docker-project"
4version = "0.1.0"
5edition = "2024"
6
7[dependencies]
8# none, ehehe

That’s all we need. Build it with docker build and connect VS Code. The source file is located inside the src folder. You can run your code like this

1cargo build
2cargo run

The algorithm itself isn’t that tricky. You’ll find everything on Github .

Whats up, Rust?

Rating: 4/12 – Wouldn’t use it freely

Don’t get me started. I didn’t know that Rust has so many strange rules. There’s this interesting concept of ownership: values belong to a variable as long as you don’t assign that variable to another variable. If you pass a value from one vector to another, you can’t access it in the original vector anymore.

And then there are many important operators scattered across the code, like:

• & for borrowing (referencing a value without taking ownership)
• * for de-referencing (accessing the value a reference points to)

What I do like, though, is the error handling. Rust uses Ok and Err to make handling errors much cleaner and explicit:

1Err("Value not valid")
2Ok(())

This approach forces you to handle potential issues early on, which is great for reliability.

See you next day…

As the challenge at AoC is not about the syntax but the algorithm, I decided to try a different approach this year: a new language every day. I am probably not going to explain the code in detail, but I will point out characteristics of each particular language that I think are worth mentioning. Let’s see how far I get. Please don’t take my judgement to serious.

Disclaimer: Of course, I am using AI to get the actual syntax, but not for the algorithm itself. I usually use ClaudeAI for that, as I’ve experienced the best results with the free version there.

On the first day, I’m starting with F# — the sister of C# — which focuses on functional programming.

Setting Up the Development Environment

First, I need to set up my development environment. Since I don’t want to pollute my system with tons of different interpreters, I prefer to work in Docker containers. Above all, this requires the Dev Containers extension . To make VS Code ready for F#, I also need the Ionide extension .

Here is the Dockerfile for a containerized F# environment:

 1# Use official .NET SDK image with F# support
 2FROM mcr.microsoft.com/dotnet/sdk:8.0
 3
 4# Install additional tools
 5RUN apt-get update && \
 6    apt-get install -y \
 7    git \
 8    curl \
 9    vim \
10    sudo
11
12# Create vscode user with sudo permissions
13RUN groupadd -r vscode \
14    && useradd -m -s /bin/bash -g vscode -G sudo vscode \
15    && echo "vscode ALL=(ALL) NOPASSWD:ALL" >> /etc/sudoers.d/vscode \
16    && chmod 0440 /etc/sudoers.d/vscode
17
18# Set working directory and ensure proper ownership
19WORKDIR /app
20RUN chown -R vscode:vscode /app
21
22# Ensure .NET tools are in PATH
23ENV PATH="/home/vscode/.dotnet/tools:${PATH}"
24
25# Set the default user to vscode
26USER vscode
27
28# Ensure .NET tools are installed for the vscode user
29RUN dotnet tool list --global || true
30
31# Default command
32CMD ["/bin/bash"]

Developing inside a container requires /.devcontainer/devcontainer.json to look like this:

 1{
 2    "name": "F# Dev Environment",
 3    "build": {
 4        "dockerfile": "../Dockerfile",
 5        "context": ".."
 6    },
 7    "remoteUser": "vscode",
 8    "workspaceFolder": "/app",
 9    "customizations": {
10        "vscode": {
11            "extensions": [
12                "Ionide.ionide-fsharp",
13                "ms-dotnettools.csharp"
14            ]
15        }
16    },
17    "mounts": [
18        "source=${localWorkspaceFolder},target=/app,type=bind,consistency=cached"
19    ],
20    "containerUser": "vscode",
21    "remoteEnv": {
22        "DOTNET_CLI_HOME": "/app"
23    }
24}

Now, after building and running the container with docker-compose build; docker-compose up -d, I can connect to the container by either pressing CMD+SHIFT+P or using the small blue button on the bottom left, selecting the option “Connect to Dev Container.”

Day 1 - About differences and products

( task - solution )

The first day consists of two simple tasks, so I won’t go into too much detail:

1. Order two lists incrementally, then get the difference for each list item and sum all differences up.
2. For each item on the first list, count the occurrences on the second list, compute the product i * frequency(i), and then get the sum of all products.

Whats up, F#?

8 of 12, would like to stay in touch

Well, I certainly havent had the chance to get familar with F#, but at the first glance I like how you can connect output to adjecent commands using the pipe operator:

1let readListFromFile (filePath: string) =
2    File.ReadAllLines(filePath) 
3    |> Array.map int
4    |> Array.toList

This makes things quiete easy, resulting in a clearer and more concise coding style. Seems like F# is a good choice for hands one problem solving.

See you next day…