L'avent du code 2021 - Partie 1

[Jean-Balteryx]

Bonjour à toutes et à tous,

Nous connaissons tous le calendrier de l’avent, les chocolats, les Lego, Playmobil peut-être. On en trouve d’autres pour apprendre, comme celui de @grossal et @RolandSchubert qui donne des astuces quotidiennes concernant l’utilisation d’Alteryx ! Mais avec @Ladarthure nous souhaitons vous parler d’un autre calendrier de l’avent : l'avent du code !

C'est un projet créé par Eric Wastl qui, chaque année, construit un scénario autour de Noël, impliquant la plupart du temps des elfes, découpé en 25 jours avec un problème en deux parties à résoudre par jour.

Il a été lancé sur la communauté Alteryx par @jdunkerley79 qui a créé un leaderboard pour les utilisateurs Alteryx qui souhaitent participer et se challenger entre eux ! L’objectif est de résoudre les problèmes chaque jour, en utilisant Alteryx, et sans intégrer de code extérieur (donc pas de Run Command, pas de R tool, ni de Python tool).

Si vous souhaitez y participer vous pouvez vous inscrire ici : https://adventofcode.com

Pour rejoindre le leaderboard de la communauté, voici le code nécessaire : 453066-ca912f80

Avec @Ladarthure, nous tentons donc de participer à ce calendrier de l'avent et de résoudre l’ensemble de ces challenges en utilisant Alteryx, et nous en profitons pour vous partager nos workflows ainsi que ce que nous avons appris sur chaque challenge !

Cet article est le premier d'une série de 5 articles. Il traite les jours 1 à 5 de l'avent du code.

Jour 1 : https://adventofcode.com/2021/day/1

Partie 1

Partie 2

Arthur : l’utilisation du multi-row formula qui permet de faire référence à plusieurs lignes précédentes, dans notre cas 3 lignes pour faire des totaux glissants et un point de vigilance sur le paramétrage des lignes qui n’existent pas !

Jean-Baptiste : pour ce problème, l'utilisation de l'outil Multi-Row Formula paraissait évidente. Pourquoi ? Parce qu'il faut comparer chaque valeur avec la précédente afin de déterminer s'il y a une augmentation ou non. Une fois cela déterminé, il suffisait de compter le nombre d'augmentations pour avoir le résultat.

La différence entre les deux parties était que dans la deuxième, la valeur à comparer était la somme de la valeur de la ligne et des deux précédentes. Il fallait donc également filtrer pour cette deuxième partie, les 3 premières lignes puisqu'il n'y avait pas de somme complète à comparer.

Point d'attention : la configuration des lignes qui n'existent pas. On a vite fait de perdre quelques minutes voire quelques neurones ...

Jour 2 : https://adventofcode.com/2021/day/2

Partie 1

Partie 2

Arthur : Le running total ou simplement comment créer un total cumulé, dans notre cas c’est ce qui nous a permis de faire un total de l’aim qui permet de calculer l’angle pour la profondeur et la direction dans notre exemple. On peut aussi le faire en utilisant un multi-row formula, ici l’avantage est la simplicité de configuration !

Jean-Baptiste : pour la première partie, j'ai voulu avoir les 3 valeurs nécessaires (une par direction) dans 3 champs différents pour calculer le résultat final. Pour ce faire, j'ai agréger les données en faisant la somme des valeurs pour chaque direction puis j'ai pivoter la donnée pour avoir un champ par direction. Ensuite, j'ai utilisé un outil Formule pour calculer le résultat final.

Pour la deuxième partie, j'ai utilisé un Multi-Row Formula pour calculer la valeur de l'aim à chaque ligne. Ensuite, j'ai filtrer les données pour ne garder que la direction "forward" puisqu'il n'y a plus besoin des directions "up" et "down" après avoir calculé l'aim. À partir de là, il ne reste plus qu'à calculer la profondeur pour chaque ligne, calculer la somme totale de la valeur du mouvement et de la profondeur, puis calculer le résultat final.

Jour 3 : https://adventofcode.com/2021/day/3

Partie 1

Partie 2

