Premier programme en C, qu'en pensez-vous? [Débutant(e)]

**fremen167** · 16/12/2007, 17h25

Envoyé par Emmanuel Delahaye

Non. Encore une fois, il n'y a pas de variables globales dans ce code. Le codeur a pris le soin de ne pas utiliser de variable globales, mais des variables locales à main(), comme il est d'usage. Je ne vois pas l'intérêt de pourrir son code avec des usages d'un autre age. Le BASIC, c'est fini...

Je ne sais pas pourquoi tu réponds agressivement.

Mais effectivement, j'avais mal regardé, les variables sont déclarées dans le main... au temps pour moi.

**beware** · 16/12/2007, 23h07

Ne vous battez pas

Alors pour répondre :

L'abus des printf pour l'affichage de plusieurs lignes est du a ma connaissance de la fonction. En effet je savais pas qu'on pouvait s'en servir comme tu l'as fait. Je pensais qu'il fallait remettre printf pour chaque ligne.
Pareil pour ce qui est des fonctions placés aprés le main. C'est comme ca que je l'ai vu dans mes cours, donc je reproduis

**beware** · 17/12/2007, 12h29

Bonjour,

J'ai modifié encore un peu mon programme :

Ajout d'une demande pour rejouer en fin de partie.
Ajout d'une fonction d'initialisation. En cas de nouvelle partie pour remettre tous les tableaux à 0.
J'ai modifié le code de l'affichage pour prendre en compte la remarque d'Emmanuel.

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
 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
#define COUP_MAX    12      // Nombre de coup Maximal
#define NB_CHIFFRE  5       // Nombre de chiffre dans le code
#define BORNE_MAX   10      // Borne superieur du hasard
 
 
// Differentes entrees du menu d'affichage
#define ESSAI       'e'     /* Afficher l'historique des combinaisons entrees et du resultat associe */
#define GAGNE       'g'     /* Affiche le message GAGNANT */
#define PERDU       'p'     /* Affiche le message PERDANT */
#define MENU        'm'     /* Affiche le menu principal */
 
#define OK  1
#define KO  0
 
#define BIEN_PLACE  0
#define MAL_PLACE   1
 
#define REJOUER     'o'
#define QUITTER     'n'
 
 
 
// Fonctions
static void init (int res[COUP_MAX][2], int code[NB_CHIFFRE], int essai[COUP_MAX][NB_CHIFFRE]);
static void hasard(int code[NB_CHIFFRE]);
static void saisie (int Ligne, int essai[COUP_MAX][NB_CHIFFRE]);
static void teste (int Ligne, int res[COUP_MAX][2], int code[NB_CHIFFRE], int essai[COUP_MAX][NB_CHIFFRE]);
static void affichage(char mode, int res[COUP_MAX][2], int code[NB_CHIFFRE], int essai[COUP_MAX][NB_CHIFFRE], int Ligne, int coup);
 
 
 
