gros fichier texte

**étoile de mer** · 15/09/2008, 06h23

bonjour à tous,
j'ai un probleme c'est que jai implementé un programme qui fait des traitement sur des lignes d'un fichier texte, ce fichier est trop géant =26000 lignes .
ben ca l'air que le programme plante.

c'est pour cela je m'adresse à vous si vous avez une idéé (traitememnt par bloc ou autre idée

)
merci à vous.

**ram-0000** · 15/09/2008, 08h55

Personnellement, je travaille sur des fichiers qui font plusieurs millions de lignes et plusieurs dizaines ou centaines de mega octets et je n'ai pas de problèmes.

Tu dois donc avoir un problème dans ton code. On peut en savoir un peu plus STP ?

**Spout** · 15/09/2008, 09h16

Envoyé par cyrine

ben ca l'air que le programme plante

"Ça a l'air" ?
Quels sont les symptômes?
Quelles sont les erreurs?
Quel comportement est attendu?
Quel comportement obtiens-tu?
Quel code utilises-tu?

Comme tu peux le voir, nous ne sommes pas devins...

**étoile de mer** · 15/09/2008, 10h20

ok merci
voila le main :

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
#include<stdio.h> 
    #include<stdlib.h> 
    #include<string.h> 
    #include<memory.h>
 
    #include "table_hash.h" 
    #define TAILLEHASH 307 
    #define IDLIMIT 1000
    #define NBRSEQ 10 
    #define SEUIL 2 
 
#define PATH "C:\\essai.txt"
 
 
    //"C:\\essai1.txt"
 
    int main() 
 
    {   int valeur;
 
        int res = 0;
    	FILE *F=NULL; 
    	char mot[100]; 
    	int i,j; 
    	unsigned int cle,pt; 
    	int nl=1, pos=1; 
    	//nl=pos=1; 
    	int f; 
    	char c; 
    	//int seuil; 
    	//Liste **L; 
    	SListe *seq2=NULL; 
    	SListe **seq, *tmp; 
 
    	Liste **TableHash; 
    	TableHash = (Liste **) malloc (TAILLEHASH * sizeof(Liste *)); 
    	for(i=0;i<TAILLEHASH;++i) 
    		TableHash[i] = NULL; 
 
    	pt=hash_cle("."); 
    	//printf("%d",pt); 
    	//printf("Entrez votre valeur de support minimal"); 
        //scanf("%d", &valeur); 
 
    	printf("debut du programme \n----------------------------------\n");   
    	F=fopen(PATH,"r"); 
    	printf("Ouverture du Fichier \n----------------------------------\n");   
    	while(fscanf(F,"%s",mot)==1){ 
    		cle = hash_cle(mot); 
    		if ((cle!=pt ) && (! ChercherMotDansTableHash(TableHash,mot))) 
                TableHash[cle] = InsertionEnTete(TableHash[cle],mot,cle);
    		if(fgetc(F)==EOF)
    			break;
    	} 
    	fclose(F); 
    	printf ("nombre de lignes \n----------------------------------\n"); 
 
 
 
 
 
 
    		F = fopen (PATH, "r");
 
    F = fopen (PATH, "r");
   if (F != NULL)
   {
 
      char buffer[BUFSIZ];
      int nb_read;
 
      while ((nb_read = fread (buffer, 1, sizeof buffer, F)) > 0)
      {
         int i;
 
         for (i = 0; i < nb_read; i++)
         {
            if (buffer[i] == '\n')
            {
               res++;
            }
         }
      }
      fclose (F);
      printf ("%i\n", res);
   }
   else
   {
      perror (PATH);
   }
 
 
 
    	F=fopen(PATH,"r"); 
    	PosLigne(F,TableHash); 
 
    	//filtrage  
    	printf("\nla liste filtre :\n----------------------------------"); 
 
    	FiltreListe(TableHash,SEUIL); 
    	AfficherTableHash(TableHash); 
 
 
    	//géneration des 2seq 
        Generer2seq(TableHash, SEUIL, &seq2); // seq2 c pour stocker les 2seq     	
 
    	// les sequences  
    	seq =(SListe **) malloc (NBRSEQ * sizeof(SListe *)); // les tableau des toutes les Nseq  
    	seq[0]=NULL; 
    	Generer2seq(TableHash, SEUIL, &seq[0]); // ici on stocke les 2 seq qui seront elaguées par la suite 
    	printf("\nles listes des seq initiaux:\n----------------------------------\n"); 
    	printf("-----------------------------------------2seq\n");
        AfficherSListe(TableHash, seq[0]); 
    	// génération des Nseq 
 
    	for (i=0; i< NBRSEQ; i++){
    		seq[i+1]=GenererNseq(TableHash, SEUIL, &seq[i], &seq2); 
 
    		if (TailleSListe(seq[i+1]) == 0) // si on arrive plus a generer on sort de boucle 
    			break; 
    			printf("\n-----------------------------------------%dseq\n",i+3); 
 
    			AfficherSListe(TableHash, seq[i+1]); 
   				elagage(seq[i+1], &seq[i], SEUIL); 
    	} 
 
    	// boucle d'affichage des resultats 
    	for (j=0; j <= i; j++){ 
    		printf("\nla liste des %d seq elagues:\n----------------------------------\n",(j+2)); 
    		AfficherSListe(TableHash, seq[j]); 
    	} 
 
 
    	printf("\n\nvoila la liste des regles d'association\n----------------------------------\n"); 
    		F= fopen(PATH,"r"); 
    	//int n=nb_lignes(F); 
    	printf(">>le nombre ligne : %i\n\n",res);
    	for (j=0; j <= i; j++){ 
    		GenRA(seq[j], TableHash, res); 
    	} 
 
 printf ("%i\n", res);
    	scanf("%c",c); 
 
    	return 0; 
    }

enfin là, il m'affiche seulement le nombre de ligne du fichier qui est la premierer instruction, et apres le curseur clignote; c'est a dire ya pas de message d'erreur ou des exception

help svp

**étoile de mer** · 15/09/2008, 10h29

ah, voilà là il commence d'afficher des resultats, mais il plante(il ne continue pas ) :
voila le message :

projet1.exe a cessé de fonctionner ..;

help svp

**BainE** · 15/09/2008, 10h33

Salut,

tu peux filer une version compilable notamment "table_hash.h".

Mais ton probleme semble transpirer la corruption de memoire a plein nez.

**étoile de mer** · 15/09/2008, 10h40

ok , merci BainE,
mais je veux preciser que j'ai 4G de ram

voila le fichier main

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
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
    #include<stdio.h> 
    #include<stdlib.h> 
    #include<string.h> 
    #include<memory.h>
 
    #include "table_hash.h" 
    #define TAILLEHASH 307 
    #define IDLIMIT 1000
    #define NBRSEQ 10 
    #define SEUIL 2 
 
