Eric P. a écrit 209 commentaires

Dans la boite ou je travaille (en Australie), il n'y a pas besoin de fournir de lettre de motivation (cover letter) pour candidater.
Les RHs font une selection simple: enlevent les personnes qui n'ont pas de visa de travail ou les profils complement a cote de la plaque.
Ensuite ils demandent aux candidats de passer un test de programmation en ligne - je precise je parle du recrutement de devs. Il parait qu'on perd une bonne partie des candidats, je ne sais pas s'ils ont la femme de passer le test en ligne ou ils abandonnent apres quelques questions.
Ensuite les CVs restants vont vers le manager qui recrute, avec le resultat du test en ligne. Les CVs ici font habituellement 2-3 pages, sauf pour les 'graduates' (qui sortent d'universite et n'ont pas encore grand chose a mettre dessus). Le manager selectionne une dizaine de candidats pour entretiens.
Le premier entretien commence avec une discussion, on laisse au candidat l'opportunite de dire ce qu'il aurait dit dans une lettre de motivation, et on continue avec un nouvel exercice de programmation, mais en live et en se focalisant aussi sur la capacite a echanger, trouver des solutions constructives ensemble etc. Ce qui se passe tous les jours dans une equipe de dev.
Ensuite, un autre entretien avec un autre manager+HR, plus classique, mais c'est rare que ca change l'opinion du premier entretien.

En tant que recruteur, ce qui est assez difficile c'est essayer d'eviter les biais, notamment le biais de similitude.

Apres, pas mal d'embauches se font en fin de stage quand on est content du stagiaire (et qu'il est content du boulot qu'on fait).

Excusez l'absence d'accents dans mes commentaires, j'habite en Australie et n'ai pas de clavier francais sous la main.

Ce qu'ils ont decide est de ne plus couper le Docker Free Team Plan pour les membres actuels, mais il n'est plus possible de s'inscrire au Docker Free Team Plan depuis 2021, d'apres leur FAQ.

Donc la strategie generale ne change pas. Le Docker-sponsored Open Source plan est toujours reserve aux projets Open Source non-commerciaux.
Ca reste problematique pour les projets Open Source qui ont un petit revenu (donc ne qualifient pas pour DSOS) de publier leurs images sur Docker Hub, s'ils n'etaient pas inscrits au Free Team plan depuis 2021.

Excusez l'absence d'accents dans mes commentaires, j'habite en Australie et n'ai pas de clavier francais sous la main.

Tu as des references?
J'ai fait pas mal de traductions d'articles anglais vers le francais (sur des lieux geographiques qui ne portaient pas trop a debat) et a ma connaissance, aucun n'a ete supprime et je n'ai eu aucune remarque.

Cette page d'aide a aussi l'air de dire que la pratique est tout-a-fait possible, voire recommandee.
https://fr.wikipedia.org/wiki/Aide:Traduction

Excusez l'absence d'accents dans mes commentaires, j'habite en Australie et n'ai pas de clavier francais sous la main.

Je me doutais qu'il y avait un algorithme assez simple comme ca pour faire la conversion, mais comme Jerome ce n'est pas ma specialite du tout et a cause du fait que les entiers vont de -2 a 2 j'aurais ete incapable de le trouver.
Du coup j'ai fait un algo a ma sauce qui est nettement moins joli (mais au moins je le comprends). Mais j'ai ete plutot vite, environ une heure.

Bravo Yth pour tes algos et pour avoir remporte le leaderboard linuxfr!

Excusez l'absence d'accents dans mes commentaires, j'habite en Australie et n'ai pas de clavier francais sous la main.

J'aime beaucoup ta solution en effet. Joli et super efficace!

Chez moi aussi, c'est le calcul des grilles qui est plus long que la solution. Vu qu'il n'etait execute que moins de 300 fois par trajet, je n'ai pas cherche a l'optimiser. La ou je passe le plus de temps c'est pendant le deepcopy de ma grille avant de commencer la suivante.
Justement j'ai beaucoup ton calcul de grilles. A la place de looper sur les etats et mettre a jour la grille complete, tu calcules chaque blizzard pour chaque etat, et ensuite tu zippes tout ca avec l'unpacking operator.

