Reprise du message précédent :

Non, faut juste y penser, et se dire qu'on peut le faire en 2 fois.

C'était vraiment sympa l'IntCode l'an dernier, ça se corce assez vite aussi, c'était le fil rouge de 2019. J'avais fait les 3-4 premiers IntCode en Clojure

oui, certes, mais il a utilisé les bonnes fonctions au bon moment. Je soupçonnais qu'il existait la fonction findall, mais j'ai pas trop cherché.

Oui aussi.
Reste que comme je ne savais plus me servir des fonctions de la lib re, j'ai perdu du temps à essayer de lui faire faire ce que je voulais (la capture de la quantité et de la couleur dans le même regex), et puis voyant que l'horloge tournait, j'ai laissé tomber et me suis farci le parse à la main, ce qui n'était pas très compliqué en soi, mais est super moche.

ouai, j'ai vu, on construit un assembleur en fait. Je compte bien continuer dessus.

T'as un github quelque part ?

Tu peux même faire le matching de tout le fichier en 1 regex
https://regex101.com/r/a4D3MF/2 (en PHP : https://3v4l.org/gvFX8)

Pour le cas ici présent, matcher sans extraire c’est pas très utile, et je présume que Perl sait faire ce genre d’extractions mais j’ai pas souvenir que python en soit capable. AFAIK en python quand tu répètes un groupe tu ne récupères que sa dernière application / itération.

J'arrive à extraire en PHP et tu me dis que c'est pas possible en Python ? Tu bluffes
 

>>> import re
>>> p = re.compile(r'((\w+ \w+) bags contain)?(,? (\d+) (\w+ \w+) bags?)+?')
>>> p.findall("""light orange bags contain 1 dark maroon bag, 3 dim maroon bags, 5 striped green bags, 2 pale aqua bags.
... wavy bronze bags contain 3 pale black bags, 5 bright turquoise bags, 4 pale orange bags.
... dark coral bags contain 3 bright lavender bags, 1 pale bronze bag, 2 dull blue bags.
... dim chartreuse bags contain 2 wavy plum bags, 4 wavy teal bags, 1 dark crimson bag.""" )
[('light orange bags contain', 'light orange', ' 1 dark maroon bag', '1', 'dark maroon'), ('', '', ', 3 dim maroon bags', '3', 'dim maroon'), ('', '', ', 5 striped green bags', '5', 'striped green'), ('', '', ', 2 pale aqua bags', '2', 'pale aqua'), ('wavy bronze bags contain', 'wavy bronze', ' 3 pale black bags', '3', 'pale black'), ('', '', ', 5 bright turquoise bags', '5', 'bright turquoise'), ('', '', ', 4 pale orange bags', '4', 'pale orange'), ('dark coral bags contain', 'dark coral', ' 3 bright lavender bags', '3', 'bright lavender'), ('', '', ', 1 pale bronze bag', '1', 'pale bronze'), ('', '', ', 2 dull blue bags', '2', 'dull blue'), ('dim chartreuse bags contain', 'dim chartreuse', ' 2 wavy plum bags', '2', 'wavy plum'), ('', '', ', 4 wavy teal bags', '4', 'wavy teal'), ('', '', ', 1 dark crimson bag', '1', 'dark crimson')]

 
C'est ça que t'appelles l'extraction ou bien c'est autre chose ?

