From 68aea6a4e288d92ecc8f3d0cb544785a08c87027 Mon Sep 17 00:00:00 2001
From: Orestis <orestis.malaspinas@pm.me>
Date: Mon, 6 Nov 2023 18:58:36 +0100
Subject: [PATCH] maj 2023

---
 slides/cours_7.md | 46 ++++++++++++++++++++++++++++++----------------
 1 file changed, 30 insertions(+), 16 deletions(-)

diff --git a/slides/cours_7.md b/slides/cours_7.md
index 08b0a14..21e0761 100644
--- a/slides/cours_7.md
+++ b/slides/cours_7.md
@@ -193,9 +193,11 @@ Le plus petit élément est -9. On commence donc par décaler les valeurs de 9.
 |:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
 | -9  | -6  | -5  |  1  |  2  |  2  |  4  |  5  |  6  |
 
+* Et alors?
+
 . . .
 
-* The end.
+* Et alors rien. C'est fini.
 
 
 # Pseudo-code
@@ -250,7 +252,7 @@ rien decaler(entier taille, entier tab[taille], entier val):
 
 ```python
 rien echanger(entier tab[], entier tab2[])
-# échanger les pointeurs vers les tableaux
+# échanger les tableaux (sans copier les valeurs)
 ```
 
 # Un peu plus de détails (2/2)
@@ -262,7 +264,7 @@ rien alveole_0(entier taille, entier tab[taille],
                entier tab_tmp[taille], entier pos):
     entier k = 0
     pour i de 0 à taille-1:
-        si git(tab[i], pos):
+        si bit(tab[i], pos):
             tab_tmp[k] = tab[i]
             k = k + 1
 ```
@@ -274,7 +276,7 @@ rien alveole_0(entier taille, entier tab[taille],
 ```python
 rien alveole_1(entier taille, entier tab[taille], 
                entier tab_tmp[taille], entier pos):
-    # pareil que alveole 1 mais en partant de taille
+    # pareil que alveole_0 mais en partant de taille
 ```
 
 <!-- ```C
@@ -389,7 +391,7 @@ Ainsi, la complexité du tri par base est $\mathcal{O}(b\cdot N)$. -->
 # Principe de l'algorithme
 
 * Soit `taille` la taille du tableau à trier.
-* Pour `i = 0` à `entier(\log_2(taille))-1`:
+* Pour `i = 0` à `entier(log2(taille))-1`:
     * Fusion des paires de sous-tableaux successifs de taille `2**i` (ou moins pour l'extrémité)
 
 . . .
@@ -421,33 +423,45 @@ Ainsi, la complexité du tri par base est $\mathcal{O}(b\cdot N)$. -->
 # Pseudo-code
 
 ```python
-rien tri_fusion(entier taille, entier tab[taille]) {
+rien tri_fusion(entier taille, entier tab[taille])
     entier tab_tmp[taille];
     entier nb_etapes = log_2(size) + 1; 
     pour etape de 0 a nb_etapes - 1:
         entier gauche = 0;
-        entier taille_tranche = 2**etape;
+        entier t_tranche = 2**etape;
         tant que (gauche < taille):
-            fusion(tab[gauche..gauche+taille_tranche-1], tab[gauche+taille_tranche..gauche+2*taille_tranche-1],
-                tab_tmp[gauche..gauche+2*taille_tranche-1]); #bornes incluses
-            gauche += 2*taille_tranche;
+            fusion(
+                tab[gauche..gauche+t_tranche-1], 
+                tab[gauche+t_tranche..gauche+2*t_tranche-1],
+                tab_tmp[gauche..gauche+2*t_tranche-1]);
+            #bornes incluses
+            gauche += 2*t_tranche;
         echanger(tab, tab_tmp);
 ```
 
 # La fonction de fusion
 
+\footnotesize
+
 ```python
 # hyp: tab_g et tab_d sont triés
-rien fuction(entier tab_g[], entier tab_d[], entier res[]):
+rien fusion(entier tab_g[], entier tab_d[], entier res[]):
     entier g = taille(tab_g)
     entier d = taille(tab_d)
     entier i_g = 0, i_d = 0
     pour i = 0 à g + d:
-        si tab_g[i_g] < tab[i_d]:
+        si i_g < g et i_d < d:
+            si tab_g[i_g] < tab[i_d]:
+                res[i] = tab_g[i_g]
+                i_g = i_g + 1
+            sinon:
+                res[i] = tab_d[i_d]
+                i_d = i_d + 1
+        sinon si i_g < g:
             res[i] = tab_g[i_g]
             i_g = i_g + 1
-        sinon:
-            res[i] = tab_g[i_d]
+        sinon si i_d < d:
+            res[i] = tab_d[i_d]
             i_d = i_d + 1
 
 ```
@@ -600,7 +614,7 @@ int partition(int size, int array[size], int first, int last) {
 }
 ```
 
-# Tri rapide ou quicksort (8/8)
+<!-- # Tri rapide ou quicksort (8/8)
 
 ## Quelle est la complexité du tri rapide?
 
@@ -614,7 +628,7 @@ int partition(int size, int array[size], int first, int last) {
     * Chaque fois le tableau est séparé en $2$ parties égales.
     * On a $\log_2(N)$ partitions, et $N$ boucles $\Rightarrow N\cdot
       \log_2(N)$.
-* En moyenne: $\mathcal{O}(N\cdot \log_2(N))$.
+* En moyenne: $\mathcal{O}(N\cdot \log_2(N))$. -->
 
 # L'algorithme à la main
 
-- 
GitLab