docs et meilleure grid path

Author: Leon-ED

server/dictionnary/src/grid_path.c

@@ -1,46 +1,61 @@
 #include <stdio.h>
 #include <stdlib.h>
-#include <stdbool.h>
 #include <string.h>
-
-#define MAX_WORD_LENGTH 100
-
-// Définition de la structure de données représentant la grille de caractères
-typedef struct
+#include "include/grid_path.h"
+#include "include/libs.h"
+
+/**
+ * @brief Vérifie si une position est dans la grille
+ * @param Grid *grid - La structure grille à vérifier
+ * @param int i - La position verticale
+ * @param int j - La position horizontale
+ * @return 1 si la position est dans la grille, 0 sinon
+ *
+ */
+int checkBounds(Grid *grid, int i, int j)
 {
-    int rows;
-    int cols;
-    char *letters;
-} Grid;
+    return 1;
+}
 
-// Fonction de vérification récursive de la présence du mot dans la grille
-bool findWordInGrid(Grid *grid, int row, int col, const char *word, int *index_founded)
+/**
+ * @brief Cherche récursivement si un mot est dans la grille
+ * @details Regarde les voisins diagonaux et adjacents de la position donnée jusqu'à avoir trouvé le mot ou si toutes les cases sont épuisée
+ * @param Grid *grid - Structure de la grille à chercher
+ * @param int row - Ligne de la position initiale à chercher
+ * @param int col - Colonne de la position initiale à chercher
+ * @param char *word - Mot à chercher
+ * @param int *found_positions - Liste des positions déjà trouvées de taille = à strlen(word)
+ * @return int 0 si le mot a été trouvé, 1 sinon
+ *
+ *
+ * **/
+int grid_path_continue(Grid *grid, int row, int col, const char *word, int *index_founded)
 {
     // Si le mot est vide, c'est qu'il a été entièrement trouvé dans la grille
     if (*word == '\0')
-        return true;
+        return 1;
     // printf("%s ", word);
-    // Si la position actuelle est en dehors de la grille, on retourne false
+    // Si la position actuelle est en dehors de la grille, on retourne 0
     if (row < 0 || row >= grid->rows || col < 0 || col >= grid->cols)
-        return false;
+        return 0;
 
-    // Si le caractère de la grille ne correspond pas à celui du mot, on retourne false
+    // Si le caractère de la grille ne correspond pas à celui du mot, on retourne 0
     if (grid->letters[row * grid->cols + col] != *word)
-        return false;
+        return 0;
 
     // On marque la position actuelle comme visitée
     char tmp = grid->letters[row * grid->cols + col];
     grid->letters[row * grid->cols + col] = '*';
 
     // On vérifie récursivement les positions adjacentes et diagonales
-    bool found = findWordInGrid(grid, row + 1, col, word + 1, index_founded) ||
-                 findWordInGrid(grid, row - 1, col, word + 1, index_founded) ||
-                 findWordInGrid(grid, row, col + 1, word + 1, index_founded) ||
-                 findWordInGrid(grid, row, col - 1, word + 1, index_founded) ||
-                 findWordInGrid(grid, row + 1, col + 1, word + 1, index_founded) ||
-                 findWordInGrid(grid, row - 1, col - 1, word + 1, index_founded) ||
-                 findWordInGrid(grid, row + 1, col - 1, word + 1, index_founded) ||
-                 findWordInGrid(grid, row - 1, col + 1, word + 1, index_founded);
+    int found = grid_path_continue(grid, row + 1, col, word + 1, index_founded) ||
+                grid_path_continue(grid, row - 1, col, word + 1, index_founded) ||
+                grid_path_continue(grid, row, col + 1, word + 1, index_founded) ||
+                grid_path_continue(grid, row, col - 1, word + 1, index_founded) ||
+                grid_path_continue(grid, row + 1, col + 1, word + 1, index_founded) ||
+                grid_path_continue(grid, row - 1, col - 1, word + 1, index_founded) ||
+                grid_path_continue(grid, row + 1, col - 1, word + 1, index_founded) ||
+                grid_path_continue(grid, row - 1, col + 1, word + 1, index_founded);
 
     // On remet le caractère de la grille à sa valeur initiale
     grid->letters[row * grid->cols + col] = tmp;
@@ -51,43 +66,31 @@ bool findWordInGrid(Grid *grid, int row, int col, const char *word, int *index_f
     return found;
 }
 
-int main(int argc, char **argv)
+/**
+ *@brief Change tous les 'QU' par un caractère spécial et décale les caractères suivants
+ *@param char *word - Mot à nettoyer
+ **/
+void cleanWord(char *word)
 {
-    // Vérification du nombre d'arguments
-    if (argc < 5)
-    {
-        printf("Usage: %s <mot> <nombre de lignes> <nombre de colonnes> <grille>\n", argv[0]);
-        return 1;
-    }
-
-    // Vérification de la longueur du mot
-    if (strlen(argv[1]) > MAX_WORD_LENGTH)
-    {
-        printf("Le mot ne doit pas dépasser %d caractères\n", MAX_WORD_LENGTH);
-        return 1;
-    }
-
-    // Récupération des arguments
-    char *word = argv[1];
-    // replace in word all QU by &
     for (int i = 0; i < strlen(word); i++)
     {
         if (word[i] == 'Q' && word[i + 1] == 'U')
         {
-            word[i] = '&';
-            // shift the rest of the string
+            word[i] = QU;
             for (int j = i + 1; j < strlen(word); j++)
                 word[j] = word[j + 1];
         }
     }
+}
 
-    int rows = atoi(argv[2]);
-    int cols = atoi(argv[3]);
-    Grid grid;
-    grid.rows = rows;
-    grid.cols = cols;
-    grid.letters = malloc(rows * cols * sizeof(char));
-    char letters[argc - 4];
+/**
+ *@brief Change tous les 'QU' par un caractère spécial dans la grille
+ *@param int argc - Nombre d'arguments
+ *@param char **argv - Arguments
+ *@param char *letters - Tableau de caractères à remplir
+ **/
+void cleanGrid(int argc, char **argv, char *letters)
+{
     for (int i = 4; i < argc; i++)
     {
         letters[i - 4] = argv[i][0];
@@ -99,36 +102,94 @@ int main(int argc, char **argv)
         }
         letters[i - 4] = argv[i][0];
     }
-    strcpy(grid.letters, letters);
-    // Affichage de la grille
-    // printf("Grille de %d lignes et %d colonnes: ", rows, cols);
-    // for (size_t i = 0; i < rows*cols; i++)
-    //     printf("%c ", grid.letters[i]);
+}
 
