Advent of Code 2024

[ElkeBxl]

Advent of Code 2024

Wat is de Advent of Code?

Wederom komt december eraan, voor de puzzel fanaten is de Advent of Code er dus weer! Van 1 tot en met 25 december zijn er elke dag 2 puzzels beschikbaar, om zo het grote raadsel van dit jaar op te lossen. De raadsels zijn zo opgezet dat ze het beste met een stuk programmatuur kunnen worden opgelost. Uiteindelijk krijg je elke dag jouw eigen unieke input, waarbij één bepaalde output hoort.

Hoe ziet zo'n puzzel eruit?

• Een puzzel is gebruikelijk in een soort verhaal vorm geschreven. Een goed voorbeeld, ook om te oefenen vind je hier.
• @Soultaker heeft ook een eerste puzzel gepost voor zij die reeds wat willen oefenen.

Vorige leaderboards

Ook in 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 en 2023 deed de Tweakers community mee, dus ook dit jaar kunnen we weer aan de slag:

Jaar	Leaderboard
2015
2016
2017	Leaderboard
2018	Leaderboard
2019	Leaderboard
2020	Leaderboard
2021	Leaderboard
2022	Leaderboard
2023	Leaderboard

Hoe aan te melden

Je kan je aanmelden via website: https://www.adventofcode.com. Op de website is er weer een tweakers leaderboard. Meld je hier aan met code:

Members only: Leaderboard code

Alleen zichtbaar voor ingelogde gebruikers. Inloggen

Het kan zijn dat het leaderboard vol is, (max. 200), na een aantal dagen kan ik wat inactieve accounts eruit gooien, stuur mij dan een berichtje, als er weer plek is laat ik weten wanneer je het nog een keer kan proberen.

Een paar regels

• Discussie over de puzzels mag, maar probeer niets te spoilen voor de rest! (of gebruik de spoiler tag)
• Net zoals vorig jaar is er ook expliciet aangehaald om geen AI te gebruiken bij het oplossen van de puzzels.

De deelnemers

Members only: Overzicht van de deelnemers, taal en hun code repo:

Alleen zichtbaar voor ingelogde gebruikers. Inloggen

Stuur ElkeBxl even een PM om ook in de lijst te komen. Stuur hierbij de link naar de repository en de taal/talen die je gebruikt.

Eindwoord

Met dank aan Daanoz voor de organisatie van vorige jaren en waar ik schaamteloos deze topic text van geript heb dit jaar en vorig jaar en het jaar ervoor. If we ever meet, trakteer ik je eens iets

Succes aan iedereen!

[ Voor 15% gewijzigd door ElkeBxl op 04-12-2024 07:40 ]

[Gropah]

Nice

Helaas denk ik dat ik dit jaar niet veel tijd zal hebben om echt goed mee te doen...

[MatHack]

Ik hoop dit jaar weer mee te kunnen doen, maar het zal zeker op een langzamer tempo gaan dan vorig jaar. Naast mijn werk druk bezig met afstuderen van een masterstudie, dus de tijd is al schaars. Vermoed dat het neer gaat komen op de eerste dagen goed mee komen en dan langzaam achterraken.

[P_Tingen]

Heb er een tijd over nagedacht of ik überhaupt wel mee wil doen. Het moet er allemaal een beetje bij en vooral verder in de maand wordt het vaak meer een exercitie in taalkunde dan in programmeren en dat frustreert enorm

[Marcj]

Mijn jaarlijkse kant om aan mijn Rust kennis te werken. Op mijn werk is dat niet gelukt, maar ik vind het nog steeds erg interessant. En aangezien ik al een hele library heb voor AoC hoef ik niet zoveel tijd te spenderen deze keer.

[.oisyn]

TVP

Ik twijfel nog tussen Rust en C++. Wel al een tijdje niets meer met Rust gedaan, wel een goede manier om het een beetje bij te houden.

[KabouterSuper]

Dit jaar weer van de partij! Extra speciaal is dat mijn oudste dochter voor het eerst ook gaat meedoen. Daar verheug ik me erg op.

[Creepy]

Ik ga zeker weer starten dit jaar, eens kijken waar ik afhaak zo ergens na een weekje of 2 Ik ben nog wel aan het twijfelen in welke taal. Ik wil Rust eens gaan oppakken, dus misschien een goed idee om dit dan met Rust te doen, aan de andere kant ook wel fijn om het in een omgeving te doen waarin ik wat comfortabeler ben, Java of Go.

[P_Tingen]

KabouterSuper schreef op vrijdag 22 november 2024 @ 10:04:
Dit jaar weer van de partij! Extra speciaal is dat mijn oudste dochter voor het eerst ook gaat meedoen. Daar verheug ik me erg op.

Cool! Hoe oud is ze, wat voor opleiding (indien van toepassing)

[vliegnerd]

Ik heb nog steeds het voornemen om dit een keer in Haskell te doen, in plaats van mijn "default" taal Python.

En dan vooral om Haskell te leren, want ik denk dat ik niet heel erg ver ga komen als ik niet kan terugvallen op mijn standaard python bronnen en ervaring.

Er zijn wel Youtubers die semi-live Haskell oplossingen schrijven van AOC, die ga ik proberen te volgen, denk ik. Dus niet echt meedoen voor het snel halen van de opdrachten, maar voor de lol van het leren van een nieuwe taal.

[KabouterSuper]

P_Tingen schreef op vrijdag 22 november 2024 @ 10:20:
[...]

Cool! Hoe oud is ze, wat voor opleiding (indien van toepassing)

Ze is dit jaar begonnen met hbo elektrotechniek (het zal vast een fancier Engelse naam hebben). Ik doe AoC in Python, zij in C. Niet de gemakkelijkste taal, maar logisch als je richting embedded systems wil.

[Renzmeister]

Ik had me voorgenomen om me wat in Zig te verdiepen en te kijken hoe lang ik AoC volhoud (vorige keer niet al te lang haha.) Heb het echter behoorlijk druk met andere zaken dus misschien sla ik het dit jaar over.

[Soultaker]

Nu al een AoC topic? Het duurt nog anderhalve week.

.oisyn schreef op vrijdag 22 november 2024 @ 09:11:
TVP

Daar hebben we tegenwoordig de “Topic Volgen” checkbox voor, toch?

Renzmeister schreef op vrijdag 22 november 2024 @ 10:58:
Ik had me voorgenomen om me wat in Zig te verdiepen en te kijken hoe lang ik AoC volhoud (vorige keer niet al te lang haha.)

Ik heb vorig jaar in Zig gedaan. Voordeel: loopt erg snel. Nadeel: invoer parsen is een hoop gedoe. Ik denk dat ik het dit jaar bij Python hou, want dat is meer geschikt voor dit soort one-off taken.

[ElkeBxl]

Soultaker schreef op vrijdag 22 november 2024 @ 13:31:
Nu al een AoC topic? Het duurt nog anderhalve week.

We zijn er inderdaad vroeg bij! Als ik zo kijk naar vorige jaren, werd er vaak op 29/11 een topic geopend.

KabouterSuper schreef op vrijdag 22 november 2024 @ 10:04:
Dit jaar weer van de partij! Extra speciaal is dat mijn oudste dochter voor het eerst ook gaat meedoen. Daar verheug ik me erg op.

Cool! Veel succes beiden! Dat wordt dan samen brainstormen of gaan jullie volledig apart oplossen en erna vergelijken?

Marcj schreef op vrijdag 22 november 2024 @ 09:00:
Mijn jaarlijkse kant om aan mijn Rust kennis te werken. Op mijn werk is dat niet gelukt, maar ik vind het nog steeds erg interessant. En aangezien ik al een hele library heb voor AoC hoef ik niet zoveel tijd te spenderen deze keer.

Ik heb het al meerdere keren in Rust gestart om dan nooit te voltooien... Misschien wordt dit mijn jaar dat het toch eens lukt

MatHack schreef op vrijdag 22 november 2024 @ 06:57:
Ik hoop dit jaar weer mee te kunnen doen, maar het zal zeker op een langzamer tempo gaan dan vorig jaar. Naast mijn werk druk bezig met afstuderen van een masterstudie, dus de tijd is al schaars. Vermoed dat het neer gaat komen op de eerste dagen goed mee komen en dan langzaam achterraken.

Succes met de studie!

Zelf ga ik er dit jaar niet 's ochtendsvroeg direct aan beginnen elke dag (weekends en eventueel verlof zijn natuurlijk uitzondering). Mijn dag is altijd al druk genoeg en ben ik best niet afgeleid tijdens de werkdag

[.oisyn]

Soultaker schreef op vrijdag 22 november 2024 @ 13:31:
Daar hebben we tegenwoordig de “Topic Volgen” checkbox voor, toch?

Met een TVP komt het topic in mijn posthistory (die ik veel gebruik om GoT te navigeren), met "topic volgen" krijg je een notificatie als iemand een post maakt in het topic

[Mugwump]

Ik ga dit jaar weer lekker in Kotlin doen. Hoop ook binnenkort eens een eerste opdracht te landen waarbij ik met Kotlin aan de slag mag.

[Corniel]

KabouterSuper schreef op vrijdag 22 november 2024 @ 10:04:
Dit jaar weer van de partij! Extra speciaal is dat mijn oudste dochter voor het eerst ook gaat meedoen. Daar verheug ik me erg op.

Wat enorm gaaf! Onze dochter is 7, nog nét te jong denk ik. Haar ouders zijn waarschijnlijk wel weer beide van de partij.

En morgen heb ik op mijn werk een AoC kick-off, om mijn collega's aan te sporen ook dit jaar weer mee te doen.

[Soultaker]

Het duurt nog een week voor de officiële site opent. Voor wie alvast een beetje in de sfeer wil komen, post ik hieronder alvast een puzzel om te oefenen. (Ik schat dit in als ongeveer een midden-in-de-maand probleem qua moeilijkheid.)

Dag -7: sterrenkijken.

De Kerstman heeft nog een paar dagen om uit te rusten voor het december is. Hij leunt achterover in z'n arrenslee en kijkt omhoog en ziet de hemel vol met sterren. Die sterrenhemel kan gemodelleerd worden als een 2D raster met sterren ('*') en lege ruimte ('.'). Voorbeeld:

.......
.*.*.*.
.......
.*.*...
.......

