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…
