Parenthesons.

content/pages/algo-parenthesons.md

@@ -0,0 +1,81 @@
+status: hidden
+title: Python — 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 paremthé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-sur é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).

content/pages/parenthesons.md

@@ -8,7 +8,7 @@ robots: noindex
 
 
 Après Epitech Digital, et un doctorat en informatique vous rejoignez
-une equipe chargée de concevoir le prochain langage de programmation à
+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
@@ -42,7 +42,7 @@ fonctionnel, pour compiler Morecambe en Morecambe et boucler la
 boucle, en attendant, on code en Python). Une fonction nommée
 `is_correctly_balanced` qui prend en paramètre une chaîne de
 caractères nommée `expression`, et qui renvoie `True` si l’expression
-est correctement paremthéséee, et `False` dans le cas
+est correctement paremthésée, et `False` dans le cas
 contraire.
 
 L’équipe vous a préparé quelques tests unitaires et vous aurez la
@@ -74,7 +74,7 @@ def test_full():
 ```
 
 Dites, à quel point c’est frustrant si je vous dis que `((()))` écrit
-à l’envers çax donne `)))(((` ?
+à l’envers ça donne `)))(((` ?
 
 
 # Partie Ⅱ
@@ -83,7 +83,7 @@ En rédigant votre fonction 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 d’implementer une fonction pour tous les
+Vous ne pouvez donc vous retenir d’implementer une fonction pour toutes les
 lister !
 
 Votre fonction doit s’appeler `gen_correctly_balanced_expressions` et
@@ -95,8 +95,9 @@ chaque parenthésage étant exprimé sous la forme d’une chaine de
 caractères. Vous devinerez vite qu’il n’existe qu’une seule manière de
 parenthéser une seule paire de parenthéses, puis vous découvrirez
 qu’il existe
-- deux manieres de parenthéser deux paires,
-- 5 manieres d’en parenthéser trois,
+
+- deux manières de parenthéser deux paires,
+- 5 manières d’en parenthéser trois,
 - 14 d’en parenthéser 4,
 - ...
 - 4862 d’en parenthéser 9...
@@ -164,7 +165,7 @@ Du binaire… des nombres ! Et aucun ne commence par zéro !! Et ils
 sont tous pairs ! Ça ne peut pas être une coïncidence…
 
 Vous rédigez alors une fonction `gen_balanced_sequence` qui prend en
-paramètre `n`, le nombre de pairs de bits à utiliser, et qui renvoie
+paramètre `n`, le nombre de paires de bits à utiliser, et qui renvoie
 un iterable de nombres entiers ordonnés par ordre croissant : les
 nombres genérés par votre expérience précédente. Ces séquences sont
 interessantes, mais trop courtes :