diff --git a/Modularité/README.md b/Modularité/README.md
index 47c7abd..30c6d91 100644
--- a/Modularité/README.md
+++ b/Modularité/README.md
@@ -2,6 +2,16 @@
 
 > Comme vu lors de l'année de première, Python offre une multitude de modules, qui permettent d'utiliser de nombreuses fonctionnalités, d'adapter son programme à un usage précis, mais également de participer aux efforts de la communauté du logiciel libre.
 
+
+
+### Le programme
+
+![bo.png](assets/bo.png)
+
+
+
+
+
 ### Principe
 
 La modularité est un concept permettant la réutilisation de code au travers des fonctions, facilitant la maintenance, les tests, et donc, un gain de temps, ainsi que de visibilité. Pensez à la construction d’une maison : chaque pièce (module) a une fonction spécifique et peut être construite indépendamment des autres.
diff --git a/Modularité/assets/bo.png b/Modularité/assets/bo.png
new file mode 100644
index 0000000..2f5e14c
Binary files /dev/null and b/Modularité/assets/bo.png differ
diff --git a/Recursivité/Diviser_pour_regner/README.md b/Recursivité/Diviser_pour_regner/README.md
index b9b0abb..11cecfe 100644
--- a/Recursivité/Diviser_pour_regner/README.md
+++ b/Recursivité/Diviser_pour_regner/README.md
@@ -1,7 +1,11 @@
 
 # Diviser pour régner
 
-## 
+### Le programme
+
+<img src="../assets/bo_diviser.png" alt="bo_diviser.png" style="zoom: 50%;" />
+
+
 
 > La méthode **diviser pour régner** est une approche algorithmique puissante, souvent utilisée pour résoudre des problèmes complexes de manière récursive. Cette stratégie consiste à diviser un problème en sous-problèmes plus petits, à résoudre chaque sous-problème indépendamment, puis à combiner les solutions pour obtenir la solution finale du problème d'origine.
 
@@ -113,7 +117,7 @@ L'algorithme de tri fusion a une complexité en temps de **O(n log n)**, où `n`
 ### Inconvénients :
 - **Utilisation de mémoire** : Le tri fusion nécessite de l'espace mémoire supplémentaire pour stocker les sous-listes, ce qui peut être un inconvénient dans des contextes où la mémoire est limitée.
 
-## 
+
 
 La méthode **diviser pour régner** est une approche puissante et efficace pour résoudre des problèmes complexes, et le **tri fusion** en est un exemple emblématique. Comprendre cette méthode permet de mieux appréhender la récursivité et la manière dont des problèmes peuvent être résolus en plusieurs étapes.
 
diff --git a/Recursivité/Diviser_pour_regner/dichotomie_recursive.py b/Recursivité/Diviser_pour_regner/dichotomie_recursive.py
new file mode 100644
index 0000000..d9f8cbc
--- /dev/null
+++ b/Recursivité/Diviser_pour_regner/dichotomie_recursive.py
@@ -0,0 +1,10 @@
+def recherche(tab:list,x:int)-> bool:
+    if len(tab) == 0:
+        return False
+    m = len(tab) // 2
+    if tab[m] == x:
+        return True
+    elif tab [m] < x:
+        return recherche(tab[m+1 :],x)
+    else:
+        return recherche(tab[:m],x)
\ No newline at end of file
diff --git a/Recursivité/README.md b/Recursivité/README.md
index 598a664..45c8b0c 100644
--- a/Recursivité/README.md
+++ b/Recursivité/README.md
@@ -2,6 +2,14 @@
 
 
 
+### Le programme
+
+
+
+![bo_recusivite.png](assets/bo_recursivite.png)
+
+
+
 > La récursivité est un style de programmation permettant de simplifier l'écriture de nombreux problèmes.
 
 