Om zich te vermaken probeert de Kerstman sterrenbeelden te identificeren. Een sterrenbeeld is een verbonden figuur die gevormd wordt door lijnen te trekken tussen de sterren. Die lijnen moeten horizontaal of verticaal lopen, mogen elkaar niet kruisen, en mogen geen sterren doorkruisen. Om het niet te moeilijk te maken, beperkt de Kerstman zich tot figuren met precies 3 sterren.

De voorbeeldinvoer hierboven bevat 6 sterrenbeelden met 3 sterren:

.......  .......  .......  .......  .......  .......
.o-o-o.  .*.o-o.  .o-o.*.  .*.o.*.  .o.*.*.  .o-o.*.
.......  ...|...  ...|...  ...|...  .|.....  .|.....
.*.*...  .*.o...  .*.o...  .o-o...  .o-o...  .o.*...
.......  .......  .......  .......  .......  .......

(Merk op dat je niet één lijn van linksboven naar rechtsboven kunt trekken omdat je dan een ster zou doorkruisen. Twee lijnstukken tussen de drie bovenste sterren mag wel.)

Op dezelfde manier kun je berekenen dat dit tweede voorbeeld precies 25 sterrenbeelden met 3 sterren bevat:

....................
...........*..*.....
........*........*..
....*.....*....*....
.......*...*........
..*.*....*..........
.......*..*.........
...........*......*.
..*.*............*..
....................

Deel 1

De officiële invoer staat hieronder. Hoeveel sterrenbeelden met 3 sterren bevat die?

........................................
......*..*......................*.......
.*........*..*...*....*.............*...
....*..*.*..*.*...*...................*.
.*...*..*.....................*.........
..........*.........*.......*.....*.....
.......*.....*...*.....*..*....*.*....*.
.*.................*.*...*.........*....
....*.......*...........*.*.*.....*.....
...........................*...*......*.
.....*.*..*.............*.*.....*.......
..*...*...............*.....*....*......
.*...*......*......*.*..........*.*.....
........*.*............*.........*......
................*....*...*...........*..
.*...*.*...*...........*.........*......
...*......*..........................*..
....*.*.....*......*..*.*...*.*.*...*...
.*............*.*.......................
.........*.*.......*..*.*.*.*........*..
..........*......*.............*.*..*...
.............*.....*..*.*...*.*.........
.*..............*................*....*.
..*.*...*............*........*.*.......
........................................

Het correcte antwoord eindigt op: ...16

Deel 2

(Voor het echte AoC-gevoel pas openen als je deel 1 opgelost hebt.)

spoiler:

Na een tijdje heeft de Kerstman alle sterrenbeelden met drie sterren gevonden, en gaat hij door met sterrenbeelden met meer dan drie sterren. Daarbij gelden dezelfde beperkingen als voorheen, en merk in het bijzonder op dat lijnen elkaar niet mogen kruisen.

Neem dezelfde invoer als bij deel 1. Hoeveel sterrenbeelden zijn er met minimaal 3 en maximaal 10 sterren?

De twee voorbeelden bevatten respectievelijk 19 en 572 van die sterrenbeelden.

Het correcte antwoord eindigt op: ...735

[Remcoder]

Soultaker schreef op zondag 24 november 2024 @ 11:52:
...

Elkaar niet kruisen, betekent dit dat deze sterren 0 sterrenbeelden bevatten?

code:

.....
.*...
*.*..
.*.*.
..*..

[Soultaker]

Remcoder schreef op dinsdag 26 november 2024 @ 11:43:
[...]

Elkaar niet kruisen, betekent dit dat deze sterren 0 sterrenbeelden bevatten?

code:

.....
.*...
*.*..
.*.*.
..*..

Het niet mogen kruisen van lijnen geldt voor elk sterrenbeeld individueel. Dus in jouw voorbeeld zijn er twee sterrenbeelden te vinden:

.....    .....
.o...    .*...
*|*..    o-o..
.o-o.    .*|*.
..*..    ..o..

Het deel over kruisen van lijnen wordt eigenlijk pas bij deel 2 relevant. (Ik twijfelfde of ik het nu wel of niet moest vermelden bij deel 1.)

Voorbeeld:    Dit mag:      Dit ook:      Dit niet!
..........    ..........    ..........    ..........
.....*....    .....o....    .....*....    .....o....
..........    .....|....    ..........    .....|....
.*......*.    .*...|..o.    .o------o.    .o---x--o.
..........    .....|..|.    ........|.    .....|..|.
.....*..*.    .....o--o.    .....o--o.    .....o--o.
..........    ..........    ..........    ..........

[ElkeBxl]

Soultaker schreef op zondag 24 november 2024 @ 11:52:
Het duurt nog een week voor de officiële site opent. Voor wie alvast een beetje in de sfeer wil komen, post ik hieronder alvast een puzzel om te oefenen. (Ik schat dit in als ongeveer een midden-in-de-maand probleem qua moeilijkheid.)

Bedankt om dit te posten! Ik heb er in de topicstart naar verwezen
Zelf ben ik er gisteren aan begonnen, vanavond verder doen. Ik merk wel dat ik heel roestig ben, het lukte niet om deftig te starten

[MrHaas]

Soultaker schreef op zondag 24 november 2024 @ 11:52:

Deel 2

(Voor het echte AoC-gevoel pas openen als je deel 1 opgelost hebt.)

spoiler:

Na een tijdje heeft de Kerstman alle sterrenbeelden met drie sterren gevonden, en gaat hij door met sterrenbeelden met meer dan drie sterren. Daarbij gelden dezelfde beperkingen als voorheen, en merk in het bijzonder op dat lijnen elkaar niet mogen kruisen.

Neem dezelfde invoer als bij deel 1. Hoeveel sterrenbeelden zijn er met minimaal 3 en maximaal 10 sterren?

De twee voorbeelden bevatten respectievelijk 19 en 572 van die sterrenbeelden.

Het correcte antwoord eindigt op: ...735

Hmm, ik kom bij het grotere voorbeeld op 559 en bij de echte input op 2302920. Ik denk dat er iets fout zit bij mn intersecties bepalen aangezien deel 1 wel klopte.

[Soultaker]

MrHaas schreef op woensdag 27 november 2024 @ 12:48:
Hmm, ik kom bij het grotere voorbeeld op 559 en bij de echte input op 2302920. Ik denk dat er iets fout zit bij mn intersecties bepalen aangezien deel 1 wel klopte.

Hopelijk zit het probleem in jouw code en niet in de mijne Kun je de gevonden sterrenbeelden printen? Bijvoorbeeld, in dit formaat: mijn oplossingen voor het eerste voorbeeld.

Als je jouw uitvoer voor het tweede voorbeeld op een vergelijkbare manier kunt formatteren, dan kan ik checken welke sterrenbeelden ik wel heb die jij niet hebt, en geef ik je een voorbeeld van een sterrenbeeld dat je mist.

[MrHaas]

Soultaker schreef op woensdag 27 november 2024 @ 20:39:
[...]

Hopelijk zit het probleem in jouw code en niet in de mijne Kun je de gevonden sterrenbeelden printen? Bijvoorbeeld, in dit formaat: mijn oplossingen voor het eerste voorbeeld.

Als je jouw uitvoer voor het tweede voorbeeld op een vergelijkbare manier kunt formatteren, dan kan ik checken welke sterrenbeelden ik wel heb die jij niet hebt, en geef ik je een voorbeeld van een sterrenbeeld dat je mist.

Output en mn oplossing: https://gist.github.com/a...4542cc14c20b47aea151f8cf9

[Soultaker]

MrHaas schreef op woensdag 27 november 2024 @ 21:25:
Output en mn oplossing: https://gist.github.com/a...4542cc14c20b47aea151f8cf9

Hier is een voorbeeld wat je mist:

....................
...........*..*.....
........*........*..
....o-----o----o....
....|..*..|*........
..o-o----o|.........
..|.|..*..o.........
..|.|......*......*.
..o-o------------o..
....................

Je code lijkt ook 99% correct, maar op het oog denk ik dat ik zie waar je de mist in gaat (spoiler! niet openen als je zelf wil debuggen):

spoiler:

het lijkt erop dat je je beperkt tot 9 lijnstukken, maar de probleemstelling vraagt om alle sterrenbeelden met maximaal 10 sterren.

[MrHaas]

Soultaker schreef op woensdag 27 november 2024 @ 21:39:

Je code lijkt ook 99% correct, maar op het oog denk ik dat ik zie waar je de mist in gaat (spoiler! niet openen als je zelf wil debuggen):

spoiler:

het lijkt erop dat je je beperkt tot 9 lijnstukken, maar de probleemstelling vraagt om alle sterrenbeelden met maximaal 10 sterren.

Ah, nice catch, verkeerd geinterpreteerd idd! Nu klopt ie wel:

spoiler:

2518735

M'n oplossing is wel sloom, doet er ~1m over.

[KabouterSuper]

Soultaker schreef op woensdag 27 november 2024 @ 21:39:
[...]

Hier is een voorbeeld wat je mist:

....................
...........*..*.....
........*........*..
....o-----o----o....
....|..*..|*........
..o-o----o|.........
..|.|..*..o.........
..|.|......*......*.
..o-o------------o..
....................

Ik was ook bezig met deel 2, maar ik vind deze wel tricky. Ik heb een ander antwoord en dat komt denk ik omdat ik bovenstaande uitsluit. Ik ga ervan uit dat alle sterren in een sterrenbeeld maar één keer gebruikt mogen worden. Ik vond dat niet heel onredelijk omdat je anders ook heen en weer tussen twee sterren zou mogen (de lijnen kruizen dan namelijk ook niet). Ik had trouwens wel aangenomen dat een lijnstuk tussen twee sterren minimaal lengte 1 moet hebben, anders kan je ook loops maken. Dat zou de kerstman nooit toelaten.

Anyway, ik ga mijn code maar eens aanpassen dat ik een ster meerdere keren mag bezoeken.

[Soultaker]

KabouterSuper schreef op donderdag 28 november 2024 @ 08:38:
Ik ga ervan uit dat alle sterren in een sterrenbeeld maar één keer gebruikt mogen worden.

Maar dat wordt in de probleemstelling niet gezegd, en volgens die interpretatie kom je voor het eerste voorbeeld (wat klein genoeg is om de oplossingen met de hand uit te schrijven) niet op 19 maar op 17 sterrenbeelden.

