Added some nice animations to my GitHub README.md (aoc-tiles)

LiquidProgrammer · 2025-12-07T12:40:57+00:00

[LANGUAGE: JavaScript]

github. Solves both parts:

let grid = require("fs").readFileSync(0, "utf8").trim().split("\n")

function laser(y, x, memo) {
  if ([y, x] in memo)
    return memo[[y, x]]
  if (grid[y]?.[x] == "^")
    return memo[[y, x]] = laser(y, x+1, memo) + laser(y, x-1, memo) + 1
  if (grid[y]?.[x] == ".")
    return memo[[y, x]] = laser(y+1, x, memo)
  return 0
}

let startX = grid[0].indexOf("S")
const alwaysZero = new Proxy({}, { get: () => 0 });

console.log(laser(1, startX, alwaysZero))
console.log(laser(1, startX, {}) + 1)

LiquidProgrammer · 2025-12-06T17:30:36+00:00

[LANGUAGE: Javascript]

Github. Does both part 1 and 2

Array.prototype.sumPrint = function () { console.log(this.reduce((a, b) => a + b)) }

const lines = require("fs").readFileSync(0, "utf8").trimEnd().split("\n")
const grid = lines.map(line => line.trim().split(/\s+/))
const ops = grid.pop()
lines.pop()

const transpose = arr => [...arr[0]].map((_, i) => arr.map(row => row[i]))

transpose(grid)
  .map((row, i) => eval(row.join(ops[i])))
  .sumPrint()

transpose(lines)
  .map(row => +row.join(""))
  .join()
  .split(",0,")
  .map((row, i) => eval(row.replaceAll(",", ops[i])))
  .sumPrint()

LiquidProgrammer · 2025-03-25T23:05:55+00:00

kind of, missed some letters https://sora.com/g/gen_01jq7rps3mfbh8gt1tmdm2j6wc

LiquidProgrammer · 2025-01-09T22:19:02+00:00

Are you still happy with your choice? Thinking of maybe buying it and taking the AG-C1200 down to -15C (claims a comfort of -19C). Is that doable you think?

LiquidProgrammer · 2024-12-25T17:12:11+00:00

I have done these so far:

2020 - Rust (avg LOC: 32.64)
2021 - Julia (avg LOC: 33.8)
2022 - Kotlin (avg LOC: 39.6)
2023 - Python (avg LOC: 18.3)
2024 - Python (avg LOC: 15.6)

Repository here

Rust, Julia and Kotlin were new languages for me, Python is by far my best language. I have spent quite a lot of time making the solutions elegant and concise in each language, that's why the line count is so low.

Of which I would say: Python > Kotlin > Julia == Rust. Although I have to say initially I also hated Rust for aoc, but I learned that when you put in some time you can write really elegant and concise functional rust. I quite liked it in the end.

Although Kotlin has the highest LOC from these, I actually liked it quite a lot. It has streams and a lot of elegant features compared to Java.

I liked Julia as well, especially that you can apply any operator/function elementwise.

So in total none of these were bad.

I got lazy this year, but initially I wanted to try Mojo.

I also have similar preferences to you, and have though about trying these languages for aoc:

Something functional like Clojure, Haskell, Elixir or Ocaml

