Discussion :

[Fatouchka]

Bonjour à tous je souhaite faire un programme qui me permet de traduire des mots du français à l'italien.

Voici comment se présente mon dictionnaire :

abaissement [n.m] - recessione [n]
abaisser [vblex] - abbassare [vblex]
abandon [n] - abbandono [n]
abandonner [vblex] - abbandonare [vblex]
abattement [n] - abbattimento [n.m]
abattre [vblex] - abbattere [vblex]

Voici mon code en C :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
 
#define MAX_MOT_TAILLE 100
#define MAX_DICTIONNAIRE_TAILLE 100
 
typedef struct {
char mot_fr[MAX_MOT_TAILLE];
char mot_it[MAX_MOT_TAILLE];
} DictionnaireElement;
 
DictionnaireElement* lire_dictionnaire(char* nom_fichier, int* taille) {
FILE* fichier = fopen(nom_fichier, "r");
if (fichier == NULL) {
printf("Erreur lors de l'ouverture du fichier %s.\n", nom_fichier);
exit(1);
}
 
DictionnaireElement* dictionnaire = malloc(MAX_DICTIONNAIRE_TAILLE * sizeof(DictionnaireElement));
if (dictionnaire == NULL) {
printf("Erreur lors de l'allocation de mémoire.\n");
exit(1);
}
 
*taille = 0;
char ligne[MAX_MOT_TAILLE * 2];
while (fgets(ligne, sizeof(ligne), fichier) != NULL && *taille < MAX_DICTIONNAIRE_TAILLE) {
char mot_fr[MAX_MOT_TAILLE], mot_it[MAX_MOT_TAILLE];
if (sscanf(ligne, "%99[^-] - %99[^\n]", mot_fr, mot_it) == 2) {
strcpy(dictionnaire[*taille].mot_fr, mot_fr);
strcpy(dictionnaire[*taille].mot_it, mot_it);
(*taille)++;
} else {
printf("Erreur de lecture de la ligne du dictionnaire.\n");
}
}
 
fclose(fichier);
return dictionnaire;
}
 
char* traduire_texte(char* texte, DictionnaireElement* dictionnaire, int taille) {
char* mots = strtok(texte, " ");
char* texte_traduit = malloc(MAX_MOT_TAILLE * 100);
texte_traduit[0] = '\0';
 
while (mots != NULL) {
// Convert the current word to lowercase
for (int j = 0; mots[j]; j++) {
mots[j] = tolower(mots[j]);
}
 
int traduit = 0;
for (int i = 0; i < taille; i++) {
if (strcasecmp(mots, dictionnaire[i].mot_fr) == 0) {
strcat(texte_traduit, dictionnaire[i].mot_it);
strcat(texte_traduit, " ");
traduit = 1;
break;
}
}
if (!traduit) {
strcat(texte_traduit, mots);
strcat(texte_traduit, " ");
}
mots = strtok(NULL, " ");
}
 
return texte_traduit;
}
 
int main() {
char nom_fichier_dictionnaire[100];
printf("Entrez le nom du fichier du dictionnaire bilingue : ");
fgets(nom_fichier_dictionnaire, sizeof(nom_fichier_dictionnaire), stdin);
nom_fichier_dictionnaire[strcspn(nom_fichier_dictionnaire, "\n")] = '\0';
 
int taille_dictionnaire;
DictionnaireElement* dictionnaire = lire_dictionnaire(nom_fichier_dictionnaire, &taille_dictionnaire);
 
while (1) {
char texte_a_traduire[MAX_MOT_TAILLE * 100];
printf("Entrez le texte à traduire en français (ou 'sortir' pour quitter) : ");
fgets(texte_a_traduire, sizeof(texte_a_traduire), stdin);
texte_a_traduire[strcspn(texte_a_traduire, "\n")] = '\0'; // Removing newline character
 
if (strcmp(texte_a_traduire, "sortir") == 0) {
printf("Au revoir!\n");
break;
}
 
char* texte_traduit = traduire_texte(texte_a_traduire, dictionnaire, taille_dictionnaire);
printf("Texte traduit en italien: %s\n\n", texte_traduit);
free(texte_traduit);
}
 
free(dictionnaire);
return 0;
}