Ik had trouwens wel aangenomen dat een lijnstuk tussen twee sterren minimaal lengte 1 moet hebben, anders kan je ook loops maken.

Als je de sterren als punten ziet, dan heeft een lijnstuk tussen aangrenzende sterren ook lengte 1. Maar om verwarring te voorkomen heb ik er voor gezorgd dat er er geen sterren direct naast elkaar liggen.

---

Ik zou dit ook willen generaliseren als tips voor de echte Advent of Code problemen:

1. Lees de vraagstelling goed door. Als je je laat leiden door wat je denkt wat het probleem zou moeten zijn, in plaats van wat het probleem is, dan los je een ander probleem op dan gevraagd, en vind je niet het juiste antwoord. En als je eenmaal op het verkeerde spoor zit, kan het lastig zijn om je fout te vinden.
2. Gebruik de gegeven voorbeelden om je interpretatie te checken. De voorbeelden zijn onderdeel van de probleemstelling, en kunnen uitkomst bieden als meerdere interpretaties mogelijk zijn.
3. Check ook de officiële invoer. Bij andere programmeerwedstrijden is het gebruikelijk om je programma uitsluitend te baseren op de probleemstelling (omdat je meestal de invoer überhaupt niet te zien krijgt) maar bij Advent of Code is het vaak zo dat de officiële testinvoer minder complex is dan je op basis van de probleemstelling kan verwachten. Op z'n minst geeft de testinvoer je informatie over de grootte van het probleem, die meestal niet expliciet geformuleerd wordt. Als je bijvoorbeeld 25 regels invoer krijgt, kun je andere algoritmen overwegen dan bij 25000 regels.

Klinkt misschien vanzelfsprekend, maar dit zijn alledrie fouten die ik in het verleden gemaakt heb en die ik dit jaar ga proberen te vermijden.

[KabouterSuper]

Soultaker schreef op donderdag 28 november 2024 @ 11:02:
[...]

Maar dat wordt in de probleemstelling niet gezegd, en volgens die interpretatie kom je voor het eerste voorbeeld (wat klein genoeg is om de oplossingen met de hand uit te schrijven) niet op 19 maar op 17 sterrenbeelden.


[...]

Als je de sterren als punten ziet, dan heeft een lijnstuk tussen aangrenzende sterren ook lengte 1. Maar om verwarring te voorkomen heb ik er voor gezorgd dat er er geen sterren direct naast elkaar liggen.

---

Ik zou dit ook willen generaliseren als tips voor de echte Advent of Code problemen:

1. Lees de vraagstelling goed door. Als je je laat leiden door wat je denkt wat het probleem zou moeten zijn, in plaats van wat het probleem is, dan los je een ander probleem op dan gevraagd, en vind je niet het juiste antwoord. En als je eenmaal op het verkeerde spoor zit, kan het lastig zijn om je fout te vinden.
2. Gebruik de gegeven voorbeelden om je interpretatie te checken. De voorbeelden zijn onderdeel van de probleemstelling, en kunnen uitkomst bieden als meerdere interpretaties mogelijk zijn.
3. Check ook de officiële invoer. Bij andere programmeerwedstrijden is het gebruikelijk om je programma uitsluitend te baseren op de probleemstelling (omdat je meestal de invoer überhaupt niet te zien krijgt) maar bij Advent of Code is het vaak zo dat de officiële testinvoer minder complex is dan je op basis van de probleemstelling kan verwachten. Op z'n minst geeft de testinvoer je informatie over de grootte van het probleem, die meestal niet expliciet geformuleerd wordt. Als je bijvoorbeeld 25 regels invoer krijgt, kun je andere algoritmen overwegen dan bij 25000 regels.

Klinkt misschien vanzelfsprekend, maar dit zijn alledrie fouten die ik in het verleden gemaakt heb en die ik dit jaar ga proberen te vermijden.

Het is wel een valkuil van mij om de opgave net iets anders te interpreteren. Uitgangspunt bij mij was dat je een sterrenbeeld maakt door een pad van de ene ster naar de andere ster te maken. En dat geeft zoals je zegt niet de goede antwoorden (ook niet bij de testset zie ik achteraf). Je opgave is een mooie opwarmer voor de echte AoC....ik ben weer scherp.

[bakkerjangert]

Ik loop er tegen aan dat alles klopt, behalve het definitieve antwoord van deel 2 . Ik ben nu al even aan het debuggen maar kan niks vinden. Overigens hulde voor deze toffe opgave alhoewel deel 2 wel echt pittig is.

spoiler:

Ik kom op 2518407 ipv 2518735, net een paar honderd te laag dus.

Bijgevoegd de code in python. Als iemand ideeën heeft? Niet de snelste code, maar mijn motto is als het begrijpelijk is en werkt binnen enkele minuten is het prima.

[Soultaker]

bakkerjangert schreef op donderdag 28 november 2024 @ 15:12:
Overigens hulde voor deze toffe opgave alhoewel deel 2 wel echt pittig is.

Bedankt Misschien heb ik onderschat op hoeveel manieren je bij deel 2 er net naast kan zitten. Wellicht had ik nog een gedetailleerder voorbeeld moeten geven. (Altijd een beetje lastig dat je geen pre-formatted code of andere markup kunt gebruiken in spoiler-tags op dit forum, dat ontmoedigt het toevoegen van details achter een spoilertag.)

Bijgevoegd de code in python. Als iemand ideeën heeft? Niet de snelste code, maar mijn motto is als het begrijpelijk is en werkt binnen enkele minuten is het prima.

Ik denk dat ik het probleem zie:

spoiler:

Als je een sterrenbeeld met 10 sterren hebt, dan voeg je er nooit meer lijnstukken aan toe, terwijl dat wel mag, mits zo'n lijnstuk twee al bestaande sterren verbindt, zodat het totaal aantal sterren 10 blijft.

[bakkerjangert]

Soultaker schreef op donderdag 28 november 2024 @ 16:43:
[...]

Ik denk dat ik het probleem zie:

spoiler:

Als je een sterrenbeeld met 10 sterren hebt, dan voeg je er nooit meer lijnstukken aan toe, terwijl dat wel mag, mits zo'n lijnstuk twee al bestaande sterren verbindt, zodat het totaal aantal sterren 10 blijft.

Thanks, dat was is het inderdaad. Weer eens zon 'duhhh, waarom heb ik dat zelf niet gezien' momentje. Wel de kleinste bugfix ooit met toevoeging van 1 karakter .

[Barin]

Ben benieuwd of het me lukt mee te doen dit jaar en met welke taal dan, maar dit volgen maakt me wel weer enthousiast hoor. Kudos voor de puzzel @Soultaker !

Inhoudelijk kan ik het niet laten een lans te breken voor de andere oplossingen. "verbonden figuur" is geen vastomlijnde definitie en "gevormd door lijnen" en met "precies 3 sterren" laat in het midden of de focus op de lijnen of de verbonden sterren ligt.

Daarmee trouwens nog meer waardering voor de betatesters bij AoC; waar ik dit soort ambiguïteiten nog niet of nauwelijks heb gezien.

[Soultaker]

Barin schreef op vrijdag 29 november 2024 @ 07:22:
Inhoudelijk kan ik het niet laten een lans te breken voor de andere oplossingen. "verbonden figuur" is geen vastomlijnde definitie en "gevormd door lijnen" en met "precies 3 sterren" laat in het midden of de focus op de lijnen of de verbonden sterren ligt.

Fair. Ter verdediging moet ik zeggen dat ik het ook maar in een zondagochtend opgesteld heb, en helaas geen team van beta-testers tot m'n beschikking heb. Als een vrijwilliger zich aanmeldt voor het beta-testen hou ik me aanbevolen.

Overigens was het foutje dat bakkerjangert in z'n code had zitten niet het gevolg van het verkeerd interpreteren van het probleem. Of een sterrenbeeld wel of niet gevonden werd, was afhankelijk van de volgorde waarin lijnstukken toegevoegd werden, wat duidelijk niet de bedoeling was. Hij had het probleem dus wel goed begrepen, maar helaas deed z'n code net wat anders.

Dat soort fouten maken mensen bij de wat moeilijkere onderdelen van de officiële puzzels ook regelmatig. Ik kan je praktisch garanderen dat dat komende maand weer gaat gebeuren.

[ Voor 19% gewijzigd door Soultaker op 29-11-2024 10:59 ]

[CMG]

Ik weet niet of het gaat lukken om dit jaar weer te streamen, maar ik heb wel alvast wat voorpret gehad 😅

Ik heb een aantal jaar geleden iets gemaakt om

1) Chrome cookies file te kunnen kopieren terwijl de browser nog loopt dmv NTFS Shadow Volume Copy
2) De secure cookies uit de SQLite database the halen en te decrypten zodat ik mijn tooling kan gebruiken om automatisch de inputs beschikbaar te hebben.

Dus, ik dacht vorige week: laat ik even checken of mijn sessie nog werkt; niet dus. Even opnieuw inloggen, programma draaien, en...BOOM! Werkt niet.

Blijkt dat ze het encryptie schema een stuk moeilijker gemaakt hebben.

Ik heb een korte video gemaakt om het te beschrijven en te laten zien hoe ik het weer werkend gemaakt heb 😊

[Eupeodes]

Ik heb uit edge de cookie met de hand gekopieerd, en daarmee kan ik de inputs gewoon ophalen

[Barin]

Soultaker schreef op vrijdag 29 november 2024 @ 10:59:
[...]


Fair. Ter verdediging moet ik zeggen dat ik het ook maar in een zondagochtend opgesteld heb, en helaas geen team van beta-testers tot m'n beschikking heb. Als een vrijwilliger zich aanmeldt voor het beta-testen hou ik me aanbevolen.

Helaas, de tijd vinden voor AoC zelf wordt al lastig genoeg dit jaar. Anders had ik je graag geholpen met mijn favoriete hobby: nitpicking. Verwacht je nog meer eigen puzzels te maken? Naast de extra grote input van andere jaren?

[Soultaker]

CMG schreef op vrijdag 29 november 2024 @ 16:25:
Ik heb een aantal jaar geleden iets gemaakt om