diff --git a/Recursivité/TD/corrige_TD_recursivite.md b/Recursivité/TD/corrige_TD_recursivite.md
new file mode 100644
index 0000000..e995183
--- /dev/null
+++ b/Recursivité/TD/corrige_TD_recursivite.md
@@ -0,0 +1,161 @@
+
+# Corrigé du TD Récursivité
+
+## 1. Application du cours
+
+### 1.1 Fonction somme
+
+#### Code de la fonction :
+```python
+def somme(n):
+    if n == 0:
+        return 0
+    else:
+        return n + somme(n - 1)
+```
+
+#### Question 1 :
+**Combien d'appels de fonction sont nécessaires pour `somme(5)` ? `somme(n)` ?**
+
+- Pour `somme(5)` :
+  - La fonction appelle `somme(4)`, puis `somme(3)`, etc., jusqu'à atteindre le cas de base `somme(0)`.
+  - Il y a donc 6 appels de fonction au total : `somme(5)`, `somme(4)`, `somme(3)`, `somme(2)`, `somme(1)`, et enfin `somme(0)`.
+
+- Pour `somme(n)` :
+  - Le nombre d'appels de fonction est toujours de **n + 1**, car on part de `somme(n)` jusqu'à atteindre le cas de base `somme(0)`.
+
+### 1.2 Fonction factorielle
+
+#### Code de la fonction :
+```python
+def factorielle(n):
+    if n == 0:
+        return 1
+    else:
+        return n * factorielle(n - 1)
+```
+
+#### Question 2 :
+**Quels seront les appels effectués pour obtenir `factorielle(4)` ?**
+
+Pour calculer `factorielle(4)`, voici les appels récursifs effectués :
+1. `factorielle(4)` appelle `factorielle(3)`
+2. `factorielle(3)` appelle `factorielle(2)`
+3. `factorielle(2)` appelle `factorielle(1)`
+4. `factorielle(1)` appelle `factorielle(0)`
+5. `factorielle(0)` retourne 1 (cas de base)
+
+La récursion se termine alors et les valeurs remontent :
+- `factorielle(1)` retourne `1 * 1 = 1`
+- `factorielle(2)` retourne `2 * 1 = 2`
+- `factorielle(3)` retourne `3 * 2 = 6`
+- `factorielle(4)` retourne `4 * 6 = 24`
+
+## 2. TD
+
+### 2.1 Fonction mystère
+
+#### Code de la fonction :
+```python
+def mystere(i, k):
+    if i <= k:
+        print(i)
+        mystere(i + 1, k)
+```
+
+#### Question :
+**Que fait la fonction mystère ?**
+
+La fonction `mystere(i, k)` affiche tous les entiers de `i` à `k` inclus, un par un, en utilisant la récursivité. À chaque appel, elle incrémente `i` de 1 et réimprime jusqu'à ce que `i` dépasse `k`.
+
+Exemple : `mystere(3, 6)` affichera :
+```
+3
+4
+5
+6
+```
+
+### 2.2 Nombre de chiffres d'un nombre
+
+#### Code de la fonction :
+```python
+def nb_chiffre(n):
+    if n < 10:
+        return 1
+    else:
+        return 1 + nb_chiffre(n // 10)
+```
+
+#### Explication :
+La fonction `nb_chiffre(n)` calcule récursivement le nombre de chiffres d'un nombre `n`. Si `n` est inférieur à 10, il n'a qu'un chiffre, donc elle retourne 1. Sinon, elle divise le nombre par 10 (éliminant ainsi le dernier chiffre) et ajoute 1 au résultat de l'appel récursif.
+
+Exemples :
+```python
+>>> nb_chiffre(9)
+1
+>>> nb_chiffre(99)
+2
+>>> nb_chiffre(1000)
+4
+```
+
+### 2.3 Maximum d'un tableau
+
+#### Code de la fonction :
+```python
+def maximum(t):
+    if len(t) == 1:
+        return t[0]
+    else:
+        return max(t[0], maximum(t[1:]))
+```
+
+#### Explication :
+La fonction `maximum(t)` utilise la récursivité pour trouver le plus grand élément d'un tableau. Si le tableau ne contient qu'un seul élément, cet élément est le maximum. Sinon, la fonction compare le premier élément du tableau avec le maximum du reste du tableau (via la tranche `t[1:]`), et retourne le plus grand des deux.
+
+Exemple :
+```python
+>>> maximum([3, 1, 4, 1, 5, 9])
+9
+```
+
+## 3. Bonus
+
+### 3.1 Suite de Syracuse
+
+#### Code de la fonction :
+```python
+def syracuse(u):
+    print(u)
+    if u > 1:
+        if u % 2 == 0:
+            syracuse(u // 2)
+        else:
+            syracuse(3 * u + 1)
+```
+
+#### Explication :
+La fonction `syracuse(u)` génère et affiche les termes de la suite de Syracuse pour une valeur initiale `u`. Si `u` est pair, elle divise `u` par 2. Si `u` est impair, elle calcule `3 * u + 1`. La fonction continue de s'exécuter jusqu'à ce que `u` soit inférieur ou égal à 1.
+
+Exemple :
+```python
+>>> syracuse(7)
+7
+22
+11
+34
+17
+52
+26
+13
+40
+20
+10
+5
+16
+8
+4
+2
+1
+```
diff --git a/Recursivité/assets/bo_diviser.png b/Recursivité/assets/bo_diviser.png
new file mode 100644
index 0000000..4ea6be8
Binary files /dev/null and b/Recursivité/assets/bo_diviser.png differ
diff --git a/Recursivité/assets/bo_recursivite.png b/Recursivité/assets/bo_recursivite.png
new file mode 100644
index 0000000..cc2ed3e
Binary files /dev/null and b/Recursivité/assets/bo_recursivite.png differ