// Programme principal
int main(void)
{
    int essai[COUP_MAX][NB_CHIFFRE];       /* Tableau contenant les combinaisons essayees */
    int res[COUP_MAX][2];                  /* Tableau contenant les resultats de chaque combinaison 1 colonne *
                                            * qui compte les chiffres biens places et une pour les mal places */
    int code[NB_CHIFFRE];
    int Ligne;                             /* Indique la ligne en cours de traitement */
    int Coup;                              /* Indique le nombre de coup joue */
 
    int Nouveau;
    int err;
 
 
 
    do {
        Coup = 1;
        Ligne = 0;
        Nouveau = KO;
 
        /* Initialisation de tous les tableaux */
        init(res,code,essai);
 
 
        /* Generation du code aleatoire */
        srand(time(NULL) % RAND_MAX);
        hasard(code);
 
 
        /* Affichage du menu */
        affichage(MENU,res,code,essai,0,0);
 
 
        /* Test de l'essai */
        do {
            saisie(Ligne,essai);
            teste(Ligne,res,code,essai);                         // On teste le code entré
            affichage(ESSAI,res,code,essai, Ligne,0);          // On affiche les codes essayes et leur resultat
            Ligne++;
            Coup++;
        }
        while (res[Ligne-1][BIEN_PLACE] != NB_CHIFFRE && Coup <= COUP_MAX);
 
 
        /* Suivant le nombre de caractere bien place trouve on choisit le message a afficher */
        if (res[Ligne-1][BIEN_PLACE] == NB_CHIFFRE)
            affichage(GAGNE,res,code,essai,0,Coup);
        else
            affichage(PERDU,res,code,essai,0,Coup);
 
        /* On demande si le joueur veut rejouer */
        printf("\n\n"
               "Pour rejouer tapez 'o' sinon tapez 'n' pour quitter : ");
 
        while((c = fgetc(stdin)) != EOF && c != REJOUER && c != QUITTER) {};
 
        if (c == REJOUER)
            Nouveau = OK;
 
    }
    while (Nouveau != KO);
 
    return 0;
}
 
 
// FONCTION INIT
static void init (int res[COUP_MAX][2], int code[NB_CHIFFRE], int essai[COUP_MAX][NB_CHIFFRE]) {
    int ind_col, ind_lig;
 
    /* Initialisation du tableau CODE */
    for (ind_col = 0; ind_col < NB_CHIFFRE; ind_col++)
        code[ind_col] = 0;
 
    /* Initialisation du tableau RES */
    for (ind_lig = 0; ind_lig < COUP_MAX; ind_lig++)
        for (ind_col = 0; ind_col < NB_CHIFFRE;ind_col++)
            res[ind_lig][ind_col] = 0;
 
    /* Initialisation du tableau ESSAI */
    for (ind_lig = 0; ind_lig < 2; ind_lig++)
        for (ind_col = 0; ind_col < NB_CHIFFRE; ind_col++)
            res[ind_lig][ind_col] = 0;
}
 
 
// FONCTION HASARD
static void hasard(int code[NB_CHIFFRE]) {
 
    int val_tmp;        // valeur temporaire
    int ind_col;        // indice de colonne
    int pos;            // position de la colonne dans le tableau CODE
    int doublon;
 
    pos = 0;
    while (pos < NB_CHIFFRE){
 
        doublon = OK ;
        while (doublon == OK) {
            doublon = KO ;
            val_tmp = (rand()% (BORNE_MAX));
 
        // verifier que la valeur tiree n'est pas deja presente
            for (ind_col = 0; ind_col < pos; ind_col++) {
                if (val_tmp == code[ind_col]) {
                    doublon = OK ;
                    break;
                }
            }
        }
        code[pos++] = val_tmp;
    }
}
 
 
// FONCTION DE SAISIE DE LA COMBINAISON
static void saisie (int Ligne, int essai[COUP_MAX][NB_CHIFFRE]) {
 
    int err;                        // Permet de controler les erreurs de saisie
    int ind_col;                    // Indice de la colonne en cours
    char chaine[20];
 
    /* Acquisition des chiffres de l'essai */
    do {
        printf("\nEntrez votre combinaison : ");
        fgets(chaine, sizeof chaine, stdin);
 
        err = sscanf(chaine, "%d %d %d %d %d", &essai[Ligne][0], &essai[Ligne][1], &essai[Ligne][2], &essai[Ligne][3],&essai[Ligne][4] );
 
        if (err != NB_CHIFFRE)
            printf("Vous n'avez rentre que %d chiffre(s) au lieu de %d.\n",err,NB_CHIFFRE);
    }
    while (err != NB_CHIFFRE);
 
    /* Les chiffres sont ils compris entre 0 et 9 */
 
    for (ind_col = 0; ind_col < NB_CHIFFRE; ind_col++) {
        err = 0;
 
        while (essai[Ligne][ind_col] < 0 ||  essai[Ligne][ind_col] > 9 ) {
 
                printf("\nLe chiffre rentré dans la position %d, soit %d, est au-dessus de la borne superieure\n", ind_col+1, essai[Ligne][ind_col]);
                printf("Veuillez entrez un nouveau chiffre en remplacement : ");
                fgets(chaine, sizeof chaine, stdin);
                err = sscanf(chaine, "%d", &essai[Ligne][ind_col]);
 
                if (err != 1)
                    puts("ERREUR");
        }
    }
    printf("\n");
}
 
 
// FONCTION TEST
static void teste (int Ligne, int res[COUP_MAX][2], int code[NB_CHIFFRE], int essai[COUP_MAX][NB_CHIFFRE]) {
 
    int ind_essai, ind_code;
 
    /* On cherche d'abord les chiffres presents et bien places */
    for (ind_essai = 0; ind_essai < NB_CHIFFRE; ind_essai++) {
 
            if (essai[Ligne][ind_essai] == code[ind_essai]) {
                res[Ligne][BIEN_PLACE] += 1;            /* on ajoute un caractere bien place */
                essai[Ligne][ind_essai] += 10;          /* on s'assure que cette position n'est pas réutilisée */
                code[ind_essai] += 20;                  /* on s'assure que cette position n'est pas réutilisée */
            }
        }
 
 
    /* On cherche ensuite les chiffres presents mais mal places */
    for (ind_essai = 0; ind_essai < NB_CHIFFRE; ind_essai++) {
            for (ind_code = 0; ind_code < NB_CHIFFRE ; ind_code++) {
                if  ((essai[Ligne][ind_essai] == code[ind_code])) {
                    res[Ligne][MAL_PLACE] += 1;          /* on ajoute un caractere mal place */
                    code[ind_code] += 20;                /* on s'assure que cette position n'est pas réutilisée */
                    break ;
                }
            }
        }
 
    /* les données écrasées sont remise d'aplomb */
        for (ind_essai = 0; ind_essai < NB_CHIFFRE; ind_essai++) {
                    essai[Ligne][ind_essai] %= 10;
                    code[ind_essai] %= 10;
        }
}
 
 
// FONCTION AFFICHAGE
static void affichage(char mode, int res[COUP_MAX][2], int code[NB_CHIFFRE], int essai[COUP_MAX][NB_CHIFFRE], int Ligne, int Coup ) {
 
 
    int ind_lig;        // indice de ligne
    int ind_col;        // indice de colonne
 
 
 
    switch (mode) {
        case ESSAI :
 
            for (ind_lig = 0; ind_lig <= Ligne; ind_lig++) {
 
                /* Affichage de la combinaison */
                for (ind_col = 0; ind_col < NB_CHIFFRE; ind_col++)
                    printf("%d ",essai[ind_lig][ind_col]);
                printf("\t");
 
                /* Affichage du resultat de la combinaison */
                for (ind_col = 0; ind_col < res[ind_lig][BIEN_PLACE]; ind_col++)
                    printf("# ");
 
                for (ind_col = 0; ind_col < res[ind_lig][MAL_PLACE]; ind_col++)
                    printf("* ");
 
                /*  la difference : NB_CHIFFRE - res[ind_lig][BIEN_PLACE] - res[ind_lig][MAL_PLACE] permet de savoir
                    s'il faut afficher des espaces vides, des '.' ou aucun */
                for (ind_col = 0; ind_col < (NB_CHIFFRE - res[ind_lig][BIEN_PLACE] - res[ind_lig][MAL_PLACE]); ind_col++)
                    printf(". ");
 
                printf("\n");
            }
            break;
 
        case PERDU :
            printf("\nPERDU, le code correct etait :\t");
            for (ind_col = 0; ind_col < NB_CHIFFRE; ind_col++)
                printf("%d ", code[ind_col]);
            printf("\n\n");
            break;
 
        case GAGNE :
            printf("\nGAGNE, le code etait bien :\t");
            for (ind_col = 0; ind_col < NB_CHIFFRE; ind_col++)
                printf("%d ", code[ind_col]);
 
            printf("\nVous avez trouvez le code au bout de %d tentative(s)\n",Coup - 1);
            printf("\n\n");
            break;
 
        case MENU :
            printf("\n\n"
                   "\t\t\t*****************************\n"
                   "\t\t\t*                           *\n"
                   "\t\t\t*        MASTERMIND         *\n"
                   "\t\t\t*                           *\n"
                   "\t\t\t*****************************\n"
                   "\n\n"
                   "******************************************************************************\n"
                   "*  - Utilisez les combinaisons dans le style : a b c d e puis 'entree'       *\n"
                   "*  - Les nombres possibles sont compris entre 0 et 9                         *\n"
                   "*                                                                            *\n"
                   "* - Les caracteres # et * vous permettent de savoir le nombre                *\n"
                   "*   de chiffres de votre combinaison dans le code secret respectivement      *\n"
                   "*   bien places et mal places.                                               *\n"
                   "*                                                                            *\n"
                   "* - Vous avez droit a %d essais.                                             *\n",COUP_MAX);
 
            printf("*                                                                            *\n"
                   "******************************************************************************\n");
            break;
 
    }
  }

