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

Recursivité/Diviser_pour_regner/README.md

@@ -1,4 +1,3 @@
-
 # Diviser pour régner
 
 ### Le programme
@@ -59,54 +58,61 @@ Prenons une liste d'exemple : `[38, 27, 43, 3, 9, 82, 10]`.
 
 3. **Combiner** : Enfin, on fusionne les deux sous-listes triées :
     - `[27, 38, 43]` et `[3, 9, 10, 82]` sont fusionnées pour donner la liste triée finale : `[3, 9, 10, 27, 38, 43, 82]`.
-    
-    --------------
 
-### Implémentation en python
+--------------
+
+### Implémentation en Python
 
 ```python
-def tri_fusion(gauche:list, droite:list):
-  tab_fusion = []
-  l1, l2 = len(gauche), len(droite)
-  i1, i2 = 0,0
-  while i1 < l1 and i2 < l2:
-    if gauche[i1] < droite[i2]:
-      tab_fusion.append(gauche[i1])
-      i1 += 1
-    else:
-      tab_fusion.append(droite[i2])
-      i2 += 1
-  return tab_fusion + gauche[i1:] + droite[i2:]
+def fusionner(gauche: list, droite: list) -> list:
+    """Fusionne deux listes triées en une seule liste triée."""
+    resultat = []
+    i, j = 0, 0
 
-def fusion(tab:list):
-  if len (tab) <=1:
-    return tab
-  m = len(tab) // 2
-  return tri_fusion(fusion(tab[:m]), fusion (tab[m:]))
+    while i < len(gauche) and j < len(droite):
+        if gauche[i] < droite[j]:
+            resultat.append(gauche[i])
+            i += 1
+        else:
+            resultat.append(droite[j])
+            j += 1
+
+    # Ajouter les éléments restants
+    return resultat + gauche[i:] + droite[j:]
+
+
+def tri_fusion(tab: list) -> list:
+    """Trie une liste en utilisant l'algorithme du tri fusion."""
+    # Cas de base : une liste de 0 ou 1 élément est déjà triée
+    if len(tab) <= 1:
+        return tab
+
+    # Diviser : trouver le milieu et séparer en deux sous-listes
+    milieu = len(tab) // 2
+    gauche = tri_fusion(tab[:milieu])
+    droite = tri_fusion(tab[milieu:])
+
+    # Combiner : fusionner les deux sous-listes triées
+    return fusionner(gauche, droite)
 ```
 
-```
-	•	tab_fusion est une liste vide où seront ajoutés les éléments fusionnés.
-	•	l1 et l2 stockent les tailles respectives de gauche et droite.
-	•	i1 et i2 sont des indices qui parcourent gauche et droite.
-	2.	Boucle principale :
-	•	Tant que l’on n’a pas parcouru complètement l’une des deux listes (gauche ou droite), on compare les éléments actuels de chaque liste (c’est-à-dire gauche[i1] et droite[i2]).
-	•	Si l’élément de gauche est plus petit, on l’ajoute à tab_fusion, et on incrémente i1.
-	•	Sinon, on ajoute l’élément de droite et on incrémente i2.
-	3.	Retour des éléments restants :
-	•	Une fois que l’une des deux listes est entièrement parcourue, on ajoute les éléments restants de l’autre liste à tab_fusion. C’est ce que fait gauche[i1:] pour la première liste, et droite[i2:] pour la deuxième.
-```
+#### Explication de la fonction `fusionner`
 
-```
-Condition de base :
-	•	Si le tableau contient un seul élément (ou aucun), il est déjà trié, donc on le retourne tel quel.
-	2.	Diviser :
-	•	On divise le tableau en deux sous-tableaux de taille approximativement égale à l’aide de m = len(tab) // 2.
-	•	tab[:m] correspond à la première moitié du tableau et tab[m:] à la deuxième.
-	3.	Récursion et fusion :
-	•	On applique récursivement fusion() aux deux moitiés du tableau.
-	•	Une fois que les deux sous-tableaux sont triés, on les combine en utilisant la fonction tri_fusion.
-```
+- `resultat` est une liste vide où seront ajoutés les éléments fusionnés
+- `i` et `j` sont des indices qui parcourent respectivement `gauche` et `droite`
+- **Boucle principale** : tant que l'on n'a pas parcouru complètement l'une des deux listes, on compare les éléments actuels (`gauche[i]` et `droite[j]`)
+  - Si l'élément de gauche est plus petit, on l'ajoute à `resultat` et on incrémente `i`
+  - Sinon, on ajoute l'élément de droite et on incrémente `j`
+- **Éléments restants** : une fois qu'une liste est entièrement parcourue, on ajoute les éléments restants de l'autre liste
+
+#### Explication de la fonction `tri_fusion`
+
+- **Cas de base** : si le tableau contient un seul élément (ou aucun), il est déjà trié, donc on le retourne tel quel
+- **Diviser** : on divise le tableau en deux sous-tableaux de taille approximativement égale
+  - `tab[:milieu]` correspond à la première moitié
+  - `tab[milieu:]` correspond à la deuxième moitié
+- **Régner** : on applique récursivement `tri_fusion()` aux deux moitiés du tableau
+- **Combiner** : une fois les deux sous-tableaux triés, on les fusionne avec la fonction `fusionner`
 
 
 
@@ -133,5 +139,4 @@ Auteur : Florian Mathieu
 
 Licence CC BY NC
 
-<a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/"><img alt="Licence Creative Commons" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png" /></a> <br />Ce cours est mis à disposition selon les termes de la <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/">Licence Creative Commons Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International</a>.
-
+<a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/"><img alt="Licence Creative Commons" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png" /></a> <br />Ce cours est mis à disposition selon les termes de la <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/">Licence Creative Commons Attribution - Pas d'Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International</a>.