>>> import re
>>> p = re.compile(r'((\w+ \w+) bags contain)?(,? (\d+) (\w+ \w+) bags?)+?')
>>> p.findall("""light orange bags contain 1 dark maroon bag, 3 dim maroon bags, 5 striped green bags, 2 pale aqua bags.
... wavy bronze bags contain 3 pale black bags, 5 bright turquoise bags, 4 pale orange bags.
... dark coral bags contain 3 bright lavender bags, 1 pale bronze bag, 2 dull blue bags.
... dim chartreuse bags contain 2 wavy plum bags, 4 wavy teal bags, 1 dark crimson bag.""" )
[('light orange bags contain', 'light orange', ' 1 dark maroon bag', '1', 'dark maroon'), ('', '', ', 3 dim maroon bags', '3', 'dim maroon'), ('', '', ', 5 striped green bags', '5', 'striped green'), ('', '', ', 2 pale aqua bags', '2', 'pale aqua'), ('wavy bronze bags contain', 'wavy bronze', ' 3 pale black bags', '3', 'pale black'), ('', '', ', 5 bright turquoise bags', '5', 'bright turquoise'), ('', '', ', 4 pale orange bags', '4', 'pale orange'), ('dark coral bags contain', 'dark coral', ' 3 bright lavender bags', '3', 'bright lavender'), ('', '', ', 1 pale bronze bag', '1', 'pale bronze'), ('', '', ', 2 dull blue bags', '2', 'dull blue'), ('dim chartreuse bags contain', 'dim chartreuse', ' 2 wavy plum bags', '2', 'wavy plum'), ('', '', ', 4 wavy teal bags', '4', 'wavy teal'), ('', '', ', 1 dark crimson bag', '1', 'dark crimson')]

Aah non je suis sur mon tel’ donc j’avais raté d’avoir rendu un groupe optionnel au début pour pouvoir faire un findall, j’avais eu l’impression d’un groupe de tête suivi d’un groupe répété, qui marcherait tout le bordel en un seul match.
 
Edit: mais donc quel est l’intérêt de la répétition sur le second groupe?

Oui j'avais tenté ça aussi au début mais j'ai pas réussi.

Il avait des grosses nuts Ayerton Senna quand meme
https://www.youtube.com/watch?v=sbTrNKBAfI8

Quelle plaie ce flaie ! Je rêve d'un challenge qui ne classera plus flaie haut !

 
Première fois que j'ai un pépin avec Amazon. J'aimerais bien connaitre le souci, c'était le Kindle de ma fille pour Noel

day 8, done
D'ailleurs el muchacho, celui d'aujourd'hui devrait te plaire

Rha, done aussi, 38 minutes...

Done aussi

Done aussi en 21 minutes (12 + 9) : https://github.com/ratibus/adventof [...] 020/day_08

Bravo, au final pas mal de dev y participent aussi
 
12:24 pour les deux, Kotlin avec extensions qui vont bien:
 

Joli
J'ai merdé la lecture sur la 2è partie en lisant qu'il fallait inverser jmp et acc... J'ai perdu 5 minutes en debug
En tout cas c'était nettement plus facile que hier.
 
Tu as fait les années précédentes ? Ca dégénère à partir de quel jour ?  

C'est la 6ème année que je le fais, généralement à partir du jour 16/17 je trouve que ça deviens chaud et ça prends plus de temps.
Mais ça m'empêche pas de le prendre, le temps
Cela dit il y'a des années plus simples que d'autres, 2019 était plus difficile que 2018 AMA.

Joli, moi j'ai mis 50 mn, parce que j'essayais de reproduire le tableau de l'exemple, qui est mal foutu je trouve et les valeurs de l'acc représentent mal ce qui se passe. L'exemple m'a vachement confus.

Ah et puis ensuite, dans le 2e exercice, j'ai eu des soucis parce que je ne faisais pas un deepcopy() de la liste des instructions ce qui faisait que les swap('jmp', 'nop') s'accumulaient au lieu qu'une seule soit changée à chaque fois. J'avais lu hier quelque part que a=b[:] faisait un deepcopy de a mais c'était faux, c'est du shallow copy.
Encore un truc que j'aurais dû savoir.

ah, et si masklinn passait par là, je suis curieux de savoir comment faire proprement un swap('jmp', 'nop') plutôt que ceci:

if instructions[index] == 'jmp':
        instructions[index] = 'nop'
    elif instructions[index] == 'nop':
        instructions[index] = 'jmp'

