Discussion :

[Micke7]

Bonjour à tous,

J'essai de tirer un nombre aléatoirement entre 0 et 336531, mais apparament cela est impossible avec :

time_t t;
int nbaleatoire;

srand((unsigned) time(&t));
nbaleatoire = rand()%336531;

En effet tous les nombres que je tire se trouve dans la même fourchette de grandeur, c'est à dire 20000...

J'aimerais donc savoir s'il existe une fonction qui me permettrait de palier se probleme, ou s'il va falloir que je calcule cela tout seul?

Merci beaucoup.

PS:Ce nombre tiré va me permettre de choisir un mot au hasard dans un fichier text.

[Médinoc]

RAND_MAX est généralement égal à 32767, donc tu vas devoir faire plusieurs rand() si tu veux plus de 15 bits d'aléatoire (et même, les bits inférieurs de rand() sont généralement de basse qualité. Tu devrais n'utiliser que 10 bits par rand() si tu veux un truc de qualité)...

[mchk0123]

De plus si tu utilise succéssivement 2 rand() pour générer un entier de grand taille, tu perd un peu en qualité car le deuxième rand() à un biais de dépendance par rapport au premier().

Les paranoïaques, vont plutôt générer 2 tables avec 2 graînes différentes et piocher le premier nombre dans la table1, et le deuxième nombre dans la table2.

[Micke7]

Merci de vos réponses.
Etant donné que mon programme ne servira que pur un projet de BTS, si nbaleatoire n'est pas si aléatoire que ça ce n'est pas grave.

Pour info j'ai utilisé :

nbaleatoire2 = rand()%581;
nbaleatoire3 = rand()%581;
nbaleatoire = nbaleatoire2 * nbaleatoire3;

C'est tout simple mais ça suffit :p.


Plutot que de creer un autre topic, je vais profiter de celui là pour poser une autre question :

Si je veux utiliser plusieurs fois le fichier déclaré ainsi :
std::ifstream fichier("dico.txt");,
faut il que je le ferme à chaque opération?
Je m'explique, je suis en train de faire un pendu en C++ (ça me suffit pour débuter ;p), et il m'est impossible de faire une boucle permettant au joueur de refaire une partie lorsque la précedente est terminée. En effet, j'ai le droit à chaque fois à des bugs et je suis sûr que c'est à cause des fichiers.

