Calendrier de l'avent 🎄 (mais sans chocolats)

[Xerto]

Jour 6, la partie 1 est ezpz, la 2 j’ai semi-bruteforcée pour éviter de perdre trop de temps Il y a sûrement moyen d’être très efficace en faisant une dichotomie, mais honnêtement flemme de coder ça.

Le code donc, ça tourne en ~1.4s sur mon vieil i3

[zepostman]

Day 6 après le day 5 :

Torché en 20 minutes. Surement moyen d’optimiser aussi mais déjà c’est pas de la pure brute force donc je suis content.

[arzhuras]

Bon, j’ai put finaliser le day 5 un peu en décalé! Comme tout le monde, beaucoup de temps dans des bugs a la con mais au final un algo recursif propre et hyper rapide. C’était violent le debugage
Au final plus de ligne de print que de ligne de code
Et aussi une fonction d’overlap de la mort a garder sous le coude pour la prochaine fois !

Pas encore regardé le day 6, mais ça peut pas être pire… si ?

[astro]

@anon10092024

un vachement vicieux, lié à python et que je ne connaissais pas. J’ai suspecté assez vite un problème dans ma boucle.
Le problème en question : quand on fait un for sur une liste, et qu’on supprime l’élément en cours de la liste, python « saute » l’élément suivant !
En fait l’index change et comme il y a un élément de moins dans la liste, tout est décalé de un. C’est pas illogique quand on y réfléchi, mais ca m’a surpris.
J’ai contourné le truc en faisant un while avec un pop(), et je rajoute à la liste les éléments à vérifier restant de l’intersection

J’ai le même comportement sur le langage que j’utilise au boulot, il suffit de parcourir la liste a l’envers .

[arzhuras]

Bon Day 6, rien a voir avec hier .
Je pense que le day 5 a du en décourager qq uns!

[zepostman]

Deux heures à essayer de debug hier sans résultat. Deux minutes pendant ma pause aujourd’hui et je vois direct le souci. Dégouté. Mais j’y suis arrivé.

[anon10092024]

Bon, jour 6 qui passe tranquille en brute force (3s en python …). J’ai même pas essayé autrement. L’algo est stupide, mais ça passe.

J’avais commencé à réfléchir à l’équation associé. Mais entre une boucle for écrite en 30 secondes et résoudre l’équation, j’ai eu la flemme

Bref, jour 6 torché en 20min en buvant mon café

Jour 6

https://github.com/Nebsorg/AdventOfCode/blob/main/2023/Day06.py

2023 --- Day 6: Wait For It ---
****** First Star = 281600
****** Second Star = 33875953

Duration: 0:00:03.641092

[Grenat2]

J’ai commencé un peu tard cette année mais c’est bon j’ai rattrapé le retard.
Jour 6 tranquille, fait aussi en 20 min.
Le jour 5 n’était pas si compliqué avec la méthode bruteforce. 20 min à coder, 20 minutes à exécuter (en multithread) sur ma vieille machine. Un peu la flemme de faire un code plus optimisé, j’aurais sûrement mis plus de temps au total

[Xerto]

Pas trop de soucis pour le jour 7. Code

[arzhuras]

Pas de difficulté particulière sur ce jour 7.

Juste quelques astuces a utiliser pour se simplifier la vie:

astuce 1

Transformer TJQKA en ABCDE pour faire un tri alpha pour le rank.
Et remplacer J part 1 pour la part 2

astuce 2

Compter le nombre de carte unique pour faire la catégorisation (utilisation du set en python!) → plus que 5 cas

J’arrive a une catégorisation assez simple au final.

Résumé

uniqueCardLst = list(set(hand))
uniqueCardCnt = len(uniqueCardLst)
if uniqueCardCnt == 5: 
    handType = HIGH_CARD
elif uniqueCardCnt == 4: 
    handType = ONE_PAIR
elif uniqueCardCnt == 3:
    if hand.count(uniqueCardLst[0]) == 2 or hand.count(uniqueCardLst[1]) == 2:
        handType = TWO_PAIR
    else:
        handType = THREE_OF_A_KIND
elif uniqueCardCnt == 2:
    if hand.count(uniqueCardLst[0]) == 1 or hand.count(uniqueCardLst[0]) == 4:
        handType = FOUR_OF_A_KIND
    else:
        handType = FULL_HOUSE
elif uniqueCardCnt == 1: 
    handType = FIVE_OF_A_KIND

Avez vous trouvé d’autres astuces ?

[anon10092024]

Jour 7 terminé aussi. Pas vraiment de difficulté.

Je suis passé par l’établissement d’une valeur numérique respectant l’ordre des différents main, puis j’ai fais une fonctionne qui évalue une main suivant cette méthode.

Par contre, je n’ai pas pensé à utiliser l’ordre alphabetique comme @arzhuras et j’ai beaucoup sa solution qui est bien plus simple et efficace !

jour 7

