Woof.

Part 1 was really simple. Pick two points, make a rectangle, find the highest area.

Part 2 was basically impossible. I didn't finish it.

It looks like a grid puzzle, but that's bait, I think. The grid would be 100000x100000, so not reasonable. I figured out it actually wants to check that rectangle is all in bounds of the polygon. So, I made a function to check if a given point is on the polygon. I ran into a (literal) edge case, but other than that, it worked fine.

But the answer was wrong. So, I figured maybe I need to check the other corners. Nope, still wrong. How about the midpoint? Nah. Can I check every single point along the edge of the rectangle? No, takes too long. :/

Eventually, I start visualizing the problem. I start generating SVGs with my code. It's a circle with a giant slice taken out of it. I'm pretty sure one of the points has to be one of the ones on the slice. I even tried solving it by hand, and I still got it wrong! I don't know what I'm doing wrong.

- Part 1: 🪙 107 🕐️ 50ms
- Part 2: 🪙 DNF 🕐️ DNF

github.com/Rayquaza01/advent-o…
#AdventOfCode

For #adventofcode day 9 part 2, I write any code. Just made a graph and figured it out. Is this cheating??

RE: blog.minaspace.org/day-9-movie…

I made a mess today, because I didn't really read the description properly.

Grrrr!

#AdventOfCode

#AdventOfCode Day 9 - Nasty [hint]

There are two kinds of people today: people that know Kruskal's algorithm and people who don't.

If you do, it's pretty simple. Calculate all the distances (you don't even need sqrt since you just need to compare them), sort the pairs by distance, and add them one-by-one to the working set. I used union find to keep track of the connected components as I added edges. Once you've added 1000 edges, get the three biggest connected components and multiply their sizes together for Part 1. Keep adding until the number of non-connected components reaches 1, and then multiply the X coordinates of the last edge you added for Part 2.

If you don't, you probably eventually did something similar but it was a lot more painful. 🙃

Not my fastest solution, but still just over 500ms on my laptop, and the complexity of reducing it wasn't worth it.

#adventofcode #adventofcode2025 #python #minimumspanningtree #kruskalsalgorithm

My #Python code for Day 7, after a _tiny_ bit of cleanup since last night:

Part 1:
codeberg.org/jochie/adventofco…

codeberg.org/jochie/adventofco…

#AdventOfCode