Si vous avez le temps (et l'envie surtout...), voilà mon code. Il est loin d'être parfait mais étant donné que je débute en C++, essayer d'être comprehensif ;p.

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
#include <string> 
#include <string.h> 
#include <fstream> 
#include <iostream> 
#include <time.h>
#include <stdlib.h>
 
 
time_t t; //variable permettant de tirer aléatoirement un nombre.
int choix; //est utilisé pour selectionner le nombre de joueur.
int nbaleatoire; //sert à selectionner un mot au hasard
int nbaleatoire2;
int nbaleatoire3;
int i = 0; //entier utilisé de nombreuse fois.
int presencelettre = 0;//Variable utilisé pour vérifier si la lettre entrée a déjà était trouvée
int nbrerr = 0; //est utilisé pour calculer le nombre d'erreurs restantes.
int testerreur = 0;//Booléen : 0 = erreur, 1 = Pas d'erreur. 
int nbrlettremot =0; //Nombre de lettre que contient le mot choisi. 
int nbrlettretrouvee = 0; //Nombre de lettre du mot trouvées par le joueur
int tablmot[50];//Déclare le tableau de booléen avec nbr de case au hasard
int motexiste = 0; //Pour 2 joueur. Si le mot choisi existe = 1, sinon =0
char lettre; //Lettre tapée par l'utilisateur
std::string j1; //Nom du joueur1
std::string j2; //Nom du joueur2
std::string mot; //variable contenant chaque ligne lue 
std::string mott;//variable servant à tester le mot du joueur2
std::ifstream fichier("dico.txt");// le constructeur de ifstream permet d'ouvrir un fichier en lecture 
 
//Initialisation du tableau booléen.Chaque case correspond à une lettre du mot secret. 0 = lettre non trouvée, 1 = lettre trouvée
void inittablmot(int nbrlettres) 
{ 
     int tablmot[nbrlettres];
 
     for (i=1;i<=nbrlettres;i++)
     {
         tablmot[i] = 0;
     }
}  
 
//Test d'affichage. La lettre est affiché si booléen = 1 sinon * la remplace
void affichlettre(int nbrlettres,int tablmota[20],std::string mota) 
{
     for (i=0;i<nbrlettres;i++)
     {
         if (tablmota[i]==0)
         {
            std::cout<<"*";
         }
         else
         {
             std::cout<<mota[i];
         }
     } 
     std::cout<<"\n";  
}
 
 
//Verification si la lettre entree par le joueur se trouve dans le mot
void testlettre(int nbrlettresmot, char lettres,std::string mota,int tablmota[20])
{
     for(i=0;i<nbrlettresmot;i++)//parcours du mot
     {
      if (lettres==mota[i])//si la lettre est dans le mot
      {
       if (tablmota[i]==0)//Vérification si la lettre juste n'a pas déjà était choisi
       {
        tablmota[i]=1;
        nbrlettretrouvee=nbrlettretrouvee+1;//permet de savoir si le mot est terminé
        testerreur = 1;//annule l'erreur
       }
 
       //Si la lettre existe déjà
       else
       {
        presencelettre = 1;
       }
 
      }//fin "si" du test de presence de la lettre dans le mot
 
     }//fin "pour" du parcour du mot 
 
 
     if (presencelettre!=0)//la lettre a déjà était trouvée donc message d'erreur
     {
      std::cout<<"La lettre a deja etait trouvee\n";
      presencelettre=0;
     }
 
     //test d'erreur
     if (testerreur == 0)//La lettre entrée est soit mauvaise, soit déjà trouvée
     {
      nbrerr=nbrerr+1;//rajoute un coup au nombre de coup total
     }
     else//La lettre est bonne et n'a pas déjà était trouvée
     {
      testerreur=0;//Reinitialise l'erreur à faux.
     }
}
 
 
//test du mot en fin de partie
void testmot(int nbrlettretrouvees,int nbrlettresmot,int nbrerrs,std::string mota)
{
     if (nbrlettretrouvees==nbrlettresmot)
     {
      std::cout<<"\nBravo, vous avez trouve le mot "<<mota<<" \n\n\n";
     }
 
     //si le mot n'a pas était trouvé
     if ((nbrlettretrouvees != nbrlettresmot) and (nbrerrs==10))
     {
      std::cout<<"Desole, vous avez perdu\n";
      std::cout<<"Le mot qu'il fallait trouver etait : "<<mota<<"\n\n\n";
     }
 }
 
 
 //début du jeu
 void lancementjeu(int nbrlettresmot,std::string mota,int tablmota[20])
 {
                   while ((nbrerr != 10) and (nbrlettretrouvee != nbrlettresmot))
                   {
                    std::cout<<"\nVous avez le droit a encore "<<10 - nbrerr<<" erreurs\n";
                    std::cout<<"Quel est le mot secret? : ";
 
                    affichlettre(nbrlettresmot, tablmota, mota);
 
                    std::cout<<"Choisissez une lettre : ";
                    std::cin>>lettre;
 
                    //test des lettres entrées
                     testlettre(nbrlettresmot,lettre,mota,tablmota);
 
                    //test du mot lorsque partie terminée
                    testmot(nbrlettretrouvee,nbrlettresmot,nbrerr,mota);
 
                    }//fin while du début de partie 1 joueur.
 
 }
 
 
//Verifaiaction de l'existence du mot dans le dictionnaire
void testmotexist(std::string mota,std::string joueur)
 {
     while (motexiste == 0)
     {
      std::ifstream fichierdico("dico.txt");//ouverture du fichier dico.txt en lecture
      std::cout<<joueur<<" entrez le mot a trouver (sans majuscules ni accents)\n\n";
      std::cin>>mot;
 
      while (!fichierdico.eof() and mott != mot)//parcours le dictionnaire jusqu'a ce que le mot est trouvé 
                                                            //ou qu'on arrive à la fin du dictionnaire.
      {
       std::getline(fichierdico, mott);
      }
      fichierdico.close();         
 
      if (mott!=mot)//si aucun mot du dico = mot selectionnée
      {
       std::cout<<"\nCe mot n'est pas reference dans le dictionnaire.\nVeuillez en saisir un autre.\n\n";
      }
 
      else
      {
       motexiste=1;
      }
 
      }// fin boucle de test si le mot entré existe
}
 
 
main() 
{ 
 
  system("CLS");
 
  std::cout <<"Bienvenue dans le jeu du pendu\n\n\n";
  std::cout <<"Voulez-vous jouer seul ou a plusieurs?\n";
  std::cout <<"Tapez 1 pour 1 joueur, 2 pour 2 joueurs ou 0 pour quitter\n";
  std::cin>>choix;
 
 
 
          switch (choix)
          { 
            case 1:
 
//******************************1joueur***********************************************************************
 
 
            if ( fichier ) // ce test échoue si le fichier n'est pas ouvert 
            { 
 
              std::cout<<"\n\n********************************** 1 Joueur ************************************\n\n";
              srand((unsigned) time(&t));
              std::cout<<mot;
              //tirage d'un nombre aléatoire
              nbaleatoire2 = rand()%581;
              nbaleatoire3 = rand()%581;
              nbaleatoire = nbaleatoire2 * nbaleatoire3;
 
              //Choix d'un mot au hasard.
              while (i!=nbaleatoire)
              {
                 std::getline( fichier, mot );  
                 i=i+1;
              }
 
              std::cout<<mot;
              //recupere le nombre de lettre du mot choisi
              nbrlettremot = mot.size();
 
              //initialise le tableau de booléen
                    inittablmot(nbrlettremot);
 
              //Début du jeu
              lancementjeu(nbrlettremot,mot,tablmot);
 
            }//fin teste si fichier mots existe
 
            else //si fichier de mots n'existe pas
            {
             std::cout<<"Fichier minidoco.txt introuvable, demarrage du jeu impossible\n" ;
             std::cout<<"Seul le mode 2 joueurs est disponible\n" ;
            }
            fichier.close();
 
            break ;
 
 
 
//*****************************************2 Joueurs*****************************************************************************
            case 2: 
 
 
                 std::cout<<"\n\n********************************** 2 Joueurs ***********************************\n\n";
                 std::cout<<"\nJoueur 1 entrez votre prenom\n";
                 std::cin>>j1;
                 //fichierjou << j1;
 
                 std::cout<<"\nJoueur 2 entrez votre prenom\n";
                 std::cin>>j2;
                 //fichierjou << j2;
                 //fichierjou.close();
 
                 std::cout<<"\nQui commence par chercher le mot de l'autre?\n";
                 std::cout<<"Tapez 1 pour joueur 1 et 2 pour joueur 2\n";
                 std::cin>>choix;
                 std::cout<<"\n";
                 switch (choix)
                 { 
 
                 case 1 :
 
                 std::cout<<j1<<" Ne regardez pas.\n";
 
                 //Vérification du mot dans dictionnaire
                 testmotexist(mot,j2);
 
 
                 //recupere le nombre de lettre du mot choisi
                 nbrlettremot = mot.size();
 
                 //initialise le tableau de booléen
                 inittablmot(nbrlettremot);
 
                  //Début du jeu
                  std::cout<<"\n"<<j1<<" a vous de jouer\n";
                  lancementjeu(nbrlettremot,mot,tablmot);
 
 
                  break;
 
                  case 2 :
 
                 std::cout<<j2<<" Ne regardez pas.\n";
 
                 //Vérification du mot dans dictionnaire
                 testmotexist(mot,j1);
 
 
                 //recupere le nombre de lettre du mot choisi
                 nbrlettremot = mot.size();
 
                 //initialise le tableau de booléen
                 inittablmot(nbrlettremot);
 
                  //Début du jeu
                  std::cout<<"\n"<<j2<<" a vous de jouer\n";
                  lancementjeu(nbrlettremot,mot,tablmot);
 
 
                  break;
 
              }//fin switch du joueur qui commence dans la partie à 2 joueur
 
 
 
              break;
            }//fin switch choix nombre de joueur
 
 
 
system("pause");
} //fin main()

Je ne vous demande pas de me le corriger, mais juste de me dire où ouvrir et où fermer les fichiers, pour à la fois respecter "les régles" de programmation et pouvoir faire la boucle décrite pplus haut.

Merci à la personne qui s'y collera ;p.

ciao

[mchk0123]

nbaleatoire2 = rand()%581;
nbaleatoire3 = rand()%581;
nbaleatoire = nbaleatoire2 * nbaleatoire3;

Du n'as pas dut être trés assidu en cours de math

Code :

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

nbaleatoire = nbaleatoire2 * 581 + nbaleatoire3;

[Micke7]

Du n'as pas dut être trés assidu en cours de math

Code :

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

nbaleatoire = nbaleatoire2 * 581 + nbaleatoire3;

Bah mince, je comprend pas là, pourquoi nbaleatoire = nbaleatoire2 * 581 + nbaleatoire3?

Etant donné que tu as 581 possibilité avec nbaleatoire2 et 581 nbaleatoire3, nbaleatoire = 581 * 581 = 337561 ~~ 336531.

Aurais-je raté quelque chose?

[EDIT], j'ai testé avec ta formule et cela fonctionne mieux (les écarts de place alphabetique entre les mots est plus grands).ça n'empéche que j'aimerais bien savoir pourquoi ( afin de me coucher moins bête ;p).