Quand je l'exécute j'ai ceci :

Entrez le nom du fichier du dictionnaire bilingue : francais-italien_snp.tab
Entrez le texte à traduire en français (ou 'sortir' pour quitter) : maison
Texte traduit en italien: maison

Entrez le texte à traduire en français (ou 'sortir' pour quitter) : casa
Texte traduit en italien: casa


Donc ça ne fonctionne pas.

Pourriez-vous me dire ce qui bloque ? Merci pour votre aide.

[Sve@r]

Bonjour

Pourriez-vous me dire ce qui bloque ?

La variable "traduit" ne passe jamais à 1 donc if (!traduit) est toujours vrai. Pour le reste, mets des printf() un peu partout pour vérifier les valeurs et tu trouveras rapidement ce qui coince.

[Fatouchka]

J'avais une erreur dans cette boucle que 'ai corrigé ainsi mais ça ne fonctionne toujours pas

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
 int traduit = 0;
        for (int i = 0; i < taille; i++) {
            if (strcasecmp(mot, dictionnaire[i].mot_fr) == 0) {
                strcat(texte_traduit, dictionnaire[i].mot_it);
                strcat(texte_traduit, " ");
                traduit = 1;
                break;
            }
        }

[CGi]

Tu as remplacé mots par mot, mais mot n'est défini nul part ?

[Sve@r]

mais ça ne fonctionne toujours pas

Tant que tu ne mettras pas des printf() un peu partout pour vérifier que les valeurs de tes variables correspondent bien aux valeurs attendues, ça continuera à ne pas fonctionner !!!
Affiche mot, dictionnaire[i].mot_fr, dictionnaire[i].mot_it et etc etc etc.

[CGi]