Sauf, que j'ai encore un petit souci avec ce morceau de code :

Code :

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

1
2
 
 while((c = fgetc(stdin)) != EOF && c != REJOUER && c != QUITTER) {};

En fait ca tourne bien tant que je rentre pas les bonnes valeurs (soit 'o' ou 'n'). Mais si je demande de rejouer, j'ai un bug, puisque il prende pour 1ere nouvelle combinaison le '\n' qui reste du tampon.

**fremen167** · 17/12/2007, 13h44

Envoyé par beware

Sauf, que j'ai encore un petit souci avec ce morceau de code :

Code :

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

1
2
 
 while((c = fgetc(stdin)) != EOF && c != REJOUER && c != QUITTER) {};

En fait ca tourne bien tant que je rentre pas les bonnes valeurs (soit 'o' ou 'n'). Mais si je demande de rejouer, j'ai un bug, puisque il prende pour 1ere nouvelle combinaison le '\n' qui reste du tampon.

Tu donnes toi-même la solution à ton problème : ton fgetc ne lit qu'un caractère, donc le \n n'est pas consommé, il reste dans le buffer.

Peut-être serait-il plus simple de faire comme pour la lecture des solutions : un fgets, puis l'analyse par sscanf ?

**beware** · 17/12/2007, 15h23

