liste chainée et chaines de caractéres

Version imprimable

14/04/2013, 09h14
titi2013

liste chainée et chaines de caractéres

Bonjour à tous .
etant débutate dans le monde de la programmation je vous prie de bien vouloir me guider das la résolution de mon tp , mo programme certe pas facile doit faire des recombinaison de mots si possible je vous explique .
je donne un exemple j'ai un mot chameau et un autre rat

et j'ai une règle : ha , me , a , t

dans une premier temps je doit concaténer mes deux règles donner : hame

dans un autre temps concaténer mes deux autres règles : at

si dans mon mot j’ai le mot hame dedans ( mes deux régles concaténer) chose qui est le cas dans le mot chameau : chameau

et si dans mon autre mot j'ai le mot at dedans ( mes deux autres règle concaténer ) chose qui est le cas dans le mot : rat donc je peux faire une recombinaison

je coupe le mot cha--meau ( entre ma regle ha et me ) , ( les -- indiquent l'endoit de la coupure ).

je coupe le mot ra--t ( entre ma regle r et at ) , ( les -- indiquent l'endroit de la coupure )

je fait une recombinansion j'obtiens les mots : chat et rameau tout cela ma fonction recombiner _ mots le fait sauf que maintenant je doit prendre une liste de mots :

ab, aab , aaab, ba, baa,baaa et ma regle est { a, b, b, a} et a chaque fois les deux mots doivent etre selectionné aléatoirement a partir de ma liste de mots

ainsi appliquer ma fonction de recombinaisons et surtout que les deux nouveaux mots doivent etres remis dans ma liste .

merci beaucoup de votre aide. j'ai fais quelques changements par rapport au code poster mais bon sa fonctionne toujours pas il ya erreur de segmentatipn .

le code

Code:

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
// declaration de la structure  regle
typedef struct regle
 {
    char *u1;
    char *v1;
    char *u2;
    char *v2;
 
} regle ;
 
 
// declaration de la structure liste de mots 
typedef struct mots
{  
   char *element;
   struct mots *suivant;
}mots;
 
 
 
// question 1 fonction pour recombiner mots entre eux 
  recombiner_mots (char* mot1,  char *mot2, regle r1)
{
   char *concat1 =  malloc(200 * sizeof(char));
   char *concat2 =  malloc(200 * sizeof(char));
   char *sous_mot1 =  malloc(200 * sizeof(char));
   char *sous_mot2 =  malloc(200 * sizeof(char));
   char *coupure1 =  malloc(200 * sizeof(char));
   char *coupure2 =  malloc(200 * sizeof(char));
   char * newmot1 = malloc(200*sizeof(char));
   char * newmot2 = malloc(200*sizeof(char));
   char * recombine1 = malloc(200*sizeof(char));
   char * recombine2 = malloc(200*sizeof(char));   
 
 
   r1.u1 = malloc (20 * sizeof(char));
   r1.v1 = malloc (20 *sizeof(char));
   r1.u2 = malloc (20 * sizeof(char));
   r1.v2 = malloc (20 * sizeof(char));
 
   strcpy(r1.u1, "ha"); 
   strcpy(r1.v1, "me"); 
   strcpy(r1.u2, "a"); 
   strcpy(r1.v2, "t");
 
 
   // concatenation entre deux champs de ma structure regle 
 
   concat1=strcat(r1.u1,r1.v1);
   concat2=strcat(r1.u2,r1.v2);
  // verifier que mes mots continennet bien mes regles concatener
   sous_mot1 = strstr(mot1,concat1);
   sous_mot2 = strstr(mot2,concat2);
 
   if ((sous_mot1 == NULL)||(sous_mot2 == NULL))
   {
       printf(" pas de recombinaison possible\n ");
   }
   else
    {  /*coupure de mon premier mot au niveau de mes deux regles */
      coupure1 = strstr(mot1,r1.v1);
      /* coupure de mon deuxieme mot au niveau de mes deux regles */ 
      coupure2 = strstr(mot2,r1.v2);
      /* recopie mon mot jusqu'a la hauteur de ma coupure pour mes deux mots */
      strncpy (newmot1,mot1,strlen(mot1)-strlen(coupure1));
      strncpy (newmot2,mot2,strlen(mot2)-strlen(coupure2));
 
      /* concatene mon mot obtenu precedemment avec l'autre partie de la coupure de l'autre mot */
      recombine1=strcat(newmot1,coupure2);
      recombine2=strcat(newmot2,coupure1);
 
      /* affiche les mots recombiner */
      printf("les mots recombiner sont : %s  %s\n",recombine1,recombine2);
 
 
   } 
 
 
 
   free(concat1);
   free(concat2); 
   free(sous_mot1);
   free(sous_mot2);
   free(coupure1);
   free(coupure2);
   free(newmot1);
   free(newmot2);
   free(recombine1);
   free(recombine2);  
}
// selection d'un mot dans la liste avec un evariable generer aléatoirement 
 
mots* selection(mots *m1,int val)
{
  mots *curseur = m1;
  int i ;
  for (i=0 ; i < val ;i++)
    { 
      curseur = curseur->suivant ;
 
    }
return curseur ;
}
//question 2 
void recombiner_aleatoire(char* mot3,  char *mot4, regle r3)
{  
 
   char *concat3 = malloc(200 * sizeof(char)); 
   char *concat4 = malloc(200 * sizeof(char));
   char *sous_mot3 = malloc(200 * sizeof(char));
   char *sous_mot4 = malloc (200 * sizeof(char));
   char *coupure3 = malloc(200 * sizeof(char)); 
   char *coupure4 = malloc(200 * sizeof(char));
 
 
 
   char * newmot3 = malloc(200*sizeof(char));
   char * newmot4 = malloc(200*sizeof(char));
   char * recombine3 = malloc(200*sizeof(char));
   char * recombine4 = malloc(200*sizeof(char)); 
   r3.u1 = malloc (200 * sizeof(char));
   r3.v1 = malloc (200 *sizeof(char));
   r3.u2 = malloc (200 * sizeof(char));
   r3.v2 = malloc (200 * sizeof(char));  
 
 
   /* concatenation entre deux champs de ma structure regle soit donne ab*/
 
   concat3=strcat(r3.u1,r3.v1);
   printf(" les deux regles recombiner de aleatoire %s \n ",concat3);
 
  /* concaténation entre deux autres champs de mas trcuture regle soit ba */
   concat4=strcat(r3.u2,r3.v2);
 
   printf( " allo\n");
  // verifier que mes mots continennet bien mes regles concatener soit possibiltés d'une recombinaison 
   sous_mot3 = strstr(mot3,concat3);
   sous_mot4 = strstr(mot4, concat4);
 
   if ((sous_mot3 != NULL)&&(sous_mot4 != NULL)) 
   {
  // coupure de mon premier mot au niveau de mes deux regles 
      coupure3 = strstr(mot3,r3.v1);
 
 
      // coupure de mon deuxieme mot au niveau de mes deux regles  
      coupure4 = strstr (mot4,r3.v2);
      printf(" coucou coupure 4");
 
      // recopie mon mot jusqu'a la hauteur de ma coupure pour mes deux mots 
      strncpy (newmot3,mot3,strlen(mot3)-strlen(coupure3));
      strncpy (newmot4,mot4,strlen(mot4)-strlen(coupure4));
 
 
      // concatene mon mot obtenu precedemment avec l'autre partie de la coupure de l'autre mot 
      recombine3=strcat(newmot3,coupure4);
      printf(" recombine 3");
 
      recombine4=strcat(newmot4,coupure3);
      printf(" recombine 4");
      strcpy(mot3,recombine3);
      strcpy(mot4,recombine4);
      //ecraser en reprenant et le mettant dans mot1 
      // affiche les mots recombiner 
      printf("les mots recombiner sont : %s  %s\n",mot3,mot4);
   }
 
}
     void afficherListe(mots *m1)
      {
         mots  *tmp = m1;
         while(tmp != NULL)
          {
        /* On affiche */
            printf("%s\n", tmp->element);
        /* On avance d'une case */
             tmp = tmp->suivant;
 
          }
       }
 
 
 
 
int main ()
{
 
    regle R2;
    int nb_hasard = rand()%6;
    char *mot1 ;
    char *mot2 ;
    char *resultat;
    mot1 = malloc (200 * sizeof(char));
    mot2 = malloc (200 * sizeof(char));
    char *mot3 = malloc(200 * sizeof(char));
    char *mot4 = malloc (200 * sizeof(char));
    mots *lemotfinal;
    mots *lemotfinal2;
     int i,h,j ;
     int nb_iterations = 0; 
  //  printf("veuillez entrer un premier mot  :\n");
   // scanf("%s",mot1);
 
   // printf("veuillez entrer un deuxieme mot  :\n");
   // scanf("%s",mot2);
 
   // recombiner_mots(mot1,mot2,R2);
   // srand(time(NULL));
  // question 2
 
      mots lemot6 = {"baaa",NULL};
      mots lemot5 = {"baa",&lemot6};
      mots lemot4 = {"ba",&lemot5};
      mots lemot3 = {"aaab",&lemot4}; 
      mots lemot2 = {"aab",&lemot3};
      mots lemot1 = {"ab",&lemot2};
 
    // declaration d'une nouvelle regle 
      regle r4 ={"a","b","b","a"};
 
     //mots *lemotfinal;
    // mots *lemotfinal2;
   //  int i,h,j ;
     printf("veuillez entrer un premier mot  :\n");
     scanf("%s",mot1);
 
     printf("veuillez entrer un deuxieme mot  :\n");
     scanf("%s",mot2);
 
     recombiner_mots(mot1,mot2,R2);
     srand(time(NULL));
     for ( h= 0; h< 2 ; h++)
      {     // fonction qui me prend un mots dans la liste aleatoirement 
            i= rand()%6;
            printf(" le nombre 1 au hasard %d\n ",i);
	    lemotfinal = selection(&lemot1,i);
            printf(" lemotfinal %s\n",lemotfinal->element);
	    j= rand()%6;
            printf(" le nombre 2 au hasard %d\n ",j);
	    lemotfinal2 = selection(&lemot1,j);
            printf(" lemotfinal 2 %s\n",lemotfinal2->element ); 
 
	    recombiner_aleatoire(lemotfinal->element ,lemotfinal2->element ,r4);
            afficherListe(&lemot1);
            nb_iterations ++; 
            printf(" nombre d'iterations %d \n ",nb_iterations);
 
      }
 
     return 0;
 
 
}

14/04/2013, 10h21
moins1

Pas clair tout ça! Donne nous le vrai exposé, ça va être plus facile à comprendre peut être. Surtout que ton français laisse à désiré un peu ici. :roll:

Place ton code dans les balises de code.

:)
14/04/2013, 11h49
titi2013
ok très gentil pour la remarque . Je vais essayer de formuler autrement disant point par point pour que je puisse peut être débloquer, j'ai une liste de mots je dois recombiner deux mots de ma liste pris au hasard (d’où ma fonction sélection), la manière avec laquelle ma recombinaison doit se faire, je l'ai expliqué précédemment avec le mot rat et chameau par exemple) ensuite ajouter dans ma liste les nouveaux mots obtenus dans ma liste à la place de ceux que j'ai utilisé pour faire ma recombinaison..
dans ma fonction recombier _mots tout marche à merveille
dans ma fonction recombiner - aléatoire ça ne va pas .erreur de segmentation .
ici j'ai une liste de mots qui sont :
Code:

