Utiliser une fonction par pointeur.

Bonjour, je prend 5 nombres aléatoires entre 1 et 6 et j'essaie de multiplier le nombre d'occurence par le nombre.
Par exemple sur la suite : 1,1,1,3,4 il y a 3*1=3, le nombre à renvoyer est donc 3.
Sur la suite: 1,2,2,2,3,4 il y 2*3=6, le nombre à renvoyer est donc 6.

Toute seule cette fonction marche:

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
#include <stdio.h>
#include <stdlib.h>
 
int main(void){
int *occurence[6];
int *compte;
int *n;
int i;
int j=0;
 
n=malloc(sizeof(int)*2);
n=2;
compte=malloc(sizeof(int)*10);
for(i=1; i<6; i++){
occurence[i]=malloc(sizeof(char));
occurence[i]=2;}
 
for(i=0; i<n; i++){
*compte+=*(occurence+1);
		  }
 
if(*compte>=63){*compte+=35;}
 
printf("compte: %d ", *compte);
return 0;}

Or, quand je l'incorpore dans mon programme elle affiche segmentation fault. :weird:

Voici la partie qui bug:

Code:

1
2
3
4
5
printf("1. Compter les 1 \n");
scanf("%d",&choix);
 
	switch(choix){
		case 1: partie_superieure(occurence[1],1); break;}

Le programme complet:

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
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
char* lancer_des(char *des[], int numero_des){
	srand(numero_des);
	*des[numero_des] = rand() % 5 + 1;/*Ainsi, le chiffre sera entre 1 et 6.*/
	printf("des %d: %d \n",numero_des, *des[numero_des]);
	return (char *)des[numero_des];
}
//-----------------------------------------------------------------------------
char* trie(char *tableau[]){
int i;
int t;
int j;
for(i=1; i<7; i++){
	for(j=7; j>1; j--){
		if (*tableau[j-1]>*tableau[j]){
			t=*tableau[j-1];
			*tableau[j-1]=*tableau[j];
			*tableau[j]=t;
			             }
			 }
		  }
 
return *tableau;}
//------------------------------------------------------------------------------
int* partie_superieure(char *occurence[], int n){
int *compte;
int i;
int j=0;
 
compte=malloc(sizeof(int)*10);
 
for(i=0; i<n; i++){
*compte+=*(occurence+1);
		  }
 
if(*compte>=63){*compte+=35;}
 
printf("compte: %d ", *compte);
return *compte;  }
//------------------------------------------------------------------------------
int main(void){
srand (time(NULL));
char *des[7];
int i;
int j;
int t=0;
char *occurence[7];
int *compte;
int cpt=0;
int only=0;
int choix;
 
for(i=1; i<7; i++){
	des[i]=malloc(sizeof(char));
		  }
 
for(i=1; i<7; i++){
	*(des+i)=lancer_des(des,i);}
 
//Ainsi, la variable ne sera pas détruite à la fin de la fonction. 
compte=malloc(sizeof(int)*10);
for(i=1; i<7; i++){
occurence[i]=malloc(sizeof(char));
occurence[i]=0;
		  }
 
trie(des);
 
for (i=1; i<7; i++){ 
	if(*des[i]==*des[i+1]){occurence[*des[i]]+=1;}
		     }
for(i=1; i<7; i++){
if (occurence[i]>0){occurence[i]+=1;}
		  }
 
for(j=1; j<7; j++){
if(cpt>2){occurence[i-3]+=1; only=i-3;}
	cpt=0;
	for(i=1; i<7; i++){
		if(*des[i]!=*des[j]){cpt++;}else{cpt=0;}
			   }
		   }
 
occurence[only]=1;
 
for(i=1; i<7; i++){
printf("le nombre %d a ete repete %d fois. \n",i, occurence[i]);
		   }	
printf("1. Compter les 1 \n");
scanf("%d",&choix);
 
	switch(choix){
		case 1: partie_superieure(occurence[1],1); break;}
 
return 0;}

Merci. :)

Bonsoir.

Juste une petite remarque pour commencer, fais attention à l'indentation de ton code !
C'est difficilement lisible, surtout pour ceux qui découvrent le code.

L'erreur vient du fait que tu utilises des pointeurs à droite et à gauche alors qu'ils n'ont pas d'utilité dans ton cas.
Les variables
Code:

1 2 3 char *des[7]; char *occurence[7]; int *compte;
n'ont aucun besoin d'utiliser les pointeurs.