Arthur : Pour ce challenge, la première étape consistait à obtenir les valeur les plus fréquentes via le mode, j’ai ensuite appris à transformer un nombre binaire en nombre décimal, ce n’est pas forcément le savoir le plus utile dans le quotidien mais assez amusant à faire (pour ceux que ça intéresse : https://fr.wikihow.com/convertir-un-nombre-binaire-en-nombre-d%C3%A9cimal

La seconde partie est plus complexe au premier abord, elle nécessite de filtrer étape par étape l’ensemble de nos valeurs, dans notre cas le nombre binaire étant sur 12 positions, on peut envisager de le faire de manière « manuelle » en faisant plusieurs jointures à la suite. Cependant j’ai préféré aller vers l’option de la macro itérative qui me permet d’ajouter du dynamisme dans le processus. Dans notre cas, je vais regarder pour chaque position (une par itération) la valeur la plus fréquente pour chaque position et combiner l’ensemble de ces valeurs. En résumé à chaque itération, on va ajouter un chiffre en plus à notre suite binaire, en utilisant le nombre le plus présent ou le moins présent.

Jean-Baptiste : pour la première partie, je suis parti du principe qu'en faisant la somme des bits à une position donnée, si la somme est supérieure à 500 alors il y a une majorité de 1 et si elle est inférieure à 500, alors il y a une majorité de 0. J'ai donc décomposé les valeurs binaires pour avoir un bit par colonne (correspondant à une position) puis j'ai fait la somme de ces colonnes. En fonction de cette somme j'ai assigné la valeur 0 ou 1 à chaque position puis j'ai reconstitué la valeur binaire totale que j'ai ensuite convertie en valeur décimale. Ceci donne le taux gamma demandé. Ensuite pour calculer le taux epsilon, j'ai inversé les bits, les 0 devenant des 1 et inversement, puis j'ai converti cette nouvelle valeur binaire en valeur décimale. Enfin, j'ai multiplié les deux taux entre eux pour avoir le résultat final.

Pour la deuxième partie, j'ai dû créé une macro itérative qui a deux configurations possibles : le bit le plus présent et le bit le moins présent. Qu'est-ce que cela veut donc dire ? La macro va itérer autant de fois qu'il y a de positions dans les valeurs binaires. Pour le générateur d'oxygène, la macro va, à chaque tour (et donc chaque position), déterminer le bit le plus présent à la position correspondante. Elle va ensuite filtrer les valeurs binaires pour ne garder que celles possédant la valeur la plus présente à la position actuelle. Après avoir parcouru toutes les positions de cette façon, il ne restera qu'une seule valeur binaire.

Pour le nettoyeur de CO2 c'est le même principe en prenant le bit le moins présent à chaque tour. Là aussi, on récupère la valeur binaire qui remplit les critères à chaque tour.

Enfin, on convertit ces valeurs binaires en valeurs décimales et on les multiplie entre elles pour avoir le résultat final.

L'astuce du jour : au début j'ai crée deux macros, une qui utilise le bit le plus présent et une autre qui utilise le bit le moins présent car ce sont deux configurations différentes au niveau de l'outil Trier. Finalement il est possible de tout faire dans la même macro en utilisant des boutons radios. Le choix du bouton radio impact l'ordre de tri du compte des bits 0 et 1. Quand le premier est sélectionné, c'est le bit le plus présent qui est utilisé (ordre décroissant) et quand le deuxième bouton radio est sélectionné c'est le bit le moins présent qui est utilisé (ordre croissant). 

Jour 4 : https://adventofcode.com/2021/day/4

Partie 1

Partie 2

Arthur : Le bingo et trouver un gagnant, ou du moins le premier gagnant puis le dernier gagnant. Dans ce challenge, pour le réaliser, on génère l’ensemble des grilles et on les identifie puis on va ensuite générer des identifiants pour les lignes et les colonnes de nos grilles puis nous prenons pour chaque ligne/colonne le dernier numéro qui apparaît des 5 afin, on prend ensuite pour chaque grille le minimum ou maximum de ce calcul afin d’obtenir la première ligne trouvée ! On regarde ensuite les nombres étant passés par rapport au maximum puis via un jeu de jointure, nous récupérons nos données et réalisons les calculs nécessaires. Ce challenge m’a rappelé tout ce que l’on peut faire en faisant des jointures pour associer non pas 2 tables, mais pour voir les valeurs présentes ou obtenir différentes positions.

Jean-Baptiste : ah le bingo ! Pour trouver la carte gagnante, j'ai modifié la forme des données pour avoir les différentes lignes et colonnes de la carte de bingo dans les mêmes colonnes de données afin de ne pas avoir à les traiter différemment.

Du côté des tirages, j'ai ajouté un identifiant aux numéros tirés, correspondant à l'ordre de tirage. J'ai ensuite associé cet ordre aux différentes valeurs des cartes. Cela m'a permis de récupérer la valeur maximale de cet ordre pour chaque ligne/colonne de chaque carte afin de déterminer quelle ligne/colonne a été remplie en premier. Ayant déterminé cette ligne/colonne, j'ai récupéré la carte correspondante et garder seulement les numéros non-trouvés puis j'ai calculé la somme de ces numéros. Il ne restait plus qu'à multiplier cette valeur par le numéro tiré qui a permis de compléter la ligne/colonne.

Pour trouver la carte perdante, j'ai utilisé la même logique, en cherchant cette fois la carte qui a rempli en dernière une ligne/colonne.

Jour 5 : https://adventofcode.com/2021/day/5

Partie 1

Partie 2

Arthur : Premier challenge m’ayant posé des problèmes, l’idée est de voir les points communs entre plusieurs segments ! La première partie nécessite de ne prendre que les segments horizontaux ou verticaux et ceci se fait assez facilement en utilisant des generate rows, cela permet d’avoir l’ensemble des positions entre le point d’origine x1 et le point final x2 par exemple. La seconde partie du problème est d’utiliser aussi les diagonales, j’ai voulu simplifier le problème et réalisé plusieurs erreurs :

• Ne prendre que les intersections et oublier que les segments peuvent se superposer
• Ne prendre qu’un sens qui permettait d’aller vers le positif (donc de la gauche vers la droite et du haut vers le bas)
• Oublier qu’en utilisant des generate rows, on va générer d’abord la ligne, verticale, puis horizontale. Mais cela va générer un « triangle » et non plus être un segment mais un polygone rempli.

Une fois ces problèmes surmontés, merci à @Jean-Balteryx pour des indices et échanges permettant de me rendre compte de mes erreurs, j’ai finalement réussi à calculer ces intersections.

La leçon de ce challenge, penser à simplifier le jeu de données pour pouvoir faire des contrôles manuels, car avec plus de 500 segments, essayer de vérifier si la méthode employée est bonne n’est pas idéal et complexe, en simplifiant, on peut facilement contrôler et vérifier nos données et surtout nos calculs !

Jean-Baptiste : pour la première partie, j'ai filtré les lignes pour garder seulement les lignes droites, c'est-à-dire les lignes dont les points de début et fin partagent une des deux coordonnées. Une fois filtrées, je génère tous les points intermédiaires grâce à l'outil Generate Rows puis je compte le nombre de fois que chaque point apparaît. Je filtre pour garder les points qui apparaissent au moins deux fois et je compte le nombre de points restants.

Pour la deuxième partie, il faut ajouter les lignes diagonales. Le principe reste le même mais la façon de générer les points intermédiaires change. En effet, pour chaque point intermédiaire, on reprend les coordonnées du précédent et on ajoute 1 à chacune des coordonnées. Or si on utilise deux outils Generate Rows comme à la deuxième partie, cela va générer d'autres points qui ne sont pas dans la ligne car il y aura les cas où on ajoute 1 à seulement une des deux coordonnées. Il faut donc utiliser un Generate Rows pour la coordonnée x et un Multi-Row Formula pour la coordonnée y, ce qui permettra d'avoir cet ajout de 1 à chaque coordonnée à chaque ligne.

AOC_2021_1_5_JB.zip

AL_01-05.zip