1) Chrome cookies file te kunnen kopieren terwijl de browser nog loopt dmv NTFS Shadow Volume Copy
2) De secure cookies uit de SQLite database the halen en te decrypten zodat ik mijn tooling kan gebruiken om automatisch de inputs beschikbaar te hebben.

Mooi staaltje overengineering Ik denk dat ik in plaats daarvan een Chrome extension geschreven zou hebben, dan kun je ofwel de session cookie uit de request headers halen (tenzij secure cookies ook voor extensions verborgen worden?) of anders gewoon de invoer direct downloaden. Dat vereist nog wel dat je de opgave in de browser opent, maar dat doe ik normalerwijze toch wel.

Eupeodes schreef op vrijdag 29 november 2024 @ 17:18:
Ik heb uit edge de cookie met de hand gekopieerd, en daarmee kan ik de inputs gewoon ophalen

Dit werkt ook inderdaad, maar in het filmpje zegt CMG dat 'ie het expres wilde automatiseren.

---

Barin schreef op vrijdag 29 november 2024 @ 23:54:
Verwacht je nog meer eigen puzzels te maken? Naast de extra grote input van andere jaren?

Hmm, weet ik nog niet. Het liefste post ik ze niet in December want dan zijn mensen vooral met de AoC zelf bezig. Maar misschien dat ik er vandaag nog eentje post, ik heb wel een ideetje namelijk maar ik moet 'm nog even uitwerken.

[Soultaker]

Okee nog één probleem voor de echte AoC van start gaat. Hopelijk iets makkelijker dan het probleem dat ik eerder postte, en redelijk in de trant van het soort problemen dat je bij de AoC ook voorgeschoteld krijgt.

Dag -1: vierkantsencryptie

De kerstman heeft een gedicht geschreven. Om te voorkomen dat de tekst voortijdig uitlekt heeft hij het versleuteld met een zelfverzonnen encryptie-algoritme.

Dat werkt als volgt. Eerst plaatst hij de karakters in een vierkant rooster met even zijdenlengte. Dan roteert hij de letters met de klok mee. Hoe dat werkt, leg ik uit aan de hand van een voorbeeld.

Stel je hebt een rooster van 6x6, zoals hieronder:

abcdef
tABCDg
sL12Eh
rK43Fi
qJIHGj
ponmlk

Dit kun je zien als drie concentrische vierkanten:

abcdef    ......    ......
t....g    .ABCD.    ......
s....h    .L..E.    ..12..
r....i    .K..F.    ..43..
q....j    .JIHG.    ......
ponmlk    ......    ......

Bij een codeerstap verschuift de Kerstman alle letters binnen een vierkant met de klok mee. Voorbeeld:

a--b--c--d--e--f        t--a--b--c--d--e
|              |        |              |
t  A--B--C--D  g        s  L--A--B--C  f
|  |        |  |        |  |        |  |
s  L  1--2  E  h        r  K  4--1  D  g
|  |  |  |  |  |   =>   |  |  |  |  |  |
r  K  4--3  F  i        q  J  3--2  E  h
|  |        |  |        |  |        |  |
q  J--I--H--G  j        p  I--H--G--F  i
|              |        |              |
p--o--n--m--l--k        o--n--m--l--k--j

Nu is dit op zichzelf niet zo effectief. Om de encryptie-graad op te schroeven, voert de Kerstman de codeerstap meerdere keren achter elkaar uit. Bijvoorbeeld in 5 stappen:

Invoer:   Na 1 stap:    2:        3:        4:        5:

abcdef    tabcde    stabcd    rstabc    qrstab    pqrsta
tABCDg    sLABCf    rKLABe    qJKLAd    pIJKLc    oHIJKb
sL12Eh    rK41Dg    qJ34Cf    pI23Be    oH12Ad    nG41Lc
rK43Fi    qJ32Eh    pI21Dg    oH14Cf    nG43Be    mF32Ad
qJIHGj    pIHGFi    oHGFEh    nGFEDg    mFEDCf    lEDCBe
ponmlk    onmlkj    nmlkji    mlkjih    lkjihg    kjihgf

Het gecodeerde grid na 5 stappen is dus:

pqrsta
oHIJKb
nG41Lc
mF32Ad
lEDCBe
kjihgf

Om het te decoderen, kun je de stappen in omgekeerde volgorde uitvoeren, waarbij je natuurlijk moet weten welk aantal codeerstappen gebruikt was.

Deel 1

De gecodeerde tekst staat hieronder, maar de Kerstman heeft moeite om 'm te decoderen. Kun jij 'm helpen? Om te beginnen decodeer je 1000 stappen. Als je het goed gedaan hebt, dan zijn de letters op de diagonaal van linksboven naar rechtsonder:

spoiler:

jsuit_m__bsh_po"coeiditwohwel_r!_Pnhthulaa_wfdtrdd

_,lla_ot_samtsirhyiij,H_i_oehiadhiidtr_nopabsh!edk
arist_hnegy_neheO:_.ytnt_anu;W;aohe_house/Not_a_cl
nsag_hao_dotraeh_I_tuB.eltsiht_a_fo_nwod_eht_ekirh
dgtag_maet_sih_ot_,hgielsnkdsa_l_odtww_d_oanc_,lei
_eivmshes__e_lerifr_tA_gnarps_eH;esor_eh_yenmih_at
t_deanAfo/fyunlii_omshb___a_seapCwwedny__fts_howto
owa_ndca_e.t_asSc_de!sthltw_chikrti_eaia,__iecoeur
_jaai___a_long_winter'str_y____mnzlee_u_ad_w__alre
ats__lyratenmhreyeatlveefapnsmrieochcd_,is__vetfej
lh!wuamoled_d_my_bed_to_see_what_was_the_tndih,__s
ledhwy_fciao.nldtse_at!sliciitow_I_flew_m_nestNlw;
_Ahitin__p,j_l___kk_noHde_.e,wsh_hedkndlag_ni_elae
ae_sonisatie_appear,But_a_miniature_slhitnuropoasc
_v_t!g_n_ail-a_dah_eH;htaereh__o_,_Dhrrktihunua__m
gs_lV_Iihtsl,__mrlantAt_lngeirahrtn_nseeehets_tist
o_keyh_ac_sy_bes_courselra_"_psenhN_N_w__tl__,_rtT
oif,midruda.drhihouted,_and_caP_f!utsd_ago_nodrniw
dmeA.snbselHeo_hs_etcy._rw__llordn_imcu_enlefoh_ra
__tn__a__lfeoat__ede_lhoh_nmtneo_ut_l_pfb__h_ngers
neaddf_rer__ednsdlniHirhsra_tr_ss_e,_e_ledmts_oei_
ix__oi,usSewh_eenoosy_,;_nrn__!kihie__tahat_uatont
gcoaenfoorlaifmlnrD_ass_Io_l___eHioknehs_ho;g_nlgh
hlxwwge_rtfs_aogC__ewethe_skcste!_aoroehi_hsagir,e
tana,eidau,_rcmarw,yaderd/otaeohy__m,i_,aI_gr,ha__
!i,yarhe_dAc_e_eaone__teo-w-nh_crffst_sTa_on-_ehnn
”mN_,_clefnhopa_hnoshafwTh/_ett_reo_Iaaomwtipp,_oi
-,it_artr_du___nn__-sl_e-iW__ohse__eddsrho_kldIatg
-_en_setes_b,tnah!!-alchimnefleihwphehhe_ntcuons_h
-edhrikohlIbeeiahrd-dyipAhyylc_Helmte_.__khoml__et
-rswid'otl_yte__heihiofso_ees_t!t_u_rlWo__gtsfhhv_
-eyeee_i_al_dlw_fcpwiS_adtSWapoy_dtd,yhpaois_uoteb
-___h_rnniaah,eonnh!r_yl_Atdh;rr_rsnW_eoata_d_p_ne
-h,ntoesw_unecnwsaD_,woucyuteoe._a_Ailnio_rea_ei_f
-eai_fh_aegdeak_domcbow,And_the_bee,th_vaethnhsaao
-_e_n__qloh_t__utctowano____snow;Thhhiw_wmstcn_,hr
hdeiihnr_dept,h_!,pado_i_oowAswaaeet_nhhk___entsee
_rhh_iiiesdlwethshdnesud_dlo_elttil_aeatmetldihtd_
eotlgs__he_uy/That_shook_when_he_laughtr_vnl_aa_aC
hviwu_amtlwe_cpiel__fo,nig_yl_Be_ttiet_l_aeai_tfdh
gewwnnmo_fhen_I_saw_mdaies_ittrl_dnht_ewrgw_n___Wr
___esom!n;A_wink_of_his_eye_and_a_twihp,n__d_gS_si
koyd_satmnd_ruasDef_hcu_aton_se___heb_lyontethtn_s
;ueelemaodeiruselepe_k_lomoe_not_a_word,_bulhI."ht
stn_l,e_rwaey__h,o_y_tcnhlaoihpsutnidl__Skile__hem
p_meaisdo__k_dhnholsiawiwlo__Nn_batonwhArnprieNMia
tois_deltsen_erew_nerdlihc_eld_u_eseinr_o_owrbi_vs
bfhgnosihwTi_e_l_n_aIpHhbt_eb_dluow_noos_salohc_i,
l_c_eht_yb_gnuh_erew_sgnikcots_ehT;esurThAs_ntegA_
_sight---“Happy_Cdh__ardish_ts_ss,__ewtol_thtd_eaw
t___hwaiufito__atnmncegrutph_dsr___hguorht_lla_neh

Deel 2

Voor het echte AoC-gevoel pas openen als je deel 1 opgelost hebt.

spoiler:

Plots herinnert de Kerstman zich dat hij de tekst niet met 1000 stappen, maar met 1.000.000.000.000 (10¹²) stappen gecodeerd had! Vind de oorspronkelijke tekst. Als je het goed gedaan hebt, zie je dat meteen.

[ Voor 1% gewijzigd door .oisyn op 04-12-2024 12:44 ]

[KabouterSuper]

Soultaker schreef op zaterdag 30 november 2024 @ 15:12:
Okee nog één probleem voor de echte AoC van start gaat. Hopelijk iets makkelijker dan het probleem dat ik eerder postte, en redelijk in de trant van het soort problemen dat je bij de AoC ook voorgeschoteld krijgt.

Dag -1: vierkantsencryptie

