ioBroker Advent of Code

ignis-draco

Ich habe das über ein enum gelöst

class Strong(IntEnum):
  HIGH_CARD = 0
  ONE_PAIR = 1
  TWO_PAIR = 2
  THREE_OF_A_KIND = 3
  FULL_HOUSE = 4
  FOUR_OF_A_KIND = 5
  FIVE_OF_A_KIND = 6

  @classmethod
  def maxKind(self, value):
    if value == self.FIVE_OF_A_KIND:
      return 5 
    if value == self.FOUR_OF_A_KIND:
      return 4
    if value == self.THREE_OF_A_KIND or value == self.FULL_HOUSE:
      return 3
    if value == self.ONE_PAIR or value == self.TWO_PAIR:
      return 2 
    return 1
  
  @classmethod
  def addOneKind(self, value):
    if value == self.FIVE_OF_A_KIND:
      return self.FIVE_OF_A_KIND
    if value == self.FOUR_OF_A_KIND:
      return self.FIVE_OF_A_KIND
    if value == self.THREE_OF_A_KIND or value == self.FULL_HOUSE:
      return self.FOUR_OF_A_KIND
    if value == self.ONE_PAIR or value == self.TWO_PAIR:
      return self.THREE_OF_A_KIND
    return self.ONE_PAIR

BananaJoe

@haus-automatisierung sagte in ioBroker Advent of Code:

Habt ihr auch mit Bitmasken gearbeitet um die Wertigkeit der Typen festzulegen?

Maximal kompliziert mit Zerlegen in Arrays (die Zeilen und die Kartensätze), Textvergleich in der Reihenfolge der Kartenwertigkeit und Feststellung ob es nun ein 5er, 4er, Full House usw. ist und zuweisen eines Wertes je nach Treffer, anhand diesen Wertes die Wertigkeit der Kartensätze festgelegt, festgestellt das ich damit meine Liste genau falsch herum aufgebaut habe. Nach dem Umdrehen der Liste waren aber auch innerhalb eines Wertes (z.B. Full House) die Reihenfolge nun falsch herum war ... aber nicht immer. Um mir dann bei einem anderen die Idee mit "Suchen und Ersetzen" abzuschauen und die neuen Buchstaben dann zu sortieren damit die Wertigkeit der einzelnen Karten Alphabetisch wird. Dann kam der Einfall Präfixe zu setzen damit ich das einfach nach Text sortieren kann.

Da hat man dann seine 200 Zeilen Lösung und staunt wie kurz andere das hinbekommen mit Funktionen die ich noch nie benutzt habe.

haus-automatisierung

Teil 2 heute nervt mal richtig Durchrechnen dauert ewig... Wollte mal gucken wie hoch das Ergebnis ungefähr liegt und habe 10000000000000 eingegeben. "Answer too low". Oha...

Heute Abend mal mehr Gedanken machen wie das klappen könnte.

OliverIO

@haus-automatisierung

hah, teil2, hat ein weilchen gedauert, aber es geht dann schnell
hier mit spoiler.
meine zahl ist 13133452426987.
da hätte er ein weilchen gerechnet (monate?)

haus-automatisierung

@oliverio Jau habe ich mittlerweile auch so umgesetzt 19ms

BananaJoe

Ich fürchte ich bräuchte mal einen Tipp in die richtige Richtung. Ich habe auch schon auf Reddit gelesen das LCM bzw. die Multiplikation der Pfade mein Freund ist, mich durch diverse Seiten gehangelt welche das zu versuchen zu erklären. Aber ich verstehe trotzdem nur Bahnhof.

bluegaspode

@oliverio Das klappt aber nur, weil der Input das 'zufällig' erlaubt.

Ich bin gar nicht auf die Idee Idee gekommen und hab daher gar nicht dran gedacht.

Mal als Beispiel, wo der Ansatz nicht klappt :

Kette A: 3 Schritte bis zum ersten Z, 20 Schritte bis zu einem anderen Z, 3 Schritte zurück zum ersten Z.

Kette B: 2 Schritte bis zum ersten Z, 7 Schritte zurück zum ersten Z.

Dein kGV wäre dann 6. Nach 6 Schritten treffen sich die Geister aber gar nicht.

Gibt größere Diskussionen auf Reddit, aber am Ende stellt sich raus, dass der Weg den man vom Anfang zum ersten Z braucht der gleiche Weg wie zum nächsten Z ist (obwohl die Kette nichtmal wieder am Anfang vorbeigeht).

Naja, ich habe zu kompliziert gedacht und deswegen meine Lösung mit all den Tagesablenkungen immer noch nicht.

bluegaspode

@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'

BananaJoe

@bluegaspode ich habe da gerade eine Schranke im Gehirn.
Was meinst du mit

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

Ich nehme an du beziehst die auf die Beispieldaten?

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

Verstehe ich in diesem Zusammenhang nicht.

~~Ich starte in der ersten Zeile~~ Ich starte mit AAA, man muss den Text schon genau lesen

AAA = (BBB, CCC)
BBB = (DDD, EEE)
CCC = (ZZZ, GGG)
DDD = (DDD, DDD)
EEE = (EEE, EEE)
GGG = (GGG, GGG)
ZZZ = (ZZZ, ZZZ)

