ajout de tous les cours et TP préparés cet été

Recursivité/Corrigé_Exercices.md

@@ -0,0 +1,97 @@
+# Corrigé des exercices de révision sur la récursivité
+
+## Exercice 1 : Exponentiation rapide
+
+**Rappel :** On souhaite calculer `a^n` avec les relations de récurrence suivantes :
+- `a^0 = 1`
+- Si `n` est pair : `a^n = (a * a)^(n / 2)`
+- Sinon : `a^n = a * (a * a)^((n - 1) / 2)`
+
+1. Version récursive
+
+```python
+def exponentiation_rapide_recursive(a, n):
+    if n == 0:
+        return 1  # Cas de base
+    elif n % 2 == 0:
+        return exponentiation_rapide_recursive(a * a, n // 2)
+    else:
+        return a * exponentiation_rapide_recursive(a * a, (n - 1) // 2)
+
+# Exemple de test
+print(exponentiation_rapide_recursive(2, 10))  # Renvoie 1024
+```
+
+2. Version itérative
+
+```python
+def exponentiation_rapide_iterative(a, n):
+    result = 1
+    while n > 0:
+        if n % 2 == 1:  # Si n est impair
+            result *= a
+        a *= a
+        n //= 2  # Diviser n par 2
+    return result
+
+# Exemple de test
+print(exponentiation_rapide_iterative(2, 10))  # Renvoie 1024
+```
+
+
+
+-------
+
+**Exercice 2 : Génération d’une liste décroissante**
+
+
+
+**Fonction récursive**
+
+```python
+def generate_liste(n):
+    if n == 0:
+        return [0]  # Cas de base
+    else:
+        return [n] + generate_liste(n - 1)  # Ajoute n à la liste générée pour n-1
+
+# Exemple de test
+print(generate_liste(5))  # Renvoie [5, 4, 3, 2, 1, 0]
+```
+
+______
+
+**Exercice 3 : Multiplication égyptienne**
+
+
+
+**Utiliser la technique pour a = 13 et b = 61**
+
+| **Étapes de la multiplication égyptienne** |
+| ------------------------------------------ |
+| 13 x 61 = 61                               |
+| 6 x 122                                    |
+| 3 x 244 = 244                              |
+| 1 x 488 = 488                              |
+| **Total = 793**                            |
+
+Fonction récursive :
+
+```python
+def multiplication_egyptienne(a, b):
+    if a == 0:
+        return 0  # Cas de base : si a est 0, le produit est 0
+    elif a % 2 == 1:
+        return b + multiplication_egyptienne(a // 2, b * 2)  # Ajouter b si a est impair
+    else:
+        return multiplication_egyptienne(a // 2, b * 2)  # Continuer sans ajouter si a est pair
+
+# Exemple de test
+print(multiplication_egyptienne(13, 61))  # Renvoie 793
+```
+
+**Complexité de l’algorithme**
+
+
+
+La complexité de cet algorithme dépend du nombre de divisions de a par 2, ce qui correspond à une complexité logarithmique : **O(log a)**. En effet, chaque étape divise a par 2, ce qui signifie qu’il y aura environ log_2(a) itérations.