De kerstman heeft een gedicht geschreven. Om te voorkomen dat de tekst voortijdig uitlekt heeft hij het versleuteld met een zelfverzonnen encryptie-algoritme.

Dat werkt als volgt. Eerst plaatst hij de karakters in een vierkant rooster met even zijdenlengte. Dan roteert hij de letters met de klok mee. Hoe dat werkt, leg ik uit aan de hand van een voorbeeld.

Stel je hebt een rooster van 6x6, zoals hieronder:

abcdef
tABCDg
sL12Eh
rK43Fi
qJIHGj
ponmlk

Dit kun je zien als drie concentrische vierkanten:

abcdef    ......    ......
t....g    .ABCD.    ......
s....h    .L..E.    ..12..
r....i    .K..F.    ..43..
q....j    .JIHG.    ......
ponmlk    ......    ......

Bij een codeerstap verschuift de Kerstman alle letters binnen een vierkant met de klok mee. Voorbeeld:

a--b--c--d--e--f        t--a--b--c--d--e
|              |        |              |
t  A--B--C--D  g        s  L--A--B--C  f
|  |        |  |        |  |        |  |
s  L  1--2  E  h        r  K  4--1  D  g
|  |  |  |  |  |   =>   |  |  |  |  |  |
r  K  4--3  F  i        q  J  3--2  E  h
|  |        |  |        |  |        |  |
q  J--I--H--G  j        p  I--H--G--F  i
|              |        |              |
p--o--n--m--l--k        o--n--m--l--k--j

Nu is dit op zichzelf niet zo effectief. Om de encryptie-graad op te schroeven, voert de Kerstman de codeerstap meerdere keren achter elkaar uit. Bijvoorbeeld in 5 stappen:

Invoer:   Na 1 stap:    2:        3:        4:        5:

abcdef    tabcde    stabcd    rstabc    qrstab    pqrsta
tABCDg    sLABCf    rKLABe    qJKLAd    pIJKLc    oHIJKb
sL12Eh    rK41Dg    qJ34Cf    pI23Be    oH12Ad    nG41Lc
rK43Fi    qJ32Eh    pI21Dg    oH14Cf    nG43Be    mF32Ad
qJIHGj    pIHGFi    oHGFEh    nGFEDg    mFEDCf    lEDCBe
ponmlk    onmlkj    nmlkji    mlkjih    lkjihg    kjihgf

Het gecodeerde grid na 5 stappen is dus:

pqrsta
oHIJKb
nG41Lc
mF32Ad
lEDCBe
kjihgf

Om het te decoderen, kun je de stappen in omgekeerde volgorde uitvoeren, waarbij je natuurlijk moet weten welk aantal codeerstappen gebruikt was.

Deel 1

De gecodeerde tekst staat hieronder, maar de Kerstman heeft moeite om 'm te decoderen. Kun jij 'm helpen? Om te beginnen decodeer je 1000 stappen. Als je het goed gedaan hebt, dan zijn de letters op de diagonaal van linksboven naar rechtsonder:

spoiler:

ntuueworned__;airo_!dytwohwe__hi___a_hh,gt_r___rnl

_,lla_ot_samtsirhyiij,H_i_oehiadhiidtr_nopabsh!edk
arist_hnegy_neheO:_.ytnt_anu;W;aohe_house/Not_a_cl
nsag_hao_dotraeh_I_tuB.eltsiht_a_fo_nwod_eht_ekirh
dgtag_maet_sih_ot_,hgielsnkdsa_l_odtww_d_oanc_,lei
_eivmshes__e_lerifr_tA_gnarps_eH;esor_eh_yenmih_at
t_deanAfo/fyunlii_omshb___a_seapCwwedny__fts_howto
owa_ndca_e.t_asSc_de!sthltw_chikrti_eaia,__iecoeur
_jaai___a_long_winter'str_y____mnzlee_u_ad_w__alre
ats__lyratenmhreyeatlveefapnsmrieochcd_,is__vetfej
lh!wuamoled_d_my_bed_to_see_what_was_the_tndih,__s
ledhwy_fciao.nldtse_at!sliciitow_I_flew_m_nestNlw;
_Ahitin__p,j_l___kk_noHde_.e,wsh_hedkndlag_ni_elae
ae_sonisatie_appear,But_a_miniature_slhitnuropoasc
_v_t!g_n_ail-a_dah_eH;htaereh__o_,_Dhrrktihunua__m
gs_lV_Iihtsl,__mrlantAt_lngeirahrtn_nseeehets_tist
o_keyh_ac_sy_bes_courselra_"_psenhN_N_w__tl__,_rtT
oif,midruda.drhihouted,_and_caP_f!utsd_ago_nodrniw
dmeA.snbselHeo_hs_etcy._rw__llordn_imcu_enlefoh_ra
__tn__a__lfeoat__ede_lhoh_nmtneo_ut_l_pfb__h_ngers
neaddf_rer__ednsdlniHirhsra_tr_ss_e,_e_ledmts_oei_
ix__oi,usSewh_eenoosy_,;_nrn__!kihie__tahat_uatont
gcoaenfoorlaifmlnrD_ass_Io_l___eHioknehs_ho;g_nlgh
hlxwwge_rtfs_aogC__ewethe_skcste!_aoroehi_hsagir,e
tana,eidau,_rcmarw,yaderd/otaeohy__m,i_,aI_gr,ha__
!i,yarhe_dAc_e_eaone__teo-w-nh_crffst_sTa_on-_ehnn
”mN_,_clefnhopa_hnoshafwTh/_ett_reo_Iaaomwtipp,_oi
-,it_artr_du___nn__-sl_e-iW__ohse__eddsrho_kldIatg
-_en_setes_b,tnah!!-alchimnefleihwphehhe_ntcuons_h
-edhrikohlIbeeiahrd-dyipAhyylc_Helmte_.__khoml__et
-rswid'otl_yte__heihiofso_ees_t!t_u_rlWo__gtsfhhv_
-eyeee_i_al_dlw_fcpwiS_adtSWapoy_dtd,yhpaois_uoteb
-___h_rnniaah,eonnh!r_yl_Atdh;rr_rsnW_eoata_d_p_ne
-h,ntoesw_unecnwsaD_,woucyuteoe._a_Ailnio_rea_ei_f
-eai_fh_aegdeak_domcbow,And_the_bee,th_vaethnhsaao
-_e_n__qloh_t__utctowano____snow;Thhhiw_wmstcn_,hr
hdeiihnr_dept,h_!,pado_i_oowAswaaeet_nhhk___entsee
_rhh_iiiesdlwethshdnesud_dlo_elttil_aeatmetldihtd_
eotlgs__he_uy/That_shook_when_he_laughtr_vnl_aa_aC
hviwu_amtlwe_cpiel__fo,nig_yl_Be_ttiet_l_aeai_tfdh
gewwnnmo_fhen_I_saw_mdaies_ittrl_dnht_ewrgw_n___Wr
___esom!n;A_wink_of_his_eye_and_a_twihp,n__d_gS_si
koyd_satmnd_ruasDef_hcu_aton_se___heb_lyontethtn_s
;ueelemaodeiruselepe_k_lomoe_not_a_word,_bulhI."ht
stn_l,e_rwaey__h,o_y_tcnhlaoihpsutnidl__Skile__hem
p_meaisdo__k_dhnholsiawiwlo__Nn_batonwhArnprieNMia
tois_deltsen_erew_nerdlihc_eld_u_eseinr_o_owrbi_vs
bfhgnosihwTi_e_l_n_aIpHhbt_eb_dluow_noos_salohc_i,
l_c_eht_yb_gnuh_erew_sgnikcots_ehT;esurThAs_ntegA_
_sight---“Happy_Cdh__ardish_ts_ss,__ewtol_thtd_eaw
t___hwaiufito__atnmncegrutph_dsr___hguorht_lla_neh

Deel 2

Voor het echte AoC-gevoel pas openen als je deel 1 opgelost hebt.

spoiler:

Plots herinnert de Kerstman zich dat hij de tekst niet met 1000 stappen, maar met 1.000.000.000.000 (10¹²) stappen gecodeerd had! Vind de oorspronkelijke tekst. Als je het goed gedaan hebt, zie je dat meteen.

Mooie opgave en geheel in de AoC stijl (deel 1 kan je nog brute force doen, maar voor deel 2 moet je toch echt iets slims verzinnen).

Het doet me een beetje denken aan de cryptobox challenge, hoewel die een heel stuk lastiger is.

[Bolukan]

His_eyes---how_they_twinkled!

[Soultaker]

Het is (bijna) een week geleden dat ik de puzzel Sterrenkijken postte, en minder dan 1 dag voor het begin van Advent of Code, dus dit lijkt me een goed moment om mijn referentie-oplossingen te publiceren, aangezien ik denk dat iedereen die van plan was het probleem op te lossen dat ondertussen wel gedaan heeft.

Voor deel 1:

spoiler:

Elk sterrenbeeld met 3 sterren heeft 1 centrale ster in het midden. De andere twee sterren moeten direct links, rechts, boven of onder van de centrale ster liggen. Dat geeft precies zes mogelijke configuraties. Je kunt dus voor elke ster kijken welke sterren er omheen liggen.

Voor deel 2:

spoiler:

Het cruciale inzicht voor het oplossen van het probleem met een willekeurig aantal sterren is dat een sterrenbeeld met E+1 lijnstukken kan gevormd worden door aan een sterrenbeeld met E lijnstukken 1 lijnstuk toe te voegen. Je kunt dus beginnen met ale horizontale/verticale lijnstukken (sterrenbeelden met 2 sterren) en aan elk daarvan 1 lijnstuk toevoegen. Dit herhaal je tot je geen nieuwe sterrenbeelden met max. 10 sterren kunt vinden. Je moet daarbij voorkomen dat je dubbele sterrenbeelden vindt.

Oplossingen in Python kun je hier vinden: https://gist.github.com/m...a62baafd1519e2ef43e5d9e3a

Kudos voor de mensen die zelf de oplossing gevonden hebben (waaronder in ieder geval @MrHaas en @bakkerjangert, en misschien @KabouterSuper en @ElkeBxl). Ik hoop dat jullie er plezier aan beleefd hebben, of dat het op z'n minst een goede voorbereiding was voor de echte competitie die morgen begint.

[jeroenheijmans]

