remove arrays from cours 2 and added cours 3

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?

slides/cours_3.md

+# 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?