Ne t'égosille pas trop, nous lui avons dit la même chose sur ce fil: additioner un pointeur et un tableau de pointeurs

Et d'ailleurs, c'est même pire: (1ier code) 3 malloc sans aucun free -> c'est la fête du slip :mrgreen:

J'ai enlvé les pointeurs

Bonjour, j'ai enlevé les pointeurs et je fis une fonction reconnait, appelé la fonction dans la fonction qui calcul les points mais le programme me signala "segmentation fault." :calim2:

Voici la partie du code qui bug;

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
int choix_combinaison(int des[]){
int i;
int j;
int choix;
	printf("1. Compter les 1 \n");
	printf("2. Compter les 2 \n");
	printf("3. Compter les 3 \n");
	printf("4. Compter les 4 \n");
	printf("5. Compter les 5 \n");
	printf("6. Compter les 6 \n");
 
	printf("7. Brelan (3 des identiques) \n");
	printf("8. Full (3 des identiques et 2 des identiques) \n");
	printf("9. Carre (4 des identiques) \n");
	printf("10. Yam's (5 des identiques) \n");
 
	scanf("%d",&choix);
	printf("choix effectué");
 
	switch(choix){
		case 1: partie_superieure(1, des); break;
		case 2: partie_superieure(2, des); break;
		case 3: partie_superieure(3, des); break;
		case 4: partie_superieure(4, des); break;
		case 5: partie_superieure(5, des); break;
		case 6: partie_superieure(6, des); break;
 
		case 7: brelan(des); break;
		case 8: full(des); break;
		case 9: carre(des); break;
		case 10: yam(des); break;
		     }
			}

La compilation ne me rovoya pas "choix effectue"

Le retour de la compilation fut:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
joueur 1 joue! 
des 1: 4 
des 2: 1 
des 3: 2 
des 4: 2 
des 5: 1 
des 6: 2 
Veux-tu rejouer? (o / n) Tu as encore 3 chances. n
1. Compter les 1 
2. Compter les 2 
3. Compter les 3 
4. Compter les 4 
5. Compter les 5 
6. Compter les 6 
7. Brelan (3 des identiques) 
8. Full (3 des identiques et 2 des identiques) 
9. Carre (4 des identiques) 
10. Yam's (5 des identiques) 
2
Erreur de segmentation (core dumped)

