The name of today's game was caching/memoization, and then it _flies_

en.wikipedia.org/wiki/Memoizat…

$ ./program.py -t
[Duration 12.00µs] Part 1, filename 'sample', answer: 21
[Duration 1.32ms] Part 1, filename 'input', answer: <...>
[Duration 32.00µs] Part 2, filename 'sample', answer: 40
[Duration 2.12ms] Part 2, filename 'input', answer: <...>
Test results: 4 passed, 0 failed.

#AdventOfCode

RE: blog.minaspace.org/day-7-labor…

Calculating number of possible paths through a field?

Sounds like a highway into recursion hell!

Fortunately not!

#AdventOfCode

d:0:"06.in"
op:(+/;*/)@"*"=op@&~" "=op:*|d
:one:+/op@'+.'1_|d
:two:+/op@'n 1_'.=+\~n:0,.'+|1_|d

The fact that the input file was nearly valid K was helpful.

#AdventOfCode #APLJK #AoC2025 #ArrayProgramming

Today's #AdventOfCode problem was definitely an Advent of Input Parsing challenge. 😂

Part 1 was pretty simple, just split on spaces and collect each column into a dict keyed on the index of the number of the split array, then get either the sum or the product.

Part 2 was not all that different, except we don't split on whitespace, we collect on each column, and since the all whitespace columns have zero numbers, use the lack of numbers in a column as a sentinel to process the collected numbers we have.

It's all a little hard to explain, but it works. 🙃

github.com/biesnecker/aoc-anyh…

#adventofcode2025 #python

Day 6: Trash Compactor

I found part 2 of this puzzle rather fiddly. Difficulty is definitely increasing, bit by bit.

Note: If you’re attempting to read this as a Fediverse post, you might find it rather confusing. I recommend using a web browser to read it properly, following this link.

The challenge

Input was this time a list of number tupels, separated by blanks:

12 456 4 56

Each tupel has the same number of elements, so that we get something like a spreadsheet with rows and columns. The last item of the list contained one of the arithmetic operators + or *.

The task was to apply the corresponding arithmetic operation to each column of our spreadsheet and to sum up the results.

The idea

The first step is to store all numbers in a 2-dimensional array and then to apply the corresponding operation to each column.
codeberg.org/M1na/AOC25/src/br…
In case, you’re a Perl savvy person, you might wonder why I don’t use the convenience functions of some module, say, from List::Utils, or any modern keywords, like say.

I try do avoid these, if I can, to make the programs as portable as possible. Perl is installed on every Un*x machine or Mac, but I do not know the version, nor which additional modules might be installed, and yet, I want people to be able to just drop the file into a folder, make it executable with chmod +x program.pl and be able to execute ./program.pl input_file

The updated challenge

Oh no! The columns are not separated by an arbitrary amount of spaces, but by a single one, whilst the numbers are either preceded or followed by blanks to give every element of each column the same length. The orientation of the numbers in any given column doesn’t change.

We’re now supposed to read numbers upwards down in each column and then to apply the corresponding arithmetical operation.

The updated idea

In order to extract the numbers correctly, we need to know the width of each column (they can vary). Fortunately, the last line with the operators is always left oriented and has the same width as the rest of the column. So, we get each column’s with by just counting the white spaces after each operator.

The only exception is the last column. Whilst possibly being left oriented, it has no trailing spaces. We correct this by adding the missing ones.

We now just need to concatenate the digits at the same position in every column and apply the operation.
codeberg.org/M1na/AOC25/src/br…
#AdventOfCode #Perl

AoC day 5. Part 1 was straightforward; the naive solution that checks every ID against every range is plenty fast. For part 2 I went with a three-step approach: Read provided ranges, merge adjacent/overlapping ranges, sum up the remaining (non-overlapping) ranges.