Aloha folks! Zoals elk jaar heb ik weer een officieuze Advent of Code Survey gemaakt. Komen meestal zo'n 2000 tot 3000 reacties op binnen om wat stats te zien van welke talen enzo men gebruikt.

Voor wie zin en tijd heeft, je kunt 'm invullen (1x maar, svp - het is anoniem) op https://forms.gle/iX1mkrt17c6ZxS4t7

Op de subreddit is ook een post te vinden waar je feedback kunt achterlaten, of voorspellingen voor de uitkomsten: https://www.reddit.com/r/..._2024_participant_survey/

Veel plezier met de puzzels en 't verhaal van dit jaar allemaal!

[Thorwing]

relatief simpele start vandaag:

Kotlin:

class Day1 : Challenge(){
    private val parsed = input.lines()
        .map(String::extractInts)
        .unzip()
    private val left = parsed[0].sorted()
    private val right = parsed[1].sorted()

    override fun part1() = left.zip(right, Int::minus).sumOf(::abs)

    override fun part2() = with(right.groupingBy { it }.eachCount()){
       left.sumOf { it * getOrDefault(it, 0) }
    }
}

[ElkeBxl]

Eenvoudige vandaag, oplossing in TypeScript

[TrailBlazer]

Ik moet echt nodig iets generieks gaan maken voor het inlezen van de data. Anyway mijn oplossing in
Python.

[Eupeodes]

Een scriptje om de input binnen te halen is inderdaad erg makkelijk, mijn script maakt ook meteen een basisfile om de oplossing in te maken. En hoewel ik tegenwoordig vooral python gebruik voor mijn werk doe ik dit dus nog altijd in php omdat ik mijn scripts een aantal jaar terug in php ben gestart. Dus hier staat mijn oplossing in php.

[ Voor 17% gewijzigd door Eupeodes op 01-12-2024 08:05 ]

[Arnout]

Omdat Python best wel krachtige list operaties heeft, doe ik het in Python. Vanochtend half uur voor 1a en b, incl het "er weer inkomen" 😄

[ Voor 3% gewijzigd door Arnout op 01-12-2024 08:48 ]

[mbe81]

Ik begin elk jaar eigenlijk opnieuw en neem niets mee van het jaar daarvoor. Als ik daar naar terug kijk ben ik vaak niet meer tevreden over mijn aanpak ;-)

Mijn oplossing voor vandaag in Go:

https://github.com/mbe81/.../main/days/day01/day01.go

Moest het voor de eerste puzzel wel twee keer proberen. Mijn eerste resultaat had een negatieve waarde omdat ik ook negatieve afstanden berekende en deze optelde bij het resultaat.

[Arnout]

mbe81 schreef op zondag 1 december 2024 @ 08:50:
Moest het voor de eerste puzzel wel twee keer proberen. Mijn eerste resultaat had een negatieve waarde omdat ik ook negatieve afstanden berekende en deze optelde bij het resultaat.

Abs() is een graag geziene gast bij AdventOfCode puzzels 😄
Wat ik, door schade en schande wijs geworden 😄, nu ook eerst doe is de test input draaien voordat ik ook maar één submit doe. 🤓

[ Voor 22% gewijzigd door Arnout op 01-12-2024 08:56 ]

[mbe81]

Arnout schreef op zondag 1 december 2024 @ 08:54:
[...]

Abs() is een graag geziene gast bij AdventOfCode puzzels 😄
Wat ik, door schade en schande wijs geworden 😄, nu ook eerst doe is de test input eerst draaien voordat ik ook maar één submit doe. 🤓

Haha, de test input gaf wel het juiste resultaat. Hier zat deze negatieve waarde niet in.

[TrailBlazer]

@mbe1 en @Arnout graag dit soort dingen in een spoiler tag zetten.

[Corniel]

Nou dan ook mijn C# based oplossing dan maar: 2024-01.

Ik heb in de loop van de jaren heel wat plumbing code geschreven. Mijn code runt binnen .NET's unit test framework.

[ Voor 5% gewijzigd door Corniel op 01-12-2024 12:46 . Reden: formatting link ]

[mbe81]

TrailBlazer schreef op zondag 1 december 2024 @ 09:25:
@mbe1 en @Arnout graag dit soort dingen in een spoiler tag zetten.

Heb ik overwogen, maar een aantal posts eerder (06:40) staat in dat geval al de complete oplossing in beeld. Daarom vond ik het in dit geval niet nodig.

[Hagdos]

Arnout schreef op zondag 1 december 2024 @ 08:54:

Wat ik, door schade en schande wijs geworden 😄, nu ook eerst doe is de test input draaien voordat ik ook maar één submit doe. 🤓

Ik geef mezelf één kans om het in 1x goed te doen. Als de eerste poging fout is ga ik de test-input draaien. Dag 1 kwam ik gelukkig foutloos door dit jaar. We gaan zien hoe lang dat duurt

[Hagdos]

mbe81 schreef op zondag 1 december 2024 @ 09:37:
[...]


Heb ik overwogen, maar een aantal posts eerder (06:40) staat in dat geval al de complete oplossing in beeld. Daarom vond ik het in dit geval niet nodig.

Een stuk code skip ik makkelijk. "Gewone" tekst is moeilijker te zien of er spoilers in zitten, een enkel woord kan dan ook al genoeg zijn. Een stuk code moet je toch beter lezen voordat het een spoiler is.

Bovendien, dat iemand anders ook spoiler tags had moeten gebruiken is geen reden om het zelf niet te doen.

[Thorwing]

Hoe combineer je code tag en spoiler tag of was ik te blond vanochtend?

[TrailBlazer]

Ik denk dat de meeste de code op git gooien oid

[Soultaker]

Dit is het dichtste wat ik bij spoiler-code kan komen. (Oplossing voor dag 1 in Python, selecteren om te lezen.)

---8<--- werkt niet blijkbaar! ---8<---

Maar liever zie ik dat mensen gewoon links plaatsen naar Pastebin of Github (e.g. Gist), zeker als het meer dan een paar regels code is, zodat je het als lezer makkelijk kunt overslaan als het je niet interesseert.

[ Voor 22% gewijzigd door Soultaker op 01-12-2024 12:10 ]

[ElkeBxl]

In darkmode is die code gewoon te lezen @Soultaker

[Soultaker]

ElkeBxl schreef op zondag 1 december 2024 @ 11:43:
In darkmode is die code gewoon te lezen @Soultaker

Oh. Dan weet ik het ook niet. Liefst externe links dan maar Dan nemen die code blokken ook niet zoveel ruimte in in het topic.

[FCA]

Ik doe ook weer mee dit jaar. Had na vorig jaar eigenlijk besloten (dag 24 ) om niet meer "competitief" te doen, maar toch vanochtend om 10 voor 6 opgestaan en snel een oplossing geklopt.

Eens kijken wanneeer de klad erin komt, maar tot nu bovenaan bij mijn werk private leaderboard.
Wel een andere taal dan voorgaande jaren, afgelopen jaren altijd in Python, maar nu eens in Rust begonnen.

[Corniel]

Ik bedacht me dat het wellicht wel aardig was om een (een deel) van wat mijn plumbing doet ook te laten zien:

C#:

namespace Advent_of_Code_2024;

[Category(Category.Computation)] // categoriseert verschillende dagen op type puzzels. 
public class Day_01
{
    // Gebruikt de gespecificeerde string als input voor de puzzel en test het antwoord.
    [Example(answer: 11, "3 4;4 3;2 5;1 3;3 9;3 3")]
    // Test het antwoord op basis van de input als file (naming convention namespace + class name
    [Puzzle(answer: 1873376)]
    // Het Ints type zorgt er voor dat de input wordt gepartst to een read-only list van int32's. 
    public int part_one(Ints numbers) 
    {
       // return answer
    }

    // Voor grotere examples (grid puzzels bijvoorbeeld) is het ook mogelijk een test file in te lezen (ook weer naming convention based)
    [Example(answer: 31, Example._1)]
    [Puzzle(answer: 18997088)]
    // Lines geeft de input als een collection van strings (new line seperated)
    public int part_two(Lines lines)
    {
       // return answer
    }
}

Het grote voordeel aan mijn aanpak vind ik dat zonder extra gedoe zowel voorbeelden als de daadwerkelijke door de zelfde logica kan laten draaien, en middels een Expected Value automatisch kan laten testen. In mijn geval haken de attributen op NUnit it, maar met XUnit zou ongeveer hetzelfde hebben gekund.

[Bolukan]

Geinspireerd ook wat gemaakt om het binnenhalen van de input te automatiseren:

code:

import requests
import datetime

def fetch_input(day):
    url = f'https://adventofcode.com/2024/day/{day}/input'
    cookies = {
        'session': 'plak hier je session cookie'
    }
    response = requests.get(url, cookies=cookies)
    
    if response.status_code == 200:
        filename = f'input{day:02}.txt'
        with open(filename, 'w') as f:
            f.write(response.text)
        print(f"Input for day {day} saved to {filename}")
    else:
        print(f"Failed to retrieve input for day {day}. Status code: {response.status_code}")

today = datetime.date.today()
fetch_input(today.day)

[Soultaker]

Voor wie z'n oplossing wil testen of verbeteren, hier is een extra grote invoer voor dag 1: aoc-2024-day-1-challenge-1.zip

Correcte oplossingen eindigen op ...616 en ...238 respectievelijk voor deel 1 en 2 .

[TrailBlazer]

omdat vandaag zo eenvoudig was heb ik ook maar wat gedaan om de input te downloaden

code:

import os
import requests
import sys
from requests.exceptions import HTTPError
from requests.utils import cookiejar_from_dict
def get_session_id():
  session_id = os.environ.get("SESSION_ID",None)
  if not session_id:
    print("SESSION_ID not in environ")
    exit(1)
  return session_id

def get_input(day,session_id=get_session_id()):
  session  = requests.session()
  cookies = {"session":  session_id}
  cookies = cookiejar_from_dict(cookies)
  session.cookies.update(cookies)
  input_data = session.get(f"https://adventofcode.com/2024/day/{day}/input")
  try:
    input_data.raise_for_status()
  except HTTPError as e:
    print(e)
    exit(1)

  with open(f"day{sys.argv[1]}.input", "w") as f:
    f.write(input_data.text)


