probleme dans une fonction qui affiche le nombre de ligne du texte

**étoile de mer** · 18/09/2008, 10h00

bonjour à tous,

j'ai un problème urgent dans la fonction qui extrait les mots à partir d'un fichier en les stockant dans un hash table, tout en inserant leurs coordonnées (num-ligne, position), elle affiche le nombre de ligne du texte.

Elle affiche un nombre erroné de nombre de fichiers ainsi que les cordonnées aussi.
quelqu'un peut m'aider svp?
merci

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
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
 
#define PATH "C:\\Documents and Settings\\Raymond\\Bureau\\test.txt"
#define TAILLEHASH 307
#define SEUIL 0.2
 
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 clean_table(Liste **TableHash, const int NombreLigne, const float Seuil);
void libere(Liste *l);
 
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);
 
	/* affichage de la table */
	dump_table(TableHash);
 
	printf("Le nombre de lignes du fichier %s est %d\n", PATH, numero_ligne);
 
	/* suppression de ce qui est inutile dans la table */
	clean_table(TableHash, numero_ligne, SEUIL);
 
	/* affichage de la table (encore)*/
	dump_table(TableHash);
}
 
void libere(Liste *l)
{
	if(l == NULL)
	{
		/* petit controle juste au cas ou */
		return;
	}
 
	/* libere les coordonnees */
	Coordonnees *c = l->c;
	while(c != NULL)
	{
		Coordonnees *tmp = c->suivant;
		free(c);
		c = tmp;
	}
	free(l);
}
 
void clean_table(Liste **TableHash, const int NombreLigne, const float Seuil)
{
	for(int boucle = 0; boucle != TAILLEHASH; boucle++)
	{
		Liste *premier_valide = NULL;
		Liste *q = TableHash[boucle];
		while(q != NULL)
		{
			float suup = (float)(q->freq) / (float)(NombreLigne);
			if(suup < Seuil)
			{
				/* supprime l'element */
				Liste *tmp = q->suivant;
				libere(q);
				q = tmp;
			}
			else
			{
				if(premier_valide == NULL)
				{
					premier_valide = q;
				}
				q = q->suivant;
			}
		}
		TableHash[boucle] = premier_valide;
	}
}
 
/* 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);
 
				/* affichage des position */
				/*if(p->c != NULL)
				{
					printf("\t\t");
					Coordonnees *c = p->c;
					while(c != NULL)
					{
						printf("(%d,%d) ", c->numero_ligne, c->numero_mot);
						c = c->suivant;
					}
					printf("\n");
				}*/
				p = p->suivant;
			}
		}
	}
}

**fregolo52** · 18/09/2008, 11h05

Pour nous guider, tu peux nous dire si tes valeus sont complètement déconnantes ou si l'erreur est minime.

J'ai regardé le main et lire_mot, a priori je n'ai pas vu d'erreur.

La fonction is_good_char me parait bizarre !! C'est surement là l'erreur.

Code :

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

1
2
3
	/* code ascii superieur à 128, c'est un caractere texte */
	if(carac >= 128) return 1;
	if(carac <= 0) return 1;

Le 1er caractère 'A' a la valeur 65 pas 128
moi je verrai :

Code :

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

1
2
	/* c'est un caractere texte de A à z */
	if(carac >= 65 && carac <= 122) return 1;

Tu travailles avec des caractères, donc essaie de mettre des 'unsigned char' comme type quand tu traites des caractères.

**Emmanuel Delahaye** · 18/09/2008, 11h58

Envoyé par fregolo52

moi je verrai :

Code :

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

1
2
	/* c'est un caractere texte de A à z */
	if(carac >= 65 && carac <= 122) return 1;

ou isprint() ...

**étoile de mer** · 18/09/2008, 19h30

Envoyé par Emmanuel Delahaye

ou isprint() ...

mERCI ed? VOUS pouvez me clarifier un peu plus svp.?
merci

**Emmanuel Delahaye** · 18/09/2008, 19h41

Envoyé par cyrine

mERCI ed? VOUS pouvez me clarifier un peu plus svp.?
merci

http://man.developpez.com/man3/isalpha.3.php

**étoile de mer** · 18/09/2008, 19h54

Envoyé par Emmanuel Delahaye

http://man.developpez.com/include/ctype.php

c'est compliqué, surtout pour un niveau débutant

**Emmanuel Delahaye** · 19/09/2008, 01h14

Envoyé par cyrine

c'est compliqué, surtout pour un niveau débutant

EDIT : Oups, désolé, je me suis trompé de lien. Celui de BainE est le bon. (Correction faire)

Sinon, c'est très simple. Ce sont des fonctions standard du C (les fonction is*()) qui te disent si un caractère appartient à tel ou tel ensemble de caractères. Rien de compliqué.

Tu préfères la référence en anglais ?

http://www.opengroup.org/onlinepubs/...s/ctype.h.html

**BainE** · 19/09/2008, 09h25

Bonjour,

sinon peut etre est ce plus clair ICI

probleme dans une fonction qui affiche le nombre de ligne du texte

C

Discussions similaires

Partager

Partager