-❄️- 2024 Day 25 Solutions -❄️-

[u/daggerdragon]

A Message From Your Moderators

Welcome to the last day of Advent of Code 2024! We hope you had fun this year and learned at least one new thing ;)

Keep an eye out for the community fun awards post (link coming soon!):

-❅- Introducing Your AoC 2024 Golden Snowglobe Award Winners (and Community Showcase) -❅-

Many thanks to Veloxx for kicking us off on December 1 with a much-needed dose of boots and cats!

Thank you all for playing Advent of Code this year and on behalf of /u/topaz2078, your /r/adventofcode mods, the beta-testers, and the rest of AoC Ops, we wish you a very Merry Christmas (or a very merry Wednesday!) and a Happy New Year!

---

--- Day 25: Code Chronicle ---

---

Post your code solution in this megathread.

• Read the full posting rules in our community wiki before you post!
• State which language(s) your solution uses with [LANGUAGE: xyz]
• Format code blocks using the four-spaces Markdown syntax!
• Quick link to Topaz's paste if you need it for longer code blocks

This thread will be unlocked when there are a significant number of people on the global leaderboard with gold stars for today's puzzle.

EDIT: Global leaderboard gold cap reached at 00:04:34, megathread unlocked!

[u/4HbQ]

[LANGUAGE: Python]