use v5.36;<br>use List::Util qw(sum0 min);<br><br>my @ranges;<br>while (readline) {<br>    chomp;<br>    last if $_ eq '';<br><br>    my ($lo, $hi) = m{^ (\d+) - (\d+) \z}xa<br>        or die "bad input: '$_'";<br><br>    push @ranges, [$lo, $hi + 1];<br>}<br><br>@ranges = sort { $a->[1] <=> $b->[1] } @ranges;<br><br>for my $i (reverse 1 .. $#[url=https://infosec.exchange/tags/ranges]ranges[/url]) {<br>    if ($ranges[$i - 1][1] >= $ranges[$i][0]) {<br>        $ranges[$i - 1][1] = $ranges[$i][1];<br>        $ranges[$i - 1][0] = min $ranges[$i - 1][0], $ranges[$i][0];<br>        splice @ranges, $i, 1;<br>    }<br>}<br><br>say sum0 map $_->[1] - $_->[0], @ranges;<br>

#AdventOfCode #perl

Day 5: Cafeteria

This was a fun puzzle, easy and yet rather life like.

Note: If you’re attempting to read this as a Fediverse post, you might find it rather confusing. I recommend using a web browser to read it properly, following this link.

The challenge

Today, we were given two lists, one of possibly overlapping intervals, in the form, say, 12-35 and one of numbers, like 5, 1, 78, … and we had to determine how many numbers fit into at least one of the intervals.

The idea

Once we have the list of the intervals, grab the first number and loop over the interval and see if it fits. If so, increase the counter and proceed with the next number.
codeberg.org/M1na/AOC25/src/br…

The updated challenge

In the second part, we don’t need the list of numbers, just the intervals. We want to know, how many numbers are contained in the union of the intervals.

If we have only one interval [a, b], the result would be b – a + 1.

Consider two disjoint intervals [a, b] and [c, d]. In this case, the result would be b – a + 1 + d – c + 1.

If a ≤ c and the intervals touch (b + 1 = c) or overlap (c ≤ b) the union of the two intervals would be [a, max{b,d}] and we would only need to consider this union.

Hence, we first sort the intervals by their lower bounds. We use the built in Perl function sort for that, and then if the first two intervals are disjoint, increase the counter by the first’s length and throw it away.

if they touch or overlap, we change the second one to be the union of both and discard the first.

We continue until there is only one left.
codeberg.org/M1na/AOC25/src/br…
#AdventOfCode #Perl

I had a late start this morning and didn't have a chance to do #AdventOfCode Day 4 until just now.

I leaned on a couple of utility functions (xy_to_coord, which converts x and y to a complex number for ease of use as a key; and get_neighbors_all, returns a generate that gives the direction and coordinate of the eight squares surrounding its argument) that I'd made in previous years.

First I parsed the input into a set of roll positions, then transformed it into a dictionary of roll locations => neighbor counts.

For Part 1, I just checked the locations that had fewer than 4 neighbors. For Part 2, I put that set of locations into a queue, reduced the counts of each one's neighbors, adding any that fell below 4 neighbors into the queue, and ran until the queue was exhausted.

Both were pretty straightforward to implement. I definitely have the feeling that this was a warm up grid problem, though! 😂

github.com/biesnecker/aoc-anyh…

#adventofcode2025 #python

Looking at other people's solutions for Day 4, part 2 of #AdventOfCode, I noticed that many have used sparse representations

{ (key)->(value) : key in some set }

for the grid, instead of arrays

{ (i)->(value) : i = 1 .. n }.

Presumably for efficiency.

Here, it is not.

Looking up the existence of a key is numerically far more expensive than looping through an array and checking a simple value.

Edit: I was wrong here, check replies!

I've completed "Printing Department" - Day 4 - Advent of Code 2025 #AdventOfCode in #Fortran

A nice grid problem with a similar (but simpler) test to that used by Conway's life.

I converted the character input to a 2D array of 0s and 1s, adding a border of 0s to the input to simplify the test at the grid edges.

I managed to write the correct code for part 1 some time before I got the correct answer as I'd managed to corrupt my puzzle input courtesy of finger trouble in vi!

Once I'd solved part 1, part 2 took another 14 minutes to complete including testing with the sample input to make absolutely sure my approach was correct.

The algorithm I've used is faster at converging on the solution than the example provided in the puzzle text for part 2 as there's nothing to stop you immediately removing a roll (which may mean that the neighbouring roll(s) can be removed during the current iteration).

The sample input only takes 3 iterations to solve using my approach rather than the 10 suggested in the example.

On the Pi4B part 1 takes 0.01s, part 2 0.03s.

Code here:

github.com/psychotimmy/aoc2025…

AoC day 4. This one is silly and horribly inefficient, but it was created from the part 1 solution by only adding a single line. (And the termination logic is cheeky.)

use v5.36;<br><br>my $grid = do { local $/; readline };<br>my $width = index($grid, "\n") + 1;<br><br>my $count = 0;<br>while ($grid =~ /\@/g) {<br>    my $p = $-[0];<br>    my $bad = 0;<br>    for my $o (map +($_, -$_), 1, $width - 1, $width, $width + 1) {<br>        my $q = $p + $o;<br>        $bad++<br>            if 0 <= $q < length($grid)<br>            && substr($grid, $q, 1) eq '@';<br>    }<br>    if ($bad < 4) {<br>        $count++;<br>        substr $grid, $p, 1, '.';<br>    }<br>}<br><br>say $count;<br>

#AdventOfCode #perl

Day 3: Lobby

Note: If you’re attempting to read this as a Fediverse post, you might find it rather confusing. I recommend using a web browser to read it properly, following this link.

The challenge

Today we were given a list of integer numbers, like 19874, 20001, 89089, …

The task was to pick out two digits of each number and combine them, preserving their order forming the largest possible 2-digit number and to add them all up. Here, this would be 98, 21, 99, …

The idea

Remember that you can’t use the number’s last digit for picking the result’s first. So, we pick the first occurrence of the largest digit, store it and then take the largest digit from its position position forward, combine the two, and we’re done.
codeberg.org/M1na/AOC25/src/br…

The updated challenge

Do the same, but picking 12 digits instead of 2.

The updated idea

Basically the same as before, but 12 times.

The nice thing about Perl is that you can use integer arithmetics and string operations on the same data.
codeberg.org/M1na/AOC25/src/br…
#adventofcode #aoc2025 #aoc2025day3 #noteIfYoureAttemptingToReadThisAsAFediversePost #youMightFindItRatherConfusingIRecommendUsingAWebBrowserToReadItProperly

Day 2: Gift Shop

Note: If you’re attempting to read this as a Fediverse post, you might find it rather confusing. I recommend using a web browser to read it properly, following this link.

The challenge

We were given a comma separated list of number pairs, the pairs being separated by dashes, like 1000-1020. These were to be read as ranges of numbers like 1000, 1001, 1002, … , 1020.

The task is to sum up all the numbers which are composed of two identical halves. In this case, this would be just 1010.

The idea

In this case, a real idea isn’t needed. We just split the list of number pairs, which is given in a single line along the commas, then separate the pair, loop from the first number to the last and check whether the first half taken twice is the number as a whole. If so, we add the number to our sum.

So, this is the code:
Find the actual code at codeberg.org/M1na/AOC25/src/br…

The updated challenge

We now don’t only look at numbers made up of equal halves, but also at those made up of any number of repetitions, like 121212 (3 times 12) or 99999 (5 times 9).

The updated idea

For any given number with the length l we check, if the whole number is made up from sections with lengths from 1 to l/2.

Here is the code:
Find the actual code at codeberg.org/M1na/AOC25/src/br…
#adventofcode #aoc2025 #aoc2025day2

Brute forcing today was pretty easy:

* Iterate through the ranges;
* Check if the first half of the number was equal to the second half (part one); or,
* Iterate through chunk lengths (up to and including half the number) and check if the number was composed of a repetition of that chunk (part two).

but the ranges were big enough that checking all of them took ... well honestly still not very long on my Macbook. Maybe a quarter second.

But still slower than I wanted, so I thought for a while and came up with another approach. It's obvious that the # of candidates grows much more slowly than the amount of numbers in the range, so it's much faster to generate all possible candidates then test if they're in a range (using Python's built-in bisect to quickly search for a possible range) than the other way around. This runs almost instantly on my computer.

github.com/biesnecker/aoc-anyh…

#adventofcode #adventofcode2025 #python