Envoyé par fremen167

Tu donnes toi-même la solution à ton problème : ton fgetc ne lit qu'un caractère, donc le \n n'est pas consommé, il reste dans le buffer.

Peut-être serait-il plus simple de faire comme pour la lecture des solutions : un fgets, puis l'analyse par sscanf ?

Oui j'y avais pense. Mais je me disais que comme fgets sert, comme son nom l'indique a récupérer des chaines, c'était peut être pas nécessaire pour prendre juste un caractère. J'ai donc utiliser fgetc. Cependant, et c'est peut être pas bien codé, mais j'ai juste rajouté un getchar dans ma boucle if. Puisque c'est le seul cas ou il est nécessaire de consommer le '\n'.

**Emmanuel Delahaye** · 17/12/2007, 15h38

Envoyé par beware

Oui j'y avais pense. Mais je me disais que comme fgets sert, comme son nom l'indique a récupérer des chaines, c'était peut être pas nécessaire pour prendre juste un caractère.<...>

Une saisie de 1 caractère fait au moins le caractère et '\n'. C'est donc une chaine et fgets() est donc parfaitement adapté.

http://emmanuel-delahaye.developpez....tes.htm#saisie

**beware** · 17/12/2007, 16h19

Merci de tes indications. Donc j'ai repris l'exemple sur le lien que tu m'as donné, qui est d'ailleurs celui sur lequel j'avais fait mas fonction saisie.