https://github.com/Nebsorg/AdventOfCode/blob/main/2023/Day07.py

2023 --- Day 7: Camel Cards ---
****** First Star = 246912307
****** Second Star = 246894760

Duration: 0:00:00.012524

[Dadal]

@arzhuras

Avez vous trouvé d’autres astuces ?

Pareil, une fonction pour trier les cartes (j’me suis juste « cassé la tête » en « base 13 » parceque 13 cartes et que j’aime pas triés des strings). Et pour le type de mains, comme toi. J’ai juste mis un switch à la place des elif et je retourne un valeur. Qu’il suffit d’ajouter au début de la main pour faire le tri tout seul.

Résumé

match len(types) :
        case 5 : return 0 #highCard
        case 4 : return 1 #One pair
        case 3:             
            if t[1] ==2: return 2 #Two pair
            return 3 #3 of a kind
        case 2 : 
            if t[0] ==2: return 4 #full house
            return 5 #4 of a kind
        case 1 : return 6 #5 of a kind

Edit: Le « base 13 », c’est juste pour dire que j’ai dico carte->valeur et que j’ai une boucle qui fait

    for char in cards:
        result *= 13
        result += valueDic[char]
    return result

rien de bien difficile si on compte bien le nombre de carte (ouai j’aurais du mettre len(valueDic) à la place de 13, ça m’aurait évité un run de débug )

[arzhuras]

Suite a ta remarque, je viens de voir que depuis le Python 3.10 (sortie il y a 2 ans), ils ont enfin mit un équivalent au switch case dans Python! Ca me rendait fou ce manque.

Python Switch Statement – Switch Case Example

Enfin Bon j’ai plus qu’a le tester!

[Dadal]

Aaah c’est pour ça que je vois pleins d’exemples avec ces horribles elif partout… Les switch existaient pas. Du coup les programmeurs pythons remontent un peu dans mon estime

[arzhuras]

Et je viens de tester ! Ca marche!
Ca rend vraiment le code plus lisible

Oui, je te rassure, on ne faisait pas ça que par pure masochisme

Le Python, c’est la vie
+1 programming language war

The War of Programming Languages

[deneb]

Je bloque sur la partie 2 du jour 8. Je sens bien qu’il doit y avoir un truc où il faut détecter les moments où ça se répète et utiliser ces infos pour calculer la réponse intelligemment, mais je n’arrive pas à mettre le doigt dessus.

Va falloir que je reprenne un café ou que je sorte une feuille et un crayon.
C’est très frustrant que ça arrive le jour 8.

Bon courage à vous !

[deneb]

Bon, je l’ai passé, mais c’était vraiment du grand n’importe quoi. Je ne comprends toujours pas pourquoi bidouiller ainsi les chiffre que j’ai trouvé donne le bon résultat.
Le jeu de données fourni a un comportement bien particulier qui n’a rien de garanti à première vue, les chemins auraient pu se comporter d’autres façon, et il n’y a pas moyen de le savoir de prime abord.

Ça a fini sur un vieux site en PHP pour calculer le Least Common Multiple, je me sens sale…

[arzhuras]

Je viens de passer le jour 8.
Pour la part2, il faut simplement trouver les cycles de chaque entrée/sortie individuellement → ne surtout pas dérouler les chemins en parallèles. J’ai vérifié aussi que la sortie Z repointe bien sur le même circuit que pour l’entrée A: il y a donc qu’un seul niveau de boucle pour une entrée donnée
Et ensuite y’a plus qu’a Calculer le PPCM des différents cycles (j’ai pas refait le PPCM moi même, j’ai été chopper un bout de code sur le net… ça va rentrer dans ma librairie ça aussi!

[Xerto]

En fait l’input est bien calibré, mais il faut le découvrir (même si l’exemple donne un peu le ton) : les cycles pour chaque position de fin xxZ sont de même longueur, c’est à dire que si on part de xxZ, il faut N pas pour retourner à xxZ, si on part de yyZ, il faut aussi N pas pour retourner à yyZ. Après il faut trouver combien de steps il faut en partant de chaque uuA pour aller à un xxZ. Et finalement ça donne des équations à résoudre du type e + xN = M, d + xN = M, etc.

[deneb]

@arzhuras

J’ai vérifié aussi que la sortie Z repointe bien sur le même circuit que pour l’entrée A: il y a donc qu’un seul niveau de boucle pour une entrée donnée

Et ensuite y’a plus qu’a Calculer le PPCM

L’input est encore mieux calibrée que ça: Pour que ça marche il faut que la sortie Z repointe bien sur le même circuit que pour l’entrée A, mais aussi le fasse en autant d’étapes qu’entre l’entrée A et le début de la boucle, ce qui est loin d’être acquis vu qu’on a quelques étapes avant de commencer la boucle à chaque fois.

Rien dans le jeu d’exemple ou les instructions ne laisse à supposer que c’est forcément le cas.