Punkte werden berechnet wie @haus-automatisierung beschrieben:

• Die Rätsel werden immer Punkt 06:00 (weltweit) veröffentlicht (in den USA um also Mitternacht). Dann gilt: wer am schnellsten Part 1 gewinnt (und dann Part2) bekommt die meisten Punkte. Für alle also quasi die gleiche Chance (wenn man 'pünktlich' aufsteht).

• Man bekommt als erster immer so viele Anzahl Punkte wie Teilnehmer im Leaderboard. Als zweiter einen Punkt weniger. Das relative Ranking zueinander wird dadurch nicht beeinflusst, selbst wenn Teilnehmer dazukommen.
  Als Beispiel: Liege ich 2 Punkte hinter dem Erstplatzierten, muss ich zweimal schneller sein (z.B. an einem Tag mit Part I und Part II), um einzuholen. Mit etwas Glück setz der Erstplatzierte mal einen Tag aus, dann verliert er sehr schnell viele Punkte, weil er an so einem Tag dann nur wenig Punkte macht.

• Die Aufgaben sind in der Regel SEHR genau beschrieben, auch inkl. Beispielen. Man muss aber auch genau lesen. Nicht JEDER Corner-Case wird aktiv angesprochen, auf die muss man schon selber kommen. Wenn etwas (also Sonderfälle) nicht explizit ausgeschlossen wurde, gehe davon aus, dass es im finalen Datenset vorkommt.

• Für später: spätere Aufgaben laufen oft in hohe Zahlen rein. Sehr viele sind schon früh gescheitet, weil sie mit Java Ints arbeiten, (wer Python nutzt, hat diese Probleme nicht). Auch später: gibt es Aufgaben, die von der Berechnungszeit sehr lange dauern, wenn man simple Ansätze nutzt. Sobald das Programm länger als 1-5min rechnet, ist das ein klares Indiz, dass es Abkürzungen gibt, um das Ergebnis gut zu berechnen (also man die Gehirnzellen extra anstrengen muss)

• In der Regel sind Aufgaben an Wochenende umfangreicher / komplizierter als in der Woche

• Kurz vor Weihnachten ist der Schwierigkeitsgrad am höchsten, zum 24. + 25. fällt es dann (netterweise) wieder deutlich ab.

• Achtung: den 50igsten Stern bekommt man nur, wer alle 49 Sterne davor hat. Die Belohnung: der Ascii-Art Kalender bekommt dann meist kleine Animiationen. Außerdem sind in jedem Text versteckte Worte hinterlegt, mit lustigen Tooltips. Die kann man auch jetzt schon finden (muss man halt über jedem Wort hovern). Mit 50 Sternen bekommt man sie markiert.

• @Negalein : die 'Ausrede', dass es ohne Windows Tools nicht zu lösen ist zählt nicht. Es gibt Kandidaten, welche (meist bis zur Hälfte) alles mit Excel lösen. Als Challenge sind hierbei nur Formeln erlaubt, kein VBA
  Hier ein Beispiel für heute / Tag 4: https://www.reddit.com/r/adventofcode/comments/18ael0e/2023_day_4_a_successful_4th_day_using_only_excel/
  Hier ein Beispiel für gestern / Tag3 : https://www.reddit.com/r/adventofcode/comments/189qs63/2023_day_3_a_successful_3rd_day_using_only_excel/

Grüße von bluegaspode / Stefan (Teilnehmer seit 2018)

Was mich total motiviert 'dabeizubleiben'

