Discussion :

[Justinetsd]

Bonjour,

Je fais un appel à l'aide à toutes personne ayant des connaissances dans la programmation en DVC++, je dois réalisé dans le cadre d'un projet scolaire un programme permettant l'étude de textes. Je souhaiterais avoir d'afficher le nombre de mot, puis après que chaque mot soit affiché avec son nombre de répétition.
En espérant, avoir un retour je vous souhaite une bonne soirée.
Cordialement.

Voici le début de mon programme, je bloque sur l'affichage des mots et du nombre de répétition.

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
 
int main()
{
char str[10000],c='a';
 
int imot=0,jlettre=0, count=0;
FILE *fp;
 
fp=fopen("hauts.txt","r");
 
/* printf("Entrer une chaine de caractere: ");
gets(str);*/
 
while (!feof(fp)){
 
c=fgetc(fp);
if(c== ' ' || c== '\t' || c== '\n') count++;
else printf("%c",c);
 
}
printf("\n il y a %d mots\n",count);
 
char tabmots[count][30];
printf("%d\n",sizeof(tabmots));
fp=freopen("hauts.txt","r",fp);
 
while (!feof(fp)){
c=fgetc(fp);
if((c<65) || (c>90) || (c<97) || (c>122)) {
//printf("%s\n",tabmots[imot]);
imot++;
jlettre=0;
}
else {
tabmots[imot][jlettre++]=c;
printf("%d \t %c ",c,c);
} 
}
 
/* for(i = 0; str[i] != '\0'; i++) //compter nombre total mot dans le texte
{
if(str[i] == ' ' || str[i] == '\t' || str[i] == '\n')
{
count++; 
} 
} 
printf("il y a %d mots\n",count);*/
fclose(fp);
 
/* int tableau_mot[count], tableau_nombre_utilisation[count];
 
for (...)
{
if (mot existe pas encore)
{
ajoute au tableau
ajoute +1 a tableau_nombre_utilisation
}
else (mot existe deja)
{
cherche dans le tableau ou est le mot
recuperer le numero de la case
fait +1 dans l'autre tableau (tableau_nombre_utilisation) au bon numero de case
}
}
 
for (i=0; i<count; i++)
{
printf("\nle mot %c est apparu %d fois", tableau_mot[i], tableau_nombre_utilisation[i]); //affchage resultat (nombre de mot different total)
}*/
 
return 0;
}

voici le texte choisi ( en anglais pour éviter de compliquer la tâche avec les accents)

I have just returned from a visit to my landlord - the solitary neighbour that I shall be troubled with. This is certainly a beautiful country! In all England, I do not believe that I could have fixed on a situation socompletely removed from the stir of society. A perfect misanthropist's heaven: and Mr. Heathcliff and I aresuch a suitable pair to divide the desolation between us. A capital fellow! He little imagined how my heartwarmed towards him when I beheld his black eyes withdraw so suspiciously under their brows, as I rode up,and when his fingers sheltered themselves, with a jealous resolution, still further in his waistcoat, as I announced my name.

[Bousk]

Si tu prétends/veux faire du C++, alors fais du C++ et non du C.
Un tel programme se fait en quelques lignes avec std::ifstream, std::string & std::map.

[Justinetsd]

Bonjour,
Merci de votre retour mais je ne connais pas grand chose et du coup je me suis trompé c’est langage C dans ce cas. Il faut que dans le même langage que j’ai commencé le programme j’essaye de le finir mais je ne sais pas comment faire là suite. C’est pour cela je suis à la recherche de quelqu’un qui pourrait m’aider et m’expliquer. Merci d’avance

[Guesset]

Bonjour,

En C, ce sera plus douloureux qu'en C++ notamment pour la gestion des mots/occurrences : recherche, ordonnancement, ajout.

Comme le texte est court, il est possible de le charger entièrement dans une seule chaîne. En ce qui concerne les chaînes de caractères, il y a le choix en terme de fonction. strtok() par exemple permet de trouver tous les mots d'un texte (on spécifie les séparateurs).