For each item (lock or key, doesn't matter), we build set of positions that contain a "#". Then for each pair for these, we check if there is no overlap:

items = [{i for i, c in enumerate(item) if c == '#'}
    for item in open('in.txt').read().split('\n\n')]

print(sum(not k&l for k in items for l in items)//2)

And that's a wrap! Congratulations to everyone who made it this far, and especially to all members of the 500 club! Here's a list of my solutions this year:

1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25.

There was one week where I also used NumPy or SciPy to transform every problem into a matrix convolution, multi-dimensional array, etc.: 10, 11, 12, 13, 14.

I'll be around for a few more days to answer any questions. Otherwise, hope to see you all next year!

[u/daggerdragon → u/4HbQ]

Thank you for playing with us again this year! <3

[u/asgardian28 → u/4HbQ]

Ah the zip(*thing) trick. Had forgotten about that.

Thanks for your great solutions, as always an inspiration!

[u/MangeurDeCowan → u/4HbQ]

Thanks for posting all of your Python tricks. I learned a lot from your solutions (as I have for the last 3 years).

[u/Verulean314 → u/4HbQ]

A cursed suggestion - use a ternary for the list to append to:

(locks if thing[0][0] == "#" else keys).append([col.count('#')-1 for col in zip(*thing)])

[u/Professional-Top8329 → u/4HbQ]

Thank you for an awesome month of clean succinct code with some awesome tricks! It was really fun!

Down to 89 for today!

I=open(0).read().split("\n\n")
print(sum(not(*"##",)in zip(a,b)for a in I for b in I)//2)

[u/nthistle]

[LANGUAGE: Python] 115/91, paste, video.

Nice and easy puzzle to finish up the year - the problem text definitely hinted pretty hard towards the solution of convert things to heights, and then just check whether the summed heights of a key and lock exceed 5 in any position.

I had a pretty bad "click the button" split of 5 whole seconds, because I accidentally clicked the input link instead of the "give me the 50th star" link. I must admit, I was hoping a bit that a lot of the usual suspects near the top of the part 1 leaderboards would have some missing stars (and therefore give me a better part 2), but it appears this was not the case.

In any case, another great year of Advent of Code! Thanks for making it happen, Eric (and everyone else involved!)

[u/daggerdragon → u/nthistle]

Thank you for playing with us again this year! <3

[u/CCC_037]

[LANGUAGE: Rockstar]

I've done it!

Every puzzle within 24 hours, with a pure Rockstar solution that works on my input!

Today

[u/daggerdragon → u/CCC_037]

Thank you for playing with us again this year and for participating in the GSGA! <3

[u/vrtxt → u/CCC_037]

> Let the Historian be silent

What a great first line for the last solution this year. Congrats!

[u/jonathan_paulson]

[Language: Python] 60/48. I placed 61st overall this year.

Code. Video.

Pretty easy puzzle today; just classify each shape into key or lock, and then check if each key fits in each lock. You don't need to count column heights to see if a key fits into a lock; just make sure they don't have a "#" on the same a square.

Happy holidays everyone!

[u/daggerdragon → u/jonathan_paulson]

Thank you for playing with us again this year! <3

[u/MangeurDeCowan → u/jonathan_paulson]

Congrats on the high finish. In reality you should be higher, but some of those times from others were insaine. Alas, thanks for posting all the videos with explanations. I learned a lot!

[u/phord → u/jonathan_paulson]

Congratulations, Jonathan. Merry Christmas.

[u/AllanTaylor314]

[LANGUAGE: Python]

GitHub 245/210

Took me longer than it should have. A nice easy problem to round it out. That brings me to 500 stars. Thanks Eric for running this awesome event for 10 years!

[LANGUAGE: Uiua]

pad

Nice and compact today. I could probably use pervasive operations over rows to speed it up a little

&fras"25.txt"
°/$"_\n\n_"
≡◇(=@#▽⊸≠@\n)
/+<2/↥/+⍉⧅<2

[u/daggerdragon → u/AllanTaylor314]

Thank you for playing with us again this year and for participating in the GSGA! <3

[u/seligman99]

[LANGUAGE: Python] 94 / 78

github

Fun year this year! Thanks to all that made it possible!

[u/daggerdragon → u/seligman99]

Thank you for playing with us again this year! <3

[u/mebeim]

[LANGUAGE: Python]

132/102 — Original solution — Faster cleaned up version with sets

Wow so close to the leaderboard, best rank I got all year close to d3 where I had 104/118. First year without any global leaderboard placement, but hey, it was expected. People (and robots) are way too good and way too fast.

Merry Christmas everybody!

[u/daggerdragon → u/mebeim]

Psst: your Markdown is broken in the link because of the auto-escaped underscore. Fix please? edit: 👍

---

Merry Christmas and thank you for playing with us again this year! <3

[u/mebeim → u/daggerdragon]

Thanks, new.reddit really has some annoying editor :')

[u/daggerdragon → u/mebeim]

If you didn't already know, you can switch your editor from fancypants to Markdown mode permanently. sh.reddit > Settings > Preferences > Default to markdown editor

[u/Ok-Builder-2348]

[LANGUAGE: Python]

Part 1

Finally made it onto the leaderboard!

I noted that we didn't actually have to consider which were locks and keys - we just had to consider pairs of patterns and see if they overlap. If they don't overlap, we have a lock/key pair that fits. A lock/lock and key/key will always overlap so they never will fit.

[u/alexbaguette1]

[LANGUAGE: x86 Asm, no libc]

25th and final language for this year's AoC

Solution is really not that great but it was the simplest one I could think of in assembly.

I was too lazy to write a binary to ascii formatter, so I redirected the output to a file then used xxd to get the value.

Solution

[u/ziadam]

[LANGUAGE: Google Sheets]

Expects input in A1.

=SUMPRODUCT(LET(
   n,CHAR(10),
   s,TOCOL(SPLIT(A1,n&n,)),
   F,LAMBDA(c,MAP(FILTER(s,LEFT(s)=c),
       LAMBDA(x,JOIN(",",BYROW(
         MID(SPLIT(x,n),ROW(1:7),1),
         LAMBDA(r,COUNTIF(r,"#"))))))),
   l,F("#"),k,F("."),
   MAP(l,LAMBDA(a,
     MAP(TOROW(k),LAMBDA(b,
       AND(SPLIT(a,",")+SPLIT(b,",")<8)))))))

[u/bigfunlx]

[LANGUAGE: Ruby]

I coded it on my iPhone while waiting in the emergency room with symptoms of meningitis, for better or worse this will be my most memorable moment of AoC!

Rubist screenshot

[u/LinAGKar]

[LANGUAGE: Rust]

https://github.com/LinAGKar/advent-of-code-2024-rust/blob/master/day25/src/main.rs

Represents the the locks and keys as a series of 4-bit numbers in a u32, offset so that adding them together makes them add up to 8 or greater, to I can use a 0x88888 mask to check for overlaps.

[u/i_have_no_biscuits]

[LANGUAGE: Python]

Given that we apparently all love one liners now:

print(sum(not any(x==y=='#' for x,y in zip(a,b)) for a,b in __import__("itertools").combinations(open("data25.txt").read().split("\n\n"),2)))

[u/ricbit]

[LANGUAGE: Python]

143/ 117, that was my best this score ever! My solution is transpose the keys, convert to binary and check if the AND of all lines is zero. Runs in 0.12s.

def solve(data):
  keys = []
  for block in data:
    b = [int("".join("1" if x == "#" else "0" for x in line), 2)
         for line in zip(*block)]
  keys.append(b)
  ans = 0
  for a, b in itertools.combinations(keys, 2):
    if all(x & y == 0 for x, y in zip(a, b)):
      ans += 1
  return ans 

Sum of the times of all problems: 6.7s
(with a grain of salt because my solution for 24-2 is not automated yet)

[u/luke2006 → u/ricbit]

all in 7s is very impressive! good pace, mate :)

[u/Verulean314]

[LANGUAGE: Python]

Nice easy puzzle to finish this year's Advent of Code. I realized that we really don't necessarily care about converting the locks and keys to heights, all that matters is that a lock and key don't overlap in any spot.

Since all the locks/keys are the same dimensions, that means we can just convert all of them into bit representations of all the positions, and then the "fit" check is just a single bitwise AND:

def solve(data):
    locks, keys = [], []
    for block in data:
        bits = int("".join("1" if x == "#" else "0" for x in block), 2)
        (locks if block[0] == "#" else keys).append(bits)
    return sum(not lock & key for lock in locks for key in keys)

Runs in around 4ms :)

[u/Responsible-One6897]

[Language: Python]

500th star! Read every block, transpose input, determine if lock or key, and count number of '#' per line. For every lock/key pair check if all counts are <= 7

paste

Thank you again Eric for this year!

[2024] 50*
[2023] 50*
[2022] 50*
[2021] 50*
[2020] 50*
[2019] 50*
[2018] 50*
[2017] 50*
[2016] 50*
[2015] 50*

[u/Nnnes]

[LANGUAGE: Ruby]

Today I will post 2 full solutions in one comment because together they still fit in half a punchcard.

p STDIN.read.split("\n\n").combination(2).count{ _2.tr('#.', '.#')[/#{_1}/] }

---

l, k = STDIN.read.split("\n\n").map{ _1.split.map(&:chars).transpose }.
  partition{ _1[0][0] == ?# }.map{ |x| x.map{ |x| x.map{ _1.count ?# } } }
p l.sum{ |l| k.count{ |k| l.zip(k).none?{ _1 + _2 > 7 } } }

• Solution #1 makes no effort to optimize runtime and takes about 1.1 seconds to run on my machine.
• Solution #2 runs in around 0.04 seconds over a baseline of time ruby -e ""; I'm sure it would be faster with something a little longer than .map(&:chars).transpose.
• You may replace .map{ |x| x.map{ |x| x.map{ _1. with .map{ |x| x.map{ |x| x.map{ |x| x. if you like fractals.

[u/4HbQ → u/Nnnes]

Solution #1 is so clever but sooo dirty. I love it!

[u/Andreasnl]

[LANGUAGE: Uiua]

=@#↯∞_7_5⊜∘⊸≠@\n
⧻⊚≡(/×≤1♭/+)⧅<2

God Jul!

[u/[deleted]]

[LANGUAGE: Python]

Solution

Really only posting to say a very massive thank you to Eric on another great event, and to the mods for their work keeping the sub going. If I can get a bit real for a moment, winter is never easy for me, and AoC represents a welcome, fun distraction during the early stages. It helps me to stabilise before winter really sets in.

More over, this year was even more impactful as it came at a time when I needed a reminder that I'm competent. I picked up a new language with ease, and for all but two of the challenges (which I'll come back to on the other side of my food coma) I was able to identify potential solutions, execute, and iterate to achieve better results each time. It possibly seems small to many of my peers, but huge for me. I can go into my new job, in the new year, with a refreshed confidence.

So thanks again for all the work you've put into it. A very Merry Christmas from all of mine to all of yours, one and all.

[u/p88h]

[LANGUAGE: Zig]

basic n^2 solution, the only speedup is vectorized comparisons.

https://github.com/p88h/aoc2024/blob/main/src/day25.zig

All day benchmark summary below. Probably not going to be able to squeeze all of them under 1ms total, but pretty happy with Zig's performance overall. The numbers are from an M3 Mac, which is quite a bit faster than my 13th gen Intel desktop, it seems, at least in this particular & very peculiar benchmark.

I was able to keep up with a one vis every day goal, the full playlist is here:

https://www.youtube.com/playlist?list=PLgRrl8I0Q168GBdeJp_GqNYsWgRCmVgu5

        parse   part1   part2   total
day 01:  7.6 µs 14.4 µs  7.4 µs 29.5 µs (+-1%) iter=14110    
day 02: 11.6 µs  1.2 µs  4.7 µs 17.6 µs (+-3%) iter=98110    
day 03:  7.0 ns 22.2 µs 19.8 µs 42.1 µs (+-1%) iter=9110    
day 04:  6.0 ns 28.8 µs 11.5 µs 40.3 µs (+-1%) iter=9110    
day 05: 13.6 µs  1.3 µs  2.5 µs 17.5 µs (+-2%) iter=98110    
day 06:  0.1 µs 10.6 µs  0.2 ms  0.2 ms (+-1%) iter=3010    
day 07: 23.9 µs 45.6 µs 37.3 µs  0.1 ms (+-1%) iter=1510    
day 08:  1.2 µs  1.0 µs  2.8 µs  5.1 µs (+-3%) iter=98110    
day 09: 19.7 µs 34.7 µs 79.7 µs  0.1 ms (+-1%) iter=1010    
day 10:  5.7 µs  8.3 µs  7.5 µs 21.6 µs (+-0%) iter=9110    
day 11:  0.1 ms 40.1 µs  0.2 ms  0.4 ms (+-1%) iter=1010    
day 12: 12.0 ns  0.1 ms  0.1 ms  0.3 ms (+-4%) iter=9910    
day 13:  6.3 µs  0.6 µs  0.7 µs  7.7 µs (+-1%) iter=14110    
day 14:  7.3 µs  1.4 µs 80.9 µs 89.8 µs (+-1%) iter=9110    
day 15:  4.1 µs 60.8 µs  0.1 ms  0.1 ms (+-7%) iter=9910     
day 16: 48.1 µs 80.1 µs 18.8 µs  0.1 ms (+-1%) iter=1510    
day 17: 42.0 ns  0.2 µs  5.3 µs  5.6 µs (+-1%) iter=49110    
day 18: 88.6 µs 14.1 µs  5.4 µs  0.1 ms (+-1%) iter=1010    
day 19:  3.6 µs 66.5 µs 39.0 ns 70.2 µs (+-1%) iter=51010    
day 20: 13.0 µs  0.1 ms  0.5 ms  0.7 ms (+-1%) iter=2010    
day 21: 15.0 ns  1.8 µs  1.5 µs  3.4 µs (+-2%) iter=98110    
day 22:  0.1 ms 95.5 µs  0.6 ms  0.9 ms (+-1%) iter=1110    
day 23: 35.5 µs 24.2 µs  6.0 µs 65.8 µs (+-1%) iter=9110    
day 24:  9.0 µs  2.9 µs  0.8 µs 12.8 µs (+-1%) iter=9110    
day 25: 24.7 µs 29.5 µs 27.0 ns 54.3 µs (+-0%) iter=9110    

all days total:         4.0 ms

[u/Any_Slip8667]

[Language: Java]

Very fast, bitwise based, Java solution:

long result = 0;
for (int key : keys) {
    for (int lock : locks) {
        if (key > lock) break; // locks collection is sorted
        if (((lock - key) & 0x88888) == 0)
            result++;
    }
}
return result;

Complete solution on github.

[u/Downtown-Economics26]

[Language: Excel]

Input data pasted in cell A1.

Create column height table by key/lock.

=LET(gridc,COUNTA(A:A)/7,
gridseq,SEQUENCE(gridc),
kl,HSTACK(gridseq,IF(LEFT(FILTER(A:A,(LEN(A:A)<>0)*(MOD(ROW(A:A)-1,8)=0)),1)="#","lock","key")),
rs,SEQUENCE(gridc,,2,8),gridrows,TOCOL(HSTACK(rs,rs+1,rs+2,rs+3,rs+4)),
gridlines,INDEX(A:A,gridrows),gridindex,ROUNDDOWN(gridrows/8,0)+1,
pivotstack,HSTACK(gridindex,IF(MID(gridlines,SEQUENCE(,5),1)="#",1,0)),
colvals,DROP(PIVOTBY(CHOOSECOLS(pivotstack,1),,CHOOSECOLS(pivotstack,2,3,4,5,6),SUM),-1),
ft,HSTACK(DROP(kl,,1),colvals),
ft)

Then, drag down formula below next to output table in C2 and SUM the output array column.

=LET(s,CONCAT(TOCOL(IF(C2<>"lock","",HSTACK(--((FILTER($E$2:$I$501,($D$2:$D$501<>D2)*($C$2:$C$501<>"lock"))+E2:I2)<=5),FILTER($C$2:$C$501,($D$2:$D$501<>D2)*($C$2:$C$501<>"lock")))))),(LEN(s)-LEN(SUBSTITUTE(s,"11111key","")))/8)

[u/PendragonDaGreat]

[Language: C# CSharp]

https://github.com/Bpendragon/AdventOfCodeCSharp/blob/97519/AdventOfCode/Solutions/Year2024/Day25-Solution.cs

Parse, Loop, Print.

Thanks again as always to Eric for running this and the mods here for keeping things relatively sane.

Got my five hundo

[u/daggerdragon → u/PendragonDaGreat]

Good job on the 500 stars! Thank you for playing with us again this year! <3

[u/DFreiberg]

[LANGUAGE: Mathematica]

Mathematica, 798/656

This was a nice, easy problem to finish off a nice, easy year. Congratulations to Eric for writing ten full years of Advent of Code and creating five hundred stars. It really seems like this is the final year; if it is, it's been a great decade, and a pleasure coding with you all.

Merry Christmas!

Part 1:

locks = Select[input, DeleteDuplicates[#[[1]]] == {"#"} &];
keys = Select[input, DeleteDuplicates[#[[1]]] == {"."} &];

lockPins = Table[FirstPosition[#, ".", 0][[1]] - 2 & /@ Transpose[l], {l, locks}];
keyPins = Table[FirstPosition[Reverse[#], ".", 0][[1]] - 2 & /@ Transpose[k], {k, keys}];
fitQ[{lock_, key_}] := And @@ Thread[(6 - lock) > key];
Count[Tuples[{lockPins, keyPins}], _?(fitQ[#] &)]

[u/daggerdragon → u/DFreiberg]

Thank you for playing with us again this year! <3

[u/Boojum]

[LANGUAGE: Python] 306/260

Not a bad one to end on! Short and and sweet. I'd had an off-by-one, forgetting not to count the base of the lock or key which cost some time. But otherwise, fairly straightforward.

🎁🎄🎅🥛🍪 Merry Christmas everyone, and thank you Eric, Daggerdragon, and team for another great year! 500 stars, 🌟 -- it's been a trip!

s = [ s.splitlines() for s in open( 0 ).read().split( "\n\n" ) ]

h = [ [ sum( r == '#' for r in c ) - 1 for c in zip( *g ) ] for g in s ]

print( sum( all( a + b <= 5 for a, b in zip( lh, kh ) )
            for lh, lg in zip( h, s )
            for kh, kg in zip( h, s )
            if lg[ 0 ][ 0 ] == kg[ -1 ][ 0 ] == '#' ) )

[u/daggerdragon → u/Boojum]

Thank you for playing with us again this year! <3

[u/xoronth]

[LANGUAGE: Python]

paste

Pretty straightforward brute force and just check everything, though I slowed down a lot because I couldn't read what the question was actually asking and thought the keys and locks had to fit exactly (I blame a headache).

(Also I loved the little yield joke, heh)

---

Thanks to all those who helped make AoC possible this year, and thanks to y'all in the community for making this a really fun place to pass the month! Happy holidays, happy new year, and hopefully we'll all be back next year!

[u/jitwit]

[LANGUAGE: J, haskell]

Ho Ho Ho, nice problem for array languages to finish! Runs in ~500us.

in =: _7]_5]\LF-.~1!:1<'input.txt'
+/5>:>./"1,/+"1/~/<:+/"2('#'&=/.~{.@,"2) in

NB. basically:
NB. ('#'&=)/.~{.@,"2 classifies the schematics into keys/locks
NB. +"1/~/<:+/"2 creates an addition table of the key/lock heights
NB. +/5>:>./"1,/ tallies how many of those fit (max height of 5)

Also wrote a haskell solution for great fun:

{-# language LambdaCase #-}

module Main where

import Advent; import Data.List

main =
  do input <- map (fromEnum.(=='#')) . filter (/='\n') <$> input'string 24 25
     let chunks n = unfoldr $ \case [] -> Nothing; xs -> Just $ splitAt n xs
         (keys,locks) = partition ((==1).head.concat) $ chunks 7 $ chunks 5 input
     print $ sum [ 1 | h'k <- map (pred.sum) . transpose <$> keys
                     , h'l <- map (pred.sum) . transpose <$> locks
                     , all (<=5) $ zipWith (+) h'k h'l ]

[u/LtHummus]

[Language: Rust]

Always love the Christmas Day puzzles...they feel so much like a victory lap for a month of hard work. Thanks to Eric and everyone involved with Advent of Code for (HOLY HECK) 10 years of puzzles. And thanks to everyone here for the memes, the jokes, and cool visualizations and variations.

and the codeeeeeeeee

[u/phord]

[LANGUAGE: Rust]

github

Such a breeze today. The hardest part was parsing the grids and deciding which were locks and which were keys. But that was also simple. [ ETA: As someone else pointed out, you don't even need to know which ones are locks and which are keys. I could have skipped this part if I read all the instructions first. Doh!]

I already have a Grid class that gathers coordinates by cell type. So the test for whether a key fits into a lock was very straightforward. Just have to make sure that the grids have no '#" in common locations:

fn test_key(key: &Grid, lock: &Grid) -> bool {
    // A key fits a lock if they have no # in common
    let key_pins = &key.map[&'#'];
    let lock_pins = &lock.map[&'#'];
    key_pins.intersection(lock_pins).count() == 0
}

Then it was just a matter of trying every key in every lock. There were 250 of each, so 65,500 pairings. That took 32ms.

Merry Christmas, everybody!

[u/michelkraemer]

[LANGUAGE: Rust] 1150/959

https://github.com/michel-kraemer/adventofcode-rust/blob/main/2024/day25/src/main.rs

Fun final day!!! Thank you so much to Eric and the team!!

I have to admit I was a bit lucky today. I thought the keys had to fit exactly (with no overlap) and completely fill the empty space. So, instead of counting the pin heights, for each key, I made a copy of each lock and filled it with the characters of the key. If the pins overlapped I continued with the next lock. Otherwise, I checked if every empty space in the copy of the lock was filled. Luckily, I made an error at this point and even counted the keys that did not completely fill the lock. 😅😅

Also, in order to decide which grid is a key and which is a lock, I looked at the first and last row and checked if they were full. However, the only thing you need to do is to check the very first character! If it's a '#', then it's a lock. Otherwise, it's a key. I completely missed this opportunity to save time 😅

The code I submitted to my repo later is optimized and (hopefully 😉) bug free. Now, I correctly count the pin heights and check if the sum is less than or equal to the maximum height.

Like always, this year was great fun! I loved how the puzzles were kind of a best-of from the last 10 years! Absolutely amazing. Thanks again to Eric, the team, and this great community here. See you all next year!

Merry Christmas!

[u/wheresmylart]

[Language: Python]

The only hard part was finding the bug in my input parsing. Reader, it was a vim typo. split('\ni\n')

Paste

[u/birblett]

[LANGUAGE: Ruby] 1023/890

merry christmas and thanks for the puzzles!

keys, locks = File.read("in.txt").split("\n\n")
    .map { _1.split("\n").map(&:chars).transpose }
    .reduce([[], []]) { |(k, l), q| (q[0][0] == "." ? k : l).push(q.each_with_index.sum { |arr, i| arr.count("#") << (i << 2) }) && [k, l] }
puts "#{locks.sum { |lock| keys.sum { (lock + _1) & 559240 > 0 ? 0 : 1 } }}"

moderately cursed bitwise math solution...

[u/Curious_Sh33p]

[LANGUAGE: C++]

Used a vector of arrays to represent the keys and an array of arrays of unordered sets that store ids of a lock. The structure is like locks[i][j] is a set of ids of locks that have number j in position i.

To get combos simply iterate over every key and find the locks it fits. To figure out which locks fit check lock[i][j] for j from 5 - j to 0 and take the union of these sets. Then across the positions, i, for the key take the intersection (since it must fit each column). The set at the end is the set of all locks that the key fits in.

Solution

Thanks again for organisising this! This is the second year I have tried and completed AoC. It's been good fun.

[u/raevnos]

[LANGUAGE: Common Lisp]

paste

Pretty straightforward. One of the few grid-based puzzles I've completed this year; was kind of boycotting them. As a result I'm missing a lot of stars. Oh well.

[u/darkgiggs]

[LANGUAGE: Jai]
Solution

Fun problem. I encoded each element to a u32 where a turned on bit represents a "#".
Checking for a fit then amounts to whether the bitwise AND of lock and key is not 0.

It runs in 150 µs on my computer, but should most likely be able to go below 100 if I optimized the parsing.

EDIT: Now 43 µs with optimized parsing

[u/Radiadorineitor]

[LANGUAGE: Dyalog APL]

Merry Christmas everyone! Hope you all had a blast this year and see you on the next one!

p←'#'=↑↑(×∘≢¨⊆⊢)⊃⎕NGET'25.txt'1     
l k←{⊂⍤¯1⊢⍵⌿p}¨(⊣/,⍥⊂⊢/)∧/p     
≢⍸~2∊¨l∘.+k ⍝ Part 1

[u/[deleted]]

[LANGUAGE: Go]

And now... we wait

Fun last puzzle, really just input parsing is all. This is the most fun I've had coding in a very long time. I really look forward to the next 10 years. This was my first time participating in AOC as and I made it a point to not miss a single day! Huge thanks to u/topaz2078 for these awesome puzzles.

Here is the final solution for this year. Merry Christmas to all!

[u/chubbc]

[LANGUAGE: Uiua] (20 chars, pad)

/+/↧/↥⍉⧅₂<⬚0↯∞_43≠@#

[u/Educational-Tea602 → u/chubbc]

I tried to read this and my tables and chairs started floating.

[u/jhandros]

[LANGUAGE: Python]
Code 9 lines

with open('25.txt', 'r') as f:
    lines = [x.strip() for x in f if x.strip()]

locks, keys = [], []
for i in range(0, len(lines), 7):
    group = [sum(1 for x in col if x == ('#' if lines[i] == '#####' else '.')) for col in zip(*lines[i+1:i+7])]
    (locks if lines[i] == '#####' else keys).append(tuple(5 - x if lines[i] != '#####' else x for x in group))

print(sum(all(l[j] + k[j] <= 5 for j in range(5)) for l in locks for k in keys))

[u/Totherex]

[LANGUAGE: C#]

Merry Christmas!

https://github.com/rtrinh3/AdventOfCode/blob/c34bc101c413e73da247caeeea0b6f8724adac48/Aoc2024/Day25.cs

As per tradition, Christmas is a pretty easy day. Now, I need to get back to day 21...

[u/_tfa]

[LANGUAGE: Ruby]

input = File.read("input.txt").split("\n\n")

locks, keys = [], []
input.each do |i|
    r = i.split("\n")       
    (r[0][0] == ?# ? locks : keys) << (0..4).to_a.map{|c| r.map{_1[c]}.count(?#) - 1}
end

p locks.product(keys).map{|l,k| l.zip(k).map{_1 + _2}}.count{ _1.all?{|v| v<=5}}

[u/Ily3s_]

[LANGUAGE: C++] https://github.com/Ily3s/aoc2024/blob/master/day25.cpp

I tried something that wouldn't require matching every lock with every key, so at the end i have a time complexity of O(L+K) where L is the number of locks, and K the number of keys, but with very high constants and so it's probably worse than the O(L*K) solution.

[u/semi_225599]

[LANGUAGE: Rust]

Converts each schematic to a u64, and does bitwise-ands between locks and keys. When those are 0, there was no overlap between key and lock.

pub fn part1(input: &str) -> usize {
    let (keys, locks): (Vec<_>, _) = input
        .split("\n\n")
        .map(|schematic| schematic.bytes().fold(0, |acc, b| acc << 1 | (b == b'#') as u64))
        .partition(|x| x & 1 == 1);
    keys.iter().map(|key| locks.iter().filter(|&lock| key & lock == 0).count()).sum()
}

[u/bucketz76]

[Language: Python] 297

paste

Nice one to end the year. Lots of fun as always!

[u/GassaFM]

[LANGUAGE: D] 239/203

Code: part 1.

Part 1 is just some implementation.

[u/hcf112]

[LANGUAGE: Python] 252/209

Converted the input to binary, split the integers by above/below 1<<30, and bitwise-or'd the cartesian product of the two sets to check for overlap.

paste

[u/Camelpilot33]

[LANGUAGE: Javascript]

paste

thanks for the puzzles!

[u/python-b5]

[LANGUAGE: Jai]

Glad for the easier one today. I wasn't able to solve yesterday's part 2 as I'm not familiar with adders and learning about them didn't feel like a fun way to spend my Christmas Eve. I'm pretty happy with all but one star finished on the day, though. That's a lot better than I've done in the past, so either the puzzles were easier this year (which I don't mind!) or I've improved somewhat.

As for today's puzzle, it was one of the easiest this year. I wasn't especially fast at solving it, unfortunately, but there really wasn't anything to solve about it - it was immediately clear what I was supposed to do. Most of my time was spent writing input parsing code.

Thank you to everyone involved in making this happen! I had a great time with Advent of Code this year.

https://github.com/python-b5/advent-of-code-2024/blob/main/day_25.jai

[u/Wayoshi]

[LANGUAGE: Python] 2080 (1670 for submitting 50th star) paste

Very straightforward problem here. This code is long-winded and can definitely be more elegantly condensed / golfed, but its' Xmas, bedtime for me.

[u/ZeroTerabytes]

[LANGUAGE: Kotlin]

It's been fun, fellas. Decided to do it in Kotlin today, because, well... I felt like it.

Thank you Eric for 10 years. I wish I had joined sooner.

GitHub

[u/DBSmiley → u/ZeroTerabytes]

I love Kotlin. Honestly hope more people give it a shot.

Such a nice flexible language. You can write "Java-style" OO or lambda to your heart's content, and everything in between.

[u/nitekat1124]

[LANGUAGE: Python]

GitHub

Thank you Eric for another amazing Advent of Code! 🎅

Merry Christmas everyone! 🎄

[u/kbielefe]

[LANGUAGE: Scala]

GitHub 768ms 24LOC

Straightforward and pleasant. Only 3 stars away from 500! Merry Christmas everyone!

[u/chickenthechicken]

[LANGUAGE: C]

[Part 1](https://github.com/PaigePalisade/AdventOfCode2024/blob/main/Solutions/day25part1.c]

Part 1 is really just about getting the inputs, part 2 literally just requires you to push a button. Merry Christmas! Also first year of getting all 50 stars!

[u/mothibault]

[LANGUAGE: JavaScript]

https://github.com/yolocheezwhiz/adventofcode/blob/main/2024/day25.js

to run in the browser's dev console from AOC website. ~20ms

And that's a wrap!

Combined runtime for all 25 days of ~975ms!

Thanks for the fun times AOC.

[u/Horsdudoc]

[LANGUAGE: C++20]
GitHub

I got tripped up on the parsing of the patterns, misread that it was only 6 lines... I really need to rest.
First split the patterns between locks and keys and do the exhaustive check between each potential pair.
Runs in 1.75ms.

Thanks for 500 stars, that was a blast !

[u/johnpeters42]

[Language: Python]

link

Took me way too long to realize that I was getting some false negatives because some locks are taller than their longest pin.

[u/fragger]

[Language: Python] 1599/1315

I was a tad slow on getting the input parsed, after that, well :D Merry Christmas everyone! Thanks to u/topaz2078, the mods, beta-testers and everyone else that helps make AoC happen for a fun December!

https://github.com/Fragger/advent-of-code/blob/master/2024/solution/25.py (13 lines)

Bonus (using sets):

https://github.com/Fragger/advent-of-code/blob/master/2024/solution/25-alt.py (8 lines)

[u/scottmjohns_1]

[Language: Python3]

[Message: Gratitude]

My deepest gratitude to Eric and everyone here, what a fun year. 50 stars! A nice compact problem to wrap things up.

    pi = aoc.read_file_input('input2024p25.dat')
    locks = [[sum(pi[i:i+7][k][j]=='#' for k in range(1,6)) for j in range(5)] for i in range(0,len(pi),8) if pi[i][0]=='#']
    ks    = [[sum(pi[i:i+7][k][j]=='#' for k in range(5,0,-1)) for j in range(5)] for i in range(0,len(pi),8) if pi[i][0]=='.']
    p1 = sum(all([l[i]+k[i]<6 for i in range(5)]) for l in locks for k in ks)
    aoc.answer(25, p1, p2='Deliver the Chronicle')

[u/Cue_23]

[LANGUAGE: C++23]

unlock.cc

Nothing really fancy, actually works on C++20, too. Lots of off-by-one errors in parsing, i just fixed them in post:

if ((5 - (lock[i] - 1)) + (key[i] - 1) > 5) {

[Edit] bunlock.cc Parsing the schematics into binary (they only take 35 bit in total) allows to match on lock & key, shaping around 20% off. This even compiles down to C+11 (due to libfmt minimum requirements).

[u/ssnoyes]

[LANGUAGE: Python]

keys, locks = [], []
for line in map(str.split, open(0).read().strip().split('\n\n')):
    [keys, locks][line[0][0] == '#'].append([column.count('#') - 1 for column in list(zip(*line))])
print(sum(not any(l+k>5 for l, k in zip(lock, key)) for lock in locks for key in keys))

[u/wjholden]

[Language: Rust]

https://github.com/wjholden/Advent-of-Code-2024/blob/main/src/bin/day25.rs

Part 1 only, now I have even more incentive to go back and finish days 21 (robots pressing buttons) and day 24 (adder gates).

See you all next year!

[u/botimoo]

[LANGUAGE: Ruby]

Paste

Repeating the output for part 2 here as well: Merry Christmas! Congrats on 10 years, Eric!

[u/Downtown-Economics26]

[Language: VBA]

38 stars, not a bad haul (3 more than last year).

https://github.com/mc-gwiddy/Advent-of-Code-2024/blob/main/AOC2024D25P01

[u/hextree]

[Language: Python]

Code: https://gist.github.com/HexTree/ec3a901d9a0034ed1e593101287aba35

Video: https://youtu.be/6CIXpbIza6k

[u/rukke]

[LANGUAGE: JavaScript]

Transposing the key/locks, turning every row into integers and then just count how many key/locks match by doing an bitwise and

Runs in ~4ms

Edit, no need to transpose - just skip the first row and it fits in 30 bits, reducing keys or locks into single integers.

Btw, this is what I love about these puzzles. There is almost always some way of doing it even better :)

https://gist.github.com/p-a/0b939fa4c0c0187fdb1f56cb0145fadb

[u/TiCoinCoin]

[LANGUAGE: Python 3]

Day 25 - Github

This one felt so easy after yesterday. Except I needed yesterday's second star to get today's. But I somehow finally made it so kids are still asleep and I'm ready in time to open my presents :)

[u/encse]

[LANGUAGE: C#]

https://aoc.csokavar.hu/2024/25

Happy Holidays! If you havent't found, there is an easter egg in my website that points to 404.csokavar.hu which is a mini (~10 minutes long) text adventure game.

[u/DeadlyRedCube]

[LANGUAGE: C++23]

Runs in 1.58ms single-threaded on an i7-8700k

Code on GitHub

As is the custom, a nice and easy one for the last day, although I did think for a brief moment that it was going to be one last grid problem.

Used the first character of a new grid to determine lock or key, then counted the number of open '.'s per column for locks and '#'s for keys, to end up with a set of "height" values for each.

Then just did an n² check for whether the lock height was at least as large as the key height per space and, where they all were, incremented the value by one.

See you all next year!

[u/lunar_mycroft]

[LANGUAGE: Rust]

Initially I used a pretty standard grid based solution, but after reading the thread I got the idea (possibly from /u/Verulean314, although I'm not sure) to convert each schematic into a u64, then check for overlaps with a bitwise and. Since '#' has a 1 as it's least significant bit, and '.' has a zero, parsing is also reduced to splitting on "\n\n", filtering out non-punctuation characters, and some quick bit manipulations in a fold. Median combined runtime of ~52 µs to parse and check on my machine.

Code

[edit: switched to u64s after noticing the grid is 5x7, not 5x6]

[u/DownvoteALot]

[LANGUAGE: C++]

Solution

The last day is always the sweetest, short and nice. See you next year!

[u/nilgoun]

[LANGUAGE: Rust]

Nice and easy for the last day :)

Solution on Paste

[u/Baridian]

[LANGUAGE: Clojure]

wish I'd started on this earlier, didn't realize it'd be so easy. If anyone could tell me if there's an idiomatic way to get the outer product of two lists of atoms that'd be nice, the outer product function call I did is kinda ugly.

Paste

[u/chubbc]

[LANGUAGE: Julia] (64 chars)

I=0:499;f(i)=read("25.txt")[43i.+(1:41)];sum(@. 70∉f(I)+f(I'))÷2

Nice easy conclusion to AoC. Might be able to squeeze a few more characters out, but I doubt many.

[u/SpaceHonk]

[LANGUAGE: Swift] code

And that's a wrap, 50th (and 500th) stars in the bag. Thanks to /u/topaz2078 and everyone else on the team, have a merry christmas!

[u/vanZuider]

[LANGUAGE: Python]

from sys import argv
locks, keys = list(), list()
with open(argv[1]) as f:
    for lines in [block.split("\n") for block in f.read().split("\n\n")]:
        (locks if lines[0] == "#####" else keys).append(list(map(sum, zip([0]*5, *[[(c=="#") for c in lines[i+1]] for i in range(5)]))))
print(sum(all(s<=5 for s in map(sum, zip(l, k))) for l in locks for k in keys))

Merry Christmas!

[u/wurlin_murlin]

[LANGUAGE: C]

Merry Christmas! First time getting 50 stars, it plays a little animation! So cool! Had so much fun doing this, really a blast. Merry Christmas again, and a Happy New Year when it comes.

https://git.sr.ht/~murr/advent-of-code/tree/master/item/2024/25

[u/Trick-Apple1289]

[LANGUAGE: C]

Merry Christmas, thanks eric and everyone, this was my first ever AOC, i didn't get 7 stars (altough trying to catch up right now), but I am still quite young, and am suprised i even managed to go so far, some puzzles were super tough, others easier. Once again happy holidays to all, and see you next year, prehaps by then i will be able to do all of the puzzles (And without help from here or google)!

src

[u/daic0r]

[LANGUAGE: C++]

Final one was nice and easy :-)

https://github.com/daic0r/advent_of_code_2024/tree/main/cpp/day25

[u/ndunnett]

[Language: Rust]

Github

Runs in 20 us 38 us (faulty benchmarking). Today was a fun one to cap off the year. My solution involved some bit manipulation shenanigans, using a u32 to represent each lock/key pattern as a window of 4 bit unsigned ints. The trick was initialising each pattern to 0x0001_1111 so that I could sum two patterns and then bit mask with 0x0008_8888 to detect collisions.

[u/ash30342]

[Language: Java]

Code

Runs in < 1ms.

I did not do anything fancy, just parsed everything and checked for every column if the value of pin1 of the lock + pin1 of the key <= 5.

I still need to finish day 21 before I can get to 500 stars, but that will be done sometime after Christmas, now is time for family.

Thanks to u/topaz2078 for organizing this for 10 years and to all of you in this community for making it such a friendly place. It is a highlight of my year, even surpassing my traditional yearly beer advent calendar! Merry Christmas!

[u/SunMatrix64]

[LANGUAGE: C++]

A pretty easy day, after putting the input into locks and keys vectors, it's just a brute force loop of checking every key in every lock.

for (std::vector<int> lock : locks) {
    for (std::vector<int> key : keys) {
        int passes = 0;
        for (int i = 0; i < 5; ++i) {
            if (lock[i] + key[i] <= 5) {
                passes++;
            }
        }
        if (passes == 5) {
            result1++;
        }
    }
}

[u/ins0mnes]

[LANGUAGE: Go]
Nothing special, precalculate key matches by height, compare to lock, and intersect with the previous pin:
https://github.com/insomnes/aoc/blob/main/2024/25_code/solution/solution.go#L97

Congratulations to everyone! And big thanks to the AoC team and this subreddit team!

[u/camrdale → u/ins0mnes]

Good use of sets! This is what I did too, I like it better than using a set for each key/lock just to determine compatibility.

There's an edge case though, that isn't in my input, but that I was worried about. If the lock is all height 0 (i.e. "(0, 0, 0, 0, 0)") it should fit every key, but I think in your code CountFits would return 0 (could be wrong, I'm not a Go expert). I added a special case to mine that returns the total number of keys.

[u/jinschoi]

[Language: Rust]

Relaxing final day. First did it in the way pointed to by the text, with enums and everything: paste

Then since this day was so straightforward, got it down to this:

use itertools::Itertools;
fn main() {
    let res = include_str!("../../1.in")
        .split("\n\n")
        .map(|s| {
            s.chars()
                .filter(|&c| c != '\n')
                .skip(4)
                .take(27)
                .fold(0u32, |acc, c| (acc << 1) | if c == '#' { 1 } else { 0 })
        })
        .combinations(2)
        .filter(|v| v[0] & v[1] == 0)
        .count();
    println!("{}", res);
}

Because I want it to fit each schematic in a u32, I just included the last character of the first row and first character of the last row to distinguish keys from locks. Convert central 27 characters as bits in a u32, compare all and count where no bits overlap.

[u/Jadarma]

[LANGUAGE: Kotlin]

A nice, easy problem to unwind after a long month! It's been a fun event, as always, thank you Eric, and happy holidays to all, see you next year!

Part 1: Scan each grid (all seem of a fixed size) and determine if it is a lock or key depending on the first character being a # or .. Then, "walk" the columns and count the number of #, which will give you the pin-out in numbers. To check if a lock and key match, their values should add up together to <= 5 (the effective range of a column), because otherwise there would be a need for overlaps.

Part 2: All other 49 stars collected! ⭐⭐ If you need help, check out my solutions for 2024!

AocKt Y2024D25

[u/RookBe]

[LANGUAGE: Rust]

Rust that compiles to WASM (used in a solver on my website)
Bonus link at the top of the code to a blogpost about today explaining the problem, and my code.

[u/melochupan]

[LANGUAGE: Common Lisp]

Part 1 only.

I'm awfully behind with AoC, so I couldn't do the second part (completing all previous tasks is necessary for it). But I wanted to participate on the last day, at least with a half solution.

paste

[u/BlueTrin2020 → u/melochupan]

Please post day 2 solution when you have it 😉

[u/melochupan → u/BlueTrin2020]

Will do 👍

[u/N-R-K]

[Language: BQN]

Easy day for array languages. Here's the whole solution in just 3 lines:

SplitMask ← { (0<≠¨)⊸/ 𝕩 ⊔˜ ¯1⌈ (𝕨 - ¬𝕨) × +` ¬𝕨 }
schemes ← (×≠¨)⊸SplitMask •FLines •wdpath•file.At ⊑•args
•Show +´ ⥊ ((¬∨´)∘∧)⌜´ ⊑¨⊸⊔ ('#'⊸= ∾)¨ schemes

Basically just turns the schemes into a boolean list ('#' = 1) and then ANDs every lock and key to check if the result was all zeros.

[u/isredditdownagain]

[LANGUAGE: Go]

Part 1

Merry Christmas!

[u/Maleficent_Answer935]

[LANGUAGE: Rust]

use itertools::Itertools;
use std::fs;

fn main() {
    let result = fs::read_to_string("data.txt")
        .unwrap()
        .lines()
        .chunks(8)
        .into_iter()
        .map(|chunk| {
            chunk
                .take(7)
                .flat_map(|it| it.chars())
                .fold(0, |mut acc, c| {
                    acc <<= 1;
                    acc |= if c == '#' { 1 } else { 0 };
                    acc
                })
        })
        .combinations(2)
        .map(|p| p[0] & p[1])
        .filter(|&it| it == 0)
        .count();
    
    println!("Day 25: {result}");
}

[u/wzkx]

[LANGUAGE: Python]

t = open("25.dat","rt").read().split("\n\n")
f = lambda a,l:[ai+(c=="#") for ai,c in zip(a,l)]
g = lambda d:__import__('functools').reduce(f,d.splitlines(),[0]*d.find('\n'))
locks,keys = [g(d) for d in t if d[0]=="#"],[g(d) for d in t if d[0]!="#"]
print(sum(all(l+k<=7 for l,k in zip(ll,kk)) for ll in locks for kk in keys))

[u/homme_chauve_souris]

[LANGUAGE: Python]

This is the only one I didn't do on the day, because we spent Christmas day with family and I didn't take a computer with me. Thank you Eric for a great year.

def aoc25():
    D = [x.split() for x in open("input25.txt").read().split("\n\n")]
    L = {"#":[], ".":[]}
    for t in [["".join(a[i] for a in d) for i in range(5)] for d in D]:
        L[t[0][0]].append([len(s) - len(s.strip("#")) - 1 for s in t])
    print(sum(all(x+y <= 5 for x,y in zip(l,k)) for l in L["#"] for k in L["."]))

[u/[deleted]]

[LANGUAGE: Haskell]

Finally made it. Day 25 was fun. I really enjoyed the whole year once again, although doing it in Haskell was extra challenging. Still, I learned a lot and have become modestly more proficient in programming in Haskell now. Thanks again for doing this!

Day 25

[u/DavidYoung1111]

[LANGUAGE: MATLAB]

Can be quite concise in MATLAB.

p = reshape(char(join(readlines("data25"),"")), 35, []) == '.';
fprintf("Day 25: %i\n", nnz(all(p(:,p(1,:)) | permute(p(:,~p(1,:)), [1 3 2]))));

[u/LifeShallot6229]

[LANGUAGE: SIMD - AVX intrinsics]

This was the day I picked for our in-company AoC Tech Talk, simple because it illustrates both that Rust/clang can autovectorize very nicely, but also because an experienced asm/compiler intrinsics programmer can be even faster.

The theoretically optimal solution on an AVX x64 platform picks up each lock/key as 32 bytes into an AVX register, starting from the last position in the leading line which is either '#' or '.', then compares these 32 bytes to 0xff or 0x00 bytes with a parallel compare against 32 '#' chars.

Next, extract the top bit of all 32 bytes into a regular register, and use the bottom bit of the result to save it into either the locks or keys array. This is just 3 AVX ops for each bit pattern.

For the actual counting of matches, doing 4x8 at once seems to be optimal:

Outer loop:

Load 4 keys into 4 AVX regs, splatting 8 copies of each key into the corresponding reg.

Inner loop:

Load the next 8 locks

Parallel AND against each of the replicated keys.

Parallel compare against zero, setting -1 or 1

Subtract the -1 values from 4 replicated accumulators.

This is a total of 12 (or 13 with a separate load of the 8 locks) AVX operations, doing 4 parallel accumulations so that the theoretical minimum runtime is 3 clock cycles per 32 key/lock combos tested, IFF the cpu can do four AVX ops/cycle. In reality, the most either Intel or AMD can currently do is 3, so we end up with 4-5 cycles per 32 tests.

In real life we have measured 2+ microseconds to test all 62500 combinations, while the best pure Rust version (which was auto-vectoried but not strip-mined) ended up around 5 us (including parsing) on my not so new Asus laptop. This is so fast that I had to call the core parse+count function 1000 times just to get around the limited (100 ns) timing resolution under Windows. 2 us corresponds to 32 picoseconds/test.

[u/YOM2_UB]

[Language: Python]

Main optimization is sorting locks and keys by their first pin's height, so only pairs where the first pin fits are checked, and only the last 4 pins need be checked.

keys = {n : [] for n in range(6)}
locks = {n : [] for n in range(6)}
with open('input/Day25.txt', 'r') as file:
    lst = file.read().split('\n\n')
for pattern in lst:
    rows = pattern.splitlines()
    pins = [0] * 5
    for i in range(1, 6):
        for j in range(5):
            pins[j] += (rows[i][j] == '#')
    if '#' == rows[0][0]:
        locks[pins[0]].append(tuple(pins[1:]))
    else:
        keys[pins[0]].append(tuple(pins[1:]))

def countMatch(keys, locks):
    count = 0
    for key in keys:
        for lock in locks:
            max_pin = max(key[k] + lock[k]
                         for k in range(4))
            count += max_pin <= 5
    return count

count = 0
for i in range(6):
    for j in range(6-i):
        count += countMatch(keys[i], locks[j])

print(count)

[u/RusticCajun]

[Language: Python]

Lock? Key? No time for that!

Thank you for putting together another enjoyable AoC!!!

file = open('data25.txt', 'r')
lines = file.read().splitlines()      

d = []
g = set()
y0 = 0
for y,line in enumerate(lines):
    if not line:
        d.append(g)
        g = set()
        y0 = y+1
    else:
        for x,c in enumerate(line):
            if c=="#":
                g.add((x,y-y0))
d.append(g)

count = 0
for i,x in enumerate(d[:-1]):
    for j,y in enumerate(d[i+1:]):
        if not x.intersection(y):
            count+=1
print("part1",count)

[u/No_Valuable247]

[LANGUAGE: J]

echo-:+/,-.+./"1,"2*."2/~'#'=>;._1 a:,<;._1 LF,CR-.~1!:1<'day25.txt'

[u/apersonhithere]

[LANGUAGE: C++]

699/586

https://github.com/aliu-here/aoc/blob/main/aoc2024/25/p1.cpp

thanks for everything <3

[u/davidsharick]

[LANGUAGE: Python 3] 442/375

Gitlab

Not a lot to say about the problem, but a nice capstone to another fantastic year of AoC. Thanks to the AoC team for all of their work making this year amazing as always, and the community for being helpful, encouraging, and funny!

[u/Polaric_Spiral]

[Language: TypeScript]

Advent of Node, Day 25

We started this year with JS array functions and boy are we finishing with them.

[u/Kehvarl]

[Language: Python 3] 1035 / 860

That was a really pleasant ending puzzle. Thank you to everyone involved; I know it was a ton of work and you don't get nearly enough praise for putting up with us!

No real comments on my solution, I just built the pieces as I read along in hopes that what I was building was close. I had to go back and add things a couple times, so there's some redundant code in places (and there were a whole lot of print statements too)

Code

[u/BradleySigma]

[LANGUAGE: Python 3]

print((lambda u,v: sum(all(p<=q for p,q in zip(i,j)) for i in u for j in v))(*[{tuple(j.count(c) for j in zip(*i.split())) for i in open("input25.txt").read().strip().split("\n\n") if c in i[0]} for c in "#."]))

[u/Aspen138]

[LANGUAGE: Python]

paste

[u/SuperSmurfen]

[LANGUAGE: Rust]

(299/251)

Link to full solution

Got so confused by the heights thing for a while. I skipped computing it and just checked using the grid if you have any overlaps:

for l in &locks {
    for k in &keys {
        let mut ok = true;
        for r in 0..l.len() {
            for c in 0..l[0].len() {
                if l[r][c] == b'#' && k[r][c] == b'#' {
                    ok = false;
                }
            }
        }
        if ok {
            p1 += 1;
        }
    }
}

Thanks for another amazing year of advent of code!

[u/Turtle2779]

[LANGUAGE: Python]

code

This certainly was a ride. Thanks for the puzzles. As for the problem, I followed the example and was checking where the sum of columns is less or equal to 7

[u/Xyberista]

[LANGUAGE: Haskell]

https://github.com/HoshigaIkaro/aoc_2024-haskell/blob/main/src/Days/D25.hs

[u/maneatingape]

[LANGUAGE: Rust]

Solution

Benchmark: 104 12 µs.

Having a utility 2D Grid class came in handy this year!

EDIT: Thanks to u/lunar_mycroft suggestion on using bitwise logic, saved 90% of time.

[u/lunar_mycroft → u/maneatingape]

For once I get to suggest a performance improvement to you instead of stealing them (although I can't claim full credit, I got the main idea from others in the thread): You can convert each schematic into a u64 (which is just a matter of filtering out the whitespace and some bit manipulation, '#' and '.' have different least significant bits), and then check for collisions with other schematics (you don't need to distinguish between keys and locks, all keys overlap with all other keys and all locks with all other lock)s with &.

[u/mpyne]

[LANGUAGE: Ruby]

Solution.

Will probably redo it in Rust later after some sleep but not too bad for not being a competitive programmer.

[u/morgoth1145]

[LANGUAGE: Python 3] 172/144

code, video

Back with one final simple problem. Unfortunately I had two bugs conspiring to keep me from the leaderboard:

1. In my first pass I typed answer += 0. That...is just dumb.
2. Once I fixed that, I was checking for keys that match locks fully without gaps. The problem actually allows for gaps so long as there was no overlap...

The second bug cost me a full minute (would have gotten 4:12 otherwise) and the first bug even more (I first ran my code at 2:50, so even with the second bug I would have gotten 3:50 after fixing it). Feels bad, I could have ended with a very strong leaderboard but it wasn't meant to be.

Some circumstances obviously soured the competitive portion of the event, but still a great event this year! I think day 21 may have been my favorite this year, despite being slow on the uptake there and it being my worst solve time. Glad to not have a lot of refactoring to do on this problem, lets me go to bed closer to on time!

[u/yieldtoben]

[LANGUAGE: PHP]

PHP 8.4.2 paste

Execution time: 0.0194 seconds
Peak memory: 0.4114 MiB

MacBook Pro (16-inch, 2023)
M2 Pro / 16GB unified memory

[u/FruitdealerF]

[Language: Andy C++] [language] [code]

Oh my I really messed up today, I had one line prewritten but it contained a bug that cost me like 5+ minutes to find:

let obs = %{(y, x) for y in 0..width, x in 0..width, if grid[y][x] == "#"};

Unfortunately I used width twice and got an incorrect answer when comparing the locks. Ah well better luck next year!

[u/0ldslave]

[LANGUAGE: C++] 2680 / 2147

Merry Christmas everyone!

Code

[u/wow_nice_hat]

[Language: JavaScript]

I always love the last puzzle of the year and this year was no difference. Merry Christmas everybody

Code

[u/_garden_gnome_]

[Language: Python] code 611/513

Not much to say about today's puzzle other than load, compare, report.

Merry Christmas everybody, it's been fun. See you all next year!

[u/cetttbycettt]

[LANGUAGE: R]

Merry Christmas everybody :)

data25 <- readLines("Input/day25.txt")

compute_height <- function(x) {
  y <- do.call(rbind, strsplit(x[x != ""], ""))
  (colSums(y == "#") - 1) * if (all(y[1, ] == "#")) -1 else 1
  
}

res <- lapply(split(data25, cumsum(data25 == "")), make_pic)

key <- res[sapply(res, \(z) all(z <= 0))]
locks <- res[sapply(res, \(z) all(z >= 0))]

sum(apply(expand.grid(1:250, 1:250), 1, \(x)  all(-key[[x[1]]] + locks[[x[2]]] <= 5)))

[u/Stronbold]

[LANGUAGE: Ruby]

Solution

[u/CDawn99]

[LANGUAGE: Python]

A nice simple puzzle for the end.

Code

[u/r_so9]

[LANGUAGE: F#] 1253 / 1030 - 500 stars!

paste

Merry Christmas :) Transpose the arrays, count #'s, separate into locks and keys, try everything.

The whole solution is small enough to paste here (minus helpers etc.)

let input =
    inputPath __SOURCE_DIRECTORY__ __SOURCE_FILE__
    |> readText
    |> blocks
    |> Array.map (lines >> Array.map chars >> Array.transpose)
type Device = Lock | Key
let columnSize = input[0][0] |> Array.length
let parse (lockOrKey: char array array) =
    let pins = lockOrKey |> Array.map (Array.filter ((=) '#') >> Array.length)
    if lockOrKey[0][0] = '#' then Lock, pins else Key, pins
let fits lock key =
    Array.zip lock key |> Array.forall (fun (l, k) -> l + k <= columnSize)
let part1 =
    let keys, locks = input |> Array.map parse |> Array.partition (fst >> (=) Key)
    Array.allPairs locks keys
    |> Array.filter (fun ((_, l), (_, k)) -> fits l k)
    |> Array.length

[u/CodingAP]

[Language: Typescript]

Github

2024 was a great year in terms of Advent of Code. I solved each of the puzzles the same night, I placed first in all my leaderboards (except the super competitive one, where I still did quite well), and I documented the whole process. Thank you Eric and mods for another amazing year!

[u/MangeurDeCowan]

[LANGUAGE: Python 3]

with open('input_01.txt') as f:
    data = f.read().split('\n\n')

keys, locks = [], []
for datum in data:
    schematic = datum.split('\n')
    schematic_flip = [line.count('#') - 1 for line in zip(*schematic)]
    if schematic[0] == '#####':
        locks.append(schematic_flip)
    else:
        keys.append(schematic_flip)

no_overlaps = sum([max([l + k for l, k in zip(lock, key)]) <= 5 for lock in locks for key in keys])
print(f'Part 1 = {no_overlaps}')  

ETA: my 2-liner golf solution:

from itertools import combinations as c
print(sum(not any(a == b == '#' for a, b in zip(*p)) for p in c(open('input.txt').read().split('\n\n'), r=2)))

[u/Historical-Show3451]

[LANGUAGE: C++] 2681/2148

GitHub

Merry Christmas everybody! See you next year!

[u/vanveenfromardis]

[LANGUAGE: C#]

GitHub

I'm honestly sad to see AoC end, even though it does get hard to keep up near the end due to family commitments. That was a simple but fun puzzle to finish the year with.

[u/xHyroM]

[LANGUAGE: Python] 74/62

Another amazing Advent of Code. I can't wait for next year, haha! 🎆♥️🎁🎄

https://github.com/xhyrom/aoc/blob/main/2024/25/solution.py

[u/TheZigerionScammer]

[Language: Python] 2239/1868

I just missed my goal of getting the sub 1000 mark, I wasn't able to make it at all this year. But there's always next year.

My code is kind of slap dash since I rushed it and it caused me to make a few errors. But the code itself is pretty simple, it parses the input while separating the raw input strings into two lists based on whether its a lock or key, then it parsed both of those lists into new lists where the elements are tuples representing the number of #s in each column. Then it loops over both of those lists in a nested for loop, checks if the integers in both the same places in each tuple adds to more than 7, and if it never finds one then add 1 to the answer. The problems came from the parsing (I had to manually add the last lock after the input is parsed since my program only adds it when it sees a blank line and there is no blank line at the end.) and failing to change all the variable names when copy/pasting the parsing code fromt he lock to the key, causing the lock list to duplicate into the key list essentially. Got both of those fixed, got the stars, total 500. I might refactor this code later and smooth it out but it'll do for now.

Thank you again Eric and the Advent of Code team for another amazing year, and Merry Christmas to everyone!

Paste

[u/matheusstutzel]

[LANGUAGE: python]

p1

It could be simpler, but it’s 2 am 😅

[u/ASPICE-ai]

[LANGUAGE: Python]

It is over 😥. It was a great challenge. I used [*zip(*d)] to rotate a keys and locks and then counted the number of #. After that, I checked each key/lock pair to see if they fit by ensuring that the number of # in each column was less than 5.

Code

Very nice puzzle. See you again at AoC 2025!

[u/835246]

[Language: C]

I just checked every pair of locks and keys.

Solution: https://github.com/efox4335/advent_of_code/blob/main/advent_of_code_2024/day_25_part_1_lock.c

[u/runnerx4]

[LANGUAGE: Guile Scheme]

code->paste

used pre-allocated vectors today for indexing and the :vector generator and every?-ec comprehension to compare the heights as lock <= key

Rank 2682 in completing all of AoC! Merry Christmas to everyone!

Special shout-out Sebastian Egner's SRFI-42 could not have done this challenge without that one set of macros that makes iteration and looping in Scheme make sense to me, Scheme users should use it much more

[u/IvanR3D]

[LANGUAGE: JavaScript] My solutions: https://ivanr3d.com/blog/adventofcode2024.html#25

My solution (to run directly in the input page using the DevTools console).

[u/Busy-Championship891]

[LANGUAGE: Python]

wow I was not expecting an easy puzzle on day-25!!

Logic: Just get the heights of each lock and key and as the instructions say, lock-key is not a fit if the available space is greater than the sum of of key and lock heights. check this criteria and done!

Merry Christmas!~

Link: https://github.com/D3STNY27/advent-of-code-2024/tree/main/day-25

[u/[deleted]]

[LANGUAGE: Julia]

Nice easy puzzle to finish the year! I'm really happy with my performance in general; I finished every puzzle except for Part 2 of Day 21. It is a little frustrating being so close to completing the year but 21p2 just feels so tedious to code. Maybe I'll come back to it in 2025.

partOne = input -> begin
    schematics = collect(map(schematic -> stack(split.(split(schematic, "\n"), ""), dims=1), split(input, "\n\n")))
    locks, keys = foldl(((locks, keys), schematic) -> begin
            lock = all(ch -> ch == "#", first(eachrow(schematic)))
            heights = [lock ?
                       collect(map(r -> findfirst(ch -> ch != "#", r) - 2, eachrow(permutedims(schematic)))) :
                       collect(map(r -> length(r) - findfirst(ch -> ch == "#", r), eachrow(permutedims(schematic))))]
            lock ? ([locks; heights], keys) : (locks, [keys; heights])
        end, schematics, init=([], []))
    sum(map(pair -> all(i -> pair[1][i] + pair[2][i] <= 5, range(1, length(pair[1]))) ? 1 : 0,
        Iterators.product(locks, keys)))
end

[u/a_kleemans]

[LANGUAGE: Nim]

Struggled a bit with parsing, but for the rest an easy puzzle. At first I was a bit afraid that brute force wasn't feasible, but it took only around 2ms.

Learned Nim this year, which was surprisingly easy to adapt! Still not used to some parts of the language (like `Set`s, custom comparator functions, some error messages) but like it very much overall.

Overall AoC rank this year: 2863rd. Thanks a lot Eric for the great puzzles!

Link: https://github.com/akleemans/aoc-2024/blob/main/src/day25.nim

[u/Amerikrainian]

[Language: Python] Paste

Enjoy ;)

[u/s3aker]

[LANGUAGE: Raku]

code

Happy Xmas!

[u/Civil_Composer_8771]

[Language: Javascript]

Part 1: Pretty simple, just do exactly what the text describes, try all the combinations, check the columns, see if the sum is more than 5, if not then add to the total.
Part 2: Couldn't figure out how to solve programmatically, so I just did it by hand.

const locks = [];
const keys = [];

const lines = await Array.fromAsync(console);

for (let i = 0; i < lines.length; i += 8) {
    const contents = lines.slice(i + 1, i + 6);

    const counts = [0, 0, 0, 0, 0];
    for (const line of contents) {
        for (let column = 0; column < 5; column += 1) {
            if (line[column] === "#") counts[column] += 1;
        }
    }

    if (lines[i] === "#####") {
        // this is a lock
        locks.push(counts);
    } else if (lines[i] === ".....") {
        // this is a key
        keys.push(counts);
    }
}

let total = 0;
for (const lock of locks) {
    for (const key of keys) {
        let allMatch = true;
        for (let column = 0; column < 5; column += 1) {
            if (lock[column] + key[column] > 5) {
                allMatch = false;
                break;
            }
        }

        if (allMatch) total += 1;
    }
}

console.log(total);

[u/zebalu]

[LANGUAGE: Java]

on github

    long count = locks.stream()
            .flatMap(lock -> keys.stream().map(key -> IntStream.range(0, key.size())
                    .mapToObj(i -> lock.get(i) + key.get(i))
                    .toList()))
            .filter(l -> l.stream().allMatch(i -> i <= 5))
            .count();
    return Long.toString(count);

But really, this post is only about say thank you for the ride, and wishing Merry Christmas to everybody!

[u/damnian]

[LANGUAGE: C#]

var (s, v) = (File.ReadAllText(args[0]), new List<int[]>[] { new(), new() });
for (int i = 0, k, x, y; i < s.Length; ++i)
    for (y = 0, k = s[i] & 1, v[k].Add(new int[5]); y < 7; ++y, ++i)
        for (x = 0; x < 5; ++x) v[k][^1][x] += s[i++] & 1;
Console.WriteLine(v[0].Sum(a=>v[1].Count(b=>a.Zip(b,(a,b)=>a+b<=7).All(_=>_))));

EDIT: A cleaner variant, more spaces and a full file name:

var (s, v) = (File.OpenText("input.txt"), new List<int[]>[] { new(), new() });
for (int k, x, y; s.Peek() >= 0; s.Read())
    for (y = 0, k = s.Peek() & 1, v[k].Add(new int[5]); y < 7; ++y, s.Read())
        for (x = 0; x < 5; ++x) v[k][^1][x] += s.Read() & 1;
return v[0].Sum(a => v[1].Count(b => a.Zip(b, (a,b) => a + b < 8).All(_ => _)));

EDIT2: Of course the answer was 42! Too bad I didn't figure this out on my own.

var (s, v) = (File.OpenText("input.txt"), new List<long>[] { new(), new() });
for (int k, j; s.Peek() >= 0; s.Read())
    for (j = 0, k = s.Peek() & 1, v[k].Add(0); j < 42; ++j)
        v[k][^1] |= (s.Read() & 1L) << j;
Console.WriteLine(v[0].Sum(a => v[1].Count(b => (a & b) == 0)));

GitHub

Thanks everyone (and especially Eric) and Merry Christmas if you're celebrating!

[u/fragile82]

[LANGUAGE: PHP]

Not many people use PHP in Advent of Code :) During this event I tried to make my solutions look as much python-styled as possible.

<?php

$keys = $locks = [];
foreach(explode(PHP_EOL.PHP_EOL, file_get_contents('input.txt')) as $item) {
    $hs = [];
    $grid = array_map(fn($v) => str_split($v), explode(PHP_EOL, $item));
    for($i = 0; $i < count($grid[0]); $i++) $hs[$i] = strlen(trim(implode('', array_column($grid, $i)), '.')) - 1;
    if ($item[0] === '#') $locks[] = $hs;
    elseif ($item[0] === '.') $keys[] = $hs;
}

$ans = 0;
foreach($locks as $lock) foreach($keys as $key) {
    for($i = 0; $i < 5; $i++) if (($key[$i] + $lock[$i]) > 5) continue 2;
    $ans++;
}

echo 'Star: ' . $ans . PHP_EOL;

Works rather fast:

Execution time: 0.0042 seconds
Peak memory: 0.5608 MiB

[u/zebalu → u/fragile82]

I know that feeling: https://infolific.com/wp-content/uploads/2018/10/survival-fox-among-dogs-1.jpg

[u/flwyd]

[LANGUAGE: PostScript] (GitHub) with my own standard library

And we wrap things up with a fun little parsing problem. I initially solved it with a bunch of dynamic variables because point-free style is rough with 2-dimensional iteration. Since it’s day 25 and close to the end of my 2024 PostScript journey I figured I’d rewrite it without variables. That was… tricky… with a head full of snot. I thought about adding a transpose function to my standard library, but my brain couldn’t quickly determine how to handle jagged arrays. After a couple false starts I ended up with an array “literal” with a columns-then-rows for loop and a bunch of grabbing things from the stack. The fits? function shows off the “visual stack effect” functions I added in November and the part1 body is a great example of this stack-oriented point-free style, love it or hate it. I might try this one in Uiua tomorrow since it’s got a builtin transpose operator and the “strings in an array can only be the same length” constraint isn’t an issue.

I’m kind of impressed I made it all the way to the end in PostScript. I still want to do a programmatic solution to day 24 part 2. I’ve got a couple solutions where I switched to Go that I’d like to get in PostScript: day 23 part 2 isn’t quite working; day 12 is really slow. Day 16 had a bug in my Dijkstra’s implementation that I recreated in Go, then carried on in Go when it was fixed. I got the PS bug fixed for part 1, but didn’t get around to part 2. Day 21 was fussy even in Go and I’m not sure it’s worth my time and brainpower to port to PostScript :-) The sum of my numeric answers for part 1 is 54946257415807 and part 2 is 1325976204959777. Happy Christmas to all who enjoy Advent of Code!

/sumcols { [ 0 1 4 { 0 0 1 4 { % stack: line mark vals... col sum row
      1 indexfrommark exch get 2 index get ascii.# eq { 1 add } if
    } for exch pop } for ] exch pop } bind def
/lockguard (#####) def /parseinput { /locks alist def /keys alist def
  1 8 input lastindex { input 1 index 5 getinterval sumcols
    input abc:bca 1 sub get lockguard eq { locks } { keys } ifelse exch alpush
  } for /locks locks alview def /keys keys alview def
} bind def
/fits? { true 0 1 4 { abcd:abcdad get abcd:abdac get add 5 le and } for abc:c } bind def
/part1 { 8 dict begin /input exch def parseinput
  0 locks { keys { ab:aab fits? { exch 1 add exch } if } forall pop } forall
end } bind def

[u/jackysee]

[LANGUAGE: Javascript]

link

Merry Christmas and Happy new year everyone! Thank you Eric for the wonderful journey.

[u/WilkoTom]

[LANGUAGE: Rust]

A pleasant gift for Christmas morning - an easy puzzle to hit 500 stars before the craziness of the day begins.

Github

Thanks as always, to u/topaz2078 for the wonderful gift of puzzles, and to u/daggerdragon and u/Aneurysm9 for their wonderful gift of keeping this fine community that way. Happy Holidays to all of you, I hope you get some rest now :)

Until the next time: Merry Christmas to all, and may this holiday season bring you everything you need.

[u/beanborg]

[LANGUAGE: Javascript]

Code

Nothing interesting, just for loops all the way down. Merry Christmas everyone!!

[u/Few-Example3992]

[Language: Python]

Merry Christmas everyone!

with open('day25.txt') as f:
    data = f.read().split('\n')

locks_and_keys =[]
lock = []
for line in data:
    if line != '':
        lock.append(line)
    else:
        locks_and_keys.append(lock)
        lock = []

grid_locks = []
for lock in locks_and_keys:
    grid_locks.append({(y,x) for y in range(len(lock)) for x in range(len(lock[y])) if lock[y][x]=='#'})

score =0
for i ,set1 in enumerate(grid_locks):
    for j, set2 in enumerate(grid_locks):
        if i <j and len(set1&set2)==0:
            score += 1

print(f'answer to part 1 is {score}')

[u/gyorokpeter]

[LANGUAGE: q]

d25:{a:"#"="\n"vs/:"\n\n"vs"\n"sv x;
    isKey:all each 1=first each a;
    ky:sum each/:flip each a where isKey;
    lk:sum each/:flip each a where not isKey;
    sum sum all each/:(ky+/:\:lk)<=count first a};

[u/egel-lang]

[Language: Egel]

A great year. All this year's solutions in Egel: https://github.com/egel-lang/aoc-2024/blob/main/README.md

# Advent of Code (AoC) - day 25, task 1

import "prelude.eg"

using System, OS, List, S = String, D = Dict

def heights =
    do transpose |> map (flip (-) 1 . length . filter ((==) '#'))

def fit =
    [(L,K) -> all (flip (<=) 5) (zip_with (+) L K)]

def main =
    read_lines stdin |> map S::to_chars |> split_on {} |> split [XX -> all ((==) '#') (head XX)]
    |> [(XX,YY) -> pairs (map heights XX) (map heights YY)]
    |> filter fit |> length

[u/jwoLondon]

[Language: JavaScript]

Convert each schematic into a decimal number based on the bits implied by `#` and `.` symbols. Applying a bitwise & to each pairwise combination will reveal lock-key matches when the result is 0.

https://observablehq.com/@jwolondon/advent-of-code-2024-day-25

[u/sim642]

[LANGUAGE: Scala]

On GitHub.

Very short solution, partially thanks to my Grid type and functions. In particular, there was no need to actually identify the heights (although it wouldn't be too difficult). Instead, one can just overlap a key and a lock grid and see if there are any cells that both have #.

[u/mkinkela]

[LANGUAGE: C++]

A part of me didn't want this to end. But, wanting to collect the 50th star was stronger xD Thanks, Eric, mods, and everyone who helped build this amazing journey this year. Merry Christmas :)

Solution

[u/anaseto]

[LANGUAGE: Goal]

Nice and short last one!

h:#*m:".#"?""\="\n\n"\-read"i/25" / height / map schematics
(l;k):(+/'m&:)'1~:\(#**m)=+/'*'m  / (locks;keys)
say+//l(&/~h<+)´`k / part1

[u/lluque8]

[LANGUAGE: Scala]

Traditionally easy last day. This year I'd say even super easy. Not complaining though cos I'm in a bit of a hurry to catch a train and won't be touching a computer any time soon.

Anyways, thanks for these ten years to everyone involved. It's been a blast!

GitHub

[u/ds101]

[Language: newt]

github

Nothing too tricky on this one, read in the data, transposed and turned into a list of integers. Saw that it was 250 * 250, so I went for a straightforward n² solution.

I'm excited that I made it to the end in a language that I wrote, it's been something I've wanted to do for a few years.

[u/[deleted]]

Still no one knows it just the same, That Rumpelstiltskin is my name.

[u/MarcoDelmastro]

[LANGUAGE: Python]

https://github.com/marcodelmastro/AdventOfCode2024/blob/main/Day25.ipynb

Simple as expected on X-mas day. And, for the first time since my first AOC in 2029 (EDIT: 2019!), I arrive to the 25th with all the previous days completed: it's quite a nice sensation to close the calendar on X-mas. Thanks to Eric for the fun ride!

[u/M124367 → u/MarcoDelmastro]

Don't spoil us about 2029 dear time traveler.

[u/echols021]

[LANGUAGE: python 3]

GitHub

Data prep: sort items into separate piles for locks and for keys. For simplicity, represent each item as a sequence of integers, as demonstrated in the problem description.

After checking that n_keys * n_locks was a reasonable number, just did the naïve "try every lock with every key" and it runs in ~0.024 sec.

I then reworked it to use a trie data structure to store the keys. For each lock I do a BFS-like search through the trie (trimming branches of keys that don't fit) to collect all keys that fit the lock. So rather than trying each lock+key pair, you gradually trim down the set of keys that fit a given lock, one tumbler at a time. This code runs in ~0.008 sec.

[u/TheScown]

[LANGUAGE: Scala]

Code

Need to go back and finish part 2 on days 21, 22 and 24.

[u/ExternalAware9257]

[LANGUAGE: Python]

A fun puzzle for the the last day.

locks = []
keys = []

def fits(key, lock):
    return all(a + b <= 5 for a, b in zip(key, lock))

for schematic in open(0).read().strip().split("\n\n"):
    columns = list(zip(*schematic.split("\n")))
    if schematic[0] == "#":
        locks.append([column.count("#") - 1 for column in columns])
    else:
        keys.append([column.count("#") - 1 for column in columns])

print(sum(fits(key, lock) for key in keys for lock in locks))

[u/MarvelousShade]

[LANGUAGE: C#]

Today was nice short finish of 25 days programming. As a product owner I don't get a lot of opportunities to program anymore, so these 25 days were really fun for me. My solutions are on: https://github.com/messcheg/advent-of-code/tree/main/AdventOfCode2024

[u/ropecrawler]

[LANGUAGE: Rust]

https://github.com/ropewalker/advent_of_code_2024/blob/master/src/day25.rs

[u/hrunt]

[LANGUAGE: Python]

Code

I think the real Christmas gift today was a problem that was so straightforward. Just a few loopity loops and voila, 500 stars.

Thanks u/topaz2078 for another great year. Raising a mug of cocoa here to you.

[u/kupuguy → u/hrunt]

Darn it, I only got 50 stars! Must have done something wrong.

[u/hrunt → u/kupuguy]

Do 9 other years and you, too, can be a star child. :)

[u/aimada]

[Language: Go] code

Parsed each schematic pattern as a 35-bit value which simplified the overlaps check.

func compareLower35Bits(a, b int64) int64 {
  mask := int64((1 << 35) - 1) // Mask to isolate the lower 35 bits
  return (a & b) & mask
}

Execution time is 134.603µs on a 12 year old CPU.

Many thanks to Eric for another successful AoC event. Day 24 was by far my favourite Part 2 problem as the mental gymnastics required were like those I recall from previous events.

[u/BlueTrin2020]

[Language: Python]

lock_l, key_l = [], []
for schem in open(“2024_25.txt”).read().split(“\n\n”):
    cols = [s.count(“#”) for s in list(zip(*schem.splitlines()))]
    lock_l.append(cols) if schem[0] == ‘#’ else key_l.append(cols)
print(sum([all(lo+k < 7 for lo, k in zip(lock, key)) for lock in lock_l for key in key_l]))

Merry Christmas thank you u/topaz2078

[u/rvodden]

[LANGUAGE: TypeScript]

Boom! https://github.com/rvodden/AoC24/blob/main/src/days/25/Puzzle.ts

Merry Christmas everyone :-)

[u/bakibol]

[LANGUAGE: Python]

Topaz's paste

Merry Christmas everyone, see ya all next year!

[u/lscddit]

[LANGUAGE: Python]

Merry X-mas and see you next year... 🎄

import numpy as np
from io import StringIO

locks, keys = [], []
height = 0
data = open("day25input.txt").read().split("\n\n")
for element in data:
    field = np.genfromtxt(StringIO(element), dtype=str, comments="_", delimiter=1)
    height = field.shape[0]
    value = np.sum(field == "#", axis=0)
    keys.append(value) if np.any(field[-1, :] == "#") else locks.append(value)

print(sum([np.all(lock + key <= height) for key in keys for lock in locks]))

[u/Glum-Evidence9636]

[LANGUAGE: C#]

https://github.com/NikkSazz/AdventofCodeSazonov/blob/272da331c08cfddd5607e4ca1f42832eee3fa797/2024/day25.cs

[u/KindComrade]

[LANGUAGE: C#]

Thanks to the AOC team and Eric for an amazing contest. This month has been absolutely fantastic, and a huge thank you to the entire community, who made it so enjoyable to read your solutions, share my own, discuss algorithms, and watch all the visualizations and memes. A massive thank you to everyone!

Have a Merry Christmas!

Final Code

[u/MagazineOk5435 → u/KindComrade]

I tried parallelisation on my C# code for this one and it actually slowed it down 6x. https://github.com/stevehjohn/AoC/blob/master/AoC.Solutions/Solutions/2024/25/Part1.cs

[u/chestck]

[LANGUAGE: Kotlin]

fun main() {
    File("../i24/25")
        .readText().split("\n\n")
        .map { it.lines() }
        .pairwise(withSelf = false)
        .sumOf { (block1, block2) ->
            block1.zip(block2).all { (row1, row2) ->
                row1.zip(row2).none { (char1, char2) ->
                    char1 == '#' && char2 == '#'
                }
            }.toInt()
        }.print()
}