#define PATH "C:\\Users\\CYRINE\\Documents\\out.txt"
 
 
    //"C:\\essai1.txt"
 
    int main() 
 
    {   int valeur;
 
        int res = 0;
    	FILE *F=NULL; 
    	char mot[100]; 
    	int i,j; 
    	unsigned int cle,pt; 
    	int nl=1, pos=1; 
    	//nl=pos=1; 
    	int f; 
    	char c; 
    	//int seuil; 
    	//Liste **L; 
    	SListe *seq2=NULL; 
    	SListe **seq, *tmp; 
 
    	Liste **TableHash; 
    	TableHash = (Liste **) malloc (TAILLEHASH * sizeof(Liste *)); 
    	for(i=0;i<TAILLEHASH;++i) 
    		TableHash[i] = NULL; 
 
    	pt=hash_cle("."); 
    	//printf("%d",pt); 
    	//printf("Entrez votre valeur de support minimal"); 
        //scanf("%d", &valeur); 
 
    	printf("debut du programme \n----------------------------------\n");   
    	F=fopen(PATH,"r"); 
    	printf("Ouverture du Fichier \n----------------------------------\n");   
    	while(fscanf(F,"%s",mot)==1){ 
    		cle = hash_cle(mot); 
    		if ((cle!=pt ) && (! ChercherMotDansTableHash(TableHash,mot))) 
                TableHash[cle] = InsertionEnTete(TableHash[cle],mot,cle);
    		if(fgetc(F)==EOF)
    			break;
    	} 
    	fclose(F); 
    	printf ("nombre de lignes \n----------------------------------\n"); 
 
 
 
 
 
 
    		F = fopen (PATH, "r");
 
    F = fopen (PATH, "r");
   if (F != NULL)
   {
 
      char buffer[BUFSIZ];
      int nb_read;
 
      while ((nb_read = fread (buffer, 1, sizeof buffer, F)) > 0)
      {
         int i;
 
         for (i = 0; i < nb_read; i++)
         {
            if (buffer[i] == '\n')
            {
               res++;
            }
         }
      }
      fclose (F);
      printf ("%i\n", res);
   }
   else
   {
      perror (PATH);
   }
 
 
 
    	F=fopen(PATH,"r"); 
    	PosLigne(F,TableHash); 
 
    	//filtrage  
    	printf("\nla liste filtre :\n----------------------------------"); 
 
    	FiltreListe(TableHash,SEUIL); 
    	AfficherTableHash(TableHash); 
 
 
    	//géneration des 2seq 
        Generer2seq(TableHash, SEUIL, &seq2); // seq2 c pour stocker les 2seq     	
 
    	// les sequences  
    	seq =(SListe **) malloc (NBRSEQ * sizeof(SListe *)); // les tableau des toutes les Nseq  
    	seq[0]=NULL; 
    	Generer2seq(TableHash, SEUIL, &seq[0]); // ici on stocke les 2 seq qui seront elaguées par la suite 
    	printf("\nles listes des seq initiaux:\n----------------------------------\n"); 
    	printf("-----------------------------------------2seq\n");
        AfficherSListe(TableHash, seq[0]); 
    	// génération des Nseq 
 
    	for (i=0; i< NBRSEQ; i++){
    		seq[i+1]=GenererNseq(TableHash, SEUIL, &seq[i], &seq2); 
 
    		if (TailleSListe(seq[i+1]) == 0) // si on arrive plus a generer on sort de boucle 
    			break; 
    			printf("\n-----------------------------------------%dseq\n",i+3); 
 
    			AfficherSListe(TableHash, seq[i+1]); 
   				elagage(seq[i+1], &seq[i], SEUIL); 
    	} 
 
    	// boucle d'affichage des resultats 
    	for (j=0; j <= i; j++){ 
    		printf("\nla liste des %d seq elagues:\n----------------------------------\n",(j+2)); 
    		AfficherSListe(TableHash, seq[j]); 
    	} 
 
 
    	printf("\n\nvoila la liste des regles d'association\n----------------------------------\n"); 
    		F= fopen(PATH,"r"); 
    	//int n=nb_lignes(F); 
    	printf(">>le nombre ligne : %i\n\n",res);
    	for (j=0; j <= i; j++){ 
    		GenRA(seq[j], TableHash, res); 
    	} 
 
 printf ("%i\n", res);
    	scanf("%c",c); 
 
    	return 0; 
    } 
 
    void ParcourirElementTableHash(Liste **TableHash,char *mot){ 
    	int cle; 
    	Liste *p; 
    	cle = hash_cle(mot); 
 
    	for(p=TableHash[cle];p!=NULL;p=p->suivant) 
    		if(strcmp(mot,p->mot) == 0){ 
    			printf("%s : ",mot); 
    			AfficherCoordonnees(p->c); 
    		} 
    } 
 
    Liste *InsertionEnTete(Liste *L,char *mot, int cle){ 
        Liste *nouveau; 
    	nouveau = (Liste *) malloc (sizeof(Liste)); 
    	if (L == NULL){ 
              nouveau->ID =1*IDLIMIT+cle;
              }else {
                  nouveau->ID = L->ID + IDLIMIT;
                  }
    	nouveau->freq=0; 
    	strcpy(nouveau->mot,mot);
    	nouveau->suivant = L; 
    	nouveau->c = NULL; 
    	return nouveau; 
    } 
 
    SListe *InsertionEnTeteS(SListe *L, int id, int succ){ 
        SListe *nouveau; 
    	nouveau = (SListe *) malloc (sizeof(SListe)); 
    	nouveau->freq=0; 
    	nouveau->m=NULL; 
    	nouveau->m=InsertionEnTeteMot(nouveau->m,id,succ); 
    	nouveau->suivant = L; 
    	nouveau->c = NULL; 
    	return nouveau; 
    } 
 
    Coordonnees *InsertionEnTeteCoordonnee(Coordonnees *C,int nl ,int pos){ 
    	Coordonnees *nouveau; 
    	nouveau = (Coordonnees *) malloc (sizeof(Coordonnees)); 
    	nouveau->pos = pos; 
    	nouveau->nl = nl; 
    	nouveau->suivant = C; 
    	return nouveau; 
    } 
 
    mots *InsertionEnTeteMot(mots *m,int id,int succ){ 
    	mots *nouveau; 
    	nouveau = (mots *) malloc (sizeof(mots)); 
    	nouveau->ID=id; 
    	nouveau->successif=succ;
    	nouveau->suivant = m; 
 
    	return nouveau; 
    }
 
 
    void AfficherListe(Liste *L){ 
    	Liste *p; 
    	for(p=L;p!=NULL;p=p->suivant){ 
    		printf("%s \n",p->mot); 
    		printf("%d : ",p->freq); 
    		AfficherCoordonnees(p->c); 
    	} 
    } 
 
    int TailleSListe(SListe *L){ 
    	SListe *p; 
    	int t=0;
    	for(p=L;p!=NULL;p=p->suivant){ 
    		t++;
    	} 
    	return t;
    } 
 
 
    void AfficherSListe(Liste **TableHash,SListe *L){ 
    	SListe *p; 
    	for(p=L;p!=NULL;p=p->suivant){ 
    		AfficheSeqMot(TableHash, p->m); 
    		printf("%d : ",p->freq); 
    		AfficherCoordonnees(p->c); 
    	} 
    } 
 
    void AfficherCoordonnees(Coordonnees *C){ 
    	Coordonnees *p; 
    	for(p=C;p!=NULL;p=p->suivant) 
    		printf(" (%d,%d) ",p->nl,p->pos); 
    	printf("\n"); 
    } 
 
    unsigned int exiteCoordonnees(Coordonnees *C, int ligne){ 
    	Coordonnees *p; 
    	for(p=C;p!=NULL;p=p->suivant) 
    		if (p->nl == ligne)
               return 1; 
        return 0;
    } 
 
 
     int ContientSeqMots(mots *m1,mots *m2){ 
    	if (m2==NULL) 
    	return 1;
    	else {
             if (m1 == NULL)
             return 0;
             if (m1->ID == m2->ID) 
                  return ContientSeqMots(m1->suivant,m2->suivant);
             else
                  return ContientSeqMots(m1->suivant,m2);
 
             }
 
    } 
 
 
    void AfficheSeqMot(Liste **TableHash, mots *m){ 
    	mots *p; 
    	for(p=m;p!=NULL;p=p->suivant) {
    		AfficheMot(TableHash,p->ID) ;
    		if (p->successif == 1)
               printf("_");
            else
               printf(" ");
        }
    	printf("\n"); 
    } 
 
    void AfficheMot(Liste **TableHash,int id){ 
    	int cle=id % IDLIMIT;
    	Liste *p;
        //Liste *l=TableHash[cle]
 
    	for(p=TableHash[cle];p!=NULL;p=p->suivant) 
    		if (p->ID == id){
              printf("%s",p->mot); 
              break;
              } 
    }
 
    Liste *getMot(Liste **TableHash,int id){ 
    	int cle=id % IDLIMIT;
    	Liste *p;
        //Liste *l=TableHash[cle]
 
    	for(p=TableHash[cle];p!=NULL;p=p->suivant) 
    		if (p->ID == id){
              return p; 
              } 
 
      return NULL;
    }  
 
    int dernierMot(SListe *p){ 
    	mots *m; 
    	int s; 
    	for(m=p->m;m!=NULL;m=m->suivant) 
    		s=m->ID; 
    	return s; 
    } 
 
 
    unsigned int hash_cle(char *mot){ 
    	unsigned int val = 0; 
    	for(;*mot!='\0';++mot) 
    		val = *mot + 31 * val; 
    	return val % TAILLEHASH; 
    } 
 
    void AfficherTableHash(Liste **TableHash){ 
    	int i; 
    	for(i=0;i<TAILLEHASH;++i) 
    		if(TableHash[i] != NULL){ 
    			printf("\n----------------------------Conteneur %d \n",i); 
    			AfficherListe(TableHash[i]); 
    			printf(""); 
    		} 
    } 
 
    unsigned int ChercherMotDansTableHash(Liste **TableHash,char *mot){ 
 
    	Liste *p; 
    	unsigned int cle; 
 
    	cle = hash_cle(mot); 
    	for(p=TableHash[cle];p!=NULL;p=p->suivant) 
    		if(strcmp(p->mot,mot)==0) 
    			return 1; 
    		return 0; 
    } 
 
    void FiltreListe(Liste **TableHash, int seuil) 
    {  
    	Liste *p ,*last;  
    	Coordonnees *c=NULL;  
    	int i,supp=0,nb=0;  
    	for(i=0;i<TAILLEHASH;++i)  
    		if(TableHash[i] != NULL) 
    		{  
    			nb=0;  
    			last=TableHash[i];  
    			for(p=TableHash[i];p!=NULL;p=p->suivant) 
    			{  
    				supp=0;  
    				nb++;  
    				if(p->freq < seuil) 
    				{ // mot n'est pas frequent  
    					if (last==p) // cas du première mot  
    					{  
    						TableHash[i]=p->suivant;  
    						last=p->suivant;  
    					}  
    					else  
    						last->suivant=p->suivant;  
    					nb--;  
    				} 
    				else  
    					last=p;  
    			}  
    			if (nb==0)  
    				TableHash[i] = NULL;  
    		}  
    } 
 
 void Generer2seq(Liste **TableHash, int seuil, SListe **seq){ 
 
    	Liste *p1, *p2, *t;
        SListe *ss; 
    	int maxPosC1; 
    	int maxPosC2;  
    	Coordonnees *c1,*c2, *c; 
    	int i,j,supp1=0,supp2=0,sms1=0,sms2=0,nb=0; 
    	char s1[50], s2[50],*t1,*t2; 
    	ss=*seq; 
    	// printf("\nconstruction des 2seq \n---------------\n"); 
    	for(i=0;i<TAILLEHASH;++i) 
    		if(TableHash[i] != NULL) 
    			for(p1=TableHash[i];p1!=NULL;p1=p1->suivant) 
    				for(j=i;j<TAILLEHASH;++j) 
    					if(TableHash[j] != NULL){ 
    						if (j==i) 
    							t=p1; 
    						else 
    							t=TableHash[j]; 
    						for(p2=t;p2!=NULL;p2=p2->suivant){ 
 
 
                           if (p1->ID != p2->ID){   // si 2 mots differents trouvés
                            SListe *tmp1=NULL, *tmp2=NULL , *succ1=NULL, *succ2=NULL;
                            tmp1=InsertionEnTeteS(tmp1,p1->ID,0);
                            tmp2=InsertionEnTeteS(tmp2,p2->ID,0);
                            tmp1->m=InsertionEnTeteMot(tmp1->m,p2->ID,0);
                            tmp2->m=InsertionEnTeteMot(tmp2->m,p1->ID,0);  
 
                            succ1=InsertionEnTeteS(succ1,p1->ID,0);
                            succ2=InsertionEnTeteS(succ2,p2->ID,0);
                            succ1->m=InsertionEnTeteMot(succ1->m,p2->ID,1);
                            succ2->m=InsertionEnTeteMot(succ2->m,p1->ID,1);                       
                              //  printf("creation TMP1 et TMP2 : %s ,%s\n",s1,s2);
                                supp1=0;supp2=0;sms1=0;sms2=0;
                                for(c1=p1->c;c1!=NULL;c1=c1->suivant)  // calcule de supp
                                 for(c2=p2->c;c2!=NULL;c2=c2->suivant){
                                   if (c1->nl == c2->nl){
                                     if(c1->pos > c2->pos){
                                         if ( c1->pos == c2->pos +1 ){
                                            succ1->c=InsertionEnTeteCoordonnee(succ1->c,c1->nl ,c1->pos);    
                                            sms1++;
                                            }else  
                                         if (!exiteCoordonnees(tmp1->c,c1->nl)) {
                                            tmp1->c=InsertionEnTeteCoordonnee(tmp1->c,c1->nl ,c1->pos);    
                                            supp1++;
                                            }
                                         }
                                     else{
                                         if ( c2->pos == c1->pos +1 ){
                                            succ2->c=InsertionEnTeteCoordonnee(succ2->c,c1->nl ,c2->pos);    
                                            sms2++;
                                            }else  
                                         if (!exiteCoordonnees(tmp2->c,c1->nl)) {
                                             tmp2->c=InsertionEnTeteCoordonnee(tmp2->c,c1->nl ,c2->pos);
                                             supp2++;
                                             }   
                                         }
                                     }
                                 }   
                                        if(sms1 >=seuil){ 
 
    										succ1->freq=sms1; 
    										if (*seq==NULL) 
    											*seq=succ1; 
    										else   
    											ss->suivant=succ1; 
    										ss=succ1; 
    									}else {
    									    supp1 += sms1;
    									    for(c=succ1->c;c!=NULL;c=c->suivant)
    									      tmp1->c=InsertionEnTeteCoordonnee(tmp1->c,c->nl ,c->pos);  
                                         }
    									if(sms2 >=seuil){ 
 
    										succ2->freq=sms2; 
    										if (*seq==NULL) 
    											*seq=succ2; 
    										else   
    											ss->suivant=succ2; 
    										ss=succ2; 
    									} else { // sms2 < seuil
    									    supp2 += sms2;
    									    for(c=succ2->c;c!=NULL;c=c->suivant)
    									      tmp2->c=InsertionEnTeteCoordonnee(tmp2->c,c->nl ,c->pos);  
                                         }
 
    									if(supp1 >=seuil){ 
 
    										tmp1->freq=supp1; 
    										if (*seq==NULL) 
    											*seq=tmp1; 
    										else   
    											ss->suivant=tmp1; 
    										ss=tmp1; 
 
    									} 
    									if(supp2 >=seuil){ 
    										//printf("%d ",supp2); 
    										tmp2->freq=supp2; 
    										if (*seq==NULL) 
    											*seq=tmp2; 
    										else   
    											ss->suivant=tmp2; 
    										ss=tmp2; 
    									} 
 
 
    							}  
    						} 
 
    					} 
    		Verifier1(seq);
 
    } 
 
    int MaxPos(Liste **TableHash,char mot[50],int ligne) {   /* int MaxPos(Liste**,char[50],int)  * Retour la position Maximale d'un Mot dans une Ligne */  
    	Liste *p1;  
    	int i=0;   
    	int maxPos=-1; 
    	Coordonnees *c; 
    	for(i=0;i<TAILLEHASH;i++)   
 
    		if(TableHash[i]!=NULL)   
    			for(p1=TableHash[i];p1!=NULL;p1=p1->suivant)         
    				if(strcmp(p1->mot,mot)==0)            
    					for(c=p1->c;c!=NULL;c=c->suivant)              
    						if(c->nl==ligne)                
    							if(c->pos > maxPos)                  
    								maxPos = c->pos;    
    	return maxPos; 
    } 
 
 
    SListe * GenererNseq(Liste **TableHash, int seuil,SListe **s, SListe **seq){ 
 
    	SListe *p1, *p2, *ss, *t=NULL; 
    	Coordonnees *c1,*c2,*c=NULL; 
    	int i,j, id1, id2,supp1=0,ok=0,nb=1; 
    	char *s1, *s2,*t1,*t2; 
    	mots *m, *mt; 
        ss=*seq; 
 
    	for(p1=*s;p1!=NULL;p1=p1->suivant){ 
    		//  printf("boucle1"); 
    		id1=dernierMot(p1);  
    		for(p2=*seq;p2!=NULL;p2=p2->suivant){ 
    			        // printf("boucle2"); 
    			supp1=0; 
    			c=NULL; 
    			m=p2->m; 
    			id2=m->ID;           
    			if (id1 == id2){                                   
    				for(c1=p1->c;c1!=NULL;c1=c1->suivant) 
    					for(c2=p2->c;c2!=NULL;c2=c2->suivant){               
    						if (c1->nl==c2->nl){   // si 2 mots differents trouvés 
    							c=InsertionEnTeteCoordonnee(c,c2->nl,c2->pos); 
    							supp1++; 
    						} 
    					}  // fin calcul supp 
    					if(supp1 >= seuil){ 
    						mt=NULL;                             
    						for(m=p1->m;m->suivant!=NULL;m=m->suivant) 
    							mt=InsertionEnTeteMot(mt,m->ID,m->successif); 
    						for(m=p2->m;m->suivant!=NULL;m=m->suivant) 
    							mt=InsertionEnTeteMot(mt,m->ID,m->successif); 
 
    						t=InsertionEnTeteS(t,dernierMot(p2),0); 
    						for(m=mt;m!=NULL;m=m->suivant) 
    							t->m=InsertionEnTeteMot(t->m,m->ID,m->successif);  
    						t->c=c; 
    						t->freq=supp1; 
    					} 
    			} 
    		} 
        } 
       Verifier(t);
    	return t;   
    } 
 
 
 
    void elagage(SListe *t, SListe **s,int seuil){ 
    	SListe *p1, *p2,*ss; 
    	int s1, s2; 
    	for(p1=t;p1!=NULL;p1=p1->suivant){ 
    		ss=*s; 
    		s1=dernierMot(p1); 
 
    		for(p2=*s;p2!=NULL;p2=p2->suivant){ 
    			s2=dernierMot(p2); 
 
    			 if ( ( (ContientSeqMots(p1->m, p2->m )==1) && (s1==s2)) && (p1->freq == p2->freq) ){ // ){
                                           //&& s1==s2 && p1->freq == p2->freq && p1->c->nl == p2->c->nl && p1->c->pos == p2->c->pos)
                    	// p2->freq -= p1->freq ;
                    	// if (p2->freq < seuil){
    				  //  printf("%i", p1->c->nl);
                        //  printf("%i", p2->c->nl);                
    				if(ss==p2){ // premier element 
 
    					ss=p2->suivant; 
    					*s=p2->suivant; 
    				} 
    				else 
    					ss->suivant=p2->suivant; 
 
 
    			}else           
    				ss=p2; 
 
    		} 
 
    	}  
    } 
 
      /* void elagage(SListe *t, SListe **s){ 
    	SListe *p1, *p2,*ss; 
    	int s1, s2; 
    	for(p1=t;p1!=NULL;p1=p1->suivant){ 
    		ss=*s; 
    		s1=dernierMot(p1); 
    		for(p2=*s;p2!=NULL;p2=p2->suivant){ 
    			s2=dernierMot(p2); 
    			
    			if (ContientSeqMots(p1->m, p2->m )==1 &&s1==s2 && p1->freq==p2->freq && p1->c->nl == p2->c->nl && p1->c->pos == p2->c->pos){ // && (p1->freq >= p2->freq)){
                   
                    
    				//     printf("%s %s",s1,s2);                 
    				if(ss==p2){ // premier element 
    					ss=p2->suivant; 
    					*s=p2->suivant; 
    				} 
    				else 
    					ss->suivant=p2->suivant; 
                    
    			}else           
    				ss=p2; 
    		} 
    		
    	}  
}
    
     */
    void PosLigne(FILE *F,Liste **TableHash)  
    {   
    	char s[50];   
    	int nl,pos,i;   
    	Liste *p;   
    	Coordonnees *c;   
    	int trouve =0;   
    	nl=pos=1;   
    	for(i=0;i<TAILLEHASH;++i)   
    		if(TableHash[i]!=NULL)   
    			for(p=TableHash[i];p!=NULL;p=p->suivant)   
    				p->freq=0; 
    			while(fscanf(F,"%s",s)==1)  
    			{   
    				for(i=0;i<TAILLEHASH;++i)   
    				{  
    					if(TableHash[i]!=NULL)   
    					{  
    						for(p=TableHash[i];p!=NULL;p=p->suivant)   
    						{  
    							Coordonnees *x;//ou Coordonnees x; sans le *  
    							if(strcmp(p->mot,s)==0)   
    							{    
    								/*Avant l'insertion*/   
    								trouve=0; 
    								for(x=p->c;x!=NULL;x=x->suivant)   
    									if(x->nl == nl) //même ligne   
    										trouve=1;   
    									if(trouve==0)   
    										p->freq=p->freq+1;    
    									p->c=InsertionEnTeteCoordonnee(p->c,nl ,pos);    
    							}   
    						}   
    					}  
    				}  
    				/*ici :p*/  
    				if(fgetc(F)=='\n')  
    				{   
    					++nl; // ou nl++; ça change rien  
    					pos=0;   
    				}   
    				++pos;//pareil ou pos++; ça change rien non plus  
    			}  
    } 
 
 
 
 
 
 
 
 
 
 
   void GenRA(SListe * l, Liste **TableHash, int n) 
    { 
    	SListe *q;    
    	float support; 
    	float confiance; 
    	char *motSucc, *t1;
 
    	for(q=l;q!=NULL;q=q->suivant)    
    	{    
    		mots *m;   
            motSucc=strcpy(motSucc,""); 
    		for(m=q->m;m!=NULL && m->suivant!=NULL;m=m->suivant) 
    		{ 
                Liste *t=getMot(TableHash,m->ID);
                t1=strcat(motSucc,t->mot);
                if (m->successif == 1) {
 
                        t1=strcat(motSucc,"_");
                }
                else
                {               
        			mots *s;  
       			    t1=strcat(motSucc," ");
                    printf("%s",motSucc);   
                    printf("-> ",t->mot);//a->
 
 
 
 
 
                    // comment la ligne suivante et t'aura l'affiches des regles du forme a b c -> d
        			 motSucc=strcpy(motSucc,""); 
        			//////////////////////////////////
 
 
        			for(s=m->suivant;s!=NULL;s=s->suivant)    
        			{ 
        				AfficheMot(TableHash,s->ID); //b après c 
                        printf(" ");
 
 
        			} 
 
        			printf("\n\tfrequence %i", q->freq); 
        			support=(float)(q->freq)/(float)(n);     //ça serait pas n+1 le nbre ligne 
        			confiance =(float)(support)/(float)((float)(t->freq)/(float)(n)); 
        			printf(" / %i ",t->freq); 
        			printf("\tsupport : %f\n", support); 
        			printf("\tConfiance : %f\n",  confiance ); 
 
            }
    		}  
    	} 
    	//printf("%i", n+1); 
    } 
 
 
    /*
    
    int calculFrequence(Liste **TableHash, char mot[50]){ 
    	
    	Liste *p ; 
    	int cle; 
    	Coordonnees *c; 
    	int currentLine=-1; 
    	int i,supp=0; 
    	cle=hash_cle(mot); 
    	for(p=TableHash[cle]; p!=NULL; p=p->suivant) 
        { 
    		if(strcmp(p->m->mot, mot)==0){ 
    			c=p->c;       
    			
    			for(c=p->c;c!=NULL;c=c->suivant) 
    				if (c->nl != currentLine) 
    				{ 
    					currentLine = c->nl; 
    					supp++; 
    				} 
    		} 
    	} 
    	
    	return supp; 
    	
    } 
    
    void Verifier(Liste **L) 
    { 
    	Liste *l; 
    	l=*L; 
    	for(l=*L;l!=NULL;l=l->suivant) 
    	{ 
    		Coordonnees *c; 
    		int line=-1; 
    		int freq=0; 
    		for(c=l->c;c!=NULL;c=c->suivant) 
    			if(line!=c->nl) 
    			{ 
    				freq++; 
    				line=c->nl; 
    			} 
    			l->freq=freq; 
    	} 
    } 
    
    
    //*/
    void Verifier(SListe *L) 
{ 
	SListe *l; 
	l=L; 
	for(l=L;l!=NULL;l=l->suivant) 
	{ 
		Coordonnees *c; 
		int line=-1; 
		int freq=0; 
		for(c=l->c;c!=NULL;c=c->suivant) 
			if(line!=c->nl) 
			{ 
				freq++; 
				line=c->nl; 
			} 
			l->freq=freq; 
	} 
 
} 
 void Verifier1(SListe **L) 
    { 
    	SListe *l; 
    	l=*L; 
    	for(l=*L;l!=NULL;l=l->suivant) 
    	{ 
    		Coordonnees *c; 
    		int line=-1; 
    		int freq=0; 
    		for(c=l->c;c!=NULL;c=c->suivant) 
    			if(line!=c->nl) 
    			{ 
    				freq++; 
    				line=c->nl; 
    			} 
    			l->freq=freq; 
    	} 
    }

et là le tablehach.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
#ifndef TABLE_HASH 
#define TABLE_HASH 
 
typedef struct c{ 
	int pos; 
	int nl; 
	struct c *suivant; 
}Coordonnees; 
 
typedef struct L{    
    int ID; 
    int freq; 
	char mot[50]; 
	Coordonnees *c; 
	struct L *suivant; 
}Liste; 
 
typedef struct m{ 
    int ID; 
    int successif;
	struct m *suivant; 
}mots; 
 
typedef struct L2{    
    int freq; 
	mots *m; 
	Coordonnees *c; 
	struct L2 *suivant; 
}SListe; 
 
int nb_lignes (FILE *fp) 
{ 
  int n=0; 
  char c; 
 
  while ((c = fgetc(fp)) != EOF) 
  { 
    if (c == '\n') 
    { 
      n++; 
    } 
  } 
  return n; 
} 
 
 
 
Liste *InsertionEnTete(Liste *L,char *mot, int cle); 
SListe *InsertionEnTeteS(SListe *L, int id, int succ); // construit la liste des seq
Coordonnees *InsertionEnTeteCoordonnee(Coordonnees *C,int nl,int pos); 
mots *InsertionEnTeteMot(mots *m,int id, int succ); 
void AfficherListe(Liste *L); 
void AfficherSListe(Liste **TableHash,SListe *L); // affiche la liste des seq
int TailleSListe(SListe *L);
void AfficherCoordonnees(Coordonnees *C); 
unsigned int exiteCoordonnees(Coordonnees *C, int ligne); 
void AfficheMot(Liste ** TableHash,int id); 
Liste *getMot(Liste **TableHash,int id);
void AfficheSeqMot(Liste **TableHash, mots *m); // affiche les sequences des mots
int ContientSeqMots(mots *m1,mots *m2);
int dernierMot(SListe *p); 
unsigned int hash_cle(char *mot); 
void AfficherTableHash(Liste **TableHash); 
unsigned int ChercherMotDansTableHash(Liste **TableHash,char *mot); 
void PosLigne(FILE *F,Liste **TableHash); 
void ParcourirElementTableHash(Liste **TableHash,char *mot); 
void FiltreListe(Liste **L, int seuil); 
void Generer2seq(Liste **TableHash, int seuil, SListe **seq); 
SListe * GenererNseq(Liste **TableHash, int seuil,SListe **se, SListe **seq); 
void GenRA(SListe * l, Liste **TableHash, int n); 
void elagage(SListe *t, SListe **s, int seuil); 
//void elagage(SListe *t, SListe **s); 
void Verifier(SListe *L) ;
 void Verifier1(SListe **L);
 
 
#endif

merci

**KindPlayer** · 15/09/2008, 10h55

ahhhhhhhh t'as vu la taille du code à regarder

on cherche un peu une aiguille dans une botte de foin. As tu fais quelques tests unitaires? De quelles fonctions es tu sure? Quelle(s) est (sont) celle(s) qui semble(nt) poser problème?

**étoile de mer** · 15/09/2008, 10h59

Envoyé par KindPlayer

ahhhhhhhh t'as vu la taille du code à regarder

on cherche un peu une aiguille dans une botte de foin. As tu fais quelques tests unitaires? De quelles fonctions es tu sure? Quelle(s) est (sont) celle(s) qui semble(nt) poser problème?

merci KindPlayer, mais moi j'ai testé mon code sur un fichier d'une dizaine de ligne et ca fonctionne nikel, le probleme c'est dans la taille du fichier je pense.

je sais pas quoi faire , je suis perdue

**ram-0000** · 15/09/2008, 11h09

Je viens de mettre ton code dans mon compilateur et voici le flot de warning qu'il me sort à la compilation :

1>test.cpp(105) : warning C4101: 'valeur' : variable locale non référencée
1>test.cpp(114) : warning C4101: 'f' : variable locale non référencée
1>test.cpp(119) : warning C4101: 'tmp' : variable locale non référencée
1>test.cpp(468) : warning C4101: 't2' : variable locale non référencée
1>test.cpp(464) : warning C4101: 'maxPosC1' : variable locale non référencée
1>test.cpp(468) : warning C4101: 's2' : variable locale non référencée
1>test.cpp(468) : warning C4101: 's1' : variable locale non référencée
1>test.cpp(468) : warning C4101: 't1' : variable locale non référencée
1>test.cpp(465) : warning C4101: 'maxPosC2' : variable locale non référencée
1>test.cpp(599) : warning C4101: 'i' : variable locale non référencée
1>test.cpp(600) : warning C4101: 't2' : variable locale non référencée
1>test.cpp(600) : warning C4101: 's2' : variable locale non référencée
1>test.cpp(600) : warning C4101: 's1' : variable locale non référencée
1>test.cpp(600) : warning C4101: 't1' : variable locale non référencée
1>test.cpp(599) : warning C4101: 'j' : variable locale non référencée
1>test.cpp(229) : warning C4700: variable locale 'c' non initialisée utilisée
1>test.cpp(768) : warning C4700: variable locale 'motSucc' non initialisée utilisée

Les 1er warning ne sont pas grave (même si cela ne fait pas très pro). Ce sont des variables locales non utilisées qui peuvent être supprimées

Les 2 derniers warning me semblent les plus graves, ils signifient qu'une variable est utilisée avant d'être initialisée d'où un comportement imprévisible.

Au fait, une petite question, c'est quoi le but de ton programme ?

**étoile de mer** · 15/09/2008, 11h19

merci ram000,
mais apparememnt la cause du plantag du programe c'est autre chose à part ces 2erreurs , car il continue pas à afficher la table de hachage.
j'ai mis un mesage juste apres l'affichage de la table de hachage, il n'apparait pas !!
bizarre
merci

en fait au premier je lits le fiichier texte, il stocke tous les mots du texte dans une table de hachage avec leurs coordonnées (numero ligne, position dans la ligne).
puis il filtre les mots selon leurs frequence dans le texte, il supprime les mots qui ont un frequence < seuil fixé.,,,,,

**BainE** · 15/09/2008, 11h34

Re,

que ca "fonctionneotte" sur 10 lignes ne veut pas dire que ca tourne qu poil, mais vu le probleme, je dirai plutot que le debordement memoire n est visible qu a partir d une certaine taille.

faudrait qu on puisse voir les fonction de manipulation de listes (table_hash.c peut etre ?), histoire de compiler le tout.

Par contre faut corriger tous ces warnings.

**étoile de mer** · 15/09/2008, 11h37

merci BainE,
c'est seulement ces 2 fichier que jai posté cidessus.
ca me fait plaisir de m'aider .
merci

**étoile de mer** · 15/09/2008, 11h47

Bon, là j'en sur d'une chose; c'est que le programme reussi à lire tout le fichier et à mettre les mots dans la table de hachage et à aafficher cette derniere.
donc il seplante dans la fonction de filtrage.
Donc au boulot

**étoile de mer** · 15/09/2008, 12h08

ca plante ici au niveau de cette ligne.

Code :

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

Generer2seq(TableHash, SEUIL, &seq2); // seq2 c pour stocker les 2seq

je pense qu'il a expiré toute la memoire car apres l'affichage de la table de hachage , il reste du temps pour aqu'apres il affiche le message : projet a cessé de fonctionner...
help svp

**ram-0000** · 15/09/2008, 12h15

Il est gros ton fichier "C:\\Users\\CYRINE\\Documents\\out.txt", tu peux le mettre en attachement afin de tester ?

Quelques remarques concernant ton code :

le fichier est ouvert 5 fois en lecture et fermé 2 fois. Outre le fait qu'il manque des fclose(), ce fichier ne devrait être ouvert qu'une seule fois et tout le traitement doit être fait durant la lecture.
Le résultat du fopen() n'est testé qu'une seule fois. C'est probablenent correct dans ton environnement de test mais tester les ouvertures permet de rendre le code plus robuste et permet de ne pas exécuter certaiunes portiens de code si le fichier ne peut être ouvert.
l'indentation de test fonction est trop profonde. J'ai compté jusqu'à un niveau de 8, c'est beaucoup trop pour permettre une compréhension aisée (d'autant plus qu'il n'y a pas beaucoup de commentaires.

Il faut mettre des blocs { } explicites même si cela n'est pas utile, cela aidera à la lecture

Code :

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

1
2
3
4
5
6
7
8
9
10
for(m=p1->m;m->suivant!=NULL;m=m->suivant) 
mt=InsertionEnTeteMot(mt,m->ID,m->successif);
 
doit être remplacé par :
 
for(m=p1->m;m->suivant!=NULL;m=m->suivant) 
{
   mt=InsertionEnTeteMot(mt,m->ID,m->successif);
}
par exemple, c'est plus lisible

Tu as un bugs si les mots que tu lis dans ton fichier font plus de 100 caractères

**étoile de mer** · 15/09/2008, 12h51

MERCI RAM000
le programme plante dans une fonction qui utilise des données deja stockées dans une table de hachage, donc je pense à ce niveau ya pa un probleme au niveau du fichier texte non?

**ram-0000** · 15/09/2008, 12h54

Envoyé par cyrine

MERCI RAM000
le programme plante dans une fonction qui utilise des données deja stockées dans une table de hachage, donc je pense à ce niveau ya pa un probleme au niveau du fichier texte non?

Je ne sais pas, donne un fichier de test qui reproduit le problème (même si ce n'est pas le vrai fichier pour des causes de confidentialité). Tant que l'on a pas la structure de ton fichier, on parle dans le vide.

**Emmanuel Delahaye** · 15/09/2008, 13h30

Envoyé par cyrine

ok , merci BainE,
mais je veux preciser que j'ai 4G de ram

voila le fichier main

Pour le moment, j'ai tout regroupé en un fichier, supprimmer le code non utilise et les variables inutiles et il reste ceci à corriger d'urgence avant de fire quoi que ce soit :

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
 
 
-------------- Build: Debug in hello ---------------
 
[ 50.0%] Compiling: main.c
[100.0%] Linking console executable: bin\Debug\hello.exe
C:\dev\hello\main.c: In function `dernierMot':
C:\dev\hello\main.c:487: warning: 's' might be used uninitialized in this function
C:\dev\hello\main.c: At top level:
C:\dev\hello\main.c:597: warning: unused parameter 'seuil'
C:\dev\hello\main.c: In function `GenRA':
C:\dev\hello\main.c:660: warning: 'motSucc' might be used uninitialized in this function
Output size is 36.76 KB
Process terminated with status 0 (0 minutes, 1 seconds)
0 errors, 3 warnings

Le code :

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
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
 
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<memory.h>
 
#define TAILLEHASH 307
#define IDLIMIT 1000
#define NBRSEQ 10
#define SEUIL 2
 
#if 0
#define PATH "C:\\Users\\CYRINE\\Documents\\out.txt"
#else
#define PATH "out.txt"
#endif
 
typedef struct c
{
   int pos;
   int nl;
   struct c *suivant;
}
Coordonnees;
 
typedef struct L
{
   int ID;
   int freq;
   char mot[50];
   Coordonnees *c;
   struct L *suivant;
}
Liste;
 
typedef struct m
{
   int ID;
   int successif;
   struct m *suivant;
}
mots;
 
typedef struct L2
{
   int freq;
   mots *m;
   Coordonnees *c;
   struct L2 *suivant;
}
SListe;
 
int nb_lignes (FILE * fp)
{
   int n = 0;
   char c;
 
   while ((c = fgetc (fp)) != EOF)
   {
      if (c == '\n')
      {
         n++;
      }
   }
   return n;
}
 
mots *InsertionEnTeteMot (mots * m, int id, int succ)
{
   mots *nouveau;
   nouveau = (mots *) malloc (sizeof (mots));
   nouveau->ID = id;
   nouveau->successif = succ;
   nouveau->suivant = m;
 
   return nouveau;
}
 
SListe *InsertionEnTeteS (SListe * L, int id, int succ)
{
   SListe *nouveau;
   nouveau = (SListe *) malloc (sizeof (SListe));
   nouveau->freq = 0;
   nouveau->m = NULL;
   nouveau->m = InsertionEnTeteMot (nouveau->m, id, succ);
   nouveau->suivant = L;
   nouveau->c = NULL;
   return nouveau;
}
 
Coordonnees *InsertionEnTeteCoordonnee (Coordonnees * C, int nl, int pos)
{
   Coordonnees *nouveau;
   nouveau = (Coordonnees *) malloc (sizeof (Coordonnees));
   nouveau->pos = pos;
   nouveau->nl = nl;
   nouveau->suivant = C;
   return nouveau;
}
 
unsigned int exiteCoordonnees (Coordonnees * C, int ligne)
{
   Coordonnees *p;
   for (p = C; p != NULL; p = p->suivant)
      if (p->nl == ligne)
         return 1;
   return 0;
}
 
void Verifier1 (SListe ** L)
{
   SListe *l;
   l = *L;
   for (l = *L; l != NULL; l = l->suivant)
   {
      Coordonnees *c;
      int line = -1;
      int freq = 0;
      for (c = l->c; c != NULL; c = c->suivant)
         if (line != c->nl)
         {
            freq++;
            line = c->nl;
         }
      l->freq = freq;
   }
}
 
void Generer2seq (Liste ** TableHash, int seuil, SListe ** seq)
{
 
   Liste *p1, *p2, *t;
   SListe *ss;
   Coordonnees *c1, *c2, *c;
   int i, j, supp1 = 0, supp2 = 0, sms1 = 0, sms2 = 0;
   ss = *seq;
/* printf("\nconstruction des 2seq \n---------------\n"); */
 
   for (i = 0; i < TAILLEHASH; ++i)
      if (TableHash[i] != NULL)
         for (p1 = TableHash[i]; p1 != NULL; p1 = p1->suivant)
            for (j = i; j < TAILLEHASH; ++j)
               if (TableHash[j] != NULL)
               {
                  if (j == i)
                     t = p1;
                  else
                     t = TableHash[j];
                  for (p2 = t; p2 != NULL; p2 = p2->suivant)
                  {
 
                     if (p1->ID != p2->ID)
/* si 2 mots differents trouvés */
                     {
                        SListe *tmp1 = NULL, *tmp2 = NULL, *succ1 =
                           NULL, *succ2 = NULL;
                        tmp1 = InsertionEnTeteS (tmp1, p1->ID, 0);
                        tmp2 = InsertionEnTeteS (tmp2, p2->ID, 0);
                        tmp1->m = InsertionEnTeteMot (tmp1->m, p2->ID, 0);
                        tmp2->m = InsertionEnTeteMot (tmp2->m, p1->ID, 0);
 
                        succ1 = InsertionEnTeteS (succ1, p1->ID, 0);
                        succ2 = InsertionEnTeteS (succ2, p2->ID, 0);
                        succ1->m = InsertionEnTeteMot (succ1->m, p2->ID, 1);
                        succ2->m = InsertionEnTeteMot (succ2->m, p1->ID, 1);
/* printf("creation TMP1 et TMP2 : %s ,%s\n",s1,s2); */
 
                        supp1 = 0;
                        supp2 = 0;
                        sms1 = 0;
                        sms2 = 0;
/* calcule de supp */
                        for (c1 = p1->c; c1 != NULL; c1 = c1->suivant)
                           for (c2 = p2->c; c2 != NULL; c2 = c2->suivant)
                           {
                              if (c1->nl == c2->nl)
                              {
                                 if (c1->pos > c2->pos)
                                 {
                                    if (c1->pos == c2->pos + 1)
                                    {
                                       succ1->c =
                                          InsertionEnTeteCoordonnee (succ1->c,
                                                                     c1->nl,
                                                                     c1->pos);
                                       sms1++;
                                    }
                                    else
                                       if (!exiteCoordonnees
                                           (tmp1->c, c1->nl))
                                    {
                                       tmp1->c =
                                          InsertionEnTeteCoordonnee (tmp1->c,
                                                                     c1->nl,
                                                                     c1->pos);
                                       supp1++;
                                    }
                                 }
                                 else
                                 {
                                    if (c2->pos == c1->pos + 1)
                                    {
                                       succ2->c =
                                          InsertionEnTeteCoordonnee (succ2->c,
                                                                     c1->nl,
                                                                     c2->pos);
                                       sms2++;
                                    }
                                    else
                                       if (!exiteCoordonnees
                                           (tmp2->c, c1->nl))
                                    {
                                       tmp2->c =
                                          InsertionEnTeteCoordonnee (tmp2->c,
                                                                     c1->nl,
                                                                     c2->pos);
                                       supp2++;
                                    }
                                 }
                              }
                           }
                        if (sms1 >= seuil)
                        {
 
                           succ1->freq = sms1;
                           if (*seq == NULL)
                              *seq = succ1;
                           else
                              ss->suivant = succ1;
                           ss = succ1;
                        }
                        else
                        {
                           supp1 += sms1;
                           for (c = succ1->c; c != NULL; c = c->suivant)
                              tmp1->c =
                                 InsertionEnTeteCoordonnee (tmp1->c, c->nl,
                                                            c->pos);
                        }
                        if (sms2 >= seuil)
                        {
 
                           succ2->freq = sms2;
                           if (*seq == NULL)
                              *seq = succ2;
                           else
                              ss->suivant = succ2;
                           ss = succ2;
                        }
                        else
/* sms2 < seuil */
                        {
                           supp2 += sms2;
                           for (c = succ2->c; c != NULL; c = c->suivant)
                              tmp2->c =
                                 InsertionEnTeteCoordonnee (tmp2->c, c->nl,
                                                            c->pos);
                        }
 
                        if (supp1 >= seuil)
                        {
 
                           tmp1->freq = supp1;
                           if (*seq == NULL)
                              *seq = tmp1;
                           else
                              ss->suivant = tmp1;
                           ss = tmp1;
 
                        }
                        if (supp2 >= seuil)
                        {
/* printf("%d ",supp2); */
 
                           tmp2->freq = supp2;
                           if (*seq == NULL)
                              *seq = tmp2;
                           else
                              ss->suivant = tmp2;
                           ss = tmp2;
                        }
 
                     }
                  }
 
               }
   Verifier1 (seq);
 
}
 
unsigned int hash_cle (char const *mot)
{
   unsigned int val = 0;
   for (; *mot != '\0'; ++mot)
      val = *mot + 31 * val;
   return val % TAILLEHASH;
}
 
unsigned int ChercherMotDansTableHash (Liste ** TableHash, char *mot)
{
 
   Liste *p;
   unsigned int cle;
 
   cle = hash_cle (mot);
   for (p = TableHash[cle]; p != NULL; p = p->suivant)
      if (strcmp (p->mot, mot) == 0)
         return 1;
   return 0;
}
 
Liste *InsertionEnTete (Liste * L, char *mot, int cle)
{
   Liste *nouveau;
   nouveau = (Liste *) malloc (sizeof (Liste));
   if (L == NULL)
   {
      nouveau->ID = 1 * IDLIMIT + cle;
   }
   else
   {
      nouveau->ID = L->ID + IDLIMIT;
   }
   nouveau->freq = 0;
   strcpy (nouveau->mot, mot);
   nouveau->suivant = L;
   nouveau->c = NULL;
   return nouveau;
}
 
void PosLigne (FILE * F, Liste ** TableHash)
{
   char s[50];
   int nl, pos, i;
   Liste *p;
   int trouve = 0;
   nl = pos = 1;
   for (i = 0; i < TAILLEHASH; ++i)
      if (TableHash[i] != NULL)
         for (p = TableHash[i]; p != NULL; p = p->suivant)
            p->freq = 0;
   while (fscanf (F, "%s", s) == 1)
   {
      for (i = 0; i < TAILLEHASH; ++i)
      {
         if (TableHash[i] != NULL)
         {
            for (p = TableHash[i]; p != NULL; p = p->suivant)
            {
/* ou Coordonnees x; sans le * */
               Coordonnees *x;
               if (strcmp (p->mot, s) == 0)
               {
/*Avant l'insertion */
 
                  trouve = 0;
                  for (x = p->c; x != NULL; x = x->suivant)
/* même ligne */
                     if (x->nl == nl)
                        trouve = 1;
                  if (trouve == 0)
                     p->freq = p->freq + 1;
                  p->c = InsertionEnTeteCoordonnee (p->c, nl, pos);
               }
            }
         }
      }
/*ici :p */
 
      if (fgetc (F) == '\n')
      {
/* ou nl++; ça change rien */
         ++nl;
         pos = 0;
      }
/* pareil ou pos++; ça change rien non plus */
      ++pos;
   }
}
 
void FiltreListe (Liste ** TableHash, int seuil)
{
   Liste *p, *last;
   int i, supp = 0, nb = 0;
   for (i = 0; i < TAILLEHASH; ++i)
      if (TableHash[i] != NULL)
      {
         nb = 0;
         last = TableHash[i];
         for (p = TableHash[i]; p != NULL; p = p->suivant)
         {
            supp = 0;
            nb++;
            if (p->freq < seuil)
/* mot n'est pas frequent */
            {
/* cas du première mot */
               if (last == p)
               {
                  TableHash[i] = p->suivant;
                  last = p->suivant;
               }
               else
                  last->suivant = p->suivant;
               nb--;
            }
            else
               last = p;
         }
         if (nb == 0)
            TableHash[i] = NULL;
      }
}
 
void AfficherCoordonnees (Coordonnees * C)
{
   Coordonnees *p;
   for (p = C; p != NULL; p = p->suivant)
      printf (" (%d,%d) ", p->nl, p->pos);
   printf ("\n");
}
 
void AfficherListe (Liste * L)
{
   Liste *p;
   for (p = L; p != NULL; p = p->suivant)
   {
      printf ("%s \n", p->mot);
      printf ("%d : ", p->freq);
      AfficherCoordonnees (p->c);
   }
}
 
void AfficheMot (Liste ** TableHash, int id)
{
   int cle = id % IDLIMIT;
   Liste *p;
/* Liste *l=TableHash[cle] */
 
   for (p = TableHash[cle]; p != NULL; p = p->suivant)
      if (p->ID == id)
      {
         printf ("%s", p->mot);
         break;
      }
}
 
void AfficheSeqMot (Liste ** TableHash, mots * m)
{
   mots *p;
   for (p = m; p != NULL; p = p->suivant)
   {
      AfficheMot (TableHash, p->ID);
      if (p->successif == 1)
         printf ("_");
      else
         printf (" ");
   }
   printf ("\n");
}
 
 
void AfficherSListe (Liste ** TableHash, SListe * L)
{
   SListe *p;
   for (p = L; p != NULL; p = p->suivant)
   {
      AfficheSeqMot (TableHash, p->m);
      printf ("%d : ", p->freq);
      AfficherCoordonnees (p->c);
   }
}
 
void AfficherTableHash (Liste ** TableHash)
{
   int i;
   for (i = 0; i < TAILLEHASH; ++i)
      if (TableHash[i] != NULL)
      {
         printf ("\n----------------------------Conteneur %d \n", i);
         AfficherListe (TableHash[i]);
      }
}
 
int dernierMot (SListe * p)
{
   mots *m;
   int s;
   for (m = p->m; m != NULL; m = m->suivant)
      s = m->ID;
   return s;
}
 
void Verifier (SListe * L)
{
   SListe *l;
   l = L;
   for (l = L; l != NULL; l = l->suivant)
   {
      Coordonnees *c;
      int line = -1;
      int freq = 0;
      for (c = l->c; c != NULL; c = c->suivant)
         if (line != c->nl)
         {
            freq++;
            line = c->nl;
         }
      l->freq = freq;
   }
}
 
SListe *GenererNseq (int seuil, SListe ** s,
                     SListe ** seq)
{
 
   SListe *p1, *p2, *ss, *t = NULL;
   Coordonnees *c1, *c2, *c = NULL;
   int id1, id2, supp1 = 0;
   mots *m, *mt;
   ss = *seq;
 
   for (p1 = *s; p1 != NULL; p1 = p1->suivant)
   {
/* printf("boucle1"); */
 
      id1 = dernierMot (p1);
      for (p2 = *seq; p2 != NULL; p2 = p2->suivant)
      {
/* printf("boucle2"); */
 
         supp1 = 0;
         c = NULL;
         m = p2->m;
         id2 = m->ID;
         if (id1 == id2)
         {
            for (c1 = p1->c; c1 != NULL; c1 = c1->suivant)
               for (c2 = p2->c; c2 != NULL; c2 = c2->suivant)
               {
                  if (c1->nl == c2->nl)
/* si 2 mots differents trouvés */
                  {
                     c = InsertionEnTeteCoordonnee (c, c2->nl, c2->pos);
                     supp1++;
                  }
/* fin calcul supp */
               }
            if (supp1 >= seuil)
            {
               mt = NULL;
               for (m = p1->m; m->suivant != NULL; m = m->suivant)
                  mt = InsertionEnTeteMot (mt, m->ID, m->successif);
               for (m = p2->m; m->suivant != NULL; m = m->suivant)
                  mt = InsertionEnTeteMot (mt, m->ID, m->successif);
 
               t = InsertionEnTeteS (t, dernierMot (p2), 0);
               for (m = mt; m != NULL; m = m->suivant)
                  t->m = InsertionEnTeteMot (t->m, m->ID, m->successif);
               t->c = c;
               t->freq = supp1;
            }
         }
      }
   }
   Verifier (t);
   return t;
}
 
int TailleSListe (SListe * L)
{
   SListe *p;
   int t = 0;
   for (p = L; p != NULL; p = p->suivant)
   {
      t++;
   }
   return t;
}
 
int ContientSeqMots (mots * m1, mots * m2)
{
   if (m2 == NULL)
      return 1;
   else
   {
      if (m1 == NULL)
         return 0;
      if (m1->ID == m2->ID)
         return ContientSeqMots (m1->suivant, m2->suivant);
      else
         return ContientSeqMots (m1->suivant, m2);
 
   }
 
}
 
void elagage (SListe * t, SListe ** s, int seuil)
{
   SListe *p1, *p2, *ss;
   int s1, s2;
   for (p1 = t; p1 != NULL; p1 = p1->suivant)
   {
      ss = *s;
      s1 = dernierMot (p1);
 
      for (p2 = *s; p2 != NULL; p2 = p2->suivant)
      {
         s2 = dernierMot (p2);
 
         if (((ContientSeqMots (p1->m, p2->m) == 1) && (s1 == s2))
             && (p1->freq == p2->freq))
/* ){ */
         {
/* && s1==s2 && p1->freq == p2->freq && p1->c->nl == p2->c->nl && p1->c->pos == p2->c->pos) */
 
/* p2->freq -= p1->freq ; */
 
/* if (p2->freq < seuil){ */
 
/* printf("%i", p1->c->nl); */
 
/* printf("%i", p2->c->nl); */
 
            if (ss == p2)
/* premier element */
            {
 
               ss = p2->suivant;
               *s = p2->suivant;
            }
            else
               ss->suivant = p2->suivant;
         }
         else
            ss = p2;
      }
   }
}
 
Liste *getMot (Liste ** TableHash, int id)
{
   int cle = id % IDLIMIT;
   Liste *p;
/* Liste *l=TableHash[cle] */
 
   for (p = TableHash[cle]; p != NULL; p = p->suivant)
      if (p->ID == id)
      {
         return p;
      }
 
   return NULL;
}
 
void GenRA (SListe * l, Liste ** TableHash, int n)
{
   SListe *q;
   float support;
   float confiance;
   char *motSucc, *t1;
 
   for (q = l; q != NULL; q = q->suivant)
   {
      mots *m;
      motSucc = strcpy (motSucc, "");
      for (m = q->m; m != NULL && m->suivant != NULL; m = m->suivant)
      {
         Liste *t = getMot (TableHash, m->ID);
         t1 = strcat (motSucc, t->mot);
         if (m->successif == 1)
         {
 
            t1 = strcat (motSucc, "_");
         }
         else
         {
            mots *s;
            t1 = strcat (motSucc, " ");
            printf ("%s", motSucc);
/* a-> */
            printf ("-> %s", t->mot);
 
/* comment la ligne suivante et t'aura l'affiches des regles du forme a b c -> d */
 
            motSucc = strcpy (motSucc, "");
/* //////////////////////////////// */
 
            for (s = m->suivant; s != NULL; s = s->suivant)
            {
/* b après c */
               AfficheMot (TableHash, s->ID);
               printf (" ");
 
            }
 
            printf ("\n\tfrequence %i", q->freq);
/* ça serait pas n+1 le nbre ligne */
            support = (float) (q->freq) / (float) (n);
            confiance =
               (float) (support) / (float) ((float) (t->freq) / (float) (n));
            printf (" / %i ", t->freq);
            printf ("\tsupport : %f\n", support);
            printf ("\tConfiance : %f\n", confiance);
 
         }
      }
   }
/* printf("%i", n+1); */
 
}
 
int main (void)
{
   int res = 0;
   FILE *F = NULL;
   char mot[100];
   int i, j;
   unsigned int cle, pt;
   SListe *seq2 = NULL;
   SListe **seq;
 
   Liste **TableHash;
   TableHash = (Liste **) malloc (TAILLEHASH * sizeof (Liste *));
   for (i = 0; i < TAILLEHASH; ++i)
      TableHash[i] = NULL;
 
   pt = hash_cle (".");
 
   printf ("debut du programme \n----------------------------------\n");
   F = fopen (PATH, "r");
   printf ("Ouverture du Fichier \n----------------------------------\n");
   while (fscanf (F, "%s", mot) == 1)
   {
      cle = hash_cle (mot);
      if ((cle != pt) && (!ChercherMotDansTableHash (TableHash, mot)))
         TableHash[cle] = InsertionEnTete (TableHash[cle], mot, cle);
      if (fgetc (F) == EOF)
         break;
   }
   fclose (F);
   printf ("nombre de lignes \n----------------------------------\n");
 
   F = fopen (PATH, "r");
 
   F = fopen (PATH, "r");
   if (F != NULL)
   {
 
      char buffer[BUFSIZ];
      int nb_read;
 
      while ((nb_read = fread (buffer, 1, sizeof buffer, F)) > 0)
      {
         int i;
 
         for (i = 0; i < nb_read; i++)
         {
            if (buffer[i] == '\n')
            {
               res++;
            }
         }
      }
      fclose (F);
      printf ("%i\n", res);
   }
   else
   {
      perror (PATH);
   }
 
   F = fopen (PATH, "r");
   PosLigne (F, TableHash);
 
/* filtrage */
 
   printf ("\nla liste filtre :\n----------------------------------");
 
   FiltreListe (TableHash, SEUIL);
   AfficherTableHash (TableHash);
 
/* géneration des 2seq */
 
/* seq2 c pour stocker les 2seq */
   Generer2seq (TableHash, SEUIL, &seq2);
 
/* les sequences */
 
/* les tableau des toutes les Nseq */
   seq = (SListe **) malloc (NBRSEQ * sizeof (SListe *));
   seq[0] = NULL;
/* ici on stocke les 2 seq qui seront elaguées par la suite */
   Generer2seq (TableHash, SEUIL, &seq[0]);
   printf
      ("\nles listes des seq initiaux:\n----------------------------------\n");
   printf ("-----------------------------------------2seq\n");
   AfficherSListe (TableHash, seq[0]);
/* génération des Nseq */
 
   for (i = 0; i < NBRSEQ; i++)
   {
      seq[i + 1] = GenererNseq (SEUIL, &seq[i], &seq2);
 
/* si on arrive plus a generer on sort de boucle */
      if (TailleSListe (seq[i + 1]) == 0)
         break;
      printf ("\n-----------------------------------------%dseq\n", i + 3);
 
      AfficherSListe (TableHash, seq[i + 1]);
      elagage (seq[i + 1], &seq[i], SEUIL);
   }
 
/* boucle d'affichage des resultats */
 
   for (j = 0; j <= i; j++)
   {
      printf
         ("\nla liste des %d seq elagues:\n----------------------------------\n",
          (j + 2));
      AfficherSListe (TableHash, seq[j]);
   }
 
   printf
      ("\n\nvoila la liste des regles d'association\n----------------------------------\n");
   F = fopen (PATH, "r");
/* int n=nb_lignes(F); */
 
   printf (">>le nombre ligne : %i\n\n", res);
   for (j = 0; j <= i; j++)
   {
      GenRA (seq[j], TableHash, res);
   }
 
   printf ("%i\n", res);
 
   return 0;
}

Nota : je ne ferais pas le nettoyage une deuxième fois. Donc, tu repars de ce que j'ai posté. Merci.

**étoile de mer** · 15/09/2008, 13h47

Envoyé par ram-0000

Je ne sais pas, donne un fichier de test qui reproduit le problème (même si ce n'est pas le vrai fichier pour des causes de confidentialité). Tant que l'on a pas la structure de ton fichier, on parle dans le vide.

voila le fichier , parrait qu'il ya des erreurs faut les corriger

gros fichier texte

C

Discussions similaires

Partager

Partager