• man lernt wahnsinnig viel, auch wenn man steckenbleibt (zur Not 24h warten, und dann von den Diskussionen oder anderen Lösungen lernen)
• dadurch dass es so viele Lösungen gibt, kann man gut reflektieren, wo man selber steht. Geht der Code kürzer, geht er lesbarer, wie würde es in anderen Sprachen aussehen - gibt es da Konstrukte, die es in der eigenen Sprache nicht gibt
• wer ChatGPT(Pro) oder GitHub Copilot noch nie ausprobiert hat: dieser Monat lohnt sich extrem, mal 30€ auszugeben und auf Herz und Nieren zu testen. ChatGPT, wenn man komplett ahnungslos ist und Tipps braucht, CoPilot nimmt einem viel Arbeit beim späteren Schreiben ab.
• die Community auf Reddit ist der Hammer, jeden Tag entstehen Visualisierungen, Tutorials, Games zur aktuellen Aufgabe. z.B. hier: der heutige Tag als Interaktives Mini-Game, wo du die Rubbellose mit der Maus freirubbeln kannst ) (https://www.reddit.com/r/adventofcode/comments/18afumn/2023_day_4_part_1python_terminal_visualization/). Ja - wie geil ist das denn (wenn andere zu viel Zeit haben :D)

Habt ihr irgendeinen "Code Of Conduct" fürs Leaderboard (im Sinne von 'selber lösen' vs. 'fertige Lösung einfach ausführen')

Die Top10 des weltweiten Leaderboards haben für die Lösung von Part II heute alle mehr als 4min gebraucht. Jemand im IOBroker Leaderboard hat es in 2:35 geschafft.

Die gleiche Person hat Part II an Tag 2 in 11sek geschafft, während die Top10 des globalen Leaderboard als Minimum 30sek benötig haben.

Da ich selbst auf anderen Leaderboards unterwegs bin, stört es mich selber hier nicht.
Wollte aber der Transparenz halber drauf hinweisen.

Nachvollziehbar ist das über Plugins wie dieses hier, welches die verfügbaren Statistiken direkt im Leaderboard einblenden: https://chromewebstore.google.com/detail/advent-of-code-charts/ipbomkmbokofodhhjpipflmdplipblbe?pli=1

@oliverio die Zeiten des globalen Leaderboard zweifle ich gar nicht, das sind die besten der besten (spezialisiert auf genau solche Rätsel) und einige von denen streamen ja auch.

Ich habe mich nur gefragt, ob es realistisch ist, dass es im ioBroker Leaderboard eine Person gibt, die schon an 2 Tagen mit der Lösung des 2ten Teil die komplette Top 10 des weltweiten Leaderboard zeitlich schlagen konnte

Ich selbst nutze Java zur Lösung, reviewe parallel regelmäßig die Python Lösungen, weil mich die Eleganz der Sprache immer wieder fasziniert.

@ignis-draco said in ioBroker Advent of Code:

mehr als 2:35 hat bei mir alleine die Brechung von Part 2 benötigt

Bei mir waren es 13min. Ein klares Zeichen, dass man nicht den besten Weg gefunden hat, um das Rätsel zu lösen, aber ich habs rechnen lassen, solange ich am umschreiben war ... und dann war die Rechnung schneller fertig als eine komplett neue Lösung.

Mit dem richtigen Algorithmus sind immer <1s (egal welche Programmiersprache) möglich.
Bei Tag 5 Teil 2 auch, man muss sich dann was besseres einfallen lassen, als jede Zahl einzeln durchzurechnen, sondern clevere Weg finden, wie man ganze Gruppen von Zahlen am Stück 'behandeln' kann, ohne dass dann das Ergebnis deswegen falsch wird.
Da wirds dann tüftelig, wenn der Code am Ende auch noch verständlich bleiben soll.

@bananajoe
etwas ausführlicher.

Für Teil 1 hast du alles richtig gemacht. Teil 2 baut darauf auf, du musst es mit etwas Mathematik kombinieren.

Stell dir vor, du verfolgt die LR Anweisungen, dann entsteht ja eine "Kette" wie du von xxA nach xxZ kommst. Im Original sind mehrere Ketten 'versteckt', die du ja alle gleichzeitig ablaufen sollst.

Dies hier ist ein neues ausgedachtes Beispiel:

Pfad 1 (mit 6 Schritten vom ersten xxA bis zum ersten xxZ):
AAA -> AAB -> AAC -> AAD -> AAE -> AAF -> AAZ

Pfad2 (mit 14 Schritten vom ersten xxA bis zum ersten xxZ)

BBA -> BBB -> BBC-> BBD -> BBE -> BBF -> BBG -> BBH -> BBI -> BBJ -> BBK -> BBL -> BBM -> BBN -> BBZ

Die "Ketten" gehen dann natürlich weiter, man landet ja immer wieder regelmäßig beim AAZ oder BBZ. Die Inputdaten des Rätsels sind so aufgebaut, dass du in der ersten Kette, wenn du 'AAZ' nach 6 Schritten gefunden hast, die Kette weitergeht und du dann erneut nach 6 Schritten das nächste 'AAZ' findest.

In der 2ten Kette findest du nach jedem 14ten Schritt das 'BBZ'.

Wenn man das in Zahlen ausdrückst, findest du ein 'AAZ' aus der ersten Kette also an folgenden Stellen (vielfache von 6)
06 -> 12 -> 18 -> 24 -> 30 -> 36 -> 42 -> 48 -> 56 -> ...

Das 'BBZ' findest du an vielfachen von 14:
14 .........................-> 28 ...............-> 42

42 ist hier die magische Nummer. Beide 'Ketten' haben an der 42igsten Stelle ihr AAZ bzw. BBZ als die Bedingung die du suchen sollst.

42 ist das kleinste gemeinsame Vielfache von 6 und 14.

Um das Rätsel zu lösen musst du also:

• alle Startpunkte finden ('xxA'). Von jedem Startpunkt suchen, bis du das erste 'xxZ' findest. Diese "Kettenlänge" musst du dir merken.

Wenn du weißt, wie lang alle Ketten sind, musst du von allen Ketten das kleinste gemeinsame Vielfache berechnen. Das wäre der Punkt, wo, wenn du alle Ketten mehrfach gleichzeitig abfährst zum ersten mal bei allen gleichzeitig ein 'xxZ' findest.

@bananajoe Man hätte das Labyrinth auch Lasercutten können, um dann manuell zu zählen:

https://www.reddit.com/r/adventofcode/comments/18fjhb9/2023_day_10_laser_cut_solution/

[Day 20]

Mensch, die heutige Aufgabe ist doch perfekt für Hausautomatisierung.

Ein paar Flip Flops hier, ein paar Verbinder ... das muss sich doch in den LogikEngines umsetzen lassen (mind. Part 1),

ist fast so wie die Logik für "offene Fenster zählen"

@bananajoe hhhmm - also die Gesamtsumme an Lösungen ist im Bereich:
4.500.100.000.000

das müsstest du irgendwie in eine Zahl abgespeichert bekommen.
der 'Long' Dateintyp (was auch immer das bei AutoIT ist, reicht in der Regel dafür aus)

Auch die Rekursionstiefe passt.
Der längste String im Input ist zu 20Zeichen lang, den machst du 5mal größer, sind 100 Zeichen.
Das ist deine maximale Rekursionstiefe (pro Zeichen = 1x Rekursion)

Ich habe es auch anders gemacht, auf jeder Rekursionsstufe prüfe ich immer eine komplette Gruppe.
6 Gruppen * 5 = 30

Das heißt ich bin bei Rekursionstiefe von 'nur' 30.

Der Algorithmus geht dann so

sucheLoesungen(pattern, startposition, gruppen[]) {
    // ab der Startposition, finde alle Positionen wo die allerste Gruppe von der Länge hinpassen könnte
    // für alle diese Positionen
         // neueStartPosition = ersteGruppeStartPositon + ersteGruppeLaenge+1
         // neueGruppen = alteGruppen (ohne die erste, die wir gerade festgelegt haben)
         // ergebnis += sucheLoesungen (pattern, neueStartPosition, neue Gruppen)
}

und noch den Cache dazu, dass es für Teil2 passt.

Vielleicht noch das Beispiel:
?#?#?#?#?#?#?#?

du rufst die Funktion natürlich zuerst mit dem vollen String auf:
anzahlLoesungen('?#?#?#?#?#?#?#?', '1,3,1,6')

deine Funktion ruft sich in kleinen Schritten aber erstmal so lange selber auf, bis du bei der Frage gelandet bist (das hintere Ende vom Text):

anzahlLoesungen('#?#?#?', '6')

und selbst das wird immer kleiner, bis du bei der Frage

anzahlLoesungen ('?', 1)

angelangt bist (das allerletzte Ende mit verkleinerter Restgruppe).

Und dieses Problem ist soooo klein, dass du sagen kannst "passt, es gibt für dieses kleine Problem genau eine Lösung").
Das ist tatsächlich das erste was in deinem Cache landet, die Rekursion sorgt also subtil dafür, dass das Problem eigentlich 'von hinten' gelöst wirst.

