Discussion :

[debuteenc]

Bonsoir,

J'utilise à nouveau un algo pour générer des caractères aléatoires (quatre) bornés (parmi RGBYMC et .). La fonction générateur s'appelle "char tirer_couleur()" et retourne un caractère.

J'ai créé une fonction qui appelle "char tirer_couleur()" et qui collectionne lesdits caractères. Jusque là, tout se passe bien. Ensuite j'ai créé une variable string qui contient les 4 caractères concaténés. Ensuite je retourne la variable string que je peux afficher.

Le hic, c'est que chaque tirage comporte le caractère "B", comme première caractère de la série. J'ai utilisé ailleurs, le même générateur et je n'ai pas eu ce même problème...
Je sèche... Tout d'abord que pensez-vous du code? et dans un deuxième temps auriez-vous une piste à suivre pour le caractère "B" ?

Merci et bon week-end

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
#include <iostream>
#include <ctime>
 
// pour les nombres aléatoires
#include <random>
#include <cstring> // strlen
 
using namespace std;
 
// ======================================================================
// Couleur au hasard
std::uniform_int_distribution<int> distribution;
std::default_random_engine generateur(time(NULL)); /* NOT using std::random_device since not
                                                    * all compilers seems to support it :-( */
char tirer_couleur()
{
  static const char* const couleurs = ".RGBCYM";
  static const int nb = strlen(couleurs) - 1;
 
  return couleurs[distribution(generateur,
                               std::uniform_int_distribution<int>::param_type {0, nb})];
}
 
 string tirer_memoriser_combinaison()
{
    char rand1(' '),rand2 (' '),rand3(' '),rand4(' ') ;
 
    rand1 = tirer_couleur();
    rand2 = tirer_couleur();
    rand3 = tirer_couleur();
    rand4 = tirer_couleur();
 
    string result;
    result += rand1;
    result += rand2;
    result += rand3;
    result += rand4;
 
    return result;
}
 
// ======================================================================
 
void jouer()
{
    /*Tirer et mémoriser les couleurss choisies par l'ordinateur*/
 
     string combinaison = tirer_memoriser_combinaison(); // appel de la fonction tirer et mémoriser
     cout <<combinaison<<endl;
}
 
int main()
{
 
   jouer();
 
  return 0;
}

[kaitlyn]

Ah ha ! Salut,

Il me semblait bien que je t'avais déjà posé la question

P.-S. Est-ce que le code dans ce -> message provient du livre en question ? Quel est son titre ? Son édition ?

et la réponse était que ça sort d'une grande école, c'est ça ? Désolée je suis vraiment en train de surtout quand je vois la 13ème ligne avec son message.

Bon fin des plaisanteries. Alors le problème vient de time(NULL) qui produit une graine (seed) trop faïble (valeur de faible grandeur et qui ne change pas de manière significative) ce qui donne des séquences, surtout le début, très mal distribuées. D'où le phénomène de répétition que tu constates. Dans les faits on se retrouve avec un générateur de faible entropie.

Donc pour y remédier on peut utiliser comme graine std::chrono::system_clock::now().time_since_epoch().count() après avoir inclus l'en-tête <chrono>.

Et puis tant qu'à faire

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <iostream>
#include <chrono>
#include <random>
 
char tirer_couleur()
{
    static const char arr[]= ".RGBCYM";
    static const int n= sizeof arr - 2;  // 1 pour le zéro de fin de chaine et 1 pour l'indexation qui commence à zéro
    static auto seed= std::chrono::system_clock::now().time_since_epoch().count();
    static std::uniform_int_distribution<> dis{0, n};
    static std::default_random_engine gen(seed); 
    return arr[dis(gen)];
}

tout en restant dans la lignée de ton code de sorte que ça te reste familier.

[debuteenc]

Merci! Ça à l'air de bien fonctionner. Je joint le code créé.
Comme on peut le voir, ma fonction retourne 4 "char". Pour faciliter leur traitement je souhaite n'avoir plus qu'une seul variable...Cependant, je ne sais comment faire. Dois-je modifier ma fonction, son appel?

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
/*Tirer et mémoriser les couleurss choisies par l'ordinateur*/
 
char tirer_memoriser(char &val1, char &val2, char &val3, char &val4)
{
for (int i=0;i<5;i++)
 
         {
           char c (tirer_couleur());  // définition de la variable locale c
 
            if (i == 0)
              {
                char val1(' '), val2(' '), val3(' '), val4(' ');  //Initialisation des variables
              }
             if (i == 1)
              {
                val1=c;
              }
            if (i == 2)
              {
                val2=c;
              }
            if (i == 3)
              {
                val3=c;
              }
            if (i == 4)
              {
                val4=c;
              }
      }
}
 
// ======================================================================
void jouer()
{
    /*Tirer et mémoriser les couleurss choisies par l'ordinateur*/
 
        char rand1, rand2, rand3, rand4;
        tirer_memoriser(rand1, rand2, rand3, rand4);
 
        afficher_couleurs(rand1,rand2,rand3,rand4);
}

[Astraya]

std::tuple

[jo_link_noir]

std::array serait plus cohérent, on peut boucler dessus.

Au passage, la boucle de qui fait une chose différente à chaque tour de boucle ne sert à rien... Ce n'est pas une boucle.

Code :

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

1
2
3
4
5
6
7
8
 
std::array<char, 4> tirer_memoriser()
{
  std::array<char, 4> couleurs;
  for (char& c : couleurs)
    c = tirer_couleur();
  return couleurs;
}

[debuteenc]

Merci pour les infos! Malheureusement je n'ai pas le droit d'utiliser des arrays......Pas encore...

En ce qui concerne la boucle, je n'ai pas trouvé mieux, de plus propre, pour répéter 4 fois un appel à une fonction...je sui bien sûr preneur de toute amélioration.

Je vous souhaite une excellente soirée remplie de surprises agréables

Jean-Pierre