Donc au finale j'obtiens une fonction dans ce genre la :

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
 
        do {
            char saisie[5];
 
             printf("\n\n"
                     "Pour rejouer tapez 'o' sinon tapez 'n' pour quitter : ");
 
            fgets (saisie, sizeof saisie, stdin);
            ret = sscanf (saisie, "%c", &c);
 
            if (ret != 1)
                printf("\nERREUR\n");
 
            else if (c == REJOUER)      /* Si on rentre 'o', on demande une nouvelle partie */
                Nouveau = OK;
 
            else if (c ==  QUITTER)     /* Si on rentre 'n', on veut quitter le jeu */
                break;
 
            else {
                printf("\nERREUR. La commande n'est pas reconnue");
                ret = 0;
            }
        }
        while (ret != 1);

Mais je me demande si l'utilisation du sscanf a besoin d'être contrôler. Puisque si on rentre 1 chiffre ca le gêne pas, puisque c'est un caractère, et que si on tape un plus grand mot, il ne prendra de toute façon que le 1er caractère.

De plus, je vérifie ensuite quel lettre a ete enregistre pour traiter les trois cas possibles (oui, non, autre)

**beware** · 20/12/2007, 12h58

Bon, j'ai pas fait beaucoup de changement.
J'ai rajouté des commentaires, et remis quelques accolades dans des boucles. Puisque j'ai lu sur un site, qui etait liste sur le site d'Emmanuel, que c'était mieux de mettre des accolades dans les boucles meme si ces dernieres ne comptaient qu'une ligne.

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
 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
 
#define COUP_MAX    12      // Nombre de coup Maximal
#define NB_CHIFFRE  5       // Nombre de chiffre dans le code
#define BORNE_MAX   10      // Borne superieur du hasard
 
 
// Differentes entrees du menu d'affichage
#define ESSAI       'e'     /* Afficher l'historique des combinaisons entrees et du resultat associe */
#define GAGNE       'g'     /* Affiche le message GAGNANT */
#define PERDU       'p'     /* Affiche le message PERDANT */
#define MENU        'm'     /* Affiche le menu principal */
 
 
#define OK  1               /* Valeur indiquant que le programme doit se relancer */
#define KO  0               /* Valeur indiquant que le programme doit s'arreter */
 
#define BIEN_PLACE  0       /* Valeur denombrant les chiffres presents et bien places */
#define MAL_PLACE   1       /* Valeur denombrant les chiffres presents mais mal places */
 
#define REJOUER     'o'     /* Caractere entre par le joueur pour pouvoir rejouer */
#define QUITTER     'n'     /* Caractere entre par le joueur pour quitter en fin de partie */
 
 
 
/* Prototypes des fonctions */
static void init (int res[COUP_MAX][2], int code[NB_CHIFFRE], int essai[COUP_MAX][NB_CHIFFRE]);
static void hasard(int code[NB_CHIFFRE]);
static void saisie (int Ligne, int essai[COUP_MAX][NB_CHIFFRE]);
static void teste (int Ligne, int res[COUP_MAX][2], int code[NB_CHIFFRE], int essai[COUP_MAX][NB_CHIFFRE]);
static void affichage(char mode, int res[COUP_MAX][2], int code[NB_CHIFFRE], int essai[COUP_MAX][NB_CHIFFRE], int Ligne, int coup);
 
 
 
/* Programme principal */
int main(void)
 
