Parenthésons !

content/pages/python-parenthesons.md

@@ -0,0 +1,115 @@
+status: hidden
+title: Algo Avancé — Parenthésons
+slug: iej2Aepe-parenthesons
+robots: noindex
+
+
+# Partie Ⅰ
+
+
+Après Epitech Digital, et un doctorat en informatique vous rejoignez
+une équipe chargée de concevoir le prochain langage de programmation à
+la mode : le Morecambe.
+
+Dans l’equipe « ASV », « Age^WAnalyse Syntaxique et Validation », vous
+travaillez sur le parenthésage des expressions :
+
+- `(a + b)` est valide.
+- `)a + b(` n’est pas valide.
+- `(a + (b + c))` est valide.
+- `(a + (b + c)` n’est pas valide.
+- `a * (b + c) + (d / 2)` est valide…
+
+Jusque-là ça va, mais Morecambe est un langage moderne, il ne s’arrête
+pas aux mathématiques classiques, et permet d’exprimer de la logique
+combinatoire, du lambda-calcul, de la sémantique dénotationnelle (en
+convergence et en divergence), et j’en passe, ainsi :
+
+- `(λa ∘ λb)(3)` est valide, c’est une simple composition des
+  fonctions `a` et `b`, immédiatement appellée.
+- `⍼((a∘b)(3))|⍼((c∘d)(12))` est valide, c’est le « Right Angle with
+  Downwards ZigZag Arrow » qui permet la dénotation (divergente, pour
+  le coup), le `|` ne servant qu’à chaîner, comme en bash,
+  naturellement.
+- `[¬(a ⋀ b) ⋁ ¬(c ⋀ d)] ∀ a⍼((c∘d)(12)` n’est cependant **PAS**
+  valide, bien qu’[Augustus De
+  Morgan](https://fr.wikipedia.org/wiki/Lois_de_De_Morgan) aurait pu
+  la corriger en un coup de cuiller à pot.
+
+Votre première tâche sera donc d’inventer un algorithme (qu’on pourra
+rédiger en Morecambe une fois le compilateur Morecambe fonctionnel),
+nommé `is_correctly_balanced` qui prend en paramètre une chaîne de
+caractères nommée `expression`, et qui renvoie vrai si l’expression
+est correctement paremthésée, et faux dans le cas contraire.
+
+L’équipe vous a préparé des specs sur une nappe en papier tachée
+d'huile pimentée :
+
+```python
+Bonnes expressions :
+
+```text
+()
+(((())))
+()()()()
+()(())()
+(a + b)
+(a + (b + c))
+a * (b + c) + (d / 2)
+(λa ∘ λb)(3)
+⍼((a∘b)(3))|⍼((c∘d)(12))
+```
+
+Mauvaises expressions :
+
+``text
+)(
+(((
+((()
+()))
+()()()(
+)a + b(
+(a + (b + c)
+[¬(a ⋀ b) ⋁ ¬(c ⋀ d)] ∀ a⍼((c∘d)(12)
+``
+
+Dites, à quel point c’est frustrant si je vous dis que `((()))` écrit
+à l’envers ça donne `)))(((` ?
+
+
+# Partie Ⅱ
+
+En rédigant votre algo’ vous remarquez un fait amusant : donné un
+certain nombre de paires de parenthéses, il n’y a qu’un nombre fini de
+possibilités pour les agencer.
+
+Vous ne pouvez donc vous retenir de griffonner un algo qui permet de
+tous les lister !
+
+Votre algo, `gen_correctly_balanced_expressions` prend un seul
+parametre `n` : le nombre de paires de parenthéses.
+
+Elle doit renvoyer tous les parenthésages possibles, chaque
+parenthésage étant une chaîne de caractères.
+
+Voici par exemple les 14 parenthésages valides avec quatres paires de
+parenthéses :
+
+- `(((())))`
+- `((()()))`
+- `(()(()))`
+- `(()()())`
+- `((())())`
+- `()((()))`
+- `()(()())`
+- `()()(())`
+- `()()()()`
+- `()(())()`
+- `(())(())`
+- `(())()()`
+- `((()))()`
+- `(()())()`
+
+Cet algorithme s’avèrera très utile par la suite : vos collègues ont
+déjà l'idée de l'utiliser pour tester votre premier algo. Mais il faudra
+attendre l'implémentation en Morecambe pour ça…