Mais un travail caractère par caractère est possible et assez facile. Il n'est pas nécessaire de faire 2 passages car ce qui n'est pas séparateur est mot (ce serait différent s'il y avait des nombres ou des mots composés). On peut utiliser un marqueur binaire, par exemple in word, pour savoir si on est dans un mot ou un espace car les deux peuvent avoir plusieurs caractères mais seul le premier change l'état de inWord. Cela permet donc de gérer entre autres les commencements de mot.

Ne pas oublier de forcer la casse des mots (tout en majuscules ou tout en minuscules) si on ne veut pas différencier "in" et "In" par exemple.

Salut.

[hurukan]

Déjà j'aime bien le nom des variables est parlant, je vais tenter de faire quelque chose... en C c'est pas si compliqué...

[hurukan]

Bon ça n'a pas été sans peine mais voilà un essai...

...ça marche mais il faudra pouvoir gérer les mots composés, les éventuelles césures, ...
De plus pour le moment les caractères accentués/spéciaux ne sont pas gérés du tout (non utf8).

analyzer.h

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
/* 
 * File:   analyzer.h
 * Author: Dimitri "Hurukan" <soundlord@gmail.com>
 *
 * Créé le March 1, 2022, 6:18 AM
 *  
 */
 
#ifndef ANALYZER_H
#define ANALYZER_H
 
// ****************************************************************************
// SECTION : fichiers d'inclusions
// ****************************************************************************
 
// **************************************************************************** 
// Définitions des constantes symboliques
// **************************************************************************** 
 
// **************************************************************************** 
// Définition(s) des structures, types et énumérations
// ****************************************************************************
 
typedef struct s_Word
{
	char *pPattern;
	int	 occurence;
}t_Word;
 
// **************************************************************************** 
// Définition(s) des variables statiques/externes
// **************************************************************************** 
 
// **************************************************************************** 
// Définition(s) des fonctions
// **************************************************************************** 
 
 
#endif /* ANALYZER_H */

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
319
320
321
322
323
324
325
326
327
328
/* 
 * File:   txtanalyzer.c
 * Author: Dimitri "Hurukan" <soundlord@gmail.com>
 *
 * Créé le March 1, 2022, 4:59 AM
 */
 
// ****************************************************************************
// HISTORIQUE
// ****************************************************************************
 
// **************************************************************************** 
// Fichiers de définitions
// **************************************************************************** 
 
#include <stdio.h>
#include <stdlib.h>
 
#include <stdbool.h>      
#include <unistd.h>
#include <string.h>
 
#include "analyzer.h"
 
// **************************************************************************** 
// Déclaration des constantes symboliques
// **************************************************************************** 
 
// **************************************************************************** 
// Déclaration des variables globales, externes, ...
// **************************************************************************** 
 
// ****************************************************************************
// SECTION : prototypes des fonctions en test pour CE code source
// ****************************************************************************
 
char* extractWord(char*);
int IsExists(char*,t_Word*,int);
void Insert(char*,t_Word*,int);
 
/*
 * FONCTION PRINCIPALE
 */
int main(int argc,char** argv)
{
#ifdef OLD
	char str[10000],c='a';
 
	int imot=0,jlettre=0, count=0;
	FILE *fp;
 
	fp=fopen("hauts.txt","r");
 
	/* printf("Entrer une chaine de caractere: ");
	gets(str);*/
 
	while (!feof(fp))
	{
 
		c=fgetc(fp);
		if(c== ' ' || c== '\t' || c== '\n') count++;
		else printf("%c",c);
 
	}
	printf("\n il y a %d mots\n",count);
 
	char tabmots[count][30];
	printf("%d\n",sizeof(tabmots));
	fp=freopen("hauts.txt","r",fp);
 
	while (!feof(fp))
	{
			c=fgetc(fp);
			if((c<65) || (c>90) || (c<97) || (c>122)) {
			//printf("%s\n",tabmots[imot]);
			imot++;
			jlettre=0;
		}
		else 
		{
			tabmots[imot][jlettre++]=c;
			printf("%d \t %c ",c,c);
		} 
	}
 
	/* for(i = 0; str[i] != '\0'; i++) //compter nombre total mot dans le texte
	{
		if(str[i] == ' ' || str[i] == '\t' || str[i] == '\n')
		{
			count++; 
		} 
	} 
	printf("il y a %d mots\n",count);*/
	fclose(fp);
#endif
 
	char	*texte;						// ici je vais mettre tout en mémoire pour ne pas devoir faire des accès disques (si les fichiers font moins de 4.2Go ça devrait aller ^^)
	FILE	*descFichier;			
 
	descFichier=fopen("texte.txt","r");
	if(!descFichier) return(EXIT_FAILURE);
 
	long tailledufichier;
	fseek(descFichier,0L,SEEK_END);						// je me positionne dans le fichier à la fin de celui-ci...
	tailledufichier=ftell(descFichier);				// je récupère la taille du fichier
	fseek(descFichier,0L,SEEK_SET);						// je reviens au début du fichier sinon dès que je vais lire je vais me taper un EOF ^^
 
	texte=(char*)calloc(tailledufichier+1,sizeof(char));
	if(!texte) return(EXIT_FAILURE);
 
	fread(texte,1,tailledufichier,descFichier);
 
	// je devrais faire des tests mais j'ai la flemme :{
	// Nous avons le texte en mémoire... on peut fermer le descripteur
 
	fclose(descFichier);
 
	// Nous allons analyser le texte en considérant que les mots sont séparés par
	// soit un espace (32 ASCII) soit par un caractère de ponctuation (selon les normes dactylographiques)
 
	// Pour la répétition des mots là par réflexe j'utiliserais une de mes librairies mais pour "simplifier" nous passerons par "autre chose"
	// Ma librairie permet la gestion de listes/files... ce serait bien d'avoir cela pour notre projet... 
 
	// Pour chaque mot il faut lui associer un nombre indiquant le nombre de fois qu'il apparaît dans le texte...
	// Sans ma librairie je serais tenté de créer un tableau de structures le soucis c'est que ce tableau devra avoir une taille fixe
	// et c'est là que ma librairie va me manquer ^^
 
	// On va donc compter le nombre de mots c'est ce qu'il y a de plus facile...
 
	// Pour les occurences on va devoir se creuser un peu si je ne peux pas utiliser ma librairie...
	// Dans le fichier analyzer.h j'ai défini une structure:
 
	//typedef struct s_Word
	//{
	//	char *pPattern;
	//	int	 occurence;
	//}t_Word;
 
	// Qui va nous servir par la suite...
 
	long curseurlecture=0L;
	long nbMots=0L;
 
	t_Word tabMots[tailledufichier/3];					// normalement un mot est composé d'au moins trois caractères sinon ce sont des prépositions ici c'est juste pour contourner le fait que je ne sache utiliser ma librairie 
 
	// JE HAIS de faire ceci mais j'ai pas le choix ici (ouin ouin ma librairie mes listes et mes piles etc...)
 
	memset(tabMots,0,(tailledufichier/3)*sizeof(t_Word)); // on met tout à zéro en mémoire à partir de l'adresse de tabMots (sinon on risque des surprises !!)
 
 
	while(curseurlecture<tailledufichier)
	{
		//lecture caractère par caractère et détection de l'espace et du retour de ligne plus ponctuation...
		// ce serait "plus simple" avec les expression rationelles/régulières mais je ne sais pas si tu as déjà vu ces mécanismes (le Perl est plus adapté pour ce genre de traitements ^^)
 
		if(texte[curseurlecture]<10 && texte[curseurlecture]>=0) 
		{
			curseurlecture++;
			continue;
		}
		if(texte[curseurlecture]==12 || texte[curseurlecture]==11) 
		{
			curseurlecture++;
			continue;
		}
		if(texte[curseurlecture]>=14 && texte[curseurlecture]<=31) 
		{
			curseurlecture++;
			continue;
		}
 
		if(texte[curseurlecture]==10 || texte[curseurlecture]==13) 
		{
			curseurlecture++;
			continue;
		}
 
		// ici je traite le cas de la parenthèse dans les règles dactylographiques communes
 
		if(texte[curseurlecture]==' ' && texte[curseurlecture+1]==')')
		{
			curseurlecture++;					// ')' ne doit pas être traité
			continue;																												
		}
 
 
		// ici je traite le point final du texte
		if(texte[curseurlecture]=='.' && curseurlecture>=tailledufichier-1)
		{
			break;
		}
 
		if(texte[curseurlecture]==' ' || texte[curseurlecture]=='.' || texte[curseurlecture]==',' || texte[curseurlecture]==';' || texte[curseurlecture]==':' || texte[curseurlecture]=='.') 
		{
			if(texte[curseurlecture+1]==' ') // cas des doubles espaces
			{
				curseurlecture++;
				continue;
			}
			if(texte[curseurlecture+1]=='-') 
			{
				curseurlecture++;							
				continue;
			}
			if(texte[curseurlecture+1]=='.') // cas des "trois petits points"
			{
				curseurlecture++;
				continue;
			}
 
			// le mot se trouve donc APRES le caractère de ponctuation <--
 
 
 
			char *targetWord=extractWord(&texte[curseurlecture+1]);
			int indice=IsExists(targetWord,tabMots,tailledufichier/3);
			if(indice>=0)
			{
				tabMots[indice].occurence++;
			}
			else Insert(targetWord,tabMots,tailledufichier/3);
 
			nbMots++;
		}
 
		// dans les textes anglophones je ne pense pas qu'il existe des césures du style anglo-saxon... en français il faut considérer qu'il s'agit d'un mot et non deux...
		// il y a un petit risque de "effet de bord" dans l'instruction qui suit...
 
		if(texte[curseurlecture]=='-' && (texte[curseurlecture+1]<='Z' && texte[curseurlecture+1]>='A') && (texte[curseurlecture+1]<='z' && texte[curseurlecture+1]>='a')) 
		{
			/*char *targetWord=extractWord(&texte[curseurlecture+1]);
			int indice=IsExists(targetWord,tabMots,tailledufichier/3);
			if(indice>=0)
			{
				tabMots[indice].occurence++;
			}
			else Insert(targetWord,tabMots,tailledufichier/3);*/
 
			nbMots++;
		}
 
		// pour les autres caractères de ponctuation je ne pense pas qu'ils puissent indiquer l'existence d'un mot qui les suit... sauf peut-être la parenthèse
 
		if(texte[curseurlecture]=='(' && texte[curseurlecture+1]==' ') 
		{
			curseurlecture+=2;						// ' ' ne doit pas être traité une seconde fois
			nbMots++;
		}
		curseurlecture++;
	}
	printf("Nombre de mots dans le texte: %05ld\n",nbMots);
	printf("Résumé: \n");
 
	// Je HAIS faire ceci... blah blah blah
 
	int position=0;
	while(position<tailledufichier/3)
	{
		if(tabMots[position].pPattern!=NULL)	printf("[%s] %02d\n",tabMots[position].pPattern,tabMots[position].occurence);
		position++;
	}
 
 
 
 
 
 
 
 
	return(EXIT_SUCCESS);
}
 
// ****************************************************************************
// SECTION : implémentation des fonctions
// ****************************************************************************
char* extractWord(char *startpos)
{
	long adressedepart=(long)startpos;
	long taillemot=0L;
	if(startpos==NULL) return NULL;
	while((*startpos<='Z' && *startpos>='A') || (*startpos<='z' && *startpos>='a'))
	{
		startpos++;
	}
	// ...si nous arrivons ici c'est qu'il s'agit d'un mot (pour la césure nous verrons plus tard
	taillemot=(long)startpos-adressedepart;
	if(taillemot<=0) return NULL;
	char *tmp=(char*)calloc(taillemot+1,sizeof(char));
	strncpy(tmp,(char*)adressedepart,taillemot);
	return tmp;
}
 
int IsExists(char *pattern, t_Word *source,int size)
{
	if(pattern==NULL) return -1;
	// je déteste faire ça mais j'ai pas le choix ici
 
	int position;
	for(position=0;position<size;position++)
	{
		if(source[position].pPattern==NULL) continue;
		if(strcmp(source[position].pPattern,pattern)==0) 
		{
			return position;
		}
	}
	return -1;
}
 
void Insert(char *word,t_Word *target,int size)
{
	// nouvelle entrée
	// c'est horrible je sais mais sans ma librairie j'écris de la m...
 
	if(word==NULL) return;
 
	int position=0;
	for(;position<size;position++)
	{
		if(target[position].pPattern==NULL)
		{
				target[position].pPattern=(char*)calloc(strlen(word)+1,sizeof(char));
				strcpy(target[position].pPattern,word);
				target[position].occurence=1;
				break;
		}
	}
}

[Sve@r]

Bonjour

Voici le début de mon programme, je bloque sur l'affichage des mots et du nombre de répétition.

Juste un détail: on n'utilise pas feof() pour détecter une fin de fichier. Oui ça semble à priori étonnant vu son nom mais quand on y réfléchit un peu...

Accessoirement tu peux éviter de le lire 50 fois pour chercher 50 trucs dedans. Le lire une seule fois et chercher ces 50 trucs durant la seule et unique lecture sera plus efficace. Mais si tu veux vraiment le lire plusieurs fois, alors rewind() permet de te remettre au début sans avoir alors besoin de le réouvrir.

[Guesset]

Bonjour,

Une manière de faire, pas la meilleure, parmi de nombreuses. Les mots composés sont traités mais pas les césures. Ce n'est pas très difficile mais un peu ennuyeux car il faut tester qu'il y a, juste après le '-', au plus deux caractères, \10 et \13 et au moins un /10, avant la prochaine lettre tout en évitant d'être au delà de la fin de fichier. Si il y avait une césure, le programme actuel considérerait qu'il y a deux mots.

Code C :

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
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <stdbool.h>
#include <malloc.h>
#include <string.h>
 
typedef struct {
   int   nb;
   char  *pWord;
} Word_t;
Word_t   *List;                                  // Liste des mots et de leur occurrence
int      ListLen, ListLast;                      // Longueur de la liste, dernier indice utilisé
 
// Ajouter un nouveau mot à la liste ou augmenter son nombre d'apparitions_________________________
void AddWord(char *p) {
   if(p == NULL) return;
   int i;
   for(i = 0; i <= ListLast; i++)                // Recherche linéaire ;-(
      if(strcmp(p, List[i].pWord) == 0) break;   // Bingo ! on sort de la boucle
   if(i <= ListLast)                             // Le mot existe déjà dans la liste
      List[i].nb = List[i].nb + 1;               //    On augmente le nombre d'une unité
   else {                                        // Le mot n'existe pas dans la liste
      ListLast++;                                //    On l'ajoute à la fin ;-(
      List[ListLast].pWord = p;
      List[ListLast].nb    = 1;
   }
}
 
// Le principe retenu consiste à mettre en majuscule les caractères trouvés et à mettre un caractère
// nul '\0' à la place de tout caractère non lettre. Dans la liste, il n'y a pas recopie des mots
// mais juste un pointeur sur le texte traité. Les '\0' ajoutés délimitent les mots.
// Algo meilleur que O(n²/8) pour n caractères. Une liste triée serait plus efficace en O(nln(n)
// car elle permettrait la recherche dichotomique.
//_________________________________________________________________________________________________
int main(int argc,char** argv) {
   char	*pTxt;                                   // Mettre en mémoire
   FILE	*fileTxt;
   fileTxt = fopen("texte.txt", "r");
   if(!fileTxt) return -1;
   // Lire la taille du texte....................
   fseek(fileTxt, 0, SEEK_END);                  // Se placer en fin de fichier
   long lenTxt = ftell(fileTxt);                 // Taille du fichier
   fseek(fileTxt, 0, SEEK_SET);                  // Revenir au début pour lecture effective
   // Charger le texte en mémoire................
   pTxt = (char*) calloc(lenTxt+2, sizeof(char));
   if(!pTxt) return -2;
   fread(pTxt, 1, lenTxt, fileTxt);              // Charger pTxt avec lenTxt x 1 char de fileTxt
   fclose(fileTxt);
   pTxt[lenTxt] = '\0';                          // Par sécurité, s'assurer d'une fin de texte
   // Liste des mots trouvés.....................
   ListLast = -1;                                // Dernier indice utilisé dans la liste
   ListLen  = (lenTxt + 1) >> 1;                 // Majorant du nb de mots (1 caractère 1 espace)
   List     = calloc(ListLen, sizeof(Word_t));   // Affectation de l'espace mémoire utile et RàZ
   if(List == NULL) return -3;
   // Traitement du texte........................
   int  nbWords = 0;
   bool inWord  = false;                         // Sommes nous dans un mot ?
   char *p, *pStart = NULL;                      // PCurseur sur le texte et début du prochain mot
   for(int index = 0; index < lenTxt; index++) {
      p  = pTxt + index;
      *p = toupper(*p);
      if(*p >= 'A' && *p <= 'Z') {               // Est-ce une lettre ?
         if(inWord) continue;                    // Dans un mot ? On passe au caractère suivant
         else {
            inWord = true;                       // Début de mot
            ++nbWords;                           // Un mot de plus
            pStart = p;                          // Adresse actuelle sur le début de mot
         }
      }
      else {                                     // Ce n'est pas une lettre
         if(*p == '-' && inWord                  // Mot composé ? lettres '-' lettres
         && ((p[1] >= 'A' && p[1] <= 'Z') || (p[1] >= 'a' && p[1] <= 'z')) ) continue;
         *p = '\0';                              // On la force à 0 (fin de chaîne)
         if(inWord) {
            inWord = false;                      //            ", as I announced my name."
            AddWord(pStart);                     // ° <=>'\0   "°°AS°I°ANNOUNCED°MY°NAME°"
         }                                       // pStart        ^  ^ ^         ^  ^
      }
   }
   if(inWord) AddWord(pStart);                   // Si dernier mot non suivi d'un séparateur
   // Affichages.................................
   printf("Nombre total de mots : %d dont %d differents\n", nbWords, ListLast+1);
   for(int i = 0; i <= ListLast; i++) {
      printf("%14s : %3d", List[i].pWord, List[i].nb);
      nbWords -= List[i].nb;
      if((i & 3) == 3) printf("\n");
   }
   if(nbWords != 0) printf("\n%d", nbWords);
   getchar();                                    // Inutile en debug sous IDE
   return 0;
}

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
 
Nombre total de mots : 114 dont 85 differents
             I :   8          HAVE :   2          JUST :   1      RETURNED :   1
          FROM :   2             A :   7         VISIT :   1            TO :   2
            MY :   3      LANDLORD :   1           THE :   3      SOLITARY :   1
     NEIGHBOUR :   1          THAT :   2         SHALL :   1            BE :   1
      TROUBLED :   1          WITH :   2          THIS :   1            IS :   1
     CERTAINLY :   1     BEAUTIFUL :   1       COUNTRY :   1            IN :   2
           ALL :   1       ENGLAND :   1            DO :   1           NOT :   1
       BELIEVE :   1         COULD :   1         FIXED :   1            ON :   1
     SITUATION :   1  SOCOMPLETELY :   1       REMOVED :   1          STIR :   1
            OF :   1       SOCIETY :   1       PERFECT :   1 MISANTHROPIST :   1
             S :   1        HEAVEN :   1           AND :   3            MR :   1
    HEATHCLIFF :   1       ARESUCH :   1      SUITABLE :   1          PAIR :   1
        DIVIDE :   1    DESOLATION :   1       BETWEEN :   1            US :   1
       CAPITAL :   1        FELLOW :   1            HE :   1        LITTLE :   1
      IMAGINED :   1           HOW :   1   HEARTWARMED :   1       TOWARDS :   1
           HIM :   1          WHEN :   2        BEHELD :   1           HIS :   3
         BLACK :   1          EYES :   1      WITHDRAW :   1            SO :   1
  SUSPICIOUSLY :   1         UNDER :   1         THEIR :   1         BROWS :   1
            AS :   2          RODE :   1            UP :   1       FINGERS :   1
     SHELTERED :   1    THEMSELVES :   1       JEALOUS :   1    RESOLUTION :   1
         STILL :   1       FURTHER :   1     WAISTCOAT :   1     ANNOUNCED :   1
          NAME :   1
Process returned 0 (0x0)   execution time : 0.015 s
Press any key to continue.

Salutations

[hurukan]

C'est beau !! Bravo !!

[Guesset]

Bonjour Hurukan,

...C'est beau...

Je te remercie mais je me suis inspiré de ton code .

C'est toujours plus facile à partir d'un existant . Finalement, il y a peu de différences : inversion de la logique séparateurs-lettres (plus simple) et mise à 0 de tout ce qui n'est pas lettre pour ne pas avoir à copier les mots.

Il resterait à modifier AddWord : recherche dichotomique et insertion d'un mot dans l'ordre. Il n'est pas sûr que le gain O(n.ln(n)) soit présent sur des faibles volumes comme ce texte car l'insertion est assez coûteuse. Mais avec de plus forts volumes, en prenant en considération que le vocabulaire reste toujours limité (un texte 2 fois plus long n'utilise pas 2 fois plus de mots différents), le taux d'insertion diminue tandis que celui des recherches croit. Cela devrait se révéler payant.

J'ai utilisé Code Blocks sous Windows.

Salut