{
    int essai[COUP_MAX][NB_CHIFFRE];       /* Tableau contenant les combinaisons essayees */
    int res[COUP_MAX][2];                  /* Tableau contenant les resultats de chaque combinaison 1 colonne *
                                            * qui compte les chiffres biens places et une pour les mal places */
    int code[NB_CHIFFRE];
    int Ligne;                             /* Indique la ligne en cours de traitement */
    int Coup;                              /* Indique le nombre de coup joue */
 
    int Nouveau;
    int ret;                                /* Valeur utilisé pour controler la saisie en fin de jeu */
    char c;                                 /* Caractere saisie en fin de jeu */
 
 
 
    do {
        Coup = 1;
        Ligne = 0;
        Nouveau = KO;
 
        /* Initialisation de tous les tableaux */
        init(res,code,essai);
 
 
        /* Generation du code aleatoire */
        srand(time(NULL) % RAND_MAX);
        hasard(code);
 
 
        /* Affichage du menu */
        affichage(MENU,res,code,essai,0,0);
 
 
        /* Test de l'essai */
        do {
            saisie(Ligne,essai);                                    /* On recupere la combinaison du joueur */
            teste(Ligne,res,code,essai);                            /* On teste la combinaison */
            affichage(ESSAI,res,code,essai, Ligne,0);               /* On affiche toutes les combinaison essayes et leur resultat */
            Ligne++;
            Coup++;
        }
        while (res[Ligne-1][BIEN_PLACE] != NB_CHIFFRE && Coup <= COUP_MAX);
 
 
        /* Suivant le nombre de caractere bien place trouve on choisit le message a afficher */
        if (res[Ligne-1][BIEN_PLACE] == NB_CHIFFRE) {
            affichage(GAGNE,res,code,essai,0,Coup);
        }
        else {
            affichage(PERDU,res,code,essai,0,Coup);
        }
 
 
        /* On demande si le joueur veut rejouer */
        printf("\n\n"
               "Pour rejouer tapez 'o' sinon tapez 'n' pour quitter : ");
        do {
            char saisie[5];
            fgets (saisie, sizeof saisie, stdin);
            ret = sscanf (saisie, "%c", &c);
 
            if (ret != 1) {
                printf("\nERREUR\n");
            }
 
            else if (c == REJOUER) {              /* Si on rentre 'o', on demande une nouvelle partie */
                Nouveau = OK;
            }
 
            else if (c ==  QUITTER) {             /* Si on rentre 'n', on veut quitter le jeu */
                break;
            }
 
            else {
                printf("\nERREUR. La commande n'est pas reconnue"
                       "\n\n"
                       "Pour rejouer tapez 'o' sinon tapez 'n' pour quitter : ");
                ret = 0;
            }
        }
        while (ret != 1);
 
    }
    while (Nouveau != KO);
 
    return 0;
}
 
 
/* Fonction d'initialisation des tableaux */
static void init (int res[COUP_MAX][2], int code[NB_CHIFFRE], int essai[COUP_MAX][NB_CHIFFRE]) {
    int ind_col, ind_lig;
 
    /* Initialisation du tableau CODE */
    for (ind_col = 0; ind_col < NB_CHIFFRE; ind_col++) {
        code[ind_col] = 0;
    }
 
    /* Initialisation du tableau RES */
    for (ind_lig = 0; ind_lig < COUP_MAX; ind_lig++) {
        for (ind_col = 0; ind_col < NB_CHIFFRE;ind_col++) {
            res[ind_lig][ind_col] = 0;
        }
    }
 
    /* Initialisation du tableau ESSAI */
    for (ind_lig = 0; ind_lig < 2; ind_lig++) {
        for (ind_col = 0; ind_col < NB_CHIFFRE; ind_col++) {
            res[ind_lig][ind_col] = 0;
        }
    }
}
 
 
 