if __name__ == "__main__":
  if os.path.isfile(f"day{sys.argv[1]}.input"):
    print(f"day{sys.argv[1]}.input exist exiting")
    exit(1)

[MueR]

Soultaker schreef op zondag 1 december 2024 @ 15:09:
Voor wie z'n oplossing wil testen of verbeteren, hier is een extra grote invoer voor dag 1: aoc-2024-day-1-challenge-1.zip

Correcte oplossingen eindigen op ...616 en ...238 respectievelijk voor deel 1 en 2 .

Part 1 output: ...616 (909.199µs)
Part 2 output: ...238 (12.414609ms)

I'll allow it. Lekker simpele oplossing

[ Voor 9% gewijzigd door MueR op 01-12-2024 15:22 ]

[Soultaker]

MueR schreef op zondag 1 december 2024 @ 15:17:
[...]

Part 1 output: ...616 (909.199µs)
Part 2 output: ...238 (12.414609ms)

I'll allow it. Lekker simpele oplossing

Nette oplossing, maar de timings erken ik niet, want je hebt zowel het sorteren (voor deel 1) als het populeren van de occurrences map (voor deel 2) in je input-functie weggemoffeld, terwijl dat natuurlijk onderdeel van het oplossen is.

[Bolukan]

4 seconde nodig om je big input file te lezen (+number parsing), en dan nog 0,45 seconde voor deel 1 en 0,3 seconde voor deel 2. Voor de normale input is 0,02 seconde nodig voor alles. (wel exclusief het programmeren ! )

PS: Het parsen van de lines naar integers kan nog van 3,2 naar 2,0 sec door gebruik te maken van itertools.zip_longest. Bij de normale input is dan gemiddeld 0,01 seconde nodig voor alles.

[ Voor 43% gewijzigd door Bolukan op 01-12-2024 15:52 ]

[Woy]

Dag 1 was weer lekker eenvoudig zoals altijd, dit jaar weer eens kijken hoe ver ik kom.

https://github.com/rverst.../blob/main/Y2024/Day01.cs

[P_Tingen]

Ok, de eerste dag is om er in te komen, maar hoe de fuq kun je beide opgaven in NEGEN seconden oplossen?

https://adventofcode.com/2024/leaderboard/day/1

[gedonie]

Eens kijken hoe ver ik dit jaar kom met de opdrachten van AoC.

Heb in ieder geval mijn repo wat opgeschoond en dag 1 even gedaan in Java:

https://github.com/gjong/...nt/years/y2024/Day01.java

Dit jaar de repo aangepast dat de unit testen automatisch worden gegenereerd op basis van de input tekst bestanden.

[SideSplitter]

Gezien ik al enige tijd op de planning heb om Rust te leren, leek AoC mij een mooi moment om daarmee te beginnen. Gelukkig was de oplossing voor dag 1 niet al te moeilijk (en ja, het uitrekenen van deel 2 kan zeker netter).

P_Tingen schreef op zondag 1 december 2024 @ 16:12:
Ok, de eerste dag is om er in te komen, maar hoe de fuq kun je beide opgaven in NEGEN seconden oplossen?

https://adventofcode.com/2024/leaderboard/day/1

Met een LLM

[ Voor 3% gewijzigd door SideSplitter op 01-12-2024 16:47 ]

[Daos]

Woy schreef op zondag 1 december 2024 @ 16:02:
Dag 1 was weer lekker eenvoudig zoals altijd, dit jaar weer eens kijken hoe ver ik kom.

https://github.com/rverst.../blob/main/Y2024/Day01.cs

spoiler:

Je hebt de Select niet nodig bij het maken van de lookup. De code die hier nu staat kan je ook in de ToDictionary zetten.

[Friits]

Terug voor een nieuw jaar! Ik hoop nog wat nieuwe Python-handigheidjes te leren. Vandaag heb ik zo veel mogelijk uitbesteed aan NumPy.

spoiler:

from numpy import sort, loadtxt, isin

L, R = sort(loadtxt('in.txt', int).T)
print(sum(abs(L - R)), sum(isin(R, L) * R))

[FCA]

Soultaker schreef op zondag 1 december 2024 @ 15:09:
Voor wie z'n oplossing wil testen of verbeteren, hier is een extra grote invoer voor dag 1: aoc-2024-day-1-challenge-1.zip

Correcte oplossingen eindigen op ...616 en ...238 respectievelijk voor deel 1 en 2 .

Met een wat geoptimaliseerde oplossing (vooral in de inputparsing...), plus een fix voor de grootte van de output. Op een laptop van een jaar of 3 terug.

code:

Day 1 - Part 1 : XXXXXX616
        generator: 5.2µs,
        runner: 47.9674ms

Day 1 - Part 2 : XXXXXXXXXXXXXXX238
        generator: 900ns,
        runner: 86.6611ms

Ter referentie, voor de gewone input:

code:

AOC 2024
Day 1 - Part 1 : XXXX851
        generator: 3.5µs,
        runner: 78.6µs

Day 1 - Part 2 : XXXXX182
        generator: 300ns,
        runner: 104.9µs

[Soultaker]

