fix

.vscode/launch.json

@@ -1,7 +1,7 @@
 {
-    // Use IntelliSense to learn about possible attributes.
-    // Hover to view descriptions of existing attributes.
-    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    // Utilisez IntelliSense pour en savoir plus sur les attributs possibles.
+    // Pointez pour afficher la description des attributs existants.
+    // Pour plus d'informations, visitez : https://go.microsoft.com/fwlink/?linkid=830387
     "version": "0.2.0",
     "configurations": []
 }

.vscode/settings.json

@@ -0,0 +1,7 @@
+{
+    "files.associations": {
+        "algorithm": "c",
+        "format": "c",
+        "cstdlib": "c"
+    }
+}

.vscode/tasks.json

@@ -2,7 +2,7 @@
     "tasks": [
         {
             "type": "cppbuild",
-            "label": "C/C++: gcc build active file",
+            "label": "C/C++: gcc générer le fichier actif",
             "command": "/usr/bin/gcc",
             "args": [
                 "-fdiagnostics-color=always",
@@ -17,31 +17,11 @@
             "problemMatcher": [
                 "$gcc"
             ],
-            "group": "build",
-            "detail": "Task generated by Debugger."
-        },
-        {
-            "type": "cppbuild",
-            "label": "C/C++: cl.exe build active file",
-            "command": "cl.exe",
-            "args": [
-                "/Zi",
-                "/EHsc",
-                "/nologo",
-                "/Fe${fileDirname}\\${fileBasenameNoExtension}.exe",
-                "${file}"
-            ],
-            "options": {
-                "cwd": "${fileDirname}"
-            },
-            "problemMatcher": [
-                "$msCompile"
-            ],
             "group": {
                 "kind": "build",
                 "isDefault": true
             },
-            "detail": "Task generated by Debugger."
+            "detail": "Tâche générée par le débogueur."
         }
     ],
     "version": "2.0.0"

Readme.MD

@@ -1,9 +0,0 @@
-TD 3
-
-Ajout des fonctionnalités
-
-Hugo :
-
-Pour ajouter les chronomètre, j'ai utilisé une clock pour compter les 30 secondes etre les réponses 
-
-Lyanis :

compte_rendu.txt

@@ -0,0 +1,3 @@
+ex2 les functionnalité ont etait codé la mienne ne functionne pas pour l instant on passe  
+
+la creation de pull request

pendu.c

@@ -2,22 +2,33 @@
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
-#include <unistd.h>
-#include <signal.h>
-#include <ctype.h>
 
 #define MAX_WORDS 14
 #define MAX_TRIES 6
+#define MAX_WORDS_LENGTH 50
 
 const char *words[MAX_WORDS] = {
-    "programmation", "ordinateur", "langage", "jeu", 
-    "algorithmique", "fontainebleau", "koala", 
-    "anticonstitutionnellement", "code", "canard", 
-    "gyroscope", "periclitation", "susurrer", 
+    "programmation",
+    "ordinateur",
+    "langage",
+    "jeu",
+    "algorithmique",
+    "fontainebleau",
+    "koala",
+    "anticonstitutionnellement",
+    "code",
+    "canard",
+    "gyroscope",
+    "periclitation",
+    "susurrer",
     "eclesiastique"
 };
 
-// Fonction pour afficher le pendu
+// Prototypes des fonctions
+char** selecte_words(int word_length, int* size);
+char** word_merge(int word_length, int* size2);
+char** merge_string_arrays(char** array1, char** array2, int size1, int size2);
+
 void display_hangman(int tries) {
     switch (tries) {
         case 0: printf("  ----\n  |  |\n  |\n  |\n  |\n  |\n--------\n"); break;
@@ -30,152 +41,184 @@ void display_hangman(int tries) {
     }
 }
 
-// Fonction pour gérer le signal d'alarme
-void alarm_handler(int sig) {
-    printf("\nTrop tard ! Vous avez dépassé les 30 secondes.\n");
-    exit(1);  
+int ask_word_length() {
+    int word_length;
+
+    printf("Veuillez entrer la longueur du mot souhaitée (entier positif) : ");
+    
+    while (scanf("%d", &word_length) != 1 || word_length <= 0) {
+        printf("Entrée invalide. Veuillez entrer un entier positif : ");
+        while (getchar() != '\n'); // vider le buffer
     }
 
-// Fonction pour filtrer les mots selon la taille maximale
-int filter_words(const char *filtered_words[], int max_word_length) {
-    int count = 0;
+    return word_length;
+}
+
+char* difficult(int word_length) {
+    int size1 = 0, size2 = 0;
+
+    char** selected_words = selecte_words(word_length, &size1);
+    if (selected_words == NULL) {
+        printf("Erreur lors de la sélection des mots\n");
+        return NULL;
+    }
+
+    char** merged_words = word_merge(word_length, &size2);
+    if (merged_words == NULL) {
+        printf("Erreur lors de la fusion des mots\n");
+        return NULL;
+    }
+
+    char** final_words = merge_string_arrays(selected_words, merged_words, size1, size2);
+
+    // Libérer la mémoire des tableaux intermédiaires
+    for (int i = 0; i < size1; i++) free(selected_words[i]);
+    for (int i = 0; i < size2; i++) free(merged_words[i]);
+    free(selected_words);
+    free(merged_words);
+
+    if (final_words == NULL) {
+        printf("Erreur lors de la fusion finale des mots\n");
+        return NULL;
+    }
+
+    // Sélectionner un mot aléatoire
+    char* chosen_word = final_words[rand() % (size1 + size2)];
+
+    // Libérer la mémoire du tableau final_words après avoir choisi un mot
+    for (int i = 0; i < size1 + size2; i++) {
+        free(final_words[i]);
+    }
+    free(final_words);
+
+    return chosen_word;
+}
+
+char** merge_string_arrays(char** array1, char** array2, int size1, int size2) {
+    int merged_size = size1 + size2;
+    char** merged_array = (char**)malloc(merged_size * sizeof(char*));
+    if (merged_array == NULL) {
+        printf("Erreur d'allocation de mémoire\n");
+        return NULL;
+    }
+
+    for (int i = 0; i < size1; i++) {
+        merged_array[i] = (char*)malloc((strlen(array1[i]) + 1) * sizeof(char));
+        if (merged_array[i] == NULL) {
+            printf("Erreur d'allocation de mémoire pour array1[%d]\n", i);
+            return NULL;
+        }
+        strcpy(merged_array[i], array1[i]);
+    }
+
+    for (int i = 0; i < size2; i++) {
+        merged_array[size1 + i] = (char*)malloc((strlen(array2[i]) + 1) * sizeof(char));
+        if (merged_array[size1 + i] == NULL) {
+            printf("Erreur d'allocation de mémoire pour array2[%d]\n", i);
+            return NULL;
+        }
+        strcpy(merged_array[size1 + i], array2[i]);
+    }
+
+    return merged_array;
+}
+
+char** selecte_words(int word_length, int* size) {
+    char** word_Selected = (char**)malloc(MAX_WORDS * sizeof(char*));
+    if (word_Selected == NULL) {
+        printf("Erreur d'allocation de mémoire\n");
+        return NULL;
+    }
+
+    *size = 0; // initialiser la taille à 0
+
+    for (int i = 0; i < MAX_WORDS && words[i][0] != '\0'; i++) {
+        if (strlen(words[i]) == word_length) {
+            word_Selected[*size] = (char*)malloc((strlen(words[i]) + 1) * sizeof(char));
+            if (word_Selected[*size] == NULL) {
+                printf("Erreur d'allocation de mémoire pour le mot sélectionné\n");
+                return NULL;
+            }
+            strcpy(word_Selected[*size], words[i]);
+            (*size)++;
+        }
+    }
+
+    return word_Selected;
+}
+
+char** word_merge(int word_length, int* size2) {
+    int max_combinations = MAX_WORDS * MAX_WORDS;
+    char** word_combinations = (char**)malloc(max_combinations * sizeof(char*));
+    if (word_combinations == NULL) {
+        printf("Erreur d'allocation de mémoire pour les combinaisons\n");
+        return NULL;
+    }
+
+    *size2 = 0;
+
     for (int i = 0; i < MAX_WORDS; i++) {
-        if (strlen(words[i]) <= max_word_length) {
-            filtered_words[count++] = words[i];
+        for (int j = 0; j < MAX_WORDS; j++) {
+            if (i != j && (strlen(words[i]) + strlen(words[j]) == word_length - 1)) {
+                word_combinations[*size2] = (char*)malloc((strlen(words[i]) + strlen(words[j]) + 2) * sizeof(char)); // +2 pour l'espace et '\0'
+                if (word_combinations[*size2] == NULL) {
+                    printf("Erreur d'allocation de mémoire pour une combinaison\n");
+                    return NULL;
                 }
-    }
-    return count;
-}
-
-// Fonction pour choisir plusieurs mots uniques aléatoirement
-void choose_random_words(const char *filtered_words[], int num_filtered_words, char *result, int max_length) {
-    int total_length = 0;
-    while (total_length < max_length) {
-        int index = rand() % num_filtered_words;
-        const char *chosen_word = filtered_words[index];
-        
-        if (total_length + strlen(chosen_word) + 1 > max_length) {
-            break;
-        }
-
-        strcat(result, chosen_word);
-        total_length += strlen(chosen_word);
-
-        if (total_length < max_length) {
-            strcat(result, " ");
-            total_length++;
+                snprintf(word_combinations[*size2], strlen(words[i]) + strlen(words[j]) + 2, "%s %s", words[i], words[j]);
+                (*size2)++;
             }
         }
     }
 
-// Fonction pour initialiser le mot deviné avec des underscores
-void initialize_guessed_word(char guessed[], const char *word, int word_length) {
-    for (int i = 0; i < word_length; i++) {
-        guessed[i] = (word[i] == ' ') ? ' ' : '_';  // Gérer les espaces
-    }
-    guessed[word_length] = '\0';
-}
-
-// Fonction pour traiter chaque saisie de l'utilisateur
-int handle_guess(char guess, const char *word, char guessed[], int word_length, int *score) {
-    int found = 0;
-    clock_t start_time = clock();
-
-    for (int i = 0; i < word_length; i++) {
-        if (word[i] == guess) {
-            if (guessed[i] == '_') {
-                guessed[i] = guess;
-                found = 1;
-                *score += 1000 - (clock() - start_time) * 1000 / CLOCKS_PER_SEC;
-            }
-        }
-    }
-
-    return found;
-}
-
-// Fonction principale pour jouer une partie
-int play_game(const char *word, int word_length) {
-    char guessed[word_length + 1];
-    int tries = 0;
-    int guessed_correctly = 0;
-    int score = 0;
-
-    initialize_guessed_word(guessed, word, word_length);
-
-    while (tries < MAX_TRIES && guessed_correctly < word_length) {
-        printf("\nMot à deviner : %s\n", guessed);
-        display_hangman(tries);
-        char guess;
-
-        alarm(30);
-        printf("Entrez une lettre (ou '1' pour quitter) : ");
-        scanf(" %c", &guess);
-        alarm(0);
-
-        if (guess == '1') {
-            printf("Vous avez quitté le jeu. À bientôt !\n");
-            return 0;
-        }
-
-        if (!isalpha(guess)) {
-            printf("Veuillez entrer une lettre valide.\n");
-            continue;
-        }
-
-        guess = tolower(guess);
-        int found = handle_guess(guess, word, guessed, word_length, &score);
-
-        if (!found) {
-            tries++;
-            score -= 200;  // Malus pour une mauvaise réponse
-        } else {
-            guessed_correctly += found;
-        }
-    }
-
-    if (guessed_correctly == word_length) {
-        printf("Félicitations ! Vous avez deviné le mot : %s\n", word);
-        if (tries < 3) {
-            score += 500;
-        }
-    } else {
-        printf("Désolé, vous avez perdu. Le mot était : %s\n", word);
-        display_hangman(MAX_TRIES);
-    }
-
-    printf("Votre score est : %d\n", score);
-    return score;
+    return word_combinations;
 }
 
 int main() {
     srand(time(NULL));
 
-    while (1) {
-        int max_word_length;
-        printf("Entrez la taille maximale des mots à deviner : ");
-        scanf("%d", &max_word_length);
-
-        const char *filtered_words[MAX_WORDS];
-        int num_filtered_words = filter_words(filtered_words, max_word_length);
-
-        if (num_filtered_words == 0) {
-            printf("Aucun mot ne correspond à cette taille maximale.\n");
-            continue;
+    int word_length = ask_word_length();
+    const char* word = difficult(word_length);
+    printf("le mot est :%s",word);
+    if (word == NULL) {
+        printf("Erreur : aucun mot disponible avec cette longueur.\n");
+        return 1;
     }
 
-        char word[256] = "";
-        choose_random_words(filtered_words, num_filtered_words, word, max_word_length);
-        int word_length = strlen(word);
-        int score = play_game(word, word_length);
+    int word_len = strlen(word);
+    char guessed[word_len + 1];
+    int tries = 0, guessed_correctly = 0;
 
-        char play_again;
-        printf("Voulez-vous jouer à nouveau ? (o/n) : ");
-        scanf(" %c", &play_again);
-        if (tolower(play_again) != 'o') {
-            break;
+    for (int i = 0; i < word_len; i++) guessed[i] = '_';
+    guessed[word_len] = '\0';
+
+    while (tries < MAX_TRIES && guessed_correctly < word_len) {
+        printf("\nMot à deviner : %s\n", guessed);
+        display_hangman(tries);
+        char guess;
+        printf("Entrez une lettre : ");
+        scanf(" %c", &guess);
+
+        int found = 0;
+        for (int i = 0; i < word_len; i++) {
+            if (word[i] == guess && guessed[i] == '_') {
+                guessed[i] = guess;
+                guessed_correctly++;
+                found = 1;
             }
         }
 
+        if (!found) {
+            tries++;
+        }
+    }
+
+    if (guessed_correctly == word_len) {
+        printf("Félicitations ! Vous avez deviné le mot : %s\n", word);
+    } else {
+        printf("Désolé, vous avez perdu. Le mot était : %s\n", word);
+        display_hangman(MAX_TRIES);
+    }
+
     return 0;
 }