Aber dann arbeitet sich das Programm Stück für Stück in die höheren Ebenen zurück, irgendwann wird der Cache für
anzahlLoesungen('#?#?#?', '6') gefüllt sein (auch nur 1 Lösung)

und dann tobt sich das Programm an den ganzen Fragezeichen noch weiter vorne aus.

@bananajoe

Es wird meist mit einem rekursiven Ansatz gemacht, der teilt das Problem in kleinere Probleme.

Mal ein ganz einfaches Beispiel, mit nur 4 Stellen
##.# 2,1

Du schreibst eine Funktion:
'anzahlLoesungenFuer(text, gruppen)'

Du guckst dir in der Funktion immer nur den Start an, hier also Stelle 0 im Text und findest das '#' - und denkst 'super - ich suche einen 2er Block, hier ist eine #, das passt doch super zusammen'.

Jetzt stell dir vor, du hättest ein Funktion, die dir beantwortet, wie viele Lösungen es für das Beispiel:
#.# 1,1
gibt (das ist der hintere Teil von deinem Text).

Aber hey - so eine Funktion hast du schon, die hast du gerade angefangen zu schreiben - du musst dich also nur selbst (mit manipuliertem verkürzten String und manipulierten verkürzten Gruppen) aufrufen.

Und so hangelst du dich durch einige Fälle durch.
Das nächste was du für
#.# 1,1
brauchst ist die Frage:

