Exemples - Advent of code

Comme chaque année, les développeuses et développeurs passionnés se retrouvent autour du calendrier de l'avent du code. RuleShake n'étant pas réellement un langage de programmation mais, dans sa généricité, il permet de résoudre ce type de problème.

                            |                         _...._
                         \  _  /                    .::o:::::.
                          (\o/)                    .:::'''':o:.
                      ---  / \  ---                :o:_    _:::
                           >*<                     `:}_>()<_{:'
                          >0<@<                 @    `'//\\'`    @
                         >>>@<<*              @ #     //  \\     # @
                        >@>*<0<<<           __#_#____/'____'\____#_#__
                       >*>>@<<<@<<         [__________________________]
                      >@>>0<<<*<<@<         |=_- .-/\ /\ /\ /\--. =_-|
                     >*>>0<<@<<<@<<<        |-_= | \ \\ \\ \\ \ |-_=-|
                    >@>>*<<@<>*<<0<*<       |_=-=| / // // // / |_=-_|
      \*/          >0>>*<<@<>0><<*<@<<      |=_- |`-'`-'`-'`-'  |=_=-|
  ___\\U//___     >*>>@><0<<*>>@><*<0<<     | =_-| o          o |_==_|
  |\\ | | \\|    >@>>0<*<<0>>@<<0<<<*<@<    |=_- | !     (    ! |=-_=|
  | \\| | _(UU)_ >((*))_>0><*<0><@<<<0<*<  _|-,-=| !    ).    ! |-_-=|_
  |\ \| || / //||.*.*.*.|>>@<<*<<@>><0<<@>>>>>|  ( ~~~ )/   (((((((())))))))
      ~~~~~~~~         '""""`------'  `w---w`     `------------'

Dans ce billet, nous allons voir comment résoudre la partie 1 du jour 1 du calendrier de l'avent du code de l'année 2023 avec RuleShake.

Énoncé

Pour les adeptes du advent of code, vous savez que les défis proposés chaque jour suivent un certain scénario (une histoire d'Elfes et de production de neige). Vous savez aussi que les réponses à chaque défi est une simple valeur numérique ou alphanumérique résultant de plusieurs calculs à partir de données d'entrée.

Cependant, pour simplifier la lecture de ce billet, nous allons nous focaliser sur l'attendu d'un point de vue technique du défi #1.

Soit les données d'entrée suivantes :

1abc2
pqr3stu8vwx
a1b2c3d4e5f
treb7uchet

L'idée est donc de déterminer un nombre à deux chiffres représentant un étalonnage (calibration en anglais) pour chaque ligne en concaténant le premier chiffre qui apparait dans la ligne avec le dernier chiffre. Si la ligne contient uniquement un seul chiffre, il faut le concaténer avec lui-même. Enfin, le résultat attendu est la somme de tous ces nombres.

Dans cet exemple, les valeurs d'étalonnage de ces quatre lignes sont 12, 38, 15 et 77. Les additionner donne 142.

Implémentation

Pour commencer, nous allons créer une collection de variables dans RuleShake catalog appelée ADVENTOFCODE012023.

Celle-ci va contenir les variables :

• LIGNES : variable d'entrée, multiple (tableau) de type Chaîne contenant les données d'entrée. Chaque instance contiendra une ligne de ces données.
• COMPUTED : variable calculée, multiple de type Composite (structure de données) dans laquelle seront transformée chaque ligne dans LIGNES pour extraire le nombre qui les représente.
• RESULT : variable calculée de type Nombre qui va contenir la somme attendue.

La variable COMPUTED est liée à la variable LIGNES où le nombre d'instances correspond au nombre d'instances de la variable LIGNES. Pour chaque instance, le code LIGNE permet d'accéder à la ligne des données d'entrée correspondante.

La variable COMPUTED se compose comme suit :

• LEFT_DIGIT : variable calculée de type Nombre qui, pour chaque ligne, extrait le chiffre le plus à gauche.
• RIGHT_DIGIT : variable calculée de type Nombre qui extrait le chiffre le plus à droite.
• CALIBRATION : variable calculée de type NOMBRE qui concatène LEFT_DIGIT avec RIGHT_DIGIT.

Pour rappel, le calcul dans une variable s'appuie sur le langage mvel. Ainsi, pour extraire le chiffre le plus à gauche (ou à droite), on va écrire un bout de code permettant de le faire.

Même principe pour RIGHT_DIGIT pour laquelle on va simplement inversement le sens de parcours de la ligne :

for (int i = LIGNE.value.length() - 1; i >= 0; i--) {
    if (Character.isDigit(LIGNE.value.charAt(i))) {
        return Character.getNumericValue(LIGNE.value.charAt(i));
    }
}
return 1;

Ensuite, pour concaténer les deux chiffres, on utilise cette formule dans la définition de la variable COMPUTED/CALIBRATION :

_parent.LEFT_DIGIT.value * 10 + _parent.RIGHT_DIGIT.value

astuce

Le mot clé _parent permet d'accéder à l'instance du parent en cours. Dans ce cas, cela permet de récupérer les valeurs de LEFT_DIGIT et RIGHT_DIGIT de la ligne en cours.

Enfin, pour faire la somme des étalonnages, nous écrivons la formule suivante dans la définition de la variable RESULT :

NumberHelper.sum(MultipleHelper.extract(COMPUTED, "CALIBRATION"))

astuce

Les helpers sont des fonctions pré-définies dans le socle RuleShake utilisables dans les formules de calcul.

Voir MultipleHelper.extract et NumberHelper.sum.

Test

Maintenant que nous avons terminé le paramétrage des variables nécessaires pour la résolution du défi, nous allons exécuter la collection ADVENTOFCODE012023 afin d'obtenir le résultat attendu. Pour ce faire, il est possible de simuler l'exécution d'une collection directement dans RuleShake Catalog en cliquant sur le bouton Simuler dans la fiche de la collection.

L'écran de simulation est composé d'un formulaire généré à partir des définitions des variables de la collection. Il reprend uniquement les variables de nature Entrée.

Les valeurs renseignées pour la variable Lignes sont les lignes présentes dans les données en entrée du défi. Pour évaluer la collection, il suffit de cliquer sur le bouton Simuler :

L'onglet TABLE permet de visualiser l'ensemble des variables reçues et instanciées pour cette évaluation. Elles sont représentées par leurs codes et leurs valeurs finales. On remarque donc que la valeur de la variable RESULT est 142 ce qui est bien le résultat attendu.

Les onglets REQUÊTE et RÉPONSE présentent la représentation en JSON des variables de nature NATURE dans la requête ainsi que l'ensemble des variables évaluées dans la réponse.