diff --git a/slides/cours_13.md b/slides/cours_13.md
index 45b0982ac09098015e78af3dacacf5c0e7b1ec4f..d3d4d0c731ad92047f07120862a2f534da6b06bf 100644
--- a/slides/cours_13.md
+++ b/slides/cours_13.md
@@ -515,8 +515,101 @@ J_3 = 109           Delta = 2
            d_3 = 7
           /        
 J_4 = 116
+--------------------------------------
 J_{i+1} = J_i + d_i,
 d_{i+1} = d_i + Delta, d_0 = 1, i > 0.
 ```
 
+# Méthode de chaînage
+
+## Comment ça marche?
+
+* Chaque index de la table contient un pointeur vers une liste chaînée
+  contenant les paires clés-valeurs.
+
+## Un petit dessin
+
+```
+
+
+
+
+
+
+
+
+
+
+
+```
+
+# Méthode de chaînage
+
+## Exemple
+
+On hash avec la fonction `h(key) = key % 11` (`key` est le numéro de la lettre
+de l'alphabet)
+
+```
+ U  | N | E | X | E | M | P | L | E | D | E | T | A | B | L | E
+ 10 | 3 | 5 | 2 | 5 | 2 | 5 | 1 | 5 | 4 | 5 | 9 | 1 | 2 | 1 | 5
+```
+
+## Comment on représente ça? (à vous)
+
+. . .
+
+![La méthode de chaînage](figs/fig_hash.png){width=80%}
+
+# Méthode de chaînage
+
+Avantages:
+
+* Si les clés sont grandes l'économie de place est importante (les places vides
+  sont `NULL`).
+* La gestion des collisions est conceptuellement simple.
+* Pas de problème de regroupement (clustering).
+
+# Exercice 1
+
+* Construire une table à partir de la liste de clés suivante:
+    ```
+    R, E, C, O, U, P, A, N, T
+    ```
+
+* On suppose que la table est initialement vide, de taille $n = 13$.
+* Utiliser la fonction $h1(k)= k \mod 13$ où k est la $k$-ème lettre de l'alphabet et un traitement séquentiel des collisions.
+
+# Exercice 2
+
+* Reprendre l'exercice 1 et utiliser la technique de double hachage pour traiter
+  les collisions avec
+
+\begin{align*}
+h_1(k)&=k\mod 13,\\
+h_2(k)=1+(k\mod 11).
+\end{align*}
+
+
+# Exercice 3
+
+* Stocker les numéros de téléphones internes d'une entreprise suivants dans un
+tableau de 10 positions.
+* Les numéros sont compris entre 100 et 299.
+* Soit $N$ le numéro de téléphone, la fonction de hachage est
+$$
+h(N)=N\mod 10.
+$$
+* La fonction de gestion des collisions est
+$$
+C_1(N,i)=(h(N)+3\cdot i)\mod 10.
+$$
+* Placer 145, 167, 110, 175, 210, 215 (mettre son état à occupé).
+* Supprimer 175 (rechercher 175, et mettre son état à supprimé).
+* Rechercher 35.
+* Les cases ni supprimées, ni occupées sont vides.
+* Expliquer se qui se passe si on utilise?
+$$
+C_1(N,i)=(h(N)+5\cdot i)\mod 10.
+$$
 
diff --git a/slides/figs/fig_hash.png b/slides/figs/fig_hash.png
new file mode 100644
index 0000000000000000000000000000000000000000..92e82b5949e733c846b92a3d6daa7601db740a4e
Binary files /dev/null and b/slides/figs/fig_hash.png differ