1 2 3 4 5 6 mots lemot6 = {"baaa",NULL}; mots lemot5 = {"baa",&lemot6}; mots lemot4 = {"ba",&lemot5}; mots lemot3 = {"aaab",&lemot4}; mots lemot2 = {"aab",&lemot3}; mots lemot1 = {"ab",&lemot2};
ma règle est:

Code:

regle r4 ={"a","b","b","a"};

Merci d'avance .

Bonjour,

Je pense avoir suffisamment compris pour t'aider un peu:
tes structures me semblent bien
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 // declaration de la structure regle typedef struct regle { char *u1; char *v1; char *u2; char *v2; } regle ; // declaration de la structure liste de mots typedef struct mots { char *element; struct mots *suivant; }mots;
mais attention aux allocations de mémoire et aux passages de paramètres!!
- dans

Code:

recombiner_mots (char* mot1, char *mot2, regle r1)

pourquoi mettre r1 en parametre alors qu'il est en dur dans la fonction?
d'ailleurs il faudrait mieux faire r1={"ha","me",'a','t'}, les allocations de r1 ne servent à rien
- pour la recombinaison aléatoire,

Code:

void recombiner_aleatoire(char* mot3, char *mot4, regle r3)

r3 est un paramètre de ta fonction, qui contient ta règle, or tu l'alloues à l'intérieur de ta fonction, autant dire adieu à ses valeurs...
il faut que tu le créé ta regle r3 dans le main, comme tu le fais, et la passer en parametre de ta fonction en enlevant les malloc d'r3 dans ta fonction.

Juste quelques remarques:
- il faut éviter d'avoir des valeurs "200" sur toutes les lignes, utilises une variables globale comme ça si un jour tu dois modifier cette valeur tu es tranquille
- au lieu de creer tes char* locaux en les allouant dynamiquement ce qui n'est pas nécessaire tu peux faire plus simplement

Code:

char monChar[TAILLE_CHAINE]

avec

Code:

#define TAILLE_CHAINE 200

- il est préférable d'intitialiser tes chaines

Code:

memset(monChar,0,TAILLE_CHAINE);

J'espère que ça t'aura aidé.

18/04/2013, 23h10
titi2013

merci beaucoup de votre aide cela ma beaucoup aider merci merci
j'ai bien compris et cela grâce a vous merci .