Supersnelle oplossing voor dag 1 in C++ (< 20 ms voor m'n grote invoer, exclusief invoer inlezen):

$ ./solve2 < aoc-2024-day-1-challenge-1.txt 
Reading input took 197ms
Preprocessing took 14ms
...616
Solving part 1 took 1ms
...238
Solving part 2 took 1ms

Dit maakt gebruik van het feit dat

spoiler:

de getallen in de invoer relatief dicht bij elkaar liggen. Dus in plaats van te sorteren in O(n log n) kun je in O(max_val) tijd een frequentie-tabel maken, zodat a[x] en b[x] het aantal keer is dat x voorkomt in de linker respectievelijk rechterkolom (preprocessing). Dan zijn deel 1 en deel 2 vervolgens in O(max_val) oplosbaar (zie code voor details).

[Satom]

Corniel schreef op zondag 1 december 2024 @ 13:03:
Ik bedacht me dat het wellicht wel aardig was om een (een deel) van wat mijn plumbing doet ook te laten zien:

C#:

namespace Advent_of_Code_2024;

[Category(Category.Computation)] // categoriseert verschillende dagen op type puzzels. 
public class Day_01
{
    // Gebruikt de gespecificeerde string als input voor de puzzel en test het antwoord.
    [Example(answer: 11, "3 4;4 3;2 5;1 3;3 9;3 3")]
    // Test het antwoord op basis van de input als file (naming convention namespace + class name
    [Puzzle(answer: 1873376)]
    // Het Ints type zorgt er voor dat de input wordt gepartst to een read-only list van int32's. 
    public int part_one(Ints numbers) 
    {
       // return answer
    }

    // Voor grotere examples (grid puzzels bijvoorbeeld) is het ook mogelijk een test file in te lezen (ook weer naming convention based)
    [Example(answer: 31, Example._1)]
    [Puzzle(answer: 18997088)]
    // Lines geeft de input als een collection van strings (new line seperated)
    public int part_two(Lines lines)
    {
       // return answer
    }
}

Het grote voordeel aan mijn aanpak vind ik dat zonder extra gedoe zowel voorbeelden als de daadwerkelijke door de zelfde logica kan laten draaien, en middels een Expected Value automatisch kan laten testen. In mijn geval haken de attributen op NUnit it, maar met XUnit zou ongeveer hetzelfde hebben gekund.

Dit ziet er heel gaaf uit, ondanks dat ik zelf ook een redelijk framework heb gemaakt de afgelopen jaren, moet ik voor de examples nu nog redelijk omslachtig te werk gaan, wellicht dat ik even ga spieken naar hoe jij dat hebt opgelost!

[Soultaker]

Geen idee of iemand dit interesseert, maar ik had nog een andere invalling om deel 2 sneller te maken, zonder extra datastructuur te introduceren, mits je begint met het sorteren van de arrays voor deel 1:

spoiler:

In m'n oorspronkelijke oplossing sorteer ik de arrays voor deel 1, en tel ik de frequenties in een hashtable voor deel 2. (In Python kun je daar een Counter voor gebruiken, in C++ een std::unordered_map<>.)

Maar die hashtable is niet nodig. Als je de arrays toch al gesorteerd hebt, kun je één keer door beide arrays lopen en zo de segmenten met gelijke elementen vinden. Dat is dan O(n). C++ code

Daarmee draait deel 2 in 5 ms maar dan moet je nog steeds sorteren dus het is niet sneller dan m'n beste oplossing.

[sjroorda]

Hier doen we de Advent of Code dit jaar in drievoud:
- Ik in PHP, met de verwachting te eindigen bij opdracht 8 of zo als ik het niet meer snap, of eerder als tijd een probleem wordt
- Mijn dochter die net haar eerste opdrachtjes Python krijgt op haar middelbare school in Python
- En mijn vrouw in Excel

Voor het eerste deel van opdracht 1 krijgen we allemaal hetzelfde antwoord. Nu al geslaagd .

[ Voor 9% gewijzigd door sjroorda op 01-12-2024 21:10 ]

[Trasos]

Ik ga dit jaar eens meedoen en mijn puzzels oplossen in C# met behulp van LINQPad.
Mooie manier om de mogelijkheden van die tool eens wat beter te ontdekken.

[Corniel]

Satom schreef op zondag 1 december 2024 @ 20:35:
[...]
Dit ziet er heel gaaf uit, ondanks dat ik zelf ook een redelijk framework heb gemaakt de afgelopen jaren, moet ik voor de examples nu nog redelijk omslachtig te werk gaan, wellicht dat ik even ga spieken naar hoe jij dat hebt opgelost!

Ik ben benieuwd of je er iets aan hebt.

[Soultaker]

Ik had vandaag veel last van serverproblemen. Het duurde minuten voor ik het probleem überhaupt kon openen, toen weer problemen bij het openen van de invoer, en tenslotte bij het insturen van m'n oplossing. Gisteren was dat gek genoeg geen probleem. Hopelijk lost het probleem zichzelf op de komende dagen, als meer en meer mensen afhaken

Zelf heb ik de oplossing gewoon gebruteforced: 02.py

Hier nog wat grotere invoer voor dag 2: aoc-2024-day-2-challenge-1-to-2.zip

$ time pypy3 solve.py < aoc-2024-day-2-challenge-1.txt 
...5
...7

real    0m0.195s
user    0m0.167s
sys     0m0.027s

$ time pypy3 solve.py < aoc-2024-day-2-challenge-2.txt 
...8
...0

real    0m0.167s
user    0m0.138s
sys     0m0.028s

Uitdaging is om de implementie sneller dan O(^{n^2}) te maken (waarbij n het aantal elementen op een rij is).

[MatHack]

Hier geen problemen met de servers.
Deel 2 ook gewoon bruteforce opgelost met behulp van de C# range & collection operators.

https://github.com/realma...de.Y2024/Solvers/Day02.cs

[FCA]

Deel 2 flink zitten klunzen, meer dan een uur over gedaan, omdat ik vast zat met mijn "elegante" O(n) oplossing. Uiteindelijk bedacht dat een O(n^2) natuurlijk ook zou werken, dat was snel gebeurd toen...
Voor de challenge deel 1 hierboven is de O(n^2) in Rust trouwens sneller dan Python O(n).

[Gropah]

FCA schreef op maandag 2 december 2024 @ 08:23:
Deel 2 flink zitten klunzen, meer dan een uur over gedaan, omdat ik vast zat met mijn "elegante" O(n) oplossing. Uiteindelijk bedacht dat een O(n^2) natuurlijk ook zou werken, dat was snel gebeurd toen...
[...]

Yep, same

Ben gisteren niet aan dag 1 toegekomen. Zal zo even in een verloren kwartiertje die ook op te lossen

Edit; en done

[Remcoder]

Weer een mooi gevalletje begrijpend lezen voor deel 2...

spoiler:

Ik dacht dat je 1 ongeldig verschil mocht negeren, en dat het dan nog steeds geldig was. Dan had ik het snel opgelost gehad.

Helaas had ik dus verkeerd gelezen en mocht je 1 waarde weglaten en dan opnieuw kijken of die geldig is.

[TrailBlazer]

wilde het mooi oplossen liep daar in vast en toen dacht ik het is dag 2 je hebt vast geen Chinese Remainder Theorem nodig oid dus toen maar gewoon gebruteforced.

spoiler:

voor deel 2 niet moeilijk gedaan. Als de hele reeks geldig is is de reeks ook geldig met een waarde minder. Dus gewoon 1 voor 1 een waarde uit de lijst halen en kijken of het geldig is.

Python gepruts

[ Voor 51% gewijzigd door TrailBlazer op 02-12-2024 09:23 ]

[P_Tingen]

Deel 1 leek me niet zo moeilijk, dus programma gemaakt, maar no-go. Na een paar keer mijn programma goed bekeken te hebben dacht ik toch echt dat hij goed was.

spoiler:

en dat was hij ook, ik had alleen even moeten kijken naar het aantal elementen per report. Dat zijn er natuurlijk niet netjes elke keer 6, zoals in het voorbeeld

Voor de liefhebber: deel 1 en deel 2 in Progress 4GL

[Friits]

Soultaker schreef op maandag 2 december 2024 @ 07:31:
Uitdaging is om de implementie sneller dan O(^{n^2}) te maken (waarbij n het aantal elementen op een rij is).

Niet echt elegant, maar het kan wel. Het kan allemaal nog wat slimmer en efficiënter, maar ik had geen zin om te gaan rommelen met geneste loops etc.

[ Voor 28% gewijzigd door Friits op 02-12-2024 10:23 ]

[Thorwing]

Vandaag onmeuig veel problemen gehad met de site. De opgave laadde een minuut of twee niet. Vervolgens laadde mijn input een minuut niet. Al met al veel vertraging opgelopen vanochtend.

Ik weet zeker dat deel 2 in O(n) opgelost kan worden, maar logica schrijven voor de O(n²) was vele malen makkelijker. En het zijn de eerste paar dagen dus het boeit nog niet helemaal natuurlijk.

Kotlin Dag 2

[Soultaker]

Variant voor dag 2: wat als je niet 1 fout element mag verwijderen, maar een willekeurig aantal?

Bereken voor elke regel het minimale aantal elementen dat je moet verwijderen om aan de voorwaarden te voldoen (hetzelfde als in het oorspronkelijke probleem: strict oplopend of aflopend, waarbij aangrenzenden waarden minimaal 1 en maximaal 3 verschillen). De som van die antwoorden per regel is je eindantwoord.

Bijvoorbeeld:

1 99 2 98 3 97 4
1 99 2 98 1 97 2
1 1 1 1 1 1
1 2 4 7 10

In regel 1 moet je 3 elementen verwijderen (99, 98, 97).
In regel 2 moet je 4 elementen verwijderen (1, 2, 1, 2).
In regel 3 moet je 5 elementen verwijderen (1, 1, 1, 1, 1).
In regel 4 moet je 0 elementen verwijderen.
Het totaal is 3 + 4 + 5 = 12.

Testinvoer: aoc-2024-day-2-challenge-3.zip

Referentie-oplossing:

$ time pypy3 solve-variant.py  < aoc-2024-day-2-challenge-3.txt 
...777

real    0m0.489s
user    0m0.441s
sys     0m0.044s

Hint voor een efficiënte oplossing:

spoiler:

Variant van longest increasing subsequence

[KabouterSuper]

sjroorda schreef op zondag 1 december 2024 @ 21:10:
Hier doen we de Advent of Code dit jaar in drievoud:
- Ik in PHP, met de verwachting te eindigen bij opdracht 8 of zo als ik het niet meer snap, of eerder als tijd een probleem wordt
- Mijn dochter die net haar eerste opdrachtjes Python krijgt op haar middelbare school in Python
- En mijn vrouw in Excel

Voor het eerste deel van opdracht 1 krijgen we allemaal hetzelfde antwoord. Nu al geslaagd .

Erg cool! Mijn dochter doet dit jaar voor het eerst mee (in C, ik programmeer in python). Veel succes alledrie. Als jullie een eigen account hebben gebruikt, dan hoeven jullie trouwens niet per se dezelfde antwoorden te krijgen, soms zijn er verschillende datasets voor verschillende accounts.

[ElkeBxl]

Voor zij die problemen hadden vandaag: Eric heeft gepost over een DDoS

On the second day of Advent of Code, my true love gave to me.... a pretty big DDoS right at midnight. While this definitely impacted site access, it seems to have affected everyone pretty evenly, and gold cap still took a normal amount of time for a day 2 puzzle. So, I'm leaving the scores on the global leaderboard for today as-is.

[FCA]

Friits schreef op maandag 2 december 2024 @ 09:37:
[...]


Niet echt elegant, maar het kan wel. Het kan allemaal nog wat slimmer en efficiënter, maar ik had geen zin om te gaan rommelen met geneste loops etc.

Dank voor de hint!
Mijn oplossing loopt nu keurig in O(n) tijd. Challenge 2:

code:

Day 2 - Part 1 : X8
        generator: 700ns,
        runner: 9.7985ms

Day 2 - Part 2 - brute_force : X0
        generator: 300ns,
        runner: 1.3757987s

Day 2 - Part 2 - recursing : X0
        generator: 900ns,
        runner: 10.6941ms

[Eupeodes]

Mijn eerste versie van het script had minuten nodig voor de grote inputs

spoiler:

en kwam er aanvankelijk geheel niet door door een conditie in de grote files waar ik geen rekening mee had gehouden

Nu herschreven, de officiële input is er nu in 0.0075 seconde door (was 0.0095), grote input 1 in 23 seconden (was 48) en grote input 2 in ruim 200 (was meer dan 400).

[Woy]

Deze was op zich redelijk eenvoudig, maar mijn oplossing voor deel 2 kan nog wel wat beter, maar tegenwoordig is mijn instelling bij AoC meer, if it works, it works

https://github.com/rverst.../blob/main/Y2024/Day02.cs

Het is natuurlijk niet heel lastig om de "removal" niet echt te doen, maar gewoon in de huidige array te checken of het een valid list is, en gewoon doorgaan.

[ Voor 25% gewijzigd door Woy op 02-12-2024 10:31 ]

[Mugwump]

Vanochtend even gisteren ingehaald en vandaag gemaakt. Doe het nog steeds in Kotlin dus geen megaperformanceoptimalisaties toegepast anders dan zo veel mogelijk fail fast toepassen waar je door lijstjes heenloopt om te valideren of alle elementen voldoen aan criteria.

[Marcj]

Ik heb dag 1 en dag 2 allebei even opgelost in Rust.

Ook de grote inputs van dag 2 werken best goed met mijn oplossing. Ik had eerst ook een O(n^2) oplossing gemaakt, omdat die gewoon simpel te doen was. En zelfs de grote files binnen 1 seconde oplost. Maar met de optimalisatie loopt hij wel in O(n).

De grote inputs gaan ook best vlot volgens mij:

code:

$ cat big_inputs/aoc-2024-day-1-challenge-1.txt | time ../target/release/day1
Executing
 ├── Input parsed in 99,088µs
 ├── Part 1 calculated in 267µs: ...616
 ├── Part 2 calculated in 11,523µs: ...238
 └── Total time: 110,956µs

../target/release/day1  0.11s user 0.01s system 46% cpu 0.273 total

code:

$ cat big_inputs/aoc-2024-day-2-challenge-1.txt | time ../target/release/day2
Executing
 ├── Input parsed in 11,268µs
 ├── Part 1 calculated in 303µs: ..5
 ├── Part 2 calculated in 520µs: ..7
 └── Total time: 12,122µs

../target/release/day2  0.02s user 0.01s system 116% cpu 0.018 total

$ cat big_inputs/aoc-2024-day-2-challenge-2.txt | time ../target/release/day2
Executing
 ├── Input parsed in 11,741µs
 ├── Part 1 calculated in 265µs: ..8
 ├── Part 2 calculated in 365µs: ..0
 └── Total time: 12,397µs

../target/release/day2  0.01s user 0.01s system 108% cpu 0.019 total

Zolang het parse van de input nog steeds het meeste tijd kost, ga ik geen andere optimalisaties zoeken

[Janoz]

Vorig jaar op vakantie dus alleen de eerste paar dagen gedaan. ALs het werk het toe laat dit jaar maar weer eens alle dagen proberen.

Eerste twee dagen zitten er iig al weer op waarbij ik eigenlijk weinig met efficiente algo's bezig ben geweest. Op dit moment maakt dat toch nog niet echt uit:

https://github.com/Janoz-.../java/com/janoz/aoc/y2024