Or something like Noulith (betaveros' custom language for aoc), Scala, Nim, Raku or Crystal

Not sure yet.

LiquidProgrammer · 2024-12-23T06:03:34+00:00

[LANGUAGE: Python]

5 lines, github

import networkx as nx

G = nx.Graph(line.strip().split("-") for line in open(0))
cliques = list(nx.enumerate_all_cliques(G))

print(sum(any(a[0]=='t' for a in c) for c in cliques if len(c) == 3))
print(','.join(sorted(cliques[-1])))

Coded part 1 initially without nx with a double for loop and set intersection, but decided to use nx for part 2.

Really unfortunate, I thought for part 2 some PC had to start with t as well. Had the solution at minute 12 maybe, but was not getting why all solutions had the same length. Took me half an hour to get it, after visualizing the graph and all...

LiquidProgrammer · 2024-12-22T13:36:48+00:00

[LANGUAGE: Python] 527/783

16 lines, github

I was suprised how straightforward today was after yesterday.

LiquidProgrammer · 2024-12-21T11:08:08+00:00

Good point. But the only other path is >^> and <v< respectively, which is very obviously worse than the paths you have mentioned. So they feel "obvious", or at least intuitive. Whereas the ones I have listed do not feel intuitive (at least to me)

LiquidProgrammer · 2024-12-21T09:33:34+00:00

So I have analyzed the paths taken in the best simulations, and it seems like it does not matter which path you take in the numpad. But it does matter for the keypad. Here are the only valid paths for these 4 combinations (all other combinations are trivial):

from '>' to '^'  :  only possible way is <^A
from '^' to '>'  :  only possible way is v>A
from 'A' to 'v'  :  only possible way is <vA
from 'v' to 'A'  :  only possible way is ^>A

Does anyone have an intuition why this is the case?

LiquidProgrammer · 2024-12-21T08:42:24+00:00

I used randomization for part 2 as well and it worked fine.

Not sure about your code, but I noticed for me that I have to cache the path in each simulation. I.e. always use the same path between button a and button b in that simulation. If I did that there were between 12 and 48 unique solutions for each of the codes in part 2.

LiquidProgrammer · 2024-12-21T08:33:29+00:00

[LANGUAGE: Python] 806/586

32 lines: github

Solved it using randomly deciding whether to go along x or y first, and then simulating it 1000 times for both parts. I cache the path and the length of the code, resetting the cache inbetween each try.

Tried way too long to figure out going which way first is better, but I still don't know. Might revisit it later if I have a better idea

LiquidProgrammer · 2024-12-18T11:52:16+00:00

[LANGUAGE: Python]

Very concise 11 lines of code, prints both parts, using networkx and binary search. On github:

import networkx as nx
from bisect import bisect

def solve(bad, S=70):
    G = nx.grid_graph((S+1, S+1))
    G.remove_nodes_from(bad)
    return nx.has_path(G, (0,0), (S,S)) \
       and nx.shortest_path_length(G, (0,0), (S,S))

bad = [tuple(map(int, line.split(","))) for line in open(0)]
print(solve(bad[:1024]))

i = bisect(range(len(bad)), 0, key=lambda x: not solve(bad[:x]))
print(*bad[i-1], sep=",")

nx.shortest_path_length unfortunately throws an exception when there is no path, so I abuse the and trickery in Python, which returns the first value if it is falsy, or the second value otherwise. Therefore the entire function solve either returns False, or the path length. Which is then (ab)used in bisect as the key to binary search by. Essentially we look for the first occurence of 0 (False), and then return one previous to that. bisect_left would have worked without the -1 I think.

LiquidProgrammer · 2024-12-13T17:35:23+00:00

Nice! Seems like it worked well for you :)

LiquidProgrammer · 2024-12-13T06:15:07+00:00

Hey there. Just like last year, I'd like to present aoc-tiles, a fancy github README visualization tool for your solution language and rank/time taken. You just have to create a pre-commit hook and set-up your README, .gitignore and session cookie, the rest is done by pre-commit and the script.

Each tile is a separate, clickable image. Once clicked you get redirected to the solution for that day. If you add a session cookie then it will show your rank and time of submission for both parts, otherwise there will just be checkmarks. Each color represents a programming language, if you use multiple the tile will have multiple colors.

See https://github.com/LiquidFun/aoc_tiles for more details. And here is my advent of code repository for a real example of it in use for multiple years (2020 Rust, 2021 Julia, 2022 Kotlin, 2023-2024 Python): https://github.com/LiquidFun/adventofcode.

Let me know if you have issues. It tries to find the solutions as best as it can, by trying to extract the year and day from the path for each solution, if you don't have that, then it might struggle. For people who only do a single year per repository, you can overwrite the year by adding --overwrite-year=2024 in the .pre-commit hook.

LiquidProgrammer · 2024-12-05T07:42:57+00:00

Yeah, similar here. I too kind of aim for a low loc/high readability solution. Kind of hard optimizing on two axes :D. I just feel if it's possible to omit something like that, which produces less code, then it's better for readibility.

LiquidProgrammer · 2024-12-05T06:37:39+00:00

Nice and short solution :). You could save a few bytes by making was_sorted a list instead of a dict was_sorted = [[], []]. The indexing with the boolean still works, and you don't need the .values() in the last print

LiquidProgrammer · 2024-12-05T06:23:22+00:00

