updated dates

slides/cours_6.md

@@ -143,37 +143,39 @@ int fib_imp(int n) {
 
 ## But: Calculer $x^n$
 
-* Algorithme naîf et impératif
-
-    ```C
-    int pow(x, n) {
-        if (0 == n) {
-            return 1;
-        }
-        for (int i = 1; i < n; ++i) {
-            x *= x;
-        }
-        return x;
-    }
-    ```
+* Quel est l'algorithmie le plus simple que vous pouvez imaginer?
 
 . . .
 
+```C
+int pow(int x, int n) {
+    if (0 == n) {
+        return 1;
+    }
+    for (int i = 1; i < n; ++i) {
+        x *= x;
+    }
+    return x;
+}
+```
+
 * Complexité? Combien de multiplication en fonction de `n`?
 
 # Exponentiation rapide ou indienne (2/4)
 
-* Algorithme naïf et récursif
+* Proposez un algorithme naïf et récursif
 
-    ```C
-    int pow(x, n) {
-        if (n != 0) {
-            return x * pow(x, n-1);
-        } else {
-            return 1;
-        }
+. . .
+
+```C
+int pow(x, n) {
+    if (n != 0) {
+        return x * pow(x, n-1);
+    } else {
+        return 1;
     }
-    ```
+}
+```
 
 # Exponentiation rapide ou indienne (3/4)
 
@@ -309,8 +311,7 @@ bool is_present(int n, int tab[], int elem) {
 ```
 
 * Dans le **meilleurs des cas** il faut `1` comparaison.
-* Dans le **pire des cas** (élément absent p.ex.) il faut `n`
-  comparaisons.
+* Dans le **pire des cas** (élément absent p.ex.) il faut `n` comparaisons.
 
 . . .
 
@@ -343,8 +344,7 @@ bool is_present_binary_search(int n, int tab[], int elem) {
 
 ## Recherche dichotomique
 
-![Source:
-[Wikipédia](https://upload.wikimedia.org/wikipedia/commons/a/aa/Binary_search_complexity.svg)](figs/Binary_search_complexity.svg){width=80%}
+![Source: [Wikipédia](https://upload.wikimedia.org/wikipedia/commons/a/aa/Binary_search_complexity.svg)](figs/Binary_search_complexity.svg){width=80%}
 
 . . .
 
@@ -362,20 +362,17 @@ bool is_present_binary_search(int n, int tab[], int elem) {
 
 ## Constante de proportionnalité
 
-* Pour la recherche linéaire ou dichotomique, on a des algorithmes qui sont
-  $\sim N$ ou $\sim \log_2(N)$
+* Pour la recherche linéaire ou dichotomique, on a des algorithmes qui sont $\sim N$ ou $\sim \log_2(N)$
 * Qu'est-ce que cela veut dire?
 
 . . .
 
-* Temps de calcul est $t=C\cdot N$ (où $C$ est le temps pris pour une
-  comparaisons sur une machine/compilateur donné)
+* Temps de calcul est $t=C\cdot N$ (où $C$ est le temps pris pour une comparaisons sur une machine/compilateur donné)
 * La complexité ne dépend pas de $C$.
 
 ## Le $\mathcal{O}$ de Leibnitz
 
-* Pour noter la complexité d'un algorithme on utilise le symbole
-$\mathcal{O}$ (ou "grand Ô de").
+* Pour noter la complexité d'un algorithme on utilise le symbole $\mathcal{O}$ (ou "grand Ô de").
 * Les complexités les plus couramment rencontrées sont
 
 . . .
@@ -482,8 +479,7 @@ $$
 ## Finalement
 
 $$
-\mathcal{O}(N^2\mbox{ comparaisons}) + \mathcal{O}(N\mbox{
-swaps})=\mathcal{O}(N^2).
+\mathcal{O}(N^2\mbox{ comparaisons}) + \mathcal{O}(N\mbox{swaps})=\mathcal{O}(N^2).
 $$