Le code complet:

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
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
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "projet.h"
//----------------------------------------------------------------------------
int lancer_des(int des[], int numero_des){
	srand(numero_des);
	des[numero_des] = rand() % 5 + 1;/*Ainsi, le chiffre sera entre 1 et 6.*/
	printf("des %d: %d \n",numero_des, des[numero_des]);
	return des[numero_des];
}
//---------------------------------------------------------------
int somme_des(int des[], int debut, int fin){
	int i = debut;
	int somme;
	//somme=malloc(sizeof(int));
	somme=0;
	for (i = debut; i < fin; i++){ somme += des[i]; }
	return somme;
}
//---------------------------------------------------------------
int trie(int tableau[]){
int i;
int t;
int j;
for(i=1; i<7; i++){
	for(j=7; j>1; j--){
		if (tableau[j-1]>tableau[j]){
			t=tableau[j-1];
			tableau[j-1]=tableau[j];
			tableau[j]=t;
			             }
			 }
		  }
 
return tableau;}
//---------------------------------------------------------------------
int partie_superieure(int n, int des[]){
int occurence;
int compte;
int i;
int j=0;
 
occurence=reconnait(des,n);
compte+=occurence;
if(compte>=63){compte+=35;}
 
printf("compte: %d ", compte);
return compte;  }
//---------------------------------------------------------------------
int brelan(int des[]){
int i;
int compte;
int occurence[7];
for(i=0; i<7; i++){occurence[i]=reconnait(des,i);}
for(i=0; i<6; i++){
	if(occurence[i]==3){compte=somme_des(des,0,5);}
		   }
printf("Tu as %d points ! \n", compte);
return compte;} 
//----------------------------------------------------------------------
int carre(int des[]){
int compte;
int i;
int occurence[7];
for(i=0; i<7; i++){occurence[i]=reconnait(des,i);}
for(i=0; i<6; i++){if(occurence[i]==4){compte+=somme_des(des,0,5)+20;}}
printf("Tu as %d points ! \n", compte);
return compte;}
//-----------------------------------------------------------------------
int yam(int des[]){
int i;
int compte;
int occurence[7];
for(i=0; i<7; i++){occurence[i]=reconnait(des,i);}
for(i=0; i<6; i++){if(occurence[i]==5){compte=50;}}
printf("Tu as %d points ! \n", compte);
return compte;}
//---------------------------------------------------------------------
int full(int des[]){
int i=1;
int ok=0;
int compte;
int occurence[7];
for(i=0; i<7; i++){occurence[i]=reconnait(des,i);}
for(i=1; i<6; i++){
	if(occurence[i]==3 || occurence[i]==2){
		ok++;
					}
		   }
	if(ok>=2){compte=30;}
printf("Tu as %d points ! \n", compte);
return compte;}
//-----------------------------------------------------------------------
int gsuite(int des[]){
int i=1;
int j=0;
int compte;
for(j=0; j<=1; j++){
 /*grande suite */
    if (des[1]==1+j && des[2]==2+j && des[3]==3+j && des[4]==4+j && des[5]==5+j){
                compte=20;}}
printf("Tu as %d points ! \n", compte);
return compte;}
//-----------------------------------------------------------------------		   
int psuite(int des[]){
int compte;
int i=1;
int j=0;
for(j=0; j<=2; j++){
for(i=1; i<3; i++){if(des[i]==1+j && des[i+1]==2+j && des[i+2]==3+j && des[i+3]==4+j){
        compte=15;}}}
printf("Tu as %d points ! \n", compte);
return compte;}  
//-------------------------------------------------------------------------
int reconnait(int des[], int i){
int occurence[7];
 
for(i=1; i<7; i++){occurence[i]=0;}
 
trie(des);
 
for (i=1; i<7; i++){ 
	if(des[i]==des[i+1]){occurence[des[i]]+=1;}
		     }
return occurence[i];}
//-------------------------------------------------------------------------
int choix_combinaison(int des[]){
int i;
int j;
int choix;
	printf("1. Compter les 1 \n");
	printf("2. Compter les 2 \n");
	printf("3. Compter les 3 \n");
	printf("4. Compter les 4 \n");
	printf("5. Compter les 5 \n");
	printRef("6. Compter les 6 \n");
 
	printf("7. Brelan (3 des identiques) \n");
	printf("8. Full (3 des identiques et 2 des identiques) \n");
	printf("9. Carre (4 des identiques) \n");
	printf("10. Yam's (5 des identiques) \n");
 
	scanf("%d",&choix);
	printf("choix effectue");
 
	switch(choix){
		case 1: partie_superieure(1, des); break;
		case 2: partie_superieure(2, des); break;
		case 3: partie_superieure(3, des); break;
		case 4: partie_superieure(4, des); break;
		case 5: partie_superieure(5, des); break;
		case 6: partie_superieure(6, des); break;
 
		case 7: brelan(des); break;
		case 8: full(des); break;
		case 9: carre(des); break;
		case 10: yam(des); break;
		     }
			}
/*----------------------------------------------------------------------------
 
int score(int *joueur[], int nombre_joueur, int numero_joueur){
int i;
int gagnant;
int max;
int maxi[15]; //Le nouveaux joueurs doivent entrer.
printf("\n\n              TABLEAU DES SCORES \n \n");
 
for (i=0; i<20; i++){maxi[i]=0;}
 
for(i=1; i<=nombre_joueur; i++){
printf("Le joueur %d a un score de %d \n", i, *joueur[numero_joueur]);
if(*joueur[numero_joueur]>max){gagnant=i;max=*joueur[numero_joueur];}
				}			
printf("\nLe gagnant est le joueur %d avec un score de %d ! \n", gagnant, max);
 
FILE * f;
 
f=fopen("hit.txt", "a");
fprintf("%d %d\n", gagnant, max);
 
//TRIONS POUR AVOIR LES 10 MEILLEURS
for(i=0; i<20; i++){
fscanf(f,"%d ", maxi[i]);}
trie(maxi);
fclose(f);
 
f=fopen("hit.txt", "w");
for(i=0; i<10; i++){
fprintf(f, "%d ", maxi[i]);}
}*/	
//----------------------------------------------------------------------------
void menu(){
int menu;
	printf("1. nouvelle partie \n");
	printf("2. charger une partie\n");
	printf("3. afficher les meilleurs scores \n");
 
	scanf("%d", &menu);
 
	switch (menu){
	case 1: nouvelle_partie(); break;
	case 2:  break;
	case 3: printscore();  break;
	}}