• ich habe auf Position 0 die '#' gefunden. Das passt zu dem '1' er Block, der gesucht wird.
• ABER: der 1er Block wird nur erfüllt, wenn nach der '#' auch ein '.' (oder '?') kommt. Wenn es hier zwei '##' gibt, gibt es keine Lösung mehr, und ich liefere als Funktion einfach '0 Lösungen für diesen Fall' zurück.
  Hier passt es, also kannst du deinen String jetzt um 2 Zeichen kürzen ('#.'). Da die eine Gruppe 'fertig' rufst du dich jetzt auf mit "anzahlLoesungenFuer('#', '1')" und hierfür liefert dir die Funktion zurück, dass es eine passende Lösung gibt.

Wenn du das so geschrieben hast, sollte es dir Teil 1 weiterhin korrekt ausrechnen, dein Code ist nur etwas länger geworden.

ABER: jetzt kannst du den Cache einbauen (einfach als weiteren Parameter der überall durchgeschleift wird).
Am Anfang der Funktion fragst du den Cache "gibt es schon eine Lösung für '#.# 1,1'" und kannst sofort zurückkehren falls ja.

Falls nein, machst du deine Berechnung und packst am Ende der Funktion den Wert in den Cache.

Dieser Text ist dafür da, dass es (hoffentlich?) anschaulich wird, wie sich die Funktion immer wieder selbst mit einem verkleinerten String aufrufen kann.

Ich selbst habe es (subtil) anders gemacht. Damit ich nicht immer Strings kopieren kürzen muss, heißt meine Funktion "zaehleLoesungen(text, startPosition, gruppen).
Ich gebe also immer den gleichen Text rein und erhöhe immer nur die startPosition, kommt dann aber aufs gleiche hinaus.

by the way: ich selbst hatte auch einen eher simplen Weg für Part 1, der natürlich vorne und hinten nicht gut genug für Part 2 war.

Dann habe ich was neues für den 2ten Part geschrieben, dass hat die Demo korrekt berechnet, aber dann selbst für Teil 1 nicht mehr die richtigen Ergebnisse.

Dadurch dass ich über Teil1 aber richtig viele 'Testcases' hatte, konnte ich mir sehr schnell die kaputten Fälle raussuchen, und dann Stück für Stück 3 Bugs noch fixen.

@bananajoe

Als Cache brauchst du eigentlich nur etwas was in diversen Programmiersprachen "Map / HashMap / Dictionary" heißt.

Du nimmst weiterhin AutoIt?
Dann ist das hier dein Freund: https://www.autoitscript.com/wiki/Associative_Arrays

Im Grunde geht es darum, Berechnungsergebnisse, die man schon hatte, zwischenzuspeichern.

Ich finde dieses hier ist ein schönes 'einfaches' Beispiel:
.??..??...?##. 1,1,3

Du machst dort irgendwann eine Berechnung, wo du '1,1' 'schon untergebracht hast, z.B.: so:
.#...#.

und dann bist du an der nächsten Stelle im String und fragst dich: passt hier dann irgendwo noch ein 3er Block rein. Beim ersten Mal, wenn du dich das fragst, musst du es berechnen.
In deinen Cache schreibst du dann aber z.B. rein "wenn du je wieder an der 10ten Stelle bist und nur noch den 3er Block unterbringen willst -> dann gibt es dafür noch eine Möglichkeit."

Dann suchst du nach weiteren Möglichkeiten und findest z.B. dann eine zweite Verteilung für den (1,1) Block:

..#..#. statt
.#...#.

tja - und jetzt hilft dir der Cache - weil wieder musst du dich fragen: hey ich bin an Stelle 10 - wie viele Möglichkeiten gibt es für den verbleibenden 3er Block ... und die Antwort weißt du dann schon.

Der Cache füllt sich dann auch sehr schnell, z.B. mit der Antwort für "ich bin an Stelle 4 im String -> wie viele Möglichkeiten gibt es eigentlich noch einen (1,3) er Block unterzubringen. Und in deinem Cache steht drinne, dass es aber der 4ten Position nur noch 2 Möglichkeiten gibt.

Dadurch verkürzen sich sehr schnell viele Berechnungsergebnisse.

@bananajoe Man hätte das Labyrinth auch Lasercutten können, um dann manuell zu zählen:

https://www.reddit.com/r/adventofcode/comments/18fjhb9/2023_day_10_laser_cut_solution/