Le PPCM par contre ne te fait pas gagner tant que ca vu qu'il n'est pas beaucoup plus petit que le nombre complet d'etats a connaitre.

Excusez l'absence d'accents dans mes commentaires, j'habite en Australie et n'ai pas de clavier francais sous la main.

Quelqu'un a quand meme fait une modelisation 3D de tous les problemes:
https://www.youtube.com/playlist?list=PLkVWdOnWoL8PbyxdR6_Qq46s8T4nMYlol

Ca peut etre sympa a regarder en lisant les enonces sur Advent of Code.
Je n'ose imagine le temps que cette personne a passe pour d'abord resoudre le probleme, et ensuite faire toute la modelisation 3D.

Excusez l'absence d'accents dans mes commentaires, j'habite en Australie et n'ai pas de clavier francais sous la main.

Bien joue!

Ma solution prend:

epignet@dell> time bin/pypy 2022/day24.py
trip1=249 trip2=246 trip3=240 (trip1+trip2+trip3)=735
bin/pypy 2022/day24.py 5.65s user 0.07s system 99% cpu 5.748 total

5.65s pour la partie 2.

J'utilise une liste de dictionaires pour ma grille, le dictionnaire etait le nombre de chaque caractere dans la case.
J'utilise un deque pour mon BFS.

Ce que j'ai fait pour optimiser au maximum, c'est:
python -m cProfile 2022\day24.py
qui ma dit que c'etait ma fonction qui retourne les cases libres autour de moi, qui etait la ou je passais le plus de temps. Du coup j'ai precalcule si chaque case etait libre au moment de mettre a jour les blizzards, pour ne pas avoir a le faire pour chaque essai.
Chaque essai consiste juste a est verifier les cases libres autour de soi et ajouter a un deque, ce qui est ultra rapide si les cases libres sont precalculees.

J'ai fait la partie 2 apres le repas de reveillon - eh oui il est 21:46 a Sydney a l'heure ou j'ecris, c'est peut-etre les quelques verres de Champagne qui m'ont fait un peu galerer sur un bug bete (je recalculais la grille une fois de trop apres chaque trajet) mais la partie 2 n'ajoutait pas de difficulte.

Excusez l'absence d'accents dans mes commentaires, j'habite en Australie et n'ai pas de clavier francais sous la main.

889 rounds pour moi.
Et mon programme prend moins de 2s.
Il n'est pas tres different des votres, mais je stocke les coordonnees des Elfs dans un dictionary a la place d'un set, car la plupart des acces se font a key connue. Je me suis dit qu'un acces par key serait plus rapide qu'un 'in' sur un set qui parcourerait le set.
Ce qui est en fait faux, d'apres https://wiki.python.org/moin/TimeComplexity
Le set etant implemente comme un hash table, en moyenne un in dans un set est en O(1).

Cela dit mon implementation etant presque instantanee je n'ai rien eu a faire pour la partie 2.

Excusez l'absence d'accents dans mes commentaires, j'habite en Australie et n'ai pas de clavier francais sous la main.

Alors la je suis oblige de te demander plus de details sur cette visualisation qui est absolument sublime.
Meme les axes sont super jolis.
Quelle bibliotheque ou outil as-tu utilise pour ca?

Personnellement je n'ai paradoxalement pas trop galere pour ce probleme. A peu pres une heure pour chaque partie. Pour la partie 2 je n'ai meme pas ecrit la fonction de transition de faces pour les donnees de test pour gagner du temps. C'est la premiere fois que je zappe les donnees de test. Les mouvements avaient l'air corrects sur ma visualisation, et une fois n'est pas coutume c'est passe du premier coup.

Excusez l'absence d'accents dans mes commentaires, j'habite en Australie et n'ai pas de clavier francais sous la main.