-    int index_founded[strlen(word)];
+/**
+ * @brief Cherche un mot dans la grille et affiche les positions dans l'ordre
+ * @param char *word - Mot à chercher
+ * @param Grid *grid - Structure de la grille à chercher
+ * @return int 0 si le mot a été trouvé, 1 sinon
+ **/
+int grid_path(char *word, Grid *grid)
+{
+    int found_positions[strlen(word)];
 
     // Recherche du mot dans la grille
-    bool found = false;
-    for (int i = 0; i < rows; i++)
+    for (int i = 0; i < grid->rows; i++)
     {
-        for (int j = 0; j < cols; j++)
+        for (int j = 0; j < grid->cols; j++)
         {
-            if (findWordInGrid(&grid, i, j, word, index_founded))
+            if (grid_path_continue(grid, i, j, word, found_positions))
             {
                 // printf("Mot trouvé en commençant par la position (%d, %d)\n", i, j);
-                found = true;
-                break;
+                // on a trouvé alors on affiche les positions dans le l'ordre (donc ordre inverse de la liste)
+                for (int i = strlen(word) - 1; i >= 0; i--)
+                    printf("%d ", found_positions[i]);
+                printf("\n");
+                return FOUND;
             }
         }
     }
-    if (found)
+
+    return NOT_FOUND;
+}
+
+/**
+ * @brief Affiche la grille
+ * @param Grid *grid - Structure de la grille à afficher
+ **/
+void printGrid(Grid *grid)
+{
+    printf("Grille de %d lignes et %d colonnes:\n", grid->rows, grid->cols);
+    for (size_t i = 0; i < grid->cols; i++)
     {
-        // Afficher les index des lettres du mot
-        for (int i = strlen(word) - 1; i >= 0; i--)
-            printf("%d ", index_founded[i]);
+        for (size_t j = 0; j < grid->rows; j++)
+        {
+            if (grid->letters[i * grid->cols + j] == QU)
+                printf("QU ");
+            else
+                printf("%c ", grid->letters[i * grid->cols + j]);
+        }
         printf("\n");
     }
+}
+
+int main(int argc, char **argv)
+{
+    // Vérification du nombre d'arguments
+    if (argc < 5)
+    {
+        printf("Usage: %s <mot> <nombre de lignes> <nombre de colonnes> <grille>\n", argv[0]);
+        return MISSING_PARAMS;
+    }
+
+    Grid grid;
+    // Récupération des arguments
+    grid.rows = atoi(argv[2]);
+    grid.cols = atoi(argv[3]);
+    grid.size = grid.rows * grid.cols;
+    grid.letters = malloc(grid.size * sizeof(char));
+    char *word = argv[1];
+    // On remplace les QU par un caractère spécial
+    cleanWord(word);
+    // Vérification de la longueur du mot
+    if (strlen(word) > grid.size)
+    {
+        printf("Le mot ne doit pas dépasser %d caractères\n", grid.size);
+        return WRONG_PARAMS;
+    }
+
+    // printf("Mot à chercher: %s\n", word);
+    char letters[argc - 4];
+    // On fait pareil pour la grille
+
+    cleanGrid(argc, argv, letters);
+    strcpy(grid.letters, letters); // On met le résultat dans la struct
+    // printGrid(&grid);
+    int result = grid_path(word, &grid);
+    free(grid.letters);
+    printf("%d", result);
 
-    printf("%d", !found);
-    return !found;
+    
+    return result;
 }

server/dictionnary/src/include/grid_path.h

@@ -1,6 +1,19 @@
 #include <stdlib.h>
 #include <stdio.h>
 
-char **create_matrix(int num_lines, int num_columns, char **lettres);
 
-int grid_path(char word[], int num_lines, int num_columns, char lettres[]);
+#define QU '&'
+#define VISITED '@'
+#define FOUND 0
+#define NOT_FOUND 1
+// Définition de la structure de données représentant la grille de caractères
+
+typedef struct
+{
+    int rows;
+    int cols;
+    char *letters;
+    int size;
+} Grid;
+
+int grid_path(char *word, Grid *grid);