116 lines
3.2 KiB
Markdown
116 lines
3.2 KiB
Markdown
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…
|