Ce coup ci j'ai ete paresseux, et pour la deuxieme partie mon code ne marche pas avec tous les inputs.
J'ai fait le cube correspondant a mon input en papier en inscrivant le numero des faces, pour voir quelle face transitionnait vers quelle face, et j'ai hardcode le passage d'une face a l'autre (methode wrap3D).

from dataclasses import dataclass
import re

board = []
drawboard = []
ARROWS = {0: ">", 1: "v", 2: "<", 3: "^"}
isPart2 = False

@dataclass
class Me:
    x: int
    y: int
    direction: int  # 0=R 1=D 2=L 3=U

    def wrap2D(self):
        match self.direction:
            case 0:  # right
                return next(x for x in range(len(board[self.y])) if board[self.y][x] != " "), self.y, 0
            case 1:  # down
                return self.x, next(y for y in range(len(board)) if board[y][self.x] != " "), 1
            case 2:  # left
                return len(board[self.y]) - 1, self.y, 2
            case 3:  # up
                return self.x, next(y for y in range(len(board) - 1, -1, -1) if findInBoard(self.x, y) != " "), 3

    def wrap3D(self):
        match self.direction:
            case 0:  # right
                if self.y < 50:  # right of 2 -> right of 5 reversed
                    return 99, 149 - self.y, 2
                elif self.y < 100:  # right of 3 -> down of 2
                    return self.y + 50, 49, 3
                elif self.y < 150:  # right of 5 -> right of 2 reversed
                    return 149, 49 - self.y + 100, 2
                else:  # right of 6 -> down of 5
                    return self.y - 100, 149, 3
            case 1:  # down
                if self.x < 50:  # down of 6 -> up of 2
                    return self.x + 100, 0, 1
                elif self.x < 100:  # down of 5 -> right of 6
                    return 49, self.x + 100, 2
                else:  # down of 2 -> right of 3
                    return 99, self.x - 50, 2
            case 2:  # left
                if self.y < 50:  # left of 1 -> left of 4 reverse
                    return 0, 149 - self.y, 0
                elif self.y < 100:  # left of 3 -> up of 4
                    return self.y - 50, 100, 1
                elif self.y < 150:  # left of 4 -> left of 1 reverse
                    return 50, 49 - self.y + 100, 0
                else:  # left of 6 -> up of 1
                    return self.y - 100, 0, 1
            case 3:  # up
                if self.x < 50:  # up of 4 -> left of 3
                    return 50, self.x + 50, 0
                elif self.x < 100:  # up of 1 -> left of 6
                    return 0, self.x + 100, 0
                else:  # up of 2 -> down of 6
                    return self.x - 100, 199, 3

    def moveWrap(self):
        x, y, dir = self.wrap3D() if isPart2 else self.wrap2D()
        if findInBoard(x, y) == ".":
            self.x = x
            self.y = y
            self.direction = dir

    def drawPosition(self):
        s = drawboard[self.y]
        drawboard[self.y] = s[: self.x] + ARROWS[self.direction] + s[self.x + 1 :]

    def moveBy1(self, offsetX, offsetY):
        match findInBoard(self.x + offsetX, self.y + offsetY):
            case ".":
                self.x += offsetX
                self.y += offsetY
            case " ":
                self.moveWrap()
            case "#":
                pass

    def move(self, size: int):
        for i in range(size):
            match self.direction:
                case 0:  # right
                    self.moveBy1(1, 0)
                case 1:  # down
                    self.moveBy1(0, 1)
                case 2:  # left
                    self.moveBy1(-1, 0)
                case 3:  # up
                    self.moveBy1(0, -1)
            self.drawPosition()

def findInBoard(x, y):
    if x == -1 or y == -1 or y >= len(board) or x >= len(board[y]):
        return " "
    return board[y][x]

with open("2022/input_files/day22") as f:
    data = "".join([line for line in f])
    groups = [group.split("\n") for group in data.split("\n\n")]

board = groups[0]
drawboard = board.copy()
instructions = groups[1][0]

moveSizes = list(map(int, re.findall(r"(\d+)", instructions)))
turns = re.findall(r"([A-Z]+)", instructions)

