Advent Of Code 2025

[P_Tingen]

Soultaker schreef op woensdag 3 december 2025 @ 12:09:
[...]
Qua algoritme erg netjes. Had je dat zelf bedacht of kwam dat ook van Perplexity?

Tbh geen van beide, ik had zelf redelijk beredeneerd hoe ik het aan ging pakken maar miste een paar stappen. Vervolgens gaan zoeken en op reddit een paar hints gevonden waar ik mee verder kon. Uiteindelijk vast op een extra check die Perplexity vond.

Als test heb ik de opgave trouwens ook eens in zijn geheel in Perplexity gegooid om te zien wat die ervan maakte, maar dat leverde in eerste instantie geen goede oplossing. Pas toen ik hem (het?) de goede uitkomst erbij gaf, kon hij zelf een testcase maken kennelijk en klopte het wel. De code was alleen veel "wolliger", wat ik nog niet zo gek vind met een nichetaal als de Progress 4GL. Vind het eigenlijk al knap dat er überhaupt iets werkbaars uitkomt

Over de programmeertaal zelf kan ik beter m'n mond houden

Nou ja zeg!
Het is een prima taal voor waar het voor bedoeld is, nml administratieve toepassingen obv een Progress database. Dat is precies de reden waarom ik met AoC meedoe in die 4GL, namelijk omdat het daar eigenlijk voor de meeste opgaven helemaal niet voor geschikt is

[Woy]

Dag 3 was redelijk eenvoudig. Part2 zal vast niet helemaal optimaal zijn, maar wel gewoon een nette oplossing die meer dan snel genoeg is.

https://github.com/rversteeg/AoC2025/blob/main/AdventOfCode/Day03.cs

[Soultaker]

P_Tingen schreef op woensdag 3 december 2025 @ 13:41:
Tbh geen van beide, ik had zelf redelijk beredeneerd hoe ik het aan ging pakken maar miste een paar stappen. Vervolgens gaan zoeken en op reddit een paar hints gevonden waar ik mee verder kon. Uiteindelijk vast op een extra check die Perplexity vond.

Aha. Hoe dan ook een een leuke variant. Ik vind het interessant op hoeveel verschillende manieren dit probleem opgelost kan worden. Ik heb nu een stuk of 4 varianten voorbij zien komen, waarvan de versie met een stack nog wel de meest elegante is.

Vind het eigenlijk al knap dat er überhaupt iets werkbaars uitkomt.

LLM's zijn relatief goed in “vertalen”, dat helpt waarschijnlijk, zelfs als de trainingsdata beperkt is.

[HannoOttens]

Deze dag zag ik de bui gelukkig al aankomen en kon ik deel a schrijven op een manier die makkelijk uit te breiden was voor deel b.

https://github.com/HannoO...master/2025/day03/main.go

spoiler:

Ik neem eerste de laatste 12 batterijen in een pack. Vanaf de 13e zoek ik naar links. Als ik een getal tegen kom wat net zo groot of groter als de hoogste dan vervang ik de hoogste daarmee en schuif ik de rest door.

[kahraman11]

Ik heb voor challenge 2 van dag 3 (vandaag dus) gebruik gemaakt van recursion. Programmeren is niet mijn dagelijkse vak, dus het is niet het meest mooie code maar het werkt:

spoiler: python recursion

[code]def find_highest_number(remaining_list, numbers_left, combination):
if numbers_left == 0:
return combination

highest_number = 0

for i in range(len(remaining_list) - numbers_left + 1):
number = int(remaining_list[i])
if number > highest_number:
highest_number = number

for i in range(len(remaining_list) - numbers_left + 1):
number = int(remaining_list[i])
if number == highest_number:
return find_highest_number(remaining_list[i+1:], numbers_left - 1, combination + str(number))

count = 0
with open("input.txt") as file:
numbers_left = 12
for line in file:
l = line.replace("\n", "")
result = find_highest_number(l, 12, "")
print(result)
count += int(result)

print(count)
[/code]

[Vloris]

Nadat ik vandaag (dag 3) een naïeve oplossing voor deel 1 geschreven had dacht ik voor deel 2 direct "hej, dit ziet er heel goed recursief oplosbaar uit".
Dat werkte perfect, alleen wat traag voor de echte input (geen idee hoe traag, niet op gewacht), dus toen me ook maar eens ingelezen in 'memoization' of caching van tussenresultaten tijdens de recursie. Dat werkte echt perfect.

130ms voor deel 1 + deel 2 (ik verwacht eigenlijk dat de memoization van deel 1 ervoor zorgt dat de cache van deel 2 al deels gevuld is) -- https://github.com/floris...ob/main/src/days/day03.ts

[KabouterSuper]

Aangezien de meesten klaar zijn hier mijn compact python oplossing (denk de indents er zelf bij, daar zijn spoiler-tags niet zo goed in)

spoiler:

for part,ssum in (1,0), (2,0):
for d in [d for d in open('day 03 input.txt').read().split('\n') if d!='']:
s,ans,L=0,'',-8+10*part
for end in range(L-1,-1,-1):
m,snew=max(d[s:len(d)-end]),d[s:-end].find(max(d[s:len(d)-end]))
ans,s=ans+m,s+snew+1
ssum+=int(ans)
print(part,ssum)

[ Voor 7% gewijzigd door KabouterSuper op 03-12-2025 20:50 ]

[.oisyn]

We hadden vandaag een copilot workshop. Ik had in Visual Studio in agent mode voor de grap gewoon ingetypt: "Hier is een opdracht: <link naar AoC dag 1>. Implementeer het in C++."

Ik heb de vraag gelezen noch de geproduceerde code bestudeerd. Gewoon gecompiled, gerund en het goede antwoord kwam eruit

[ Voor 3% gewijzigd door .oisyn op 03-12-2025 21:16 ]

[Ghehe]

KabouterSuper schreef op woensdag 3 december 2025 @ 20:50:
Aangezien de meesten klaar zijn hier mijn compact python oplossing (denk de indents er zelf bij, daar zijn spoiler-tags niet zo goed in)

spoiler:

for part,ssum in (1,0), (2,0):
for d in [d for d in open('day 03 input.txt').read().split('\n') if d!='']:
s,ans,L=0,'',-8+10*part
for end in range(L-1,-1,-1):
m,snew=max(d[s:len(d)-end]),d[s:-end].find(max(d[s:len(d)-end]))
ans,s=ans+m,s+snew+1
ssum+=int(ans)
print(part,ssum)

Die "-8+10*part" is wel netjes gevonden, dat had ik zelf niet bedacht.