/* Fonction Hasard qui determine le code secret */
static void hasard(int code[NB_CHIFFRE]) {
 
    int val_tmp;                /* Valeur temporaire */
    int ind_col;                /* Indice de colonne */
    int pos;                    /* Indique la position en cours dans les colonnes du tableau CODE */
    int doublon;                /* Indique si un doublon a ete trouve (1 pour Oui, 0 pour Non) */
 
    pos = 0;
    while (pos < NB_CHIFFRE){
 
        doublon = OK ;
        while (doublon == OK) {
            doublon = KO ;
            val_tmp = (rand()% (BORNE_MAX));
 
        /* Verifier que la valeur tiree n'est pas deja presente dans le code secret */
            for (ind_col = 0; ind_col < pos; ind_col++) {
                if (val_tmp == code[ind_col]) {
                    doublon = OK ;
                    break;
                }
            }
        }
        code[pos++] = val_tmp;
    }
}
 
 
/* Fonction de Saisie de la Combinaison */
static void saisie (int Ligne, int essai[COUP_MAX][NB_CHIFFRE]) {
 
    int err = 0;                        /* Variable de controle des erreurs de saisie */
    int ind_col;                        /* Indice de la colonne en cours */
    char chaine[20];                    /* Chaine de caractere pour la saisie de la combinaison */
 
 
    /* Acquisition des chiffres de l'essai */
    do {
        printf("\nEntrez votre combinaison : ");
        fgets(chaine, sizeof chaine, stdin);
 
        err = sscanf(chaine, "%d %d %d %d %d", &essai[Ligne][0], &essai[Ligne][1], &essai[Ligne][2], &essai[Ligne][3],&essai[Ligne][4] );
 
        if (err != NB_CHIFFRE) {
            printf("Vous n'avez rentre que %d chiffre(s) au lieu de %d.\n",err,NB_CHIFFRE);
        }
    }
    while (err != NB_CHIFFRE);
 
    /* Verifier que les chiffres sont compris entre 0 et 9 */
 
    for (ind_col = 0; ind_col < NB_CHIFFRE; ind_col++) {
        err = 0;
 
        while (essai[Ligne][ind_col] < 0 ||  essai[Ligne][ind_col] > 9 ) {
 
                printf("\nLe chiffre rentré dans la position %d, soit %d, est au-dessus de la borne superieure\n", ind_col+1, essai[Ligne][ind_col]);
                printf("Veuillez entrez un nouveau chiffre en remplacement : ");
                fgets(chaine, sizeof chaine, stdin);
                err = sscanf(chaine, "%d", &essai[Ligne][ind_col]);
 
                if (err != 1) {
                    puts("ERREUR");
                }
        }
    }
    printf("\n");
}
 
 
/* Fonction Test : compare la combinaison du joueur avec le code secret */
static void teste (int Ligne, int res[COUP_MAX][2], int code[NB_CHIFFRE], int essai[COUP_MAX][NB_CHIFFRE]) {
 
    int ind_essai, ind_code;
 
    /* On cherche d'abord les chiffres presents et bien places */
    for (ind_essai = 0; ind_essai < NB_CHIFFRE; ind_essai++) {
 
            if (essai[Ligne][ind_essai] == code[ind_essai]) {
                res[Ligne][BIEN_PLACE] += 1;            /* On ajoute un caractere bien place */
                essai[Ligne][ind_essai] += 10;          /* On s'assure que cette position n'est pas réutilisée */
                code[ind_essai] += 20;                  /* On s'assure que cette position n'est pas réutilisée */
            }
        }
 
 
    /* On cherche ensuite les chiffres presents mais mal places */
    for (ind_essai = 0; ind_essai < NB_CHIFFRE; ind_essai++) {
            for (ind_code = 0; ind_code < NB_CHIFFRE ; ind_code++) {
                if  ((essai[Ligne][ind_essai] == code[ind_code])) {
                    res[Ligne][MAL_PLACE] += 1;          /* On ajoute un caractere mal place */
                    code[ind_code] += 20;                /* On s'assure que cette position n'est pas réutilisée */
                    break ;
                }
            }
        }
 
    /* Les données écrasées sont remise d'aplomb */
        for (ind_essai = 0; ind_essai < NB_CHIFFRE; ind_essai++) {
                    essai[Ligne][ind_essai] %= 10;
                    code[ind_essai] %= 10;
        }
}
 
 
/* Fonction affichage */
static void affichage(char mode, int res[COUP_MAX][2], int code[NB_CHIFFRE], int essai[COUP_MAX][NB_CHIFFRE], int Ligne, int Coup ) {
 
 
    int ind_lig;        /* Indice de ligne */
    int ind_col;        /* Indice de colonne */
 
 
 
    switch (mode) {
        case ESSAI :
 
            for (ind_lig = 0; ind_lig <= Ligne; ind_lig++) {
 
                /* Affichage de la combinaison */
                for (ind_col = 0; ind_col < NB_CHIFFRE; ind_col++) {
                    printf("%d ",essai[ind_lig][ind_col]);
                }
                printf("\t");
 
                /* Affichage du resultat de la combinaison */
                for (ind_col = 0; ind_col < res[ind_lig][BIEN_PLACE]; ind_col++) {
                    printf("# ");
                }
 
                for (ind_col = 0; ind_col < res[ind_lig][MAL_PLACE]; ind_col++) {
                    printf("* ");
                }
 
                /*  la difference : NB_CHIFFRE - res[ind_lig][BIEN_PLACE] - res[ind_lig][MAL_PLACE] permet de savoir
                    s'il faut afficher des espaces vides, des '.' ou aucun */
                for (ind_col = 0; ind_col < (NB_CHIFFRE - res[ind_lig][BIEN_PLACE] - res[ind_lig][MAL_PLACE]); ind_col++) {
                    printf(". ");
                }
 
                printf("\n");
            }
            break;
 
        case PERDU :
            printf("\nPERDU, le code correct etait :\t");
            for (ind_col = 0; ind_col < NB_CHIFFRE; ind_col++) {
                printf("%d ", code[ind_col]);
            }
            printf("\n\n");
            break;
 
        case GAGNE :
            printf("\nGAGNE, le code etait bien :\t");
            for (ind_col = 0; ind_col < NB_CHIFFRE; ind_col++) {
                printf("%d ", code[ind_col]);
            }
            printf("\nVous avez trouvez le code au bout de %d tentative(s)\n",Coup - 1);
            printf("\n\n");
            break;
 
        case MENU :
            printf("\n\n"
                   "\t\t\t*****************************\n"
                   "\t\t\t*                           *\n"
                   "\t\t\t*        MASTERMIND         *\n"
                   "\t\t\t*                           *\n"
                   "\t\t\t*****************************\n"
                   "\n\n"
                   "******************************************************************************\n"
                   "*  - Utilisez les combinaisons dans le style : a b c d e puis 'entree'       *\n"
                   "*  - Les nombres possibles sont compris entre 0 et 9                         *\n"
                   "*                                                                            *\n"
                   "* - Les caracteres # et * vous permettent de savoir le nombre                *\n"
                   "*   de chiffres de votre combinaison dans le code secret respectivement      *\n"
                   "*   bien places et mal places.                                               *\n"
                   "*                                                                            *\n"
                   "* - Vous avez droit a %d essais.                                             *\n",COUP_MAX);
 
            printf("*                                                                            *\n"
                   "******************************************************************************\n");
            break;
 
    }
  }

**aliwatte** · 24/12/2007, 23h13

bonsoir !
je trouve que ton code fonctionne bien mais je le trouve trop long alors pourquoi ne veut tu pas le diviser en 2 ou 3 fichier par exemple .

**beware** · 26/12/2007, 13h37

Envoyé par aliwatte

bonsoir !
je trouve que ton code fonctionne bien mais je le trouve trop long alors pourquoi ne veut tu pas le diviser en 2 ou 3 fichier par exemple .

Tu vas rire, mais au debut j'avais, et je ne sais pour quelle raison, divise mon fichier en autant de fichier qu'il y a de fonction.

Mais j'ai tout regroupé pour poster ici. Cependant je ne vois pas ou est l'interet de diviser le fichier ? Ormis la lisibilité, ce qui est deja pas mal tu me diras.

Premier programme en C, qu'en pensez-vous? [Débutant(e)]

C

Discussions similaires

Partager

Partager