if instructions[index] == 'jmp':
        instructions[index] = 'nop'
    elif instructions[index] == 'nop':
        instructions[index] = 'jmp'

un opérateur ternaire au pire ?

p'tain tu écris tout ça en 12 mn sans faire d'erreur ? Tu respires le PHP.
 
ici ma soluce

if instructions[index] == 'jmp':
        instructions[index] = 'nop'
    elif instructions[index] == 'nop':
        instructions[index] = 'jmp'

Tu n'a pas besoin d'une deep copy si à chaque fois que tu itères sur le programme à modifier tu en refais une copie avec [:].
Pour ton truc, une solution courte si tu n'as que c'est deux là à swaper peut-être:

instructions[index] = 'jmpnop'.replace(instructions[index], '')

mais faut checker d'abord

c'est à dire ?

j'ai une liste de listes à la suite de

ohhh, un détecteur de cycles...
qui a utilisé le lièvre et la tortue ?

Je les ai mis tous les deux dans un set

 
c'est pas vraiment moins verbeux, et c'est moins clair à lire je trouve

j'ai compris cette phrase et je vois à quel algo il fait allusion !

Je suis le seul à avoir cherché l'instruction à switcher autrement qu'en mode bourrin?  
 
En gros, j'ai exécuté le programme jusqu'à la boucle infinie, et je suis remonté dans les instructions switchables.

Salut
 
Par simple curiosité vous savez si ça existe la migration de VMs a chaud entre providers de cloud différents ?
 
Merci

Comment ça fonctionnerait?

en sérialisant la mémoire ?

Puais non, python faut généralement que du shallow copy sauf requête explicite, comme la majorité des langages du style.  
 

if instructions[index] == 'jmp':
        instructions[index] = 'nop'
    elif instructions[index] == 'nop':
        instructions[index] = 'jmp'

Pas vraiment. Il y a pour les chaînes (str.translate) mais pas pour les séquences. Après tu peux utiliser un dict avec deux entrées et faire un instructions[index] = swap.get(instructions[index], instructions[index]) mais bon…

 
Et transmettant le disque. Ça existe déjà au sein d'un DC.
 
https://docs.citrix.com/en-us/citri [...] grate.html

C’est assez chaud de faire du stockage partagé de disques de VMs entre providers cloud différents, je présume.  

 
J'ai pas dit que c'était facile d'autant plus que je ne pense pas que les différents acteurs aient intérêts à le faire.    
Je me demandais juste si cela avait déjà été fait  
 
Dans le truc que je vois pour le moment qui risque d'être vraiment différent c'est la migration des connections réseau. Après pour avoir une meilleure idée du sujet il n'y a pas de secrets : il faut creuser  .

En terme de complexité on ne gagne pas vraiment si je comprends ton algo, vu qu'il faut quand même exécuter le programme pour chaque switch.

On peut le faire je pense en O(N), en n'exécutant le programme qu'une fois: on monte depuis le départ jusqu'à la boucle infinie et on mémorise acc montant pour chaque arrivée; Puis on fait pareil en partant de la fin (pour ça il faut avoir construit un graphe lors de la lecture des données d'entrée). Ensuite on boucle une dernière fois pour trouver un chemin qui, en swappant, permet d'aller du trajet montant au trajet descendant. J'ai perdu un peu de temps à essayer d'implémenter ça mais j'ai réalisé que la méthode bourrin marchait tout aussi bien...

oui voila

 
Je passe de 201 runs en mode bourrin à 56, quand même.
 
Comme amélioration, il y aurait déjà de repartir de l'instruction que tu switches au lieu de repartir du début à chaque tour.
 

Marrant la ligne finale que j'ai pour trouver l'exécution qui se termine :  
 

 
Ça dépend de la taille de la boucle, donc tu gagnes pas forcément un ordre de grandeur, mais t'as potentiellement un gain significatif en termes de temps d'exécution.