Ajoute un printf ligne ici avant le strcasecmp :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
        for (int i = 0; i < taille; i++)        {
            printf("Tu compares : %s avec %s\n", mots, dictionnaire[i].mot_fr);
            if (strcasecmp(mots, dictionnaire[i].mot_fr) == 0)
            {

Et tu verras ce que tu compares.

[Guesset]

Bonjour,

Pour trouver facilement, il y a aussi le débogueur. en faisant avancer en pas à pas à partir d'une zone de code à problème (donc à partir d'un point d'arrêt), le débogueur permet d'observer les variables que l'on veut surveiller. On peut même mettre des arrêts conditionnels qui permettent de s'arrêter là où le problème se manifeste. C'est très pratique même si, par définition, le programme ne s'arrête qu'après le pb.

C'est la loupe du codeur Holmes.

Salutations

[Fatouchka]

J'ai pu corriger le code et l'améliorer mais mon nouveau code ne prend pas en compte les accents des mots français à traduire. J'ai apporté des modifs mais il ne fonctionne pas correctement

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
 
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <wctype.h>
#include <wchar.h>
 
#define ALPHABET_SIZE 26
#define MAX_MOT_TAILLE 256
 
typedef struct TrieNode {
    struct TrieNode* enfants[ALPHABET_SIZE];
    wchar_t traduction[MAX_MOT_TAILLE];
    int est_mot_fin;
} TrieNode;
 
TrieNode* nouveau_noeud() {
    TrieNode* node = (TrieNode*)malloc(sizeof(TrieNode));
    if (node) {
        node->est_mot_fin = 0;
        for (int i = 0; i < ALPHABET_SIZE; i++) {
            node->enfants[i] = NULL;
        }
        node->traduction[0] = L'\0';
    }
    return node;
}
 
void inserer_mot(TrieNode* racine, const wchar_t* mot_fr, const wchar_t* traduction_it) {
    TrieNode* temp = racine;
    for (int i = 0; mot_fr[i] != L'\0' && i < MAX_MOT_TAILLE - 1; i++) {
        int index = towlower(mot_fr[i]) - L'a';
        if (index < 0 || index >= ALPHABET_SIZE) {
            continue;
        }
        if (!temp->enfants[index]) {
            temp->enfants[index] = nouveau_noeud();
        }
        temp = temp->enfants[index];
    }
    temp->est_mot_fin = 1;
    wcsncpy(temp->traduction, traduction_it, MAX_MOT_TAILLE - 1);
    temp->traduction[MAX_MOT_TAILLE - 1] = L'\0';
}
 
wchar_t* rechercher_traduction(TrieNode* racine, const wchar_t* mot_fr) {
    TrieNode* temp = racine;
    for (int i = 0; mot_fr[i] != L'\0'; i++) {
        int index = towlower(mot_fr[i]) - L'a';
        if (index < 0 || index >= ALPHABET_SIZE) {
            return NULL;
        }
        if (!temp->enfants[index]) {
            return NULL;
        }
        temp = temp->enfants[index];
    }
    if (temp != NULL && temp->est_mot_fin) {
        return temp->traduction;
    }
    return NULL;
}
 
void liberer_trie(TrieNode* racine) {
    if (racine) {
        for (int i = 0; i < ALPHABET_SIZE; i++) {
            liberer_trie(racine->enfants[i]);
        }
        free(racine);
    }
}
 
int main() {
    char nom_fichier[MAX_MOT_TAILLE];
    printf("Entrez le nom du fichier du dictionnaire : ");
    if (scanf("%255s", nom_fichier) != 1) {
        printf("Erreur de lecture du nom du fichier.\n");
        return 1;
    }
 
    TrieNode* racine = nouveau_noeud();
    FILE* fichier = fopen(nom_fichier, "r");
    if (fichier == NULL) {
        printf("Impossible d'ouvrir le fichier %s.\n", nom_fichier);
        perror("Erreur");
        return 1;
    } else {
        printf("Fichier ouvert avec succès : %s\n");
    }
 
    printf("Lecture du dictionnaire depuis le fichier...\n");
 
    wchar_t ligne[MAX_MOT_TAILLE * 2];
    wchar_t* token;
    wchar_t* ptr = NULL;
    while (fgetws(ligne, sizeof(ligne) / sizeof(ligne[0]), fichier) != NULL) {
        ligne[wcslen(ligne) - 1] = L'\0';  // Remove newline character
 
        token = wcstok(ligne, L"-", &ptr);
        if (token != NULL) {
            wchar_t mot_fr[MAX_MOT_TAILLE], traduction_it[MAX_MOT_TAILLE];
            wcscpy(mot_fr, token);
 
            token = wcstok(NULL, L"-", &ptr);
            if (token != NULL) {
                wcscpy(traduction_it, token);
 
                inserer_mot(racine, mot_fr, traduction_it);
            }
        }
    }
 
    printf("Lecture du dictionnaire terminée.\n");
 
    fclose(fichier);
 
    char mot_a_traduire[MAX_MOT_TAILLE];
    printf("Entrez un mot en français à traduire (ou 'q' pour quitter) : ");
    if (scanf("%255s", mot_a_traduire) != 1) {
        printf("Erreur de lecture du mot.\n");
        liberer_trie(racine);
        return 1;
    }
 
    while (strcmp(mot_a_traduire, "q") != 0) {
        wchar_t mot_fr_wide[MAX_MOT_TAILLE];
        mbstowcs(mot_fr_wide, mot_a_traduire, MAX_MOT_TAILLE);
 
        wchar_t* traduction = rechercher_traduction(racine, mot_fr_wide);
        if (traduction) {
            printf("Traduction en italien de '%s' : %ls\n", mot_a_traduire, traduction);
        } else {
            printf("Traduction non trouvée pour le mot : %s\n", mot_a_traduire);
        }
 
        printf("Entrez un mot en français à traduire (ou 'q' pour quitter) : ");
        if (scanf("%255s", mot_a_traduire) != 1) {
            printf("Erreur de lecture du mot.\n");
            break;
        }
    }
 
    liberer_trie(racine);
 
    return 0;
}