status: hidden
title: Algorithmie — Parenthésons
slug: Az6quieP-parenthesons
robots: noindex

Vous voila 7 ans après Sup'Internet^WEpitech Digital, après votre
doctorat en informatique. En tant que post-doc vous rejoignez une
équipe, dans un labo de recherche, chargée de concevoir le prochain
langage de programmation à la mode : Le Morecambe.

Dans l’equipe « analyse 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 avec `3` comme seul
  argument.

- `⍼((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 dans l’équipe ASV (Age^WAnalyse Syntaxique &
Validation), sera donc d’écrire l’algorithme qui valide le
parenthésage des expressions Morecambiennes.

L’analyse syntaxique ayant déjà été implémentée par l’équipe, votre
première tâche sera heureusement très simple :

Vous vous occuperez de la fonction `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 parenthésée, et faux
dans le cas contraire.

La chaine de caractere, `expression`, n’est heureusement pas une
expression Morecambienne complète, le reste ayant déjà été analysé, ce
qui est donné à votre fonction `is_correctly_balanced` ne contient que
des `(` et des `)`, c’est tout.

Ce qui permettra à votre équipe de rapidement écrire des tests
unitaires et de non-régression pour garantir la qualité de votre
travail, et ainsi la stabilité du Morecambe, comme :

- `is_correctly_balanced("") est vrai`
- `is_correctly_balanced("()") est vrai`
- `is_correctly_balanced("(((())))") est vrai`
- `is_correctly_balanced("()()()()") est vrai`
- `is_correctly_balanced("()(())()") est vrai`
- `is_correctly_balanced(")(") est faux`
- `is_correctly_balanced("(((") est faux`
- `is_correctly_balanced("((()") est faux`
- `is_correctly_balanced("()))") est faux`
- `is_correctly_balanced("()()()(") est faux`
- etc, etc...

En passant, c’est frustrant si je vous dis que `((()))` écrit à
l’envers ca donne `)))(((` ?

Rendu : Vous pouvez bien sûr écrire cet exercice dans le langage de
votre choix, dans un langage inventé, en Morecambe, en pseudocode,
dans un mélange de pseudocode et d’un langage qui vous plaît, peu
importe, tant que j’en comprends la logique (ayant pratiqué le
brainf*ck, le Prolog, le LISP, et l’Erlang, si je ne comprends pas
votre rendu, je saurai qui blamer).