AAA ist der aktuelle "node"
BBB und CCC sind die nächsten "nodes", abhängig davon wie die Anweisung gerade ist.
Die ist RL, also nehme ich für das R die CCC und schaue dort nach was dort bei L, also links steht.
Da steht GGG. Und weil das nicht ZZZ ist fange ich mit den Anweisungen wieder von vorne an.

Solange bis ich auf ZZZ stoße. In Part 1 zähle ich die einzelnen Schritte dafür und das ist die Lösung.
Ich erkenne aber die Abkürzung nicht. Per "Brute Force" war das noch machbar, aber natürlich für Teil 2 nicht

Nachtrag: Erkläre es bitte als wäre ich 10 Jahre alt ...

bluegaspode

@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

@bluegaspode Danke!

Ich behaupte nicht es verstanden zu haben, aber ich habe das Ergebnis (und den 2. Stern).
Ich habe alle gefunden Pfade bzw. deren Anzahlen in den von @OliverIO geposteten kgv Rechner gepackt und es kam tatsächlich die richtige Lösung dabei heraus.

Nur der Vollständig halber habe ich das noch als Funktion in mein Programm eingebaut.

So habe ich doch noch meinen 2. Stern heute geschafft, ich hatte schon verzweifelt ...

BananaJoe

Das lief heute, Day 9 schon besser, auch wenn ich wieder einen selten dämlichen Fehler drin hatte.
Meine Ausstiegsbedingung war das die Summe(!!!) aller Werte einer Stufe 0 ist. Nun gab es natürlich 4 Zeilen in den Daten wo es auch einen Schritt gab der Zufällig 0 ergibt. Ich hatte mir alles ausgeben lassen, aber erst auf den 10. Blick gesehen das bei einigen Zeilen die 0 0 0 0 fehlte.

Dafür war Part 2 mal ausgesprochen leicht ... es musste nur eine Zeile mit einem ArrayReverse ergänzt werden

OliverIO

@bananajoe sagte in ioBroker Advent of Code:

Ich behaupte nicht es verstanden zu haben

aber eigentlich dann simpel. evtl denkt man nicht direkt gleich daran, das es so funktionieren könnte.

du hast 3 start-nodes. mit
bei 1 kommst du in 2 schritten durch,
bei 2 kommst du in 3 schritten durch
bei 3 kommst du mit 4 schritten durch

dann musst du 234 machen, das ist die Anzahl der schritte wo zum ersten mal alle 3 startnodes zugleich am gleichen endpunkt ankommen. daher auch kgv=kleinster gemeinsamer vielfacher.
theoretisch kann man das auch in javascript rechnen. es kann da aber schnell zu überläufen kommen. ich denke die webseite nimmt eine andere bibliothek als die javascript eigenen rechenfunktionen zu verwenden.

BananaJoe

So, der ganze Sonntag ist nur für das Rätsel drauf gegangen ... also Teil B.
Ich hatte mir gleich am Anfang gebaut das er mir das ganze - mit richtigen Ecken und Linien - wieder als Text ausgibt (aka ASCII-Art).
Ich hatte dann zwar eine Lösung, die war aber nur nah dran und die letzten Fehler habe ich dann von Hand gezählt und abgezogen. Ich hatte alle Leerzeichen innerhalb des Pfades mit X markiert, es waren aber noch zu viele da einige ja nicht umschlossen wirklich waren. Aus dem ASCII ein png gemacht, im Malprogramm einmal das Füllwerkzeug genommen und die X die im bunten waren abgezogen.
Aber mich hatte natürlich mein Ehrgeiz gepackt das ich das mit dem Programm hinbekomme.

Da habe ich jetzt 5h dran verschwendet, ich inzwischen wieder weiter weg von der Lösung wie am Anfang. und bei fast 600 Zeilen Code.

Und sieht man andere "Flitzpiepen" die das mit weniger als 100 Zeilen machen.
Ok, ich musste mir meinen "FloodFill" auch selbst schreiben, inklusive das ich immer wieder an das Limit bei den Rekursiven Aufrufen gestoßen bin.

Hoffentlich ist morgen wieder einfach, eigentlich wollte ich heute doch ganz viel andere Sachen machen.

bluegaspode

@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

@bluegaspode sagte in ioBroker Advent of Code:

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.

genau das hatte ich auch zuletzt gemacht, mir fiel nichts besseres ein.

bluegaspode

@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

Ok, Tag 12 Teil 1 ging ja noch. Wie üblich bin ich bei einer "Brute Force" Lösung gelandet mit Logausgaben.

Für Teil 2 ist das - wie üblich - viel zu langsam. Ich habe mir schon diversen Code anderer angesehen und wie ich es verstehe ist bei denen die Lösung das "in Memory cached" zu machen ... die Möglichkeit fehlt mir irgendwie ..

Edit: und komme in die Limits von AutoIt.
Blöd das die 5 Gruppen per ? verbunden werden ...

bluegaspode

@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.

bluegaspode

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.

NEWS

ioBroker Advent of Code

Support us

1.6k
Online

30.6k
Users

77.1k
Topics

1.2m
Posts

NEWS

ioBroker Advent of Code

Support us

1.6kOnline

30.6kUsers

77.1kTopics

1.2mPosts

1.6k
Online

30.6k
Users

77.1k
Topics

1.2m
Posts