Adding the non-recursive implementation in there as well (thanks to @mina and @tshirtman for the nudges, even if perhaps they weren't intended as such):

codeberg.org/jochie/adventofco…

It runs in about half the time and doesn't require the caching structure of course. Performance stats over 10k runs:

[Duration min: 760.29µs -30.29µs/+126.71µs] Part 2, filename 'input'

vs

[Duration min: 1.93ms -106.95µs/+849.05µs] Part 2, filename 'input'

#Python #AdventOfCode

init:1+!n:#:d:`I$","\'0:"08.in"
ds:1_'ds@<ds:{(+/t*t:d[x]-d[y]),x,y}.'p@&</'p:+!n,n
conn:{(x*~f)+x[y[0]]*f:x=x[y[1]]}
steps:1000#
:one:*/t 3#>t:.#'=init conn/steps ds
:two:*/*+d {:[&/g=*g:conn[x;*y];*y;o[g;1_y]]}[init;ds]

Part 2 takes a metric eternity to converge. There must be a better solution, but this will have to do for now.

#AdventOfCode #AoC2025 #APLJK #ArrayProgramming

RE: blog.minaspace.org/day-8-playg…

Day 8 was the first puzzle of #AdventOfCode, I found challenging.

Whilst I solved it, I noticed that both parts took a few seconds to complete.

If I have learned something from previous years, it is that modern computers should be able to produce a result for every puzzle almost instantly, if you do it right.

Whilst writing up my comments (see quoted post), I already came up with a few ideas, but haven't tried them, yet.

I've completed "Playground" - Day 8 - Advent of Code 2025 #AdventOfCode adventofcode.com/2025/day/8

Nice sorting & grouping challenge, but it took me far too long to debug part 1 sadly. Part 2 was more straightforward than one could expect.

I just completed "Laboratories" - Day 7 - Advent of Code 2025 #AdventOfCode in #Fortran

Feeling smug as I found a way to do this that didn't require recursion (or a grid), so I still have a 100% record of sticking within the Fortran77 standard. I also found a use for complex numbers for the first time this year, but on reflection probably didn't really need them. Oh well.

Part 1 didn't take me too long to finish. I kept a count of the activated splitters and an array of each unique column in the grid that a beam was on after splitting (or not splitting), so that I could process the beam(s) in the next row but one. The way the puzzle input was formatted meant that every other row could be skipped, as a beam can't be split if there are no splitters. I managed to complete part 1 before breakfast.

Returning to part 2 after lunch meant that I began to regret not going for recursion after all, until I got my trusty pen and paper out.

I worked out that the simplest way to calculate the number of timelines was to keep a track on each row of the grid how many times a beam had been found on each column.

When this is the value held 'above' a splitter (starting with 1 at S), it's added to each of the columns to the left and right of the splitter. The value of the column that the splitter was in is then zeroed to avoid over-counting.

I was somewhat surprised how large the answer was - so much so I needed to use Integer * 8's - which I hadn't done at first. Fortunately the number that was spat out of my first attempt was so large (but too small) that I was suspicious ...

My part 2 solution also calculates part 1 and runs in the same time (0.08s on a Pi4B) as the part 1 solution alone.

There are some minor optimisations that I haven't done (e.g. the naive way the co-ordinates of the splitters are held and subsequently searched through could be improved) but it's Sunday and I have other things to do.

Code here:

github.com/psychotimmy/aoc2025…

AoC day 7, part 2. In principle, this problem is eminently regexable: All steps a beam takes can be described by a regex, ^ corresponds to choice/alternative, and the number of ways the regex matches is the solution. In practice, this takes forever. I tried to speed things up with embedded code blocks and a cache, but it quickly gets overly complex and I suspect there may be bugs lurking in the interaction between embedded code blocks, closures, local, and backtracking.

In the end I gave up and rewrote the regex as direct code with manual backtracking. I guess the cache makes it an instance of "dynamic programming".

use v5.36;<br><br>my $grid = do { local $/; readline };<br><br>my $w = index($grid, "\n");<br>my $wl = $w - 1;<br>my $wr = $w + 1;<br><br>#[url=https://infosec.exchange/tags/say]say[/url] $grid;<br><br>1 while $grid =~ s{<br>    [S|] .{$wl}<br>    (<br>        (?= \.\^ )<br>    |<br>        .<br>        \^?<br>    )<br>    \K \.<br>}{|}xsng;<br><br>#[url=https://infosec.exchange/tags/say]say[/url] $grid;<br><br>$grid .= 'E' x $wr . "\n";<br><br>my $p = index $grid, 'S';<br>$p += $wr;<br><br>my $count = 0;<br>my (@ alt, @cache);<br>while () {<br>    while (substr($grid, $p, 1) eq '|') {<br>        $p += $wr;<br>    }<br>    if (substr($grid, $p, 1) eq '^') {<br>        if (defined(my $c = $cache[$p])) {<br>            $count += $c;<br>        } else {<br>            push @ alt,<br>                [$p, $count],<br>                $p + 1;<br>            $p--;<br>            next;<br>        }<br>    } else {<br>        $count++;<br>    }<br>    while (@ alt && ref $alt[-1]) {<br>        my ($ap, $ac) = @{pop @ alt};<br>        $cache[$ap] = $count - $ac;<br>    }<br>    $p = pop @ alt // last;<br>}<br><br>say $count;<br>

PS: The array is called "alt", not "Alt". I had to add a weird space after @ to prevent Mastodon from changing the case and breaking the code.

#AdventOfCode #perl

Day 7: Laboratories

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

As often, we have a field. On the top, we have a beam pointing downwards. Whenever a beam hits a splitter, marked by a ^ symbol, it gets split in 2 and continues its path downwards as 2 beams, just left and right of its original position, where it might get split again.

How many times the original beam gets split?

The idea

The algorithm is straight forward: As we follow the beam(s) downwards, we check for every position if there is a splitter and if a beam is pointing at this position. If so, we increase our counter by 1. We also need to remove the beam and to add 1 just to the left and 1 just to the right of the current beam.
codeberg.org/M1na/AOC25/src/br…

The updated challenge

Now assume that a splitter doesn’t actually split the beam in two, but that it might actually go left or right. How many possible paths are there leading from top to bottom?

The updated idea

With hundreds of splitters, there are going to be a lot of paths. Fortunately, we don’t have to remember all the paths! For every splitter in a given line, we only need to know, how many paths led to this position. We just have to add this number to the left and right positions of the next line.
codeberg.org/M1na/AOC25/src/br…
#AdventOfCode #Perl

AoC day 7 part 1. An inappropriate (and slow) solution, but regex abuse is always fun. The first part draws full beams on the grid; the second part counts the number of splits by looking for all | with a ^ below.

use v5.36;<br><br>my $grid = do { local $/; readline };<br><br>my $w = index($grid, "\n");<br>my $wl = $w - 1;<br><br>#[url=https://infosec.exchange/tags/say]say[/url] $grid;<br><br>1 while $grid =~ s{<br>    [S|] .{$wl}<br>    (<br>        (?= \.\^ )<br>    |<br>        .<br>        \^?<br>    )<br>    \K \.<br>}{|}xsng;<br><br>#[url=https://infosec.exchange/tags/say]say[/url] $grid;<br>say scalar(() = $grid =~ m{ [S|] (?= .{$w} \^ ) }xsg);<br>

#AdventOfCode #perl #regex

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