Discussion :

[Emmanuel Delahaye]

oui, moi j'aime pas qu'il cosidere les ponctuation comme des mots.
mais le probleme c'est la lonteur, plusque 2 heurs maintenant et il na pas terminé

Si tu es dans une boucle infinie, c'est pas la peine d'attendre... Il vaut mieux corriger le bug !

[Emmanuel Delahaye]

bizarre, chez moi ca plante pas,
bien que tout le monde ont des problemes avec cette instruction,
je pense qu'il faut installer cod blocs urgence

Le compilateur est le même que celui de Dev-C++. Ca ne va rien changer... Par contre, on t'a indiqué comment le configurer pour qu'il t'indique mieux les erreurs...

[Trap D]

Le compilateur est le même que celui de Dev-C++. Ca ne va rien changer... Par contre, on t'a indiqué comment le configurer pour qu'il t'indique mieux les erreurs...

Ah bon, je ne savais pas

[Emmanuel Delahaye]

Ah bon, je ne savais pas

Oui, c'est MinGW. On peut espérer une version plus récente, mais c'est tout...

[étoile de mer]

oula je commence à perdre ma concentration, trop de remarque, tropd'erreurs, je sais pas d'où je vais commencer.
me reste 2 journees seulement
J'arrive pas à voir où est la boucle infinie dans la fonction "PosLigne"

[Emmanuel Delahaye]

oula je commence à perdre ma concentration, trop de remarque, tropd'erreurs, je sais pas d'où je vais commencer.
me reste 2 journees seulement
J'arrive pas à voir où est la boucle infinie dans la fonction "PosLigne"

Fait du pas à pas avec ton débogueur, tu verras bien là où ça boucle...

Mais je persiste à dire que ton programme est trop complexe pour fonctionner correctement, surtout qu'apparamment, le mot 'test unitaire' n'a pas de sens pour toi... On ne sait donc pas quelles sont les parties fiables du code. Pour le moment, officiellement, il n'y en a aucune... Il faut donc commencer pas tout fiabiliser.

Malheureusement, en 2 jours, il est impossible de faire mieux.

[étoile de mer]

mon probleme c'est que je sais pas comment utiliser le debugger
pour voir bien comment tourne le code
merci

[étoile de mer]

Malheureusement, en 2 jours, il est impossible de faire mieux.

merci pour ton encouragement

[Emmanuel Delahaye]

merci pour ton encouragement

Désolé, mais je ne vais pas te raconter d'histoires.

Par contre, si tu dois utiliser le debogueur, l'installation de Code::Blocks est requise, car celui de dev-C++ est buggé et inutilisable.

[étoile de mer]

Désolé, mais je ne vais pas te raconter d'histoires.

Par contre, si tu dois utiliser le debogueur, l'installation de Code::Blocks est requise, car celui de dev-C++ est buggé et inutilisable.

oui j'utilise maintenant code::blocks

[Emmanuel Delahaye]

oui j'utilise maintenant code bloks

Alors active l'option -g qui permet de déboguer et lance ton programme en plaçant le curseur à l'endroit où tu veux qu'il s'arrête (puis F4).

Ensuite, tu avances pas à pas avec

- Next line (instruction suivante, saute les fonctions)
- Step into (entre dans une fonction)
- Step out (sort de la fonction)