me = Me(board[0].index("."), 0, 0)

for moveSize, turn in zip(moveSizes, turns):
    me.move(moveSize)
    me.direction += 1 if turn == "R" else -1
    me.direction %= 4
me.move(moveSizes[-1])

password = 1000 * (me.y + 1) + 4 * (me.x + 1) + me.direction
print(f"{password=}")

Excusez l'absence d'accents dans mes commentaires, j'habite en Australie et n'ai pas de clavier francais sous la main.

En fait j'avais commence par un DFS (en profondeur), et je l'ai reecrit completement en un BFS (en largeur) pour justement pouvoir comparer les chemins et garder les meilleurs.
Au final la partie algo est assez simple et standard, c'est assez simple de convertir un DFS en BFS.

C'est vrai que c'est impossible de savoir quand tu as la meilleure solution.
Pour moi, j'ai commence a 100 000, Advent of code m'a confirme que c'etait le bon resultat, et je suis descendu petit a petit jusqu'a 100. A 50 ca me trouvait moins de geodes.

J'aurais pu faire le contraire, commencer bas, tester dans Advent of Code, puis monter si le resultat etait trop bas.

Comme le dit le commentaire precedent, tout depend des inputs, mais ca depend aussi de la fonction de scoring et si tu as des heuristiques en plus de la fonction de scoring.

Excusez l'absence d'accents dans mes commentaires, j'habite en Australie et n'ai pas de clavier francais sous la main.

Il faut voir le verre a moitie plein, si je regarde le leaderboard plus personne ne peut te rattraper et ta place sur le podium est garantie!

On est encore 8 actifs dans le leaderboard, donc en gros si j'ai bien compris les regles, on peut tu peux gagner au maximum 7 points par jour sur les autres, et il ne reste que 4 jours.

Excusez l'absence d'accents dans mes commentaires, j'habite en Australie et n'ai pas de clavier francais sous la main.

Personnellement j'ai fait un Tree et j'ai utilise de la recursion pour les deux parties.

1ere partie: node::calculate() renvoie child1.calculate() plus/moins/fois/divise par child2.calculate()

2e partie: node::findUnknown(expectedResult)-> Unknown
D'abord je fait un calculate() de chaque child pour savoir qui a une valeur et qui a l'unknown.
Imaginons que child1 a la valeur et node.operation est *, ma fonction retourne findUnknown(expectedResult / child1.val)
Imaginons que child1 a la valeur et node.operation est +, ma fonction retourne findUnknown(expectedResult - child1.val)
Etc.

Je fais findUnknown recursivement a partir du root et ca me donne la bonne reponse.

Excusez l'absence d'accents dans mes commentaires, j'habite en Australie et n'ai pas de clavier francais sous la main.

Tout-a-fait! C'est plus efficace comme tu le proposes et ca marche pareil.

Excusez l'absence d'accents dans mes commentaires, j'habite en Australie et n'ai pas de clavier francais sous la main.

J'oubliais de dire, sans liste chainee, avec une liste python toute bete, ca prend une demi-seconde avec les donnees reelles.

Excusez l'absence d'accents dans mes commentaires, j'habite en Australie et n'ai pas de clavier francais sous la main.