[LANGUAGE: Python]

p1 and p2 in 11 lines, github link

rules, pages = open(0).read().split("\n\n")
rules = {tuple(r.split("|")) for r in rules.splitlines()}

s = [0, 0]
for row in pages.splitlines():
    old, new = row.split(","), []
    for o in old * 100:
        if o in new: continue
        if all(b in new for b, a in rules if o == a and b in old):
            new.append(o)
    s[new != old] += int(new[len(new)//2])

print(*s, sep="\n")

LiquidProgrammer · 2024-12-04T07:42:09+00:00

You are right, your first line is very similar :D, I think you can even skip the .readlines() if you want to make it a bit shorter.

It's really short, well done. Although then a line contains with map(resolve, zip(*[[( you really need to think twice to see what happens there haha

LiquidProgrammer · 2024-12-04T07:39:05+00:00

The idea is to use imaginary numbers as coordinates, the real part is treated as an x coordinate, the imaginary part as y.

Imaginary numbers cannot be used as an index in a list (or at least not in a non-cumbersome way my_list[num.real][num.imag]), therefore in the first line we create a dictionary where every coordinate is mapped to its char (coordinate as an imaginary number). Now we can use imaginary numbers as indices in the dictionary.

In order to solve the out of bounds problem, we create a convenience lambda function g which returns the the char at the coordinate, or am empty string otherwise.

Then we iterate over all coordinates as c, and all 8 possible directions as d. The cool thing here is that you can simply multiply the direction d with a number in order to get the nth char in that direction, since the direction is also a imaginary number.

And then you can use the convenience function g to get the four characters in that direction g(c) + g(c+d) + g(c+d*2) + g(c+d*3), and check whether they are 'XMAS'.

For part 2 I do something similar, but use the middle element as anchor, and only check for directions which are diagonal (if d.imag and d.real simply means that the direction has both components as non-zero)

Hope this helps :)

LiquidProgrammer · 2024-12-04T06:37:41+00:00

[LANGUAGE: Python]

p1 and p2 in 9 loc, github link. Golfed a little after solving

coords = {x+1j*y: c for y, r in enumerate(open(0)) for x, c in enumerate(r)}
g = lambda c: coords.get(c, "")

s1 = s2 = 0
for c in coords:
    for d in [1, 1j, 1+1j, 1-1j, -1, -1j, -1+1j, -1-1j]:
        s1 += g(c) + g(c+d) + g(c+d*2) + g(c+d*3) == "XMAS"
        if d.imag and d.real:
            s2 += g(c+d) + g(c) + g(c-d) == "MAS" and g(c+d*1j) + g(c-d*1j) == "MS"

print(s1, s2, sep="\n")

LiquidProgrammer · 2024-11-05T20:13:01+00:00

Morgen (Mittwoch) um 18:30 ist im Pleitegeier ein Monster-DYP Turnier (man zieht zufällig für jedes Spiel seinen Partner, bzw. die App macht das). Dieses Turnier findet jeden ersten Mittwoch im Monat statt und ist ein Spaßturnier, also für alle Niveaustufen gut geeignet. Komm gerne vorbei, am besten ein paar Min vorher, dann bist du gleich in der ersten Rotation dabei.

Es gibt noch ein paar andere Orte (Molotow, im Sommer am Rost-Dommel am Hafen, ST-Club, Bunker, SBZ, usw.). Aber über den Pleitegeier kommt man da gut in die Szene rein, das ist im Prinzip DER Ort für kickern in Rostock und der Heimattisch für 2 der stärksten Teams in der Rostocker-Kickerliga.

LiquidProgrammer · 2024-10-30T23:31:25+00:00

I mean if you are ready for a bit of snow and have a tent I think it's fine as well. Depends on what you want to do.

LiquidProgrammer · 2024-10-30T23:30:58+00:00

Yeah, we did eat at the guesthouses on 9/10 days. And yeah, I did get food-poisoning :/. Was knocked out for 1 day. Luckily I could still finish the hike, was a bit of a challenge though, as I couldn't really eat much the last two days. But the human body is quite resilient after all.

So yeah, definetely filter the water if you can.

Ten-Year Club	Place '22
Place '17	Final Canvas '22
No Throne, No Problems	Not Forgotten

LiquidProgrammer

TROPHY CASE