added stack

slides/cours_8.md

@@ -176,7 +176,7 @@ bool board[n][n];
 ```C
 // Pour chaque ligne placer la reine sur toutes les colonnes
 // Et compter les solutions
-void nb_sol(board, co, count);
+void nbr_solutions(board, coloumn, counter);
 // Placer la reine à li, co et rendre inaccessible devant
 void placer_devant(board_ini, board, li, co);
 ```
@@ -187,16 +187,16 @@ void placer_devant(board_ini, board, li, co);
 
 ```C
 // Calcule le nombre de solutions au problème des <n> reines
-nbr_solutions(board, colonne, compteur)
+nbr_solutions(board, column, counter)
     // pour chaque ligne 
         // si la case libre
-            // si la colonne < n - 1
+            // si clumn < n - 1
                 // créer un nouveau board, poser une reine 
                 //     et mettre à jour le tableau
-                // nbr_solutions(board, colonne, compteur)
+                // nbr_solutions(board, column, counter)
             // sinon
                 // on a posé la n-ème et on a gagné
-                // compteur += 1
+                // counter += 1
 ```
 
 # Le code du problème des 8 reines (3/N)
@@ -212,4 +212,109 @@ placer_devant(old_board, board, ligne, colonne)
         // suivantes sont mises à jour
 ```
 
+# Le code du problème des 8 reines (4/N)
 
+## Compris? Alors écrivez le code et postez le!
+
+. . .
+
+## Le nombre de solutions
+
+\footnotesize
+
+```C
+// Calcule le nombre de solutions au problème des <N> reines
+void nb_sol(int n, bool board_ini[n][n], int co, int *ptr_cpt) {
+    for (int li = 0; li < n; li++) {
+        if (board_ini[li][co]) {
+            if (co < n - 1) {
+                bool board[n][n]; // alocation à chaque
+                nouvelle tentative
+                prises_devant(n, board_ini, board, li, co);
+                nb_sol(n, board, co + 1, ptr_cpt);
+            } else {
+                *ptr_cpt = (*ptr_cpt) + 1;
+            }
+        }
+    }
+}
+```
+
+
+# Le code du problème des 8 reines (5/N)
+
+\footnotesize
+
+## Placer devant
+
+```C
+// Retourne une copie du tableau <board> complété avec les positions
+// prises sur la droite droite par une reine placée en <board(li,co)>
+void prises_devant(
+    int n, bool board_ini[n][n], bool board[n][n], int li, int co) 
+{
+    copy(n, board_ini, board);
+    board[li][co] = false; // position de la reine
+    for (int j = 1; j < n - co; j++) {
+        // horizontale et diagonales à droite de la reine
+        if (j <= li) {
+            board[li - j][co + j] = false;
+        }
+        board[li][co + j] = false;
+        if (li + j < n) {
+            board[li + j][co + j] = false;
+        }
+    }
+}
+```
+
+# Les piles (1/N)
+
+## Qu'est-ce donc?
+
+* Structure de données abstraite...
+
+. . .
+
+* de type `LIFO` (*Last in first out*).
+
+![Une pile où on ajoute A, puis B avant de les retirer. Souce:
+[Wikipedia](https://upload.wikimedia.org/wikipedia/commons/e/e1/Stack_%28data_structure%29_LIFO.svg)](figs/Stack.svg){width=70%}
+
+## Des exemples de la vraie vie
+
+. . .
+
+* Pile d'assiettes, de livres, ...
+* Adresses visitées par un navigateur web.
+* Les calculatrices du passé (en polonaise inverse).
+* Les boutons *undo* de vos éditeurs de texte (aka *u* dans vim).
+
+# Les piles (2/N)
+
+## Fonctionnalités
+
+. . .
+
+1. Empiler (push), ajouter un élément sur la pile,
+2. Dépiler (pop), retirer l'élément du sommet de la pile et le retrouner,
+3. Liste vide? (is_empty?)
+
+. . .
+
+4. Jeter un oeil (peek), retourner l'élément du sommet de la pile (sans le dépiler),
+5. Nombre d'éléments (length).
+
+## Comment faire les 4,5 à partir de 1 à 3?
+
+. . .
+
+4. Dépiler l'élément, le copier, puis l'empiler à nouveau.
+5. Dépiler jusqu'à ce que la pile soit vide puis empiler à nouveau.
+
+. . .
+
+## Existe en deux goûts
+
+* Pile avec ou sans limite de capacité (à concurrence de la taille de la
+mémoire).