tu peux visualiser les paramètres, et les locales avec la fenêtre 'watch'. Tu peux ajouter une variable à surveiller (si elle est visible : les règles de visibilité du C s'appliquent pareil au débogueur).

Je te conseille de passer un peu de temps pour prendre en main le débogueur sur du code qui fonctionne et que tu connais.

[étoile de mer]

je vois pas la boucle infini, peut etre à cause de ca : for (i = 0; i < TAILLEHASH; ++i)
que cette fonction prends beaucoup du temps.
car TAILLEHASH=307

[étoile de mer]

Est-ce que tu sais bien ce que fais fscanf() avec "%s" ? Il lit les mots un à un, en considérant que les blanks (ESPACE, TAB et fin de lignes) sont des séparateurs. Il ne tient aucunement compte de la ponctuation. C'est bien clair ?

Par exemple : "sujet." est un mot alors que "florissants ." est 2 mots ("florissants" et ".")

Idem avec les virgules, tirets, apostrophes etc.

Ensuite, tu parcoures le fichier 3 fois avec des règles différentes. La dernière (PosLigne) est très étrange puisque tu mélanges les fscanf() avec des fgetc(), ce qui décale tout d'un caractère à chaque fois.. C'est pas trop clair comme manip...

.

c'est à dire vous me conseillez d'utiliser seulement le "fgets"???
est ce que je peux faire tous ces traitemment en une seule lecture du fichier???!!
vous pouvez me donner une idée svp, ??
merci d'avance

[Emmanuel Delahaye]

c'est à dire vous me conseillez d'utiliser seulement le "fgets"???
est ce que je peux faire tous ces traitemment en une seule lecture du fichier???!!
vous pouvez me donner une idée svp, ??
merci d'avance

Décrit clairement les trois traitements attendus (après tout, c'est ton projet...)
.

[étoile de mer]

Merci,
bon le 1er traitement c'est determiner le nombre de lignes dans un fichier, la valeur retournée on aura besoin apres dans la fonction GenRa,
Le 2eme traitement, c'est remplir une table de hhachage par les mots du texte : je fais un parcours du texte et j'extrais à chaque fois les mots pour les mettre dans une table de hachage.
le 3eme traitement relire le fichier texte) : accorder à chaque mot de la table de hachage des coordonnées (num-ligne, position), et sa frequence
chaque mot a une frequence c'est le nombre distincts des num-lignes .
par exemple :bonjour (1,2)(1,5)(6,3)->frequence =2.
c'est tout.
je pense que les 2 derniers traitement peuvent se faire en 1seule lecture non?
car ca bloque au niveau de la fonction POSLIGNE, il reste un temps enorme et puis il continue le travail
help svp
merci

[ram-0000]

Je te propose de reprendre ton programme sur des bases saines

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
 
initialiser table hash
ouvrir le fichier
numero ligne = 0
tant que lire une ligne est possible
   incremente numero ligne
   numero mot = 0
   tant que lire un mot dans la ligne est possible
      incremente numero mot
      ajouter mot dans table hash (parametres = mot, numero ligne, numero mot dans ligne)
         ce traitement ajoute un mot dans la table de hash ou alors met a jour la table hash en rajoutant les coordonnées du mot et en modifiant éventuellement la fréquence
   fin tant que   
fin tant que
fermer fichier
afficher nombre de lignes
afficher table hash (provisoire)
supprimer mots de la table hash qui sont pas assez frequent
afficher table hash (provisoire)
 
suite du traitement

[étoile de mer]

merci Ram 000,
en fait quoi choisir utiliser fscanf ou fgets pour lire les mots du fichier sachant qu'il faut pas considerer le point final comme un mot ?
c'est a dire j'utilise cette boucle :
while (fscanf (F, "%s", mot) == 1)
{
}

car il parait que ca causait des problemes dans l'ancien code

[ram-0000]

Voila une 1ere version. Cela lit le fichier en une fois, insere tous les mots, calcul les frequence et met a jour la liste des coordonnées en une passe.

Dit moi comment ca compile chez toi et ce que tu en penses

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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
 
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
 
#define PATH "C:\\Documents and Settings\\Raymond\\Bureau\\test.txt"
#define TAILLEHASH 307
 
typedef struct c
{	int numero_mot;
	int numero_ligne;
	struct c *suivant;
} Coordonnees;
 
typedef struct L
{	int ID;
	int freq;
	char mot[50];
	Coordonnees *c;
	struct L *suivant;
} Liste;
 
/* prototypes des fonctions */
char *lire_mot(char **from_here);
int is_good_char(const int carac);
void insere_table(Liste **TableHash, const char *mot, const int numero_ligne, const int numero_mot);
unsigned int hash_cle(const char * mot);
void dump_table(Liste **TableHash);
 
void main(void)
{
	int i;
	FILE *F;
	int numero_ligne;
	int numero_mot;
	char buffer_ligne[1024];
	char *begin;
	char *mot;
 
	/* initialiser la table de hash */
   Liste *TableHash[TAILLEHASH];
   for(i = 0; i < TAILLEHASH; ++i)
	{
      TableHash[i] = NULL;
	}
 
	/* ouverture du fichier */
   F = fopen(PATH, "r");
	if(F == NULL)
	{
		/* erreur d'ouverture du fichier  */
		printf("Erreur d'ouverture du fichier %s\n", PATH);
		exit(0);
	}
 
	/* numero de ligne = 0 */
	numero_ligne = 0;
 
	/* tant que lire une ligne est possible */
	while(fgets(buffer_ligne, sizeof(buffer_ligne), F) != NULL)
	{
		/* incremente numero ligne */
		numero_ligne++;
 
		/* numero mot = 0 */
		numero_mot = 0;
 
		begin = buffer_ligne;
		mot = lire_mot(&begin);
		while(mot != NULL)
		{
			/* incremente numero mot */
			numero_mot++;
			/* printf("Ligne %d, Mot %d = %s\n", numero_ligne, numero_mot, mot); */
 
			/* ajoute le mot dans la table de hash */
			insere_table(TableHash, mot, numero_ligne, numero_mot);
 
			/* lire mot suivant */
			mot = lire_mot(&begin);
		}
	}
 
	/* fermeture du fichier */
	fclose(F);
 
	dump_table(TableHash);
}
 
/* retourne 0 si separateur de mot */
/* retourne 1 si caractere de mot */
int is_good_char(const int carac)
{
	/* code ascii superieur à 128, c'est un caractere texte */
	if(carac >= 128) return 1;
	if(carac <= 0) return 1;
 
	/* caractere de controle, mauvais */
	if(iscntrl(carac)) return 0;
 
	/* caractere de ponctuation, mauvais */
	if(ispunct(carac)) return 0;
 
	/* caractere espace, mauvais */
	if(isspace(carac)) return 0;
 
	/* bon caractere */
	return 1;
}
 
char *lire_mot(char **from_here)
{
	char *end;
	char *begin = *from_here;
 
	/* recherche du premier caractere alphabetique */
	while(is_good_char(*begin) == 0)
	{
		/* le caractere n'est pas alphabetique */
		begin++;
	}
 
	/* verifie si fin de ligne */
	if(*begin == 0)
	{
		return NULL;
	}
 
	/* recherche du dernier caractere */
	end = begin;
	while(is_good_char(*end) != 0)
	{
		/* le caractere est alphabetique */
		end++;
	}
 
	/* termine le mot */
	*end = 0;
	end++;
	*from_here = end;
 
	return begin;
}
 
unsigned int hash_cle(const char * mot)
{
   unsigned int val = 0;
   for(; *mot != '\0'; ++mot)
	{
      val = *mot + 31 * val;
	}
   return val % TAILLEHASH;
}
 
void insere_table(Liste **TableHash, const char *mot, const int numero_ligne, const int numero_mot)
{
	/* calcule le hash du mot */
	unsigned int idx = hash_cle(mot);
 
	/* recherche du mot */
	Liste *p = TableHash[idx];
	while(p != NULL)
	{
		if(strcmp(p->mot, mot) == 0)
		{
			/* le mot est trouve */
			break;
		}
		p =p->suivant;
	}
 
	if(p == NULL)
	{
		/* le mot n'existe pas, insertion de celui ci */
		p = (Liste *)malloc(sizeof(Liste));
		if(p == NULL)
		{
			/* erreur d'allocation de memoire */
			printf("Erreur d'allocation mémoire\n");
			exit(0);
		}
 
		/* initialisation de la structure */
		p->ID = 0;
		p->freq = 1;
		strncpy(p->mot, mot, sizeof(p->mot));
 
		/* creation des coordonnees */
		p->c = (Coordonnees *)malloc(sizeof(Coordonnees));
		if(p->c == NULL)
		{
			/* erreur d'allocation de memoire */
			printf("Erreur d'allocation mémoire\n");
			exit(0);
		}
		p->c->numero_ligne = numero_ligne;
		p->c->numero_mot = numero_mot;
		p->c->suivant = NULL;
 
		/* mise a jour des liens, insertion en debut de liste */
		p->suivant = TableHash[idx];
		TableHash[idx] = p;
		return;
	}
 
	/* le mot existe */
	/* ajout des coordonnees */
	Coordonnees * c = (Coordonnees *)malloc(sizeof(Coordonnees));
	if(c == NULL)
	{
		/* erreur d'allocation de memoire */
		printf("Erreur d'allocation mémoire\n");
		exit(0);
	}
 
	/* mise a jour des informations */
	c->numero_ligne = numero_ligne;
	c->numero_mot = numero_mot;
 
	if(p->c->numero_ligne != numero_ligne)
	{
		/* c'est un nouveau numero de ligne, incremente la frequence */
		p->freq++;
	}
 
	/* mise a jour des liens */
	c->suivant = p->c;
	p->c = c;
}
 
void dump_table(Liste **TableHash)
{
	for(int boucle = 0; boucle != TAILLEHASH; boucle++)
	{
		Liste *p = TableHash[boucle];
		if(p != NULL)
		{
			printf("hash=%d\n", boucle);
			while(p != NULL)
			{
				printf("\t%s (%d : %d)\n", p->mot, p->ID, p->freq);
				p = p->suivant;
			}
		}
	}
}

Au fait, a quoit correspond le champs ID dans ta structure Liste, c'est quoi cette info.

[étoile de mer]

Voila une 1ere version. Cela lit le fichier en une fois, insere tous les mots, calcul les frequence et met a jour la liste des coordonnées en une passe.

Dit moi comment ca compile chez toi et ce que tu en penses

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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
 
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
 
#define PATH "C:\\Documents and Settings\\Raymond\\Bureau\\test.txt"
#define TAILLEHASH 307
 
typedef struct c
{	int numero_mot;
	int numero_ligne;
	struct c *suivant;
} Coordonnees;
 
typedef struct L
{	int ID;
	int freq;
	char mot[50];
	Coordonnees *c;
	struct L *suivant;
} Liste;
 
/* prototypes des fonctions */
char *lire_mot(char **from_here);
int is_good_char(const int carac);
void insere_table(Liste **TableHash, const char *mot, const int numero_ligne, const int numero_mot);
unsigned int hash_cle(const char * mot);
void dump_table(Liste **TableHash);
 
void main(void)
{
	int i;
	FILE *F;
	int numero_ligne;
	int numero_mot;
	char buffer_ligne[1024];
	char *begin;
	char *mot;
 
	/* initialiser la table de hash */
   Liste *TableHash[TAILLEHASH];
   for(i = 0; i < TAILLEHASH; ++i)
	{
      TableHash[i] = NULL;
	}
 
	/* ouverture du fichier */
   F = fopen(PATH, "r");
	if(F == NULL)
	{
		/* erreur d'ouverture du fichier  */
		printf("Erreur d'ouverture du fichier %s\n", PATH);
		exit(0);
	}
 
	/* numero de ligne = 0 */
	numero_ligne = 0;
 
	/* tant que lire une ligne est possible */
	while(fgets(buffer_ligne, sizeof(buffer_ligne), F) != NULL)
	{
		/* incremente numero ligne */
		numero_ligne++;
 
		/* numero mot = 0 */
		numero_mot = 0;
 
		begin = buffer_ligne;
		mot = lire_mot(&begin);
		while(mot != NULL)
		{
			/* incremente numero mot */
			numero_mot++;
			/* printf("Ligne %d, Mot %d = %s\n", numero_ligne, numero_mot, mot); */
 
			/* ajoute le mot dans la table de hash */
			insere_table(TableHash, mot, numero_ligne, numero_mot);
 
			/* lire mot suivant */
			mot = lire_mot(&begin);
		}
	}
 
	/* fermeture du fichier */
	fclose(F);
 
	dump_table(TableHash);
}
 
/* retourne 0 si separateur de mot */
/* retourne 1 si caractere de mot */
int is_good_char(const int carac)
{
	/* code ascii superieur à 128, c'est un caractere texte */
	if(carac >= 128) return 1;
	if(carac <= 0) return 1;
 
	/* caractere de controle, mauvais */
	if(iscntrl(carac)) return 0;
 
	/* caractere de ponctuation, mauvais */
	if(ispunct(carac)) return 0;
 
	/* caractere espace, mauvais */
	if(isspace(carac)) return 0;
 
	/* bon caractere */
	return 1;
}
 
char *lire_mot(char **from_here)
{
	char *end;
	char *begin = *from_here;
 
	/* recherche du premier caractere alphabetique */
	while(is_good_char(*begin) == 0)
	{
		/* le caractere n'est pas alphabetique */
		begin++;
	}
 
	/* verifie si fin de ligne */
	if(*begin == 0)
	{
		return NULL;
	}
 
	/* recherche du dernier caractere */
	end = begin;
	while(is_good_char(*end) != 0)
	{
		/* le caractere est alphabetique */
		end++;
	}
 
	/* termine le mot */
	*end = 0;
	end++;
	*from_here = end;
 
	return begin;
}
 
unsigned int hash_cle(const char * mot)
{
   unsigned int val = 0;
   for(; *mot != '\0'; ++mot)
	{
      val = *mot + 31 * val;
	}
   return val % TAILLEHASH;
}
 
void insere_table(Liste **TableHash, const char *mot, const int numero_ligne, const int numero_mot)
{
	/* calcule le hash du mot */
	unsigned int idx = hash_cle(mot);
 
	/* recherche du mot */
	Liste *p = TableHash[idx];
	while(p != NULL)
	{
		if(strcmp(p->mot, mot) == 0)
		{
			/* le mot est trouve */
			break;
		}
		p =p->suivant;
	}
 
	if(p == NULL)
	{
		/* le mot n'existe pas, insertion de celui ci */
		p = (Liste *)malloc(sizeof(Liste));
		if(p == NULL)
		{
			/* erreur d'allocation de memoire */
			printf("Erreur d'allocation mémoire\n");
			exit(0);
		}
 
		/* initialisation de la structure */
		p->ID = 0;
		p->freq = 1;
		strncpy(p->mot, mot, sizeof(p->mot));
 
		/* creation des coordonnees */
		p->c = (Coordonnees *)malloc(sizeof(Coordonnees));
		if(p->c == NULL)
		{
			/* erreur d'allocation de memoire */
			printf("Erreur d'allocation mémoire\n");
			exit(0);
		}
		p->c->numero_ligne = numero_ligne;
		p->c->numero_mot = numero_mot;
		p->c->suivant = NULL;
 
		/* mise a jour des liens, insertion en debut de liste */
		p->suivant = TableHash[idx];
		TableHash[idx] = p;
		return;
	}
 
	/* le mot existe */
	/* ajout des coordonnees */
	Coordonnees * c = (Coordonnees *)malloc(sizeof(Coordonnees));
	if(c == NULL)
	{
		/* erreur d'allocation de memoire */
		printf("Erreur d'allocation mémoire\n");
		exit(0);
	}
 
	/* mise a jour des informations */
	c->numero_ligne = numero_ligne;
	c->numero_mot = numero_mot;
 
	if(p->c->numero_ligne != numero_ligne)
	{
		/* c'est un nouveau numero de ligne, incremente la frequence */
		p->freq++;
	}
 
	/* mise a jour des liens */
	c->suivant = p->c;
	p->c = c;
}
 
void dump_table(Liste **TableHash)
{
	for(int boucle = 0; boucle != TAILLEHASH; boucle++)
	{
		Liste *p = TableHash[boucle];
		if(p != NULL)
		{
			printf("hash=%d\n", boucle);
			while(p != NULL)
			{
				printf("\t%s (%d : %d)\n", p->mot, p->ID, p->freq);
				p = p->suivant;
			}
		}
	}
}

Au fait, a quoit correspond le champs ID dans ta structure Liste, c'est quoi cette info.

MERCI RAM000,
c'est gentil de ta part
bon le champs ID correspond à la valeur correspondant à chaque mot.
en fait j'utilise dans les traitement le champs ID, pour l'alleger l'execution.
à la fin dans l'affichage je fais un simple matching: chaque ID avec son mot correspondant.

concernant la compilation de votre bout du code, ben ca marche, sauf qu'il ya une erreur au niveau de calcul de la frequence : si un meme mot se trouvant plus qu'une seule fois dans une ligne il est comptabilisé 1 seul .
dans l'affichage faut :
mot (num-ligne 1, position 2),....(num-ligne n, position n)
merci

[ram-0000]

bon le champs ID correspond à la valeur correspondant à chaque mot.

C'est à dire, tu peux expliquer un peu.

concernant la compilation de votre bout du code, ben ca marche, mais je vois pas la liste des coordonnes des mots.

Effectivement, je ne l'ai pas mis car cela alourdit le dump. Il suffit de modifier la fonction de dump pour le rajouter.

Est ce que tu peux expliquer en francais la suite du traitement STP ?