diff --git a/slides/cours_2.md b/slides/cours_2.md
index 27094b701e71e352895539774a4fc59d806396e9..6e0b9e05c8cbd57f5940b08f3bbf50d20da52c9e 100644
--- a/slides/cours_2.md
+++ b/slides/cours_2.md
@@ -52,7 +52,6 @@ int main() {
- Plus petit commun multiple (PPCM) de deux nombres
- Autre algorithme de calcul du PPCM de deux nombres
- Plus grand commun diviseur (PGCD) de deux nombres
-- Remplissage d'un tableau et recherche de la valeur minimale
# Le calcul du PPCM (1/5)
@@ -372,138 +371,4 @@ void main() {
}
```
-# Collections: tableaux statiques
-* Objets de même type: leur nombre est **connu à la compilation**;
-* Stockés contigüement en mémoire (très efficace);
-
- ```C
- #define SIZE 10
- int entiers[] = {2, 1, 4, 5, 7}; // taille 5, initialisé
- int tab[3]; // taille 3, non initialisé
- float many_floats[SIZE]; // taille 10, non initialisé
- ```
-* Les indices sont numérotés de `0` à `taille-1`;
-
- ```C
- int premier = entier[0]; // premier = 2
- int dernier = entier[4]; // dernier = 7
- ```
-* Les tableaux sont **non-initialisés** par défaut;
-* Les bornes ne sont **jamais** vérifiées.
-
- ```C
- int indetermine_1 = tab[1]; // undefined behavior
- int indetermine_2 = entiers[5]; // UB
- ```
-
-# Remarques
-
-* Depuis `C99` possibilité d'avoir des tableaux dont la taille est *inconnue à
- la compilation*;
-
- ```C
- int size;
- scanf("%d", &size);
- char string[size];
- ```
-
- . . .
-
-* Considéré comme une mauvaise pratique: que se passe-t-il si `size == 1e9`?
-* On préfère utiliser l'allocation **dynamique** de mémoire pour ce genre de
- cas-là (spoiler du futur du cours).
-
-# Initialisation
-
-* Les variables ne sont **jamais** initialisées en `C` par défaut.
-* Question: Que contient le tableau suivant?
-
- ```C
- double tab[4];
- ```
-
-. . .
-
-* Réponse: On en sait absolument rien!
-* Comment initialiser un tableau?
-
-. . .
-
- ```C
- #define SIZE 10
- double tab[SIZE];
- for (int i = 0; i < SIZE; ++i) {
- tab[i] = rand() / (double)RAND_MAX * 10.0 - 5.0; // double [-5;5]
- }
- ```
-
-# Recherche du minimum dans un tableau (1/2)
-
-## Problématique
-
-Trouver le minimum d'un tableau et l'indice de l'élément le plus petit.
-
-## Écrire un pseudo-code résolvant ce problème (groupe de 3), 2min
-
-. . .
-
-```C
-index = 0
-min = tab[0]
-for i in [1; SIZE] {
- if min > tab[i] {
- min = tab[i]
- index = i
- }
-}
-```
-
-# Recherche du minimum dans un tableau (2/2)
-
-## Implémenter ce bout de code en C (groupe de 3), 4min
-
-. . .
-
-```C
-int index = 0;
-float min = tab[0];
-for (int i = 1; i < SIZE; ++i) {
- if min > tab[i] {
- min = tab[i];
- index = i;
- }
-}
-```
-
-# Tri par sélection (1/2)
-
-## Problématique
-
-Trier un tableau par ordre croissant.
-
-## Idée d'algorithme
-
-```C
-ind = 0
-boucle (ind < SIZE-1) {
- Trouver le minimum du tableau, tab_min[ind:SIZE].
- Échanger tab_min avec tab[ind]
- ind += 1
-}
-```
-
-# Tri par sélection (2/2)
-
-## Implémentation par groupe de 3
-
-* Initialiser aléatoirement un tableau de `double` de taille 10;
-* Afficher le tableau;
-* Trier par sélection le tableau;
-* Afficher le résultat trié;
-* Vérifier algorithmiquement que le résultat est bien trié.
-
-
-# La fin
-
-## Des questions?
diff --git a/slides/cours_3.md b/slides/cours_3.md
new file mode 100644
index 0000000000000000000000000000000000000000..0f2ca366b80e6f8aab3592f2f56395c43312daeb
--- /dev/null
+++ b/slides/cours_3.md
@@ -0,0 +1,141 @@
+# Quelques algorithmes simples
+
+## Voyons quelques algorithmes supplémentaires
+
+- Remplissage d'un tableau et recherche de la valeur minimale
+
+# Collections: tableaux statiques
+
+* Objets de même type: leur nombre est **connu à la compilation**;
+* Stockés contigüement en mémoire (très efficace);
+
+ ```C
+ #define SIZE 10
+ int entiers[] = {2, 1, 4, 5, 7}; // taille 5, initialisé
+ int tab[3]; // taille 3, non initialisé
+ float many_floats[SIZE]; // taille 10, non initialisé
+ ```
+* Les indices sont numérotés de `0` à `taille-1`;
+
+ ```C
+ int premier = entier[0]; // premier = 2
+ int dernier = entier[4]; // dernier = 7
+ ```
+* Les tableaux sont **non-initialisés** par défaut;
+* Les bornes ne sont **jamais** vérifiées.
+
+ ```C
+ int indetermine_1 = tab[1]; // undefined behavior
+ int indetermine_2 = entiers[5]; // UB
+ ```
+
+# Remarques
+
+* Depuis `C99` possibilité d'avoir des tableaux dont la taille est *inconnue à
+ la compilation*;
+
+ ```C
+ int size;
+ scanf("%d", &size);
+ char string[size];
+ ```
+
+ . . .
+
+* Considéré comme une mauvaise pratique: que se passe-t-il si `size == 1e9`?
+* On préfère utiliser l'allocation **dynamique** de mémoire pour ce genre de
+ cas-là (spoiler du futur du cours).
+
+# Initialisation
+
+* Les variables ne sont **jamais** initialisées en `C` par défaut.
+* Question: Que contient le tableau suivant?
+
+ ```C
+ double tab[4];
+ ```
+
+. . .
+
+* Réponse: On en sait absolument rien!
+* Comment initialiser un tableau?
+
+. . .
+
+ ```C
+ #define SIZE 10
+ double tab[SIZE];
+ for (int i = 0; i < SIZE; ++i) {
+ tab[i] = rand() / (double)RAND_MAX * 10.0 - 5.0; // double [-5;5]
+ }
+ ```
+
+# Recherche du minimum dans un tableau (1/2)
+
+## Problématique
+
+Trouver le minimum d'un tableau et l'indice de l'élément le plus petit.
+
+## Écrire un pseudo-code résolvant ce problème (groupe de 3), 2min
+
+. . .
+
+```C
+index = 0
+min = tab[0]
+for i in [1; SIZE] {
+ if min > tab[i] {
+ min = tab[i]
+ index = i
+ }
+}
+```
+
+# Recherche du minimum dans un tableau (2/2)
+
+## Implémenter ce bout de code en C (groupe de 3), 4min
+
+. . .
+
+```C
+int index = 0;
+float min = tab[0];
+for (int i = 1; i < SIZE; ++i) {
+ if min > tab[i] {
+ min = tab[i];
+ index = i;
+ }
+}
+```
+
+# Tri par sélection (1/2)
+
+## Problématique
+
+Trier un tableau par ordre croissant.
+
+## Idée d'algorithme
+
+```C
+ind = 0
+boucle (ind < SIZE-1) {
+ Trouver le minimum du tableau, tab_min[ind:SIZE].
+ Échanger tab_min avec tab[ind]
+ ind += 1
+}
+```
+
+# Tri par sélection (2/2)
+
+## Implémentation par groupe de 3
+
+* Initialiser aléatoirement un tableau de `double` de taille 10;
+* Afficher le tableau;
+* Trier par sélection le tableau;
+* Afficher le résultat trié;
+* Vérifier algorithmiquement que le résultat est bien trié.
+
+
+# La fin
+
+## Des questions?