//-----------------------------------------------------------------------------
int printscore(){
int c=0;
int i;
int gagnant;
int maxi;
FILE * f;
f=fopen("hit.txt", "r");
for(i=0; i<10; i++){
	fscanf(f, "%d %d\n",gagnant, maxi);
	printf("%d. Joueur %d  avec %d points!\n",i,gagnant, maxi);}
}
/*-----------------------------------------------------------------------------    
int presave(int *compte, int numero_joueur, int*joueur)
{joueur[numero_joueur]=*compte;}
//----------------------------------------------------------------------------
int sauvegarde(int*joueur, int nombre_joueur){
int i;
int n=nombre_joueur;
FILE *f;
	f = fopen("save.txt", "a");
	for(i=0; i<n; i++){
		fprintf(f,"%d ", joueur[i]);
			   }
fprintf(f,"\n");
printf("partie sauvegardé ! \n");
}
//------------------------------------------------------------------------------
*/
int nouvelle_partie(){
srand (time(NULL));
int i;
int *joueur;
int nombre_joueur;
int des[7]; 
int des_different[6]={0,0,0,0,0,0};
int tour=3;
char reponse[100];
int numero_des;
int nombre_des;
//for(i=1; i<7; i++){des[i]=malloc(sizeof(int));}
 
printf("Combien de joueurs participent? ");
scanf("%d", &nombre_joueur);
joueur=malloc(sizeof(int)*nombre_joueur);
for(i=1; i<=nombre_joueur; i++){
printf("joueur %d joue! \n", i);
for(i=1; i<7; i++){
	des[i]=lancer_des(des,i);}
while(tour>0){
				printf("Veux-tu rejouer? (o / n) Tu as encore %d chances. ", tour);
				scanf("%s", reponse);
 
				if (reponse[0] == 'o' || reponse[0] == 'n'){
					switch (reponse[0]){
					case 'o':
						tour--;
						printf("numero tour: %d \n", tour);
						printf("nombre de des a relancer ");
						scanf("%d", &nombre_des);
 
						while (nombre_des > 0){
							printf("numero du des a relancer: ");
							scanf("%d", &numero_des);
							for(i=1; i<6; i++){
								while (numero_des==des_different[i]){
									printf("Tu as deja lance ce des ! ");
									printf("numero du des a relancer: ");
									scanf("%d", &numero_des);
								          			  }
									  }
							des[i]=lancer_des(des,i);
							des_different[nombre_des]=numero_des;
							nombre_des--;	
						}
						printf("Tes nouveaux chiffres sont: \n");
						i=0;
						for(i=0; i<6; i++){
							des_different[i]=0;
								  }
						i=1;
						while (i < 6){
							printf("Des %d: %d\n", i, des[i]);
							i++;
						}
						tour--;
 
						break;
					case 'n':
						//printf("Tes des sont enregistrees. \n                        PASSAGE\n\n                           AU\n\n                            JOUEUR\n\n                                SUIVANT\n");
						tour = 0;
						break;
					}
 
 
				}
				else{ printf("Je n'ai pas compris ta reponse. \n Entre o en minuscule pour oui et n en minuscule pour non s'il te plait. \n"); }
				}
 
choix_combinaison(des);
}
 
}
//-----------------------------------------------------------------------------
int main(void){
char c;
FILE *f;
menu();
 
fclose(f);
/*APRES
c = getchar();
if(putchar(c)=='p'){menu();}
if(putchar(c)=='s'){sauvegarde(*joueur, nombre_joueur);}*/
return 0;}

Merci pour votre aide. :aie:

Bonjour,
Attention aux indices dans les tableaux.

Code:

int des[7]; // donc les indices valides dans le tableau vont de 0 à 6 inclus.

Tu utilises ensuite les indices 1 à 6, ça n'est pas une mauvaise idée de "perdre" l'indice 0, mais admettons.
Dans la fonction de tri et reconnait() , tu utilises l'indice 7, ce qui peut amener des résultats totalement imprévisibles.
Les indices décalés sont très difficiles à relire, il peut y en avoir d'autres.

Bonjour,

scanf doit être réservé pour lire des entrées FORMATÉES, et donc pas une saisie clavier. Je pense qu'avec une meilleure gestion des entrées, ton programme irait un peu mieux.

Exemple : https://emmanuel-delahaye.developpez...ees-solides-c/