@bananajoe Dich hat der AoC Virus gefangen
Ich habe für den 2ten Teil auch was ziemlich komplexes geschrieben.

In dem Moment wo sich dir Lösung hatte, fiel mir was viel einfacheres ein...

Man kann in in Polygonen sehr einfach bestimmen, was innen und was außen ist.

Du musst dir nur aus Teil eins alle Positionen der Strecke merken (damit du den ganzen anderen 'Müll' ignorieren kannst).

Dann einfach jede Zeile von links nach rechts wandern. Dabei zählst du nur, ob du die Strecke kreuzt. Hast du sie einmal gekreuzt: bist du 'innen', zweimal gekreuzt wieder 'außen' und sie weiter. Also testest du, ob du eine gerade oder ungerade Anzahl Wege gekreuzt hast und je nachdem die leeren Felder an denen du vorbeikommst zählen oder nicht. Bei den Ecken nur bestimmte Ecke zählen, damit einen waagerechte Wände die Rechnung nicht kaputt machen.

Schau mal hier unter 'Raycasting' :
https://en.m.wikipedia.org/wiki/Point_in_polygon

Das ist hier relativ einfach weil alles schön gerade ist.

Andere haben das Labyrinth 'aufgeplustert'. Aus Jedem Punkt eine 3x3 Fläche machen., dann lässt sich der FloodFill auf der größeren Fläche einsetzen, weil er sich dann gut zwischen den Wänden durchschlängeln kann.

@bananajoe
etwas ausführlicher.

Für Teil 1 hast du alles richtig gemacht. Teil 2 baut darauf auf, du musst es mit etwas Mathematik kombinieren.

Stell dir vor, du verfolgt die LR Anweisungen, dann entsteht ja eine "Kette" wie du von xxA nach xxZ kommst. Im Original sind mehrere Ketten 'versteckt', die du ja alle gleichzeitig ablaufen sollst.

Dies hier ist ein neues ausgedachtes Beispiel:

Pfad 1 (mit 6 Schritten vom ersten xxA bis zum ersten xxZ):
AAA -> AAB -> AAC -> AAD -> AAE -> AAF -> AAZ

Pfad2 (mit 14 Schritten vom ersten xxA bis zum ersten xxZ)

BBA -> BBB -> BBC-> BBD -> BBE -> BBF -> BBG -> BBH -> BBI -> BBJ -> BBK -> BBL -> BBM -> BBN -> BBZ

Die "Ketten" gehen dann natürlich weiter, man landet ja immer wieder regelmäßig beim AAZ oder BBZ. Die Inputdaten des Rätsels sind so aufgebaut, dass du in der ersten Kette, wenn du 'AAZ' nach 6 Schritten gefunden hast, die Kette weitergeht und du dann erneut nach 6 Schritten das nächste 'AAZ' findest.

In der 2ten Kette findest du nach jedem 14ten Schritt das 'BBZ'.

Wenn man das in Zahlen ausdrückst, findest du ein 'AAZ' aus der ersten Kette also an folgenden Stellen (vielfache von 6)
06 -> 12 -> 18 -> 24 -> 30 -> 36 -> 42 -> 48 -> 56 -> ...

Das 'BBZ' findest du an vielfachen von 14:
14 .........................-> 28 ...............-> 42

42 ist hier die magische Nummer. Beide 'Ketten' haben an der 42igsten Stelle ihr AAZ bzw. BBZ als die Bedingung die du suchen sollst.

42 ist das kleinste gemeinsame Vielfache von 6 und 14.

Um das Rätsel zu lösen musst du also:

• alle Startpunkte finden ('xxA'). Von jedem Startpunkt suchen, bis du das erste 'xxZ' findest. Diese "Kettenlänge" musst du dir merken.

Wenn du weißt, wie lang alle Ketten sind, musst du von allen Ketten das kleinste gemeinsame Vielfache berechnen. Das wäre der Punkt, wo, wenn du alle Ketten mehrfach gleichzeitig abfährst zum ersten mal bei allen gleichzeitig ein 'xxZ' findest.

@bananajoe

Ein einfaches Beispiel:

Pfad 1: du brauchst 6 Schritte zum Z (und 6 bis zum nächsten)

Pfad 2: du brauchst 14 Schritte zum Z (und 14 zum dann nächsten)

kgv ist 42 (7*3*2).

Die 6er Kette kommt da nach 7 Runden an.
Die 14er Kette nach 3 Runden.

Dann hast du überall gleichzeitig ein Z.

Alles nur multiplizieren (6*14) ist auch ein Punkt wo überall ein Z ist, der ist aber zu weit 'hinten'