Fix from Nicolas

index.md

@@ -14,8 +14,8 @@ kernelspec:
 
 # TP 10 : Tri de listes chainées
 
-Dans ce TP vous allez devoir utiliser les fonctions de manipulation de liste
-chaînée que vous avez développées lors du TP précédent. Avant de commencer ce TP
+Dans ce TP vous allez devoir utiliser les fonctions de manipulation de listes
+chaînées que vous avez développées lors du TP précédent. Avant de commencer ce TP
 assurez-vous que vos fonctions pour les trois premiers exercices du TP 7
 fonctionnent parfaitement.
 

rapide.md

@@ -17,37 +17,42 @@ kernelspec:
 L'implémentation précédente du tri par sélection n'est pas optimale. En effet,
 elle parcourt deux fois la liste $l$ à chaque itération, une fois pour chercher
 le maximum et une fois pour le supprimer de la liste. Il est possible d'ajouter
-une fonction de manipulation de liste effectuant ces deux opérations
+une fonction de manipulation de listes effectuant ces deux opérations
 simultanément en mémorisant l'élément précédent celui contenant le maximum. Avec
 cette nouvelle fonction il est ensuite possible d'implémenter le tri par
 sélection de manière plus efficace.
 
-*Attention, comme vu en cours, cette modification rend l'algorithme plus
-rapide mais ne change pas sa complexité qui reste quadratique. Cette version est
-plus rapide d'un facteur constant.*
+:::{attention}
+Comme vu en cours, cette modification rend l'algorithme plus rapide
+mais ne change pas sa complexité qui reste quadratique. Cette version
+n'est plus rapide que d'un facteur constant.
+:::
 
 
-1.  Commencez donc par implémenter une fonction qui recherche et supprime la
-    valeur maximale d'une liste et la renvoie :
+1.  Commencez par définir une fonction utilisant l'optimisation
+    décrite ci-dessus pour rechercher et supprimer la valeur maximale
+    d'une liste, avant de la renvoyer :
 
     ```cpp
     int supprimer_maximum(liste *l);
     ```
 
-    *Attention: cette fonction est relativement complexe à écrire. Testez-la
-    bien en profondeur, aussi bien sur des cas simples que complexes, avant de
-    passer à la suivante.*
+	:::{attention}
+	Cette fonction est relativement technique. Testez-la bien en
+    profondeur, aussi bien sur des cas simples que complexes, avant de
+    passer à la suivante.
+	:::
 
 
 
-2.  Réécrivez maintenant votre fonction de tri par sélection de manière
-    plus efficace en utilisant cette nouvelle fonction de manipulation de
-    liste.
+2.  Redéfinissez maintenant votre fonction de tri par sélection de
+    manière plus efficace en utilisant cette nouvelle fonction de
+    manipulation de liste.
 
 
 
-3.  Il existe un autre invariant que nous avons vu en cours pour le tri par
-    sélection. Les éléments de la première liste doivent être plus petits que
-    les éléments de la seconde. Ajouter la vérification de cet invariant à
-    votre boucle.
+3.  Il existe un autre invariant que nous avons vu en cours pour le
+    tri par sélection. Les éléments de la première liste doivent être
+    inférieurs ou égaux aux éléments de la seconde. Ajoutez la
+    vérification de cet invariant à votre boucle.
 

selection.md

@@ -14,34 +14,38 @@ kernelspec:
 
 # Exercice: Tri par sélection
 
-Les fonctions de manipulation de liste chaînée que nous avons développées nous
+Les fonctions de manipulation de listes chaînées que nous avons développées nous
 permettent maintenant d'implémenter le tri par sélection sur les listes comme vu
 en cours.
 
-```cpp
-liste *tri_selection(liste *l);
-```
-
-Les principales étapes du tri sont les suivantes :
+Les principales étapes du tri d'une liste sont les suivantes :
 - Créer une nouvelle liste `r` qui va recevoir les éléments triés.
-- Tant que la liste d'origine `l` n'est pas vide faire :
+- Tant que la liste d'origine `l` n'est pas vide faire :
   - Chercher le maximum `m` de la liste `l`.
   - Supprimer la valeur `m` de la liste `l`.
   - Ajouter la valeur `m` en tête de la liste `r`.
-- Libérer la liste `l`
-- Retourner la liste `r`
+- Libérer la liste `l`.
+- Renvoyer la liste `r`.
 
 Afin de vérifier que notre implémentation est correcte, nous allons vérifier
-deux des invariants de cet algorithme à la fin de chaque itération:
-- la somme des longueurs des deux listes est constante ;
+deux des invariants de cet algorithme à la fin de chaque itération :
+- la somme des longueurs des deux listes est constante;
 - la liste `r` est une liste triée.
 
-1.  Écrire une fonction `est_triee` qui prend en paramètre une liste et renvoie
+1.  Définissez une fonction `est_triee` qui prend en paramètre une liste et renvoie
     un booléen indiquant si la liste est bien triée dans l'ordre croissant.
 
+    ```cpp
+    bool est_triee(liste *l);
+	```
+
 
 
-2.  Écrire maintenant la fonction de tri par sélection sur les listes en
+2.  Définissez maintenant la fonction de tri par sélection sur les listes en
     vérifiant bien que les invariants sont vérifiés à la fin de chaque
     itération.
 
+	```cpp
+	liste *tri_selection(liste *l);
+	```
+