Pour moi, pas de modelisation en classes aujourd'hui.
Le truc qui m'a pris du temps c'est de realiser qu'il y avait plusieurs fois les memes valeurs dans les donnees reelles. J'ai resolu ca au plus vite en stockant une liste de tuples (valeur, rang d'apparition de cette valeur).

is_part_2 = True
original_sequence = []
with open("2022/input_files/day20") as f:
    for data in f:
        n = int(data.rstrip()) * (811589153 if is_part_2 else 1)
        c = [x[0] for x in original_sequence].count(n)
        original_sequence.append((n, c))

sequence = original_sequence.copy()
for _ in range(10 if is_part_2 else 1):
    for n, occurence in original_sequence:
        old_index = sequence.index((n, occurence))
        new_index = (old_index + n) % (len(sequence) - 1)
        if new_index == 0:
            new_index = len(sequence) - 1
        sequence.insert(new_index, sequence.pop(old_index))

i0 = sequence.index((0, 0))
a = (i0 + 1000) % len(sequence)
b = (i0 + 2000) % len(sequence)
c = (i0 + 3000) % len(sequence)
print(f"{sequence[a][0]+sequence[b][0]+sequence[c][0]=}")

Excusez l'absence d'accents dans mes commentaires, j'habite en Australie et n'ai pas de clavier francais sous la main.

En fait je peux descendre mon top d'options a garder a chaque minute jusqu'a 100 et les resultats sont toujours corrects:

part1_quality_with_mult=2193 part2_quality_product=7200
pypy3.9-v7.3.10-linux64/bin/pypy day19.py 0.26s user 0.05s system 52% cpu 0.593 total
0.26s elapsed pour l'ensemble des deux parties!

Excusez l'absence d'accents dans mes commentaires, j'habite en Australie et n'ai pas de clavier francais sous la main.

Je suis un peu degoute sur celui-ci, j'ai perdu un temps fou pour une erreur bete.
J'avais du code qui me donnait les bonnes reponses 9 et 12 sur l'exemple, mais beaucoup trop lent.
Du coup je commence a ajouter des heuristiques d'optimisation. J'arrive a faire descendre le temps d'execution dans la minute, je commence a tester et je ne trouve plus que 7 et 10. Je me dis que mes optims sont trop brutales et je perd litteralement des heures a essayer de trouver des optims qui me redonnent le nombre correct… avant de realiser que j'avais introduit un bug et je ne collectais plus les ressources lors de la minute 24…

Bon apres fix de ce probleme, j'ai un algo suffisemment rapide qui me donne les bonnes reponses pour la partie 1, et aussi pour la partie 2.
Je ne garde qu'un nombre fixe d'options a chaque minute, je trie les options par score et je garde le top 200000 (j'aurais pu descendre beaucoup plus bas), donc le temps d'execution est a peu pres lineaire, et la partie 2 ne posait pas de probleme.

Excusez l'absence d'accents dans mes commentaires, j'habite en Australie et n'ai pas de clavier francais sous la main.

A peu près pareil pour moi. Mais simple BFS a la place de Dijkstra.
Code non cleané et non optimisé (pas besoin aujourd'hui, phew).

def included(cube):
    for i in range(3):
        global max_coordinate
        if cube[i] < -1 or cube[i] > max_coordinate + 1:
            return False
    return True

def get_adjacents(cube):
    x, y, z = cube
    for adj in [
        (x, y, z + 1),  # up
        (x, y, z - 1),  # down
        (x - 1, y, z),  # left
        (x + 1, y, z),  # right
        (x, y - 1, z),  # back
        (x, y + 1, z),  # front
    ]:
        if included(adj):
            yield adj

droplet = []
max_coordinate = 0
with open("2022/input_files/day18") as f:
    for data in f:
        cube = tuple(map(int, data.rstrip().split(",")))
        max_coordinate = max(max_coordinate, max(cube))
        droplet.append(cube)

# Start BFS on top left corner to find exterior area
exterior = [(0, 0, 0)]
queue = []
queue.append((0, 0, 0))
while queue:
    cube = queue.pop(0)
    for adj in get_adjacents(cube):
        if adj not in exterior and adj not in droplet:
            exterior.append(adj)
            queue.append(adj)

part1_surface = 0
part2_surface = 0
for cube in droplet:
    for adj in get_adjacents(cube):
        if adj not in droplet:
            part1_surface += 1
            if adj in exterior:
                part2_surface += 1
print(f"{part1_surface=}")
print(f"{part2_surface=}")

Excusez l'absence d'accents dans mes commentaires, j'habite en Australie et n'ai pas de clavier francais sous la main.

Je viens de le finir, et il m'a fallu plusieurs heures aussi.

Ma premiere idee d'optimisation apres la partie 1 c'etait d'utiliser @functools.lru_cache pour gagner du temps au cas ou certains des inputs se repetaient. La suite de 'jets' est tres longue, mais sur une quantite si enorme d'essais j'avais un peu d'espoir.
Le cache aidait, mais pas suffisamment pour avoir une reponse suffisamment rapide. Je voulais voir a quel point le cache etait utilise donc j'ai trouve que lru_cache ajoute une method cache_info() sur la method cachee, qui renvoit les statistiques de cache hit/cache miss.
Et je me suis rendu compte que le cache etait systematiquement utilise apres la 1927e pierre, indiquant la presence d'une boucle.
J'ai aussi perdu du temps avec le fait que le tout premier cycle donnait une hauteur legerement au dessus des suivantes, mais j'ai finalement trouve.

Par contre je cale toujours sur la deuxieme partie du jour 16, je ne me suis pas encore resolu a regarder l'entree de forum d'hier, mais je crois que je vais m'y resoudre.

Excusez l'absence d'accents dans mes commentaires, j'habite en Australie et n'ai pas de clavier francais sous la main.

Ma partie 2 prend 1min 30 (sur un PC un peu vieillot).
L'idee de l'optim c'est de ne pas lister toute les valeur ou le beacon ne peut pas etre present pour un sensor mais definir l'intervale par ses limites, et faire l'union des intervales. Car il y a tres peu d'intervales mais ils sont enormes.

C'est quoi ton optim qui donne 19 secondes?

Excusez l'absence d'accents dans mes commentaires, j'habite en Australie et n'ai pas de clavier francais sous la main.

Comment as-tu généré l'image?

Excusez l'absence d'accents dans mes commentaires, j'habite en Australie et n'ai pas de clavier francais sous la main.

Par rapport a la deuxieme partie, pour moi la version bete et mechante ne marchait pas. Le calcul pour chaque point de depart prenait plusieurs minutes, donc il etait obligatoire de 'cacher' les distances a partir de chaque point.

Excusez l'absence d'accents dans mes commentaires, j'habite en Australie et n'ai pas de clavier francais sous la main.

C'est pas tres joli non plus, mais on peut utiliser getattr/setattr pour factoriser la meme operation cote x et y dans la fonction de suivi:

def get_closer(H: Point, T: Point, axis: str, aligned: bool) -> bool:
    diff = getattr(T, axis) - getattr(H, axis)
    if abs(diff) == 2:
        get_closer_by_1(H, T, axis)
        if not aligned:
            get_closer_by_1(H, T, "y" if axis == "x" else "x")
        return True
    return False

def get_closer_by_1(H: Point, T: Point, axis):
    setattr(
        T, axis, getattr(T, axis) + (1 if getattr(H, axis) > getattr(T, axis) else -1)
    )

def follow(H: Point, T: Point):
    aligned = T.x == H.x or T.y == H.y
    if not get_closer(H, T, "y", aligned):
        get_closer(H, T, "x", aligned)

for input in inputs:
    for i in range(input[1]):
        match input[0]:
            case "U":
                H[0].y += 1
            case "L":
                H[0].x -= 1
            case "R":
                H[0].x += 1
            case "D":
                H[0].y -= 1
        for j in range(1, size_tail + 1):
            follow(H[j - 1], H[j])
        visited.add((H[size_tail].x, H[size_tail].y))

Excusez l'absence d'accents dans mes commentaires, j'habite en Australie et n'ai pas de clavier francais sous la main.

J'ai fait une solution assez similaire, en plus crade (pas d'heritage, de typing etc.).
Et surtout pas de yield dans la fonction recursive qui aplatit les repertoires (je copie les references dans une nouvelle list). J'avoue que ta solution est plus elegante, et c'est marrant que tu fasses du code presque prod ready (mypy…).
Perso je commence les problemes quand j'ai du temps dans la soiree, mais une fois que j'ai commence j'essaye de trouver la reponse le plus rapidement possible.

Excusez l'absence d'accents dans mes commentaires, j'habite en Australie et n'ai pas de clavier francais sous la main.