corrected typos

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 nbr_solutions(board, coloumn, counter);
+void nbr_solutions(board, column, counter);
 // Placer la reine à li, co et rendre inaccessible devant
 void placer_devant(board_ini, board, li, co);
 ```
@@ -224,13 +224,13 @@ placer_devant(old_board, board, ligne, colonne)
 
 ```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) {
+void nb_sol(int n, bool board_in[n][n], int co, int *ptr_cpt) {
     for (int li = 0; li < n; li++) {
-        if (board_ini[li][co]) {
+        if (board_in[li][co]) {
             if (co < n - 1) {
                 bool board[n][n]; // allocation    
                                   // à chaque nouvelle tentative
-                prises_devant(n, board_ini, board, li, co);
+                prises_devant(n, board_in, board, li, co);
                 nb_sol(n, board, co + 1, ptr_cpt);
             } else {
                 *ptr_cpt = (*ptr_cpt) + 1;
@@ -251,9 +251,9 @@ void nb_sol(int n, bool board_ini[n][n], int co, int *ptr_cpt) {
 // 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) 
+    int n, bool board_in[n][n], bool board[n][n], int li, int co) 
 {
-    copy(n, board_ini, board);
+    copy(n, board_in, board);
     board[li][co] = false; // position de la reine
     for (int j = 1; j < n - co; j++) {
         // horizontale et diagonales à droite de la reine
@@ -504,7 +504,8 @@ void *realloc(void *ptr, size_t size);
 stack_create(); // crée une pile avec une taille par défaut
 // vérifie si la pile est pleine et réalloue si besoin
 stack_push();
-// vérifie si la pile est vide/trop grande et réalloue si besoin
+// vérifie si la pile est vide/trop grande 
+// et réalloue si besoin
 stack_pop(); 
 ```
 

source_codes/piles/pile_array_int.h

@@ -14,7 +14,7 @@ typedef struct _pile {
 pile pile_creer(int max);
 //Libérer le tableau, mettre la capacité à < -1
 void pile_detruire(pile* stack);
-//Empiler un élement au sommet de pile
+//Empiler un élement au sommet de la pile
 void pile_empiler(pile* stack,int val);
 //Dépiler un élément du sommet de la pile
 int pile_depiler(pile* stack);
@@ -24,7 +24,7 @@ bool pile_est_vide(pile stack);
 bool pile_est_pleine(pile stack);
 //Consulter l'élément au sommet de la pile
 int pile_sommet(pile stack);
-//Compter du nombre d'éléments de la pile:
+//Compter du nombre d'éléments de la pile
 int pile_count(pile stack);
 
 #endif

source_codes/recursivity/rec_reines_no_alloc.c

@@ -3,18 +3,18 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-void board_ini(int n, bool board[n][n], bool val) {
-    for (int i = 0; i < n; ++i) {
-        for (int j = 0; j < n; ++j) {
+void board_init(int n, bool board[n][n], bool val) {
+    for (int i=0;i<n;i++) {
+        for (int j=0;j<n;j++) {
             board[i][j] = val;
         }
     }
 }
-// Copie les valeurs de la board_ini dans board
-void copy(int n, bool board_ini[n][n], bool board[n][n]) {
-    for (int i = 0; i < n; i++) {
-        for (int j = 0; j < n; j++) {
-            board[i][j] = board_ini[i][j];
+// Copie les valeurs de la <board_in> dans <board>
+void copy(int n, bool board_in[n][n], bool board[n][n]) {
+    for (int i=0;i<n;i++) {
+        for (int j=0;j<n;j++) {
+            board[i][j] = board_in[i][j];
         }
     }
 }
@@ -22,31 +22,31 @@ void copy(int n, bool board_ini[n][n], bool board[n][n]) {
 // 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);
+    int n, bool board_in[n][n], bool board[n][n], int li, int co) {
+    copy(n, board_in, board);
     board[li][co] = false; // position de la reine
-    for (int j = 1; j < n - co; j++) {
+    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-j][co+j] = false;
         }
-        board[li][co + j] = false;
-        if (li + j < n) {
-            board[li + j][co + j] = false;
+        board[li][co+j] = false;
+        if (li+j < n) {
+            board[li+j][co+j] = false;
         }
     }
 }
 
 // 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) {
+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];
-                prises_devant(n, board_ini, board, li, co);
-                nb_sol(n, board, co + 1, ptr_cpt);
+                prises_devant(n, board_in, board, li, co);
+                nb_sol(n, board, co+1, ptr_cpt);
             } else {
-                *ptr_cpt = (*ptr_cpt) + 1;
+                *ptr_cpt = (*ptr_cpt)+1;
             }
         }
     }
@@ -56,7 +56,7 @@ void main() {
     int n = 8;
     // échiquier où placer les reines
     bool board[n][n];
-    board_ini(n, board, true);
+    board_init(n, board, true);
     // compteur du nombre de solutions au problème des <N> reines
     int cpt = 0;
     nb_sol(n, board, 0, &cpt);

source_codes/recursivity/rec_reines_no_alloc_skel.c

+// Problème des N-reines
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+void board_init(int n, bool board[n][n], bool val) {
+   //à compléter
+}
+// Copie les valeurs de la <board_in> dans <board>
+void copy(int n, bool board_in[n][n], bool board[n][n]) {
+   //à compléter
+}
+
+// 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);
+    board[li][co] = false; // position de la reine
+    for (int j=1;j<n-co;j++) {
+        // horizontale et diagonales à droite de la reine:
+        // à compléter
+    }
+}
+
+// Calcule le nombre de solutions au problème des <N> reines
+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];
+                prises_devant(n, board_ini, board, li, co);
+                nb_sol(n, board, co+1, ptr_cpt);
+            } else {
+                *ptr_cpt = (*ptr_cpt)+1;
+            }
+        }
+    }
+}
+
+void main() {
+    int n = 8;
+    // échiquier où placer les reines
+    bool board[n][n];
+    board_init(n, board, true);
+    // compteur du nombre de solutions au problème des <N> reines
+    int cpt = 0;
+    nb_sol(n, board, 0, &cpt);
+    printf("Nombre de solutions: %d\n", cpt);
+}