diff --git a/Paradigmes/Corrige_Exercice.md b/Paradigmes/Corrige_Exercice.md
deleted file mode 100644
index 216b3e7..0000000
--- a/Paradigmes/Corrige_Exercice.md
+++ /dev/null
@@ -1,320 +0,0 @@
-# Corrigé de l'exercice — Cuisson des pâtes
-
----
-
-## Énoncé
-
-Nous voulons faire cuire des pâtes. Écrire la recette sous forme de code Python selon trois paradigmes différents.
-
----
-
-## Version impérative
-
-Liste d'instructions étape par étape, avec modification d'état.
-
-```python
-# Version impérative : liste d'instructions étape par étape
-
-def cuire_pates_imperatif():
- """Fait cuire des pâtes de manière impérative."""
-
- # État initial
- eau = "froide"
- pates = "crues"
- sel = False
-
- # Étape 1 : Remplir la casserole
- print("Remplissage de la casserole...")
- quantite_eau = 1.5 # litres
-
- # Étape 2 : Faire chauffer l'eau
- print("Chauffage de l'eau...")
- eau = "chaude"
-
- # Étape 3 : Attendre l'ébullition
- print("Attente de l'ébullition...")
- eau = "bouillante"
-
- # Étape 4 : Saler l'eau
- print("Ajout du sel...")
- sel = True
-
- # Étape 5 : Ajouter les pâtes
- print("Ajout des pâtes...")
- pates = "en cuisson"
-
- # Étape 6 : Attendre le temps de cuisson
- temps_cuisson = 10 # minutes
- print(f"Cuisson pendant {temps_cuisson} minutes...")
-
- # Étape 7 : Égoutter
- print("Égouttage des pâtes...")
- pates = "cuites"
-
- print(f"Résultat : pâtes {pates}")
- return pates
-
-
-# Exécution
-resultat = cuire_pates_imperatif()
-```
-
-**Caractéristiques :**
-- Modification d'état (variables `eau`, `pates`, `sel`)
-- Instructions séquentielles
-- Effets de bord (print)
-
----
-
-## Version fonctionnelle
-
-Une fonction pure qui prend un état et retourne un nouvel état, sans modification.
-
-```python
-# Version fonctionnelle : fonctions pures et composition
-
-def remplir_casserole(etat):
- """Retourne un nouvel état avec la casserole remplie."""
- return {**etat, "eau": "froide", "quantite_eau": 1.5}
-
-
-def chauffer_eau(etat):
- """Retourne un nouvel état avec l'eau chauffée."""
- return {**etat, "eau": "chaude"}
-
-
-def faire_bouillir(etat):
- """Retourne un nouvel état avec l'eau bouillante."""
- return {**etat, "eau": "bouillante"}
-
-
-def saler(etat):
- """Retourne un nouvel état avec le sel ajouté."""
- return {**etat, "sel": True}
-
-
-def ajouter_pates(etat):
- """Retourne un nouvel état avec les pâtes en cuisson."""
- return {**etat, "pates": "en cuisson"}
-
-
-def cuire(etat, duree):
- """Retourne un nouvel état après cuisson."""
- return {**etat, "temps_cuisson": duree, "pates": "cuites"}
-
-
-def egoutter(etat):
- """Retourne un nouvel état avec les pâtes égouttées."""
- return {**etat, "egouttees": True}
-
-
-# Composition de fonctions
-def cuire_pates_fonctionnel(etat_initial):
- """
- Fait cuire des pâtes de manière fonctionnelle.
- Chaque étape retourne un nouvel état sans modifier l'ancien.
- """
- etat = remplir_casserole(etat_initial)
- etat = chauffer_eau(etat)
- etat = faire_bouillir(etat)
- etat = saler(etat)
- etat = ajouter_pates(etat)
- etat = cuire(etat, 10)
- etat = egoutter(etat)
- return etat
-
-
-# Version encore plus fonctionnelle avec reduce
-import functools
-
-def cuire_pates_reduce(etat_initial):
- """Version avec reduce pour composer les fonctions."""
- etapes = [
- remplir_casserole,
- chauffer_eau,
- faire_bouillir,
- saler,
- ajouter_pates,
- lambda e: cuire(e, 10),
- egoutter
- ]
- return functools.reduce(lambda etat, f: f(etat), etapes, etat_initial)
-
-
-# Exécution
-etat_initial = {"pates": "crues", "sel": False}
-resultat = cuire_pates_fonctionnel(etat_initial)
-print(f"État final : {resultat}")
-
-# Vérification : l'état initial n'a pas été modifié
-print(f"État initial préservé : {etat_initial}")
-```
-
-**Caractéristiques :**
-- Pas de modification d'état (immutabilité)
-- Fonctions pures (même entrée → même sortie)
-- Composition de fonctions
-- L'état initial n'est jamais modifié
-
----
-
-## Version orientée objet
-
-Une classe `Pates` avec des attributs et une méthode `cuire()`.
-
-```python
-# Version orientée objet : classe Pates avec méthode cuire()
-
-class Casserole:
- """Représente une casserole pour la cuisson."""
-
- def __init__(self):
- self.eau = None
- self.temperature = "froide"
- self.sel = False
-
- def remplir(self, quantite=1.5):
- """Remplit la casserole d'eau."""
- self.eau = quantite
- print(f"Casserole remplie avec {quantite}L d'eau")
-
- def chauffer(self):
- """Chauffe l'eau jusqu'à ébullition."""
- self.temperature = "chaude"
- print("Chauffage en cours...")
- self.temperature = "bouillante"
- print("L'eau bout !")
-
- def saler(self):
- """Ajoute du sel dans l'eau."""
- self.sel = True
- print("Sel ajouté")
-
-
-class Pates:
- """Représente des pâtes à cuire."""
-
- def __init__(self, type_pates="spaghetti", quantite=500):
- self.type = type_pates
- self.quantite = quantite # en grammes
- self.etat = "crues"
- self.temps_cuisson = 0
-
- def cuire(self, casserole, duree=10):
- """
- Fait cuire les pâtes dans une casserole.
-
- :param casserole: (Casserole) la casserole à utiliser
- :param duree: (int) temps de cuisson en minutes
- """
- # Vérifications
- if casserole.eau is None:
- raise ValueError("La casserole doit contenir de l'eau !")
- if casserole.temperature != "bouillante":
- raise ValueError("L'eau doit être bouillante !")
-
- print(f"Ajout de {self.quantite}g de {self.type} dans la casserole")
- self.etat = "en cuisson"
-
- print(f"Cuisson pendant {duree} minutes...")
- self.temps_cuisson = duree
-
- self.etat = "cuites"
- print(f"Les {self.type} sont cuites !")
-
- def egoutter(self):
- """Égoutte les pâtes."""
- if self.etat != "cuites":
- raise ValueError("Les pâtes doivent être cuites avant d'être égouttées !")
- print("Égouttage des pâtes...")
- self.etat = "prêtes"
-
- def __str__(self):
- return f"Pates({self.type}, {self.quantite}g, état={self.etat})"
-
-
-# Exécution
-def preparer_pates_oo():
- """Prépare des pâtes en utilisant la POO."""
-
- # Création des objets
- casserole = Casserole()
- pates = Pates("fusilli", 400)
-
- print(f"Début : {pates}")
-
- # Préparation de la casserole
- casserole.remplir(2.0)
- casserole.chauffer()
- casserole.saler()
-
- # Cuisson des pâtes
- pates.cuire(casserole, duree=12)
- pates.egoutter()
-
- print(f"Fin : {pates}")
- return pates
-
-
-resultat = preparer_pates_oo()
-```
-
-**Caractéristiques :**
-- Encapsulation (attributs et méthodes regroupés)
-- Objets avec état interne
-- Interactions entre objets (Pates et Casserole)
-- Méthodes qui modifient l'état de l'objet
-
----
-
-## Tableau comparatif
-
-| Aspect | Impératif | Fonctionnel | Orienté Objet |
-|--------|-----------|-------------|---------------|
-| **État** | Variables modifiées | États immuables | Attributs d'objets |
-| **Données** | Variables simples | Dictionnaires/tuples | Objets |
-| **Actions** | Instructions séquentielles | Fonctions composées | Méthodes |
-| **Modification** | Sur place | Nouvel état retourné | Via méthodes |
-| **Réutilisabilité** | Faible | Moyenne | Forte |
-| **Testabilité** | Difficile | Facile | Moyenne |
-
----
-
-## Bonus : Version lambda
-
-```python
-# Version ultra-fonctionnelle avec lambdas et reduce
-
-import functools
-
-# Chaque étape est une lambda qui transforme l'état
-etapes = [
- lambda e: {**e, "eau": 1.5},
- lambda e: {**e, "temperature": "bouillante"},
- lambda e: {**e, "sel": True},
- lambda e: {**e, "pates": "en cuisson"},
- lambda e: {**e, "temps": 10, "pates": "cuites"},
- lambda e: {**e, "egouttees": True}
-]
-
-# Composition avec reduce
-cuire_pates_lambda = lambda etat: functools.reduce(
- lambda e, f: f(e),
- etapes,
- etat
-)
-
-# Exécution
-resultat = cuire_pates_lambda({"pates": "crues"})
-print(resultat)
-# {'pates': 'cuites', 'eau': 1.5, 'temperature': 'bouillante',
-# 'sel': True, 'temps': 10, 'egouttees': True}
-```
-
----
-
-Auteurs : Florian Mathieu, Enzo Frémeaux, Thimothée Decooster
-
-Licence CC BY NC
-
-
Ce cours est mis à disposition selon les termes de la Licence Creative Commons Attribution - Pas d'Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International.
diff --git a/Paradigmes/README.md b/Paradigmes/README.md
index 8bd7efa..da4dfc6 100644
--- a/Paradigmes/README.md
+++ b/Paradigmes/README.md
@@ -244,6 +244,211 @@ Voici une tâche simple : nous voulons faire cuire des pâtes.
- **Version fonctionnelle : une fonction pure qui prend un état (pâtes non cuites) et retourne un nouvel état (pâtes cuites).**
- **Version orientée objet : créer une classe** Pates *avec une méthode* cuire().
+??? success "Correction"
+
+ ## Version impérative
+
+ Liste d’instructions étape par étape, avec modification d’état.
+
+ ```python
+ def cuire_pates_imperatif():
+ """Fait cuire des pâtes de manière impérative."""
+
+ eau = "froide"
+ pates = "crues"
+ sel = False
+
+ print("Remplissage de la casserole...")
+ quantite_eau = 1.5
+
+ print("Chauffage de l’eau...")
+ eau = "chaude"
+
+ print("Attente de l’ébullition...")
+ eau = "bouillante"
+
+ print("Ajout du sel...")
+ sel = True
+
+ print("Ajout des pâtes...")
+ pates = "en cuisson"
+
+ temps_cuisson = 10
+ print(f"Cuisson pendant {temps_cuisson} minutes...")
+
+ print("Égouttage des pâtes...")
+ pates = "cuites"
+
+ print(f"Résultat : pâtes {pates}")
+ return pates
+
+ resultat = cuire_pates_imperatif()
+ ```
+
+ **Caractéristiques :**
+
+ - Modification d’état (variables `eau`, `pates`, `sel`)
+ - Instructions séquentielles
+ - Effets de bord (print)
+
+ ---
+
+ ## Version fonctionnelle
+
+ Une fonction pure qui prend un état et retourne un nouvel état, sans modification.
+
+ ```python
+ def remplir_casserole(etat):
+ return {**etat, "eau": "froide", "quantite_eau": 1.5}
+
+ def chauffer_eau(etat):
+ return {**etat, "eau": "chaude"}
+
+ def faire_bouillir(etat):
+ return {**etat, "eau": "bouillante"}
+
+ def saler(etat):
+ return {**etat, "sel": True}
+
+ def ajouter_pates(etat):
+ return {**etat, "pates": "en cuisson"}
+
+ def cuire(etat, duree):
+ return {**etat, "temps_cuisson": duree, "pates": "cuites"}
+
+ def egoutter(etat):
+ return {**etat, "egouttees": True}
+
+ def cuire_pates_fonctionnel(etat_initial):
+ etat = remplir_casserole(etat_initial)
+ etat = chauffer_eau(etat)
+ etat = faire_bouillir(etat)
+ etat = saler(etat)
+ etat = ajouter_pates(etat)
+ etat = cuire(etat, 10)
+ etat = egoutter(etat)
+ return etat
+
+ etat_initial = {"pates": "crues", "sel": False}
+ resultat = cuire_pates_fonctionnel(etat_initial)
+ print(f"État final : {resultat}")
+ print(f"État initial préservé : {etat_initial}")
+ ```
+
+ **Caractéristiques :**
+
+ - Pas de modification d’état (immutabilité)
+ - Fonctions pures (même entrée → même sortie)
+ - Composition de fonctions
+ - L’état initial n’est jamais modifié
+
+ ---
+
+ ## Version orientée objet
+
+ Une classe `Pates` avec des attributs et une méthode `cuire()`.
+
+ ```python
+ class Casserole:
+ def __init__(self):
+ self.eau = None
+ self.temperature = "froide"
+ self.sel = False
+
+ def remplir(self, quantite=1.5):
+ self.eau = quantite
+ print(f"Casserole remplie avec {quantite}L d’eau")
+
+ def chauffer(self):
+ self.temperature = "bouillante"
+ print("L’eau bout !")
+
+ def saler(self):
+ self.sel = True
+ print("Sel ajouté")
+
+
+ class Pates:
+ def __init__(self, type_pates="spaghetti", quantite=500):
+ self.type = type_pates
+ self.quantite = quantite
+ self.etat = "crues"
+ self.temps_cuisson = 0
+
+ def cuire(self, casserole, duree=10):
+ if casserole.eau is None:
+ raise ValueError("La casserole doit contenir de l’eau !")
+ if casserole.temperature != "bouillante":
+ raise ValueError("L’eau doit être bouillante !")
+ self.etat = "en cuisson"
+ self.temps_cuisson = duree
+ self.etat = "cuites"
+ print(f"Les {self.type} sont cuites !")
+
+ def egoutter(self):
+ if self.etat != "cuites":
+ raise ValueError("Les pâtes doivent être cuites avant d’être égouttées !")
+ self.etat = "prêtes"
+
+ def __str__(self):
+ return f"Pates({self.type}, {self.quantite}g, état={self.etat})"
+
+
+ casserole = Casserole()
+ pates = Pates("fusilli", 400)
+ casserole.remplir(2.0)
+ casserole.chauffer()
+ casserole.saler()
+ pates.cuire(casserole, duree=12)
+ pates.egoutter()
+ print(f"Fin : {pates}")
+ ```
+
+ **Caractéristiques :**
+
+ - Encapsulation (attributs et méthodes regroupés)
+ - Objets avec état interne
+ - Interactions entre objets (Pates et Casserole)
+
+ ---
+
+ ## Tableau comparatif
+
+ | Aspect | Impératif | Fonctionnel | Orienté Objet |
+ |--------|-----------|-------------|---------------|
+ | **État** | Variables modifiées | États immuables | Attributs d’objets |
+ | **Données** | Variables simples | Dictionnaires/tuples | Objets |
+ | **Actions** | Instructions séquentielles | Fonctions composées | Méthodes |
+ | **Modification** | Sur place | Nouvel état retourné | Via méthodes |
+ | **Réutilisabilité** | Faible | Moyenne | Forte |
+ | **Testabilité** | Difficile | Facile | Moyenne |
+
+ ---
+
+ ## Bonus : version lambda
+
+ ```python
+ import functools
+
+ etapes = [
+ lambda e: {**e, "eau": 1.5},
+ lambda e: {**e, "temperature": "bouillante"},
+ lambda e: {**e, "sel": True},
+ lambda e: {**e, "pates": "en cuisson"},
+ lambda e: {**e, "temps": 10, "pates": "cuites"},
+ lambda e: {**e, "egouttees": True}
+ ]
+
+ cuire_pates_lambda = lambda etat: functools.reduce(
+ lambda e, f: f(e),
+ etapes,
+ etat
+ )
+
+ resultat = cuire_pates_lambda({"pates": "crues"})
+ print(resultat)
+ ```
+
------
Auteurs : Florian Mathieu, Enzo Frémeaux, Thimothée Decooster
diff --git a/Recursivité/Exercices_Recursivité.md b/Recursivité/EXERCICES.md
similarity index 100%
rename from Recursivité/Exercices_Recursivité.md
rename to Recursivité/EXERCICES.md