refactored prises_devant by extracting copy, corrected typos such as stack => s

slides/cours_8.md

@@ -177,8 +177,10 @@ bool board[n][n];
 // Pour chaque ligne placer la reine sur toutes les colonnes
 //    et compter les solutions
 void nbr_solutions(board, column, counter);
+// Copier un tableau dans un autre
+void copy(board_in, board);
 // Placer la reine à li, co et rendre inaccessible devant
-void placer_devant(board_ini, board, li, co);
+void placer_devant(board, li, co);
 ```
 
 # Le code du problème des 8 reines (2/N)
@@ -191,9 +193,9 @@ nbr_solutions(board, column, counter)
     // pour chaque ligne 
         // si la case libre
             // si column < n - 1
-                // créer un nouveau board, poser une reine 
-                //     et mettre à jour le tableau
-                // nbr_solutions(board, column, counter)
+                // copier dans un nouveau board, y poser une reine 
+                //     et mettre à jour ce nouveau board
+                // nbr_solutions(nouveau_board, column+1, counter)
             // sinon
                 // on a posé la n-ème et on a gagné
                 // counter += 1
@@ -204,9 +206,8 @@ nbr_solutions(board, column, counter)
 ## Le calcul du nombre de solutions
 
 ```C
-// Copier board, placer une reine et mettre à jour
-placer_devant(old_board, board, ligne, colonne)
-    // board = copy(old_board); 
+// Placer une reine et mettre à jour
+placer_devant(board, ligne, colonne)
     // board est occupé à ligne/colonne
         // toutes les cases des colonnes
         //    suivantes sont mises à jour
@@ -228,12 +229,12 @@ void nb_sol(int n, bool board_in[n][n], int co, int *ptr_cpt) {
     for (int li = 0; li < n; li++) {
         if (board_in[li][co]) {
             if (co < n - 1) {
-                bool board[n][n]; // allocation    
-                                  // à chaque nouvelle tentative
-                prises_devant(n, board_in, board, li, co);
-                nb_sol(n, board, co + 1, ptr_cpt);
+                bool board[n][n]; // alloué à chaque nouvelle tentative
+                copy(n, board_in, board);         
+                prises_devant(n, board, li, co);
+                nb_sol(n, board, co+1, ptr_cpt);
             } else {
-                *ptr_cpt = (*ptr_cpt) + 1;
+                *ptr_cpt = (*ptr_cpt)+1;
             }
         }
     }
@@ -250,10 +251,7 @@ void nb_sol(int n, bool board_in[n][n], int co, int *ptr_cpt) {
 ```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_in[n][n], bool board[n][n], int li, int co) 
-{
-    copy(n, board_in, board);
+void prises_devant(int n, bool board[n][n], int li, int co) {
     board[li][co] = false; // position de la reine
     for (int j = 1; j < n - co; j++) {
         // horizontale et diagonales à droite de la reine
@@ -339,7 +337,7 @@ Et oui vous avez deviné: un tableau!
 
 ```C
 #define MAX_CAPACITY 500
-typedef struct stack_ {
+typedef struct _stack {
     int data[MAX_CAPACITY]; // les données
     int top;                // indice du sommet
 } stack;
@@ -373,8 +371,8 @@ bool stack_is_empty(stack s) {
 
 ```C
 void stack_push(stack *s, int val) {
-    stack->top += 1;
-    stack->data[stack->top] = val;
+    s->top += 1;
+    s->data[s->top] = val;
 }
 ```
 
@@ -386,8 +384,8 @@ void stack_push(stack *s, int val) {
 
 ```C
 int stack_pop(stack *s) {
-    stack->top -= 1;
-    return stack->data[stack->top+1];
+    s->top -= 1;
+    return s->data[s->top+1];
 }
 ```
 
@@ -397,7 +395,7 @@ int stack_pop(stack *s) {
 
 ```C
 int stack_peek(stack *s) {
-    return stack->data[stack->top];
+    return s->data[s->top];
 }
 ```
 
@@ -451,18 +449,18 @@ void assert(int expression);
 ```C
 #include <assert.h>
 void stack_push(stack *s, int val) {
-    assert(s->top < MAX_CAPACITY - 1);
-    stack->top += 1;
-    stack->data[stack->top] = val;
+    assert(s->top < MAX_CAPACITY-1);
+    s->top += 1;
+    s->data[s->top] = val;
 }
 int stack_pop(stack *s) {
     assert(s->top >= 0);
-    stack->top -= 1;
-    return stack->data[stack->top+1];
+    s->top -= 1;
+    return s->data[s->top+1];
 }
 int stack_peek(stack *s) {
     assert(s->top >= 0);
-    return stack->data[stack->top];
+    return s->data[s->top];
 }
 ```