diff --git a/slides/cours_8.md b/slides/cours_8.md
index b295f0dc1ece2ee021b3f3462f7f5183d250451c..61989a0d2f778f2ab47ab6c35735c3235732d313 100644
--- a/slides/cours_8.md
+++ b/slides/cours_8.md
@@ -565,7 +565,17 @@ tab est trié dans G
 
 ```
 
-# La calculatrice
+# La calculatrice (1/N)
+
+## Vocabulaire
+
+```C
+2 + 3 = 2 3 +,
+```
+
+`2` et `3` sont les *opérandes*, `+` l'*opérateur*.
+
+. . .
 
 ## La notation infixe
 
@@ -587,4 +597,67 @@ tab est trié dans G
 2 3 4 * * 2 + = (2 * (3 * 4)) + 2.
 ```
 
+# La calculatrice (2/N)
+
+## Évaluation d'expression postfixe: algorithme
+
+* Chaque *opérateur* porte sur les deux opérandes qui le précèdent.
+* Le *résultat d'une opération* est un nouvel *opérande* qui est remis au
+  sommet de la pile.
+
+## Exemple
+
+```C
+2 3 4 + * 5 - = ?
+```
+
+* On parcours de gauche à droite:
+
+```C
+Caractère lu        Pile opérandes
+    2               2
+    3               2, 3
+    4               2, 3, 4
+    +               2, (3 + 4)
+    *               2 * 7
+    5               14, 5
+    -               14 - 5 = 9
+```
+
+# La calculatrice (3/N)
+
+## Évaluation d'expression postfixe: algorithme
+
+1. La valeur d'un opérande est *toujours* empilée.
+2. L'opérateur s'applique *toujours* au 2 opérandes au sommet.
+3. Le résultat est remis au sommet.
+
+## Exercice: écrire l'algorithme (et poster sur matrix)
+
+# La calculatrice (4/N)
+
+## De infixe à post-fixe
+
+* Une *pile* est utilisée pour stocker *opérateurs* et *parenthèses*.
+* Les opérateurs on des *priorités* différentes.
+
+```C
+^   : priorité 3
+* / : priorité 2
++ - : priorité 1
+( ) : priorité 0 // pas un opérateur mais bon
+```
+
+
+# La calculatrice (5/N)
+
+## De infixe à post-fixe: algorithme
+
+* On lit l'expression infixe de gauche à droite.
 
+1. On examine le prochain caractère de l'expression infixe.
+    * Si opérande, le placer dans l'expression du résultat.
+    * Si parenthèse le mettre dans la pile (priorité 0).
+    * Si opérateur, comparer sa priorité avec celui du sommet de la pile:
+        * Si sa priorité est plus élevée, empiler.
+        * Sinon