Discussion :

[narjes81]

salut,
je developpe un programme qui contient une fonction qui permet de calculer le nombre de mots identiques entre deux chaine passé en paramètre de la fonction.
j'ai pas eu le résultat satisfaisant.le clacule est faux.voila le code de la fonction:

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
int compter_mot_identique(char *L1, char *L2,int a,int b)
{
	 int k=0, m=0,j=0,nb=0;
	 int i;
 
	 char LL1[20]="";
	 char LL2[20]="";
 
		  for(i=0;i<a+1;i++)
		 {
			 while(L1[i]!=' ')
			 {
				 LL1[k]=L1[i];
				 k++;
				 i++;
			 }
			 for(j=0;j<b+1;j++)
			 {
				 while(L2[j]!=' ')
					  {
						 LL2[m]=L2[j];
						 m++;
						 j++;
					  }
					if (strcmp(LL1,LL2)==0)
						 {
						  nb++;
						 }
						memset (LL2, 0, sizeof (LL2));
						k=0;
						m=0;
			 }
				memset (LL1, 0, sizeof (LL1));
		 }
	  return(nb);
 }

a et b qui sont passé en paramètre sont la longueur de ch1 et ch2 respectivement.
j'ai besoin de l'aide svp.

[narjes81]

de l'aide scp c trés urgent

[Sve@r]

de l'aide scp c trés urgent

Oui ben désolé, on n'est pas à ton service. Après-tout, tu as un cerveau aussi non ? Lui il est à ton service. Tu n'as qu'à le mettre à contribution...

Donc voici ce que j'ai constaté: tu fais un strcmp(LL1,LL2). Est-ce que LL1 et LL2 contiennent bien un '\0' où il faut pour que strcmp() sache où s'arrêter ?

[Anthony_CTI]

J'ai testé ta fonction dans ce main et j'ai pas eu de souci: il donne la bonne réponse.

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
 
main(void)
{
char *L1, *L2;
int a,b,nb;
L1="je ne suis pas un chat";
L2="je suis un tigre";
printf("L1 = %s \t L2 = %s \n",L1,L2);
printf("L1[8] = %c\n",L1[8]);
 
a = strlen(L1);
b = strlen(L2);
printf("a = %d \ b = %d \n",a,b);
 
nb = compter_mot_identique(L1,L2,a,b);
 
printf("nb = %d\n",nb);
}

Envoie le programme dans lequel tu appelles ta fonction. C'est peut-être là qu'est ton problème.

[narjes81]

J'ai testé ta fonction dans ce main et j'ai pas eu de souci: il donne la bonne réponse.

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
 
main(void)
{
char *L1, *L2;
int a,b,nb;
L1="je ne suis pas un chat";
L2="je suis un tigre";
printf("L1 = %s \t L2 = %s \n",L1,L2);
printf("L1[8] = %c\n",L1[8]);
 
a = strlen(L1);
b = strlen(L2);
printf("a = %d \ b = %d \n",a,b);
 
nb = compter_mot_identique(L1,L2,a,b);
 
printf("nb = %d\n",nb);
}

Envoie le programme dans lequel tu appelles ta fonction. C'est peut-être là qu'est ton problème.

merci de votre réponde

j'ai un petit souci,je pense que l'appel sucessive de fonction "compter_mot_identique" peut etre la cause.

dans le main j'appelle la fonction plusieurs fois et j'ajoute aussi que les chaine L1 et L2 passé en paramètre sont alloué dynamiquement dans le main.voila

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
   1. int main()
   2. {
   3. int compter_mot_identique(char*, char*,int ,int );
   4. int nb_foot=0,nb_cyclisme=0;
   5. char*ch1,*chaine;
   6. long lsize;
   7. int carac=0,i=0;
   8. char chemin[200];
   9. char repertoire[15]="D:\\dossier";
  10.    DIR *rep= NULL;
  11. struct dirent *fichierLu= NULL;
  12. ......
  13. .......
  14.
  15. foot = fopen("foot.txt", "r" );
  16.   if (NULL == foot)
  17.   {
  18.  printf("Impossible d'ouvrir le fichier de classe foot\n" );
  19.  return 1;
  20.   }
  21. fseek (foot, 0 , SEEK_END);  // Obtient la taille du fichier
  22. lsize = ftell (foot);
  23. rewind (foot);
  24.
  25. ch1 = (char*) malloc (lsize * sizeof(char));
  26. carac = fgetc(foot);
  27. while (carac != EOF)
  28.  {
  29.    while ( carac != ' ' && carac != '\n' && carac !=EOF ) // On continue tant que fgetc n'a pas retourné EOF (fin de fichier)
  30.     {
  31.      ch1[i]= carac;
  32.      i++;
  33.      carac = fgetc(foot);
  34.     }
  35.    ch1[i]=' ';
  36.   carac = fgetc(foot);
  37.   i++;
  38.  }
  39.   longueur1=strlen(ch1);
  40.   i=0;carac=0; lsize =0;
  41.   fclose (foot);
  42. ..
  43. ....
  44. ....
  45.
  46. rep =opendir(repertoire);
  47.   if (rep==NULL)
  48.   printf("erreur" );
  49.   fichierLu = readdir(rep);
  50. while( fichierLu!=NULL)
  51. {
  52.   if (strcmp(fichierLu->d_name, "." ) != 0 && strcmp(fichierLu->d_name, ".." ) != 0)
  53. {
  54.   sprintf(chemin, "%s\\%s", repertoire, fichierLu->d_name);
  55.   fichier = fopen(chemin,"r" );
  56.
  57.   if (NULL == fichier)
  58.   {
  59.  printf("Impossible d'ouvrir le fichier %s\n",fichierLu->d_name);
  60.  return 1;
  61.   }
  62.   fseek (fichier, 0 , SEEK_END);  // Obtient la taille du fichier
  63. lsize = ftell (fichier);
  64. rewind (fichier);
  65.
  66. chaine = (char*) malloc (lsize * sizeof(char));
  67. carac = fgetc(fichier);
  68. while (carac != EOF)
  69.  {
  70.    while ( carac != ' ' && carac != '\n' && carac !=EOF ) // On continue tant que fgetc n'a pas retourné EOF (fin de fichier)
  71.     {
  72.      chaine[i]= carac;
  73.      i++;
  74.      carac = fgetc(fichier);
  75.     }
  76.    chaine[i]=' ';
  77.   carac = fgetc(fichier);
  78.   i++;
  79.  }
  80.    longueur=strlen(chaine);;
  81.  
  82.
  83. //appel de la fonction
  84. nb_foot=compter_mot_identique(chaine,ch1,longueur,longueur1);
  85.
  86. fclose (fichier);
  87.   free(chaine);
  88. }
  89. fichierLu = readdir(rep);
  90. }
  91. free(ch1);
  92. if (closedir(rep)==-1)
  93. {
  94. printf("echec" );
  95. }
  96.
  97. return(0);
  98.
  99. }

[souviron34]

tu as suivi le cours "pourquoi faire simple alors qu'on peut faire compliqué" ???

[Thierry Chappuis]

Pourquoi ne pas te servir du tokenizer présent dans ta bibliothèque standard, à savoir strtok() (OK, c'est pas super conseillé de l'utiliser) ou sa version réentrante strtok_r() (POSIX.1). J'arrive au code suivant où le 99% des lignes sont de l'allocation ou du housekeeping (éventuellement remplacer l'allocation dynamique par de l'allocation statique si tu trouves trop lourd) :

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
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
enum Etat {MOT_DEDANS, MOT_DEHORS};
 
int compter_mots(const char *phrase, const char *delim)
{
    int nb_mots = 0;
 
    if (phrase != NULL && *phrase != '\0')
    {
        if (delim != NULL && *delim != '\0')
        {
            const char *pc = phrase;
            enum Etat etat = MOT_DEHORS;
 
            while (*pc != '\0')
            {
 
                if (etat == MOT_DEHORS && strchr(delim, *pc) == NULL)
                {
                    nb_mots++;
                    etat = MOT_DEDANS;
                }
                else if (etat == MOT_DEDANS && strchr(delim, *pc) != NULL)
                {
                    etat = MOT_DEHORS;
                }
 
                pc++;
            }
        }
    }
 
    return nb_mots;
}
 
int rechercher_mot(char *mot, char **collection)
{
    int trouve = 0;
 
    if (mot != NULL && *mot != '\0')
    {
        if (collection != NULL && *collection != NULL)
        {
            int i = 0;
 
            while (collection[i] != NULL && trouve == 0)
            {
                if (strcmp(mot, collection[i]) == 0)
                {
                    trouve = 1;
                }
                i++;
            }
        }
    }
 
    return trouve;
}
 
int compter_mots_identiques(const char *phrase1, const char *phrase2)
{
    int nb_mots = 0;
 
    if (phrase1 != NULL && *phrase1 != '\0')
    {
        if (phrase2 != NULL && *phrase2 != '\0')
        {
            char *tampon_p1 = strdup(phrase1);
            if (tampon_p1 != NULL)
            {
                char *tampon_p2 = strdup(phrase2);
                if (tampon_p2 != NULL)
                {
                    int nb_mots_p2 = compter_mots(phrase2, " \n\t") + 1;
                    char **mots_p2 = malloc(nb_mots_p2 * sizeof *mots_p2);
                    if (mots_p2 != NULL)
                    {
                        char *mot_courant = NULL;
                        int i = 0;
                        char *p1 = tampon_p1;
                        char *p2 = tampon_p2;
 
                        mots_p2[i] = strtok_r(phrase2, " \n\t", &p2);
                        while (mots_p2[i] != NULL)
                        {
                            mots_p2[++i] = strtok_r(NULL, " \n\t", &p2);
                        }
 
                        mot_courant = strtok_r(phrase1, " \n\t", &p1);
                        do
                        {
                            if (rechercher_mot(mot_courant, mots_p2) != 0)
                            {
                                nb_mots++;
                            }
                            mot_courant = strtok_r(NULL, " \n\t", &p1);
                        }
                        while (mot_courant != NULL);
 
                        free(mots_p2), mots_p2 = NULL;
                    }
 
                    free(tampon_p2), tampon_p2 = NULL;
                }
 
                free(tampon_p1), tampon_p1 = NULL;
            }
        }
    }
 
    return nb_mots;
}
 
int main(void)
{
    const char *phrase1 = "111 222 333 444 555 666 777 888 999";
    const char *phrase2 = "121 232 343 454 555 666 787 909 090 111 222";
    int nb_mots_communs = compter_mots_identiques(phrase1, phrase2);
 
    printf("Il y a %d mot(s) commun(s)\n", nb_mots_communs);
 
    return 0;
}

La bibliothèque standard de MinGW sous windows ne propose pas d'implantation de strdup() et strtok_r(). Tu peux remplacer ces appels par mes implantations naïves suivantes:

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
#define strdup(s) m_strdup(s)
#define strtok_r(s, d, b) m_strtok_r((s), (d), (b))
 
enum State {TOKEN_IN, TOKEN_OUT};
 
char *m_strdup(const char *s)
{
    char *s_ret = NULL;
 
    if (s != NULL)
    {
        size_t slen = strlen(s) + 1;
        s_ret = malloc(slen * sizeof *s_ret);
        if (s_ret != NULL)
        {
            *s_ret = '\0';
            strcat(s_ret, s);
        }
    }
 
    return s_ret;
}
 
char *m_strtok_r(const char *s, const char *delim, char **ptrptr)
{
    char *next_token = NULL;
 
    if (delim != NULL && *delim != '\0')
    {
        if (ptrptr != NULL && *ptrptr != NULL)
        {
            char *buffer = *ptrptr;
            char *pc = buffer;
            enum State state = TOKEN_OUT;
            int end = 0;
 
            if (s != NULL)
            {
                *buffer = '\0';
                strcat(buffer, s);
            }
 
            while (*pc != '\0' && end != 1)
            {
 
                if (state == TOKEN_OUT && strchr(delim, *pc) == NULL)
                {
                    next_token = pc;
                    state = TOKEN_IN;
                }
                else if (state == TOKEN_IN && strchr(delim, *pc) != NULL)
                {
                    *pc = '\0';
                    end = 1;
                }
 
                pc++;
            }
 
            *ptrptr = pc;
        }
    }
 
    return next_token;
}

Avec mes meilleures salutations

Thierry