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

[foetus]

je n'ai pas trouvé mieux, de plus propre, pour répéter 4 fois un appel à une fonction...

Es-tu sérieux ?

Pas de tableau, code hardcodé ... surtout que tu ne fais aucun test.

Code :

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

1
2
3
4
    val1 = tirer_couleur();
    val2 = tirer_couleur();
    val3 = tirer_couleur();
    val4 = tirer_couleur();

Édit : @kaitlyn dans 1 message suivant, précise que c'est du code que le P.O. avait déjà codé.
Ce n'est pas possible, c'est 1 troll entre les fonctions qui n'appellent pas et coder 1 boucle sans tableau

[debuteenc]

Les seuls tests pour cette procédure sont ceux que je faits sur le code. Mon code fonctionne...mais il n'est surement pas optimal...
Ceci dit si je remplace mon code, à l'intérieur de la procédure, par celui que vous m'avez fourni, cela ne compile pas.
J'ai cette erreur...error invalid conversion from 'char(*) ()' to 'char' [-fpermissive]

Merci pour votre diligence et disponibilité

Code :

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

1
2
3
4
5
6
7
8
9
10
/*Tirer et mémoriser les couleurss choisies par l'ordinateur*/
 
char tirer_memoriser(char &val1, char &val2, char &val3, char &val4)
{
 
    val1 = tirer_couleur;
    val2 = tirer_couleur;
    val3 = tirer_couleur;
    val4 = tirer_couleur;
}

[debuteenc]

...J'ai remplacé val1 = tirer_couleur; par val1 = (tirer_couleur()); ... et ça fonctionne!

Merci encore

[kaitlyn]

Ta première idée avec string (dans ton premier message) était je trouve bien plus intéressante. Certe elle nécessite une petite remise en forme, mais pourquoi l'avoir abandonnée ?

[debuteenc]

L'idée était de retourner un string comprenant la concaténation des 4 caractères (char) tirés...Mais, je n'ai pas trouvé comment faire...J'ai également une procédure similaire pour mémoriser des caractères saisis par le clavier. Ensuite, il faut vérifier la concordance des caractères entre eux...(Mastermind)...Avec deux strings, je pourrai les utiliser comme deux arrays, et les parcourir très simplement. Non?

[foetus]

L'idée était de retourner un string comprenant la concaténation des 4 caractères (char) tirés...Mais, je n'ai pas trouvé comment faire...

Code :

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

1
2
3
4
std::string tirer_memoriser_combinaison() {
    return (std::string(1, tirer_couleur()) + tirer_couleur() + tirer_couleur() + tirer_couleur());
//  return (std::string{ tirer_couleur() } + tirer_couleur() + tirer_couleur() + tirer_couleur());
}

Peut-être qu'il faut convertir tous les caractères en std::string, non juste celui le + à gauche.
Et la deuxième solution est la solution moderne.

[kaitlyn]

Édit : @kaitlyn dans 1 message suivant, précise que c'est du code que le P.O. avait déjà codé.
Ce n'est pas possible, c'est 1 troll entre les fonctions qui n'appellent pas, et coder 1 boucle sans tableau

Le contraste est juste énorme !

[kaitlyn]

Avec deux strings, je pourrai les utiliser comme deux arrays, et les parcourir très simplement. Non?

Oui oui, absolument.

[debuteenc]

Merci!!!!!!!!!!!!!!¨
La toute grande classe!!!
Cela fonctionne même avec le random générateur originel. Partant, plus besoin de la boucle for qui permettait une génération correcte de caractères aléatoires.

Le code s'en trouve plus aéré et compréhensible.

Bonne après-midi

[kaitlyn]

Avec une boucle ça donne un code tout aussi bien, que tu aurais d’ailleurs pu produire avec les capacités montrées dans le premier message. Tu n'en étais vraiment pas loin et rien ne t’interdit de le faire quand même. Pour ton générateur d’origine, si le delta-T entre deux lancements est suffisamment long sa faiblesse intrinsèque ne se remarque pas et c'est ce que tu viens d’expérimenter après ne pas l'avoir utilisé pendant un certains temps.

[debuteenc]

Merci pour ces précisions et encouragements. Je dois avouer que j'ai tout de même un peu de pratique du C que j'ai utilisé pour la programmation des microcontrôleurs. Cependant, c'est du grand tourisme relativement à vos conseils éclairés... La solution que vous m'avez proposée m'a permis de réduire la taille de mon code d'un facteur3! Vous trouverez ci-joint un aperçu (un test) d'une des procédures que vous m'avez permis de réaliser, et j'en suis très heureux...
Bonne soirée

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
#include <iostream>
using namespace std;
 
int main()
{
    string combinaison = ("yryr"); //simulation d'une combinaison générée par l'ordinateur
	string couleurs = ("rrry");    //simulation d'une combinaison du joueur
 
	int nb_bien_placees(0), nb_mal_placees(0);  //Compteurs de pions, de la bonne couleur, bien et mal placés
 
	for (int i=0; i<4;i++)                      //Boucle permettant de déterminer les pions bien placés
        {
            if (combinaison [i] == couleurs[i])
            {
                combinaison[i] = 'x';
                couleurs[i] = 'z';
                nb_bien_placees ++;
            }
 
        }
                cout<<combinaison<<endl;        //Affichages pour les tests
                cout<<nb_bien_placees<<endl;
 
	for (int i=0; i<4;i++)                      //Boucle permettant de déterminer les pions mal placés. Deux indices de balayage sont urilisés, i et j
        {
            for (int j=0; j<4;j++)
            {
                if (combinaison [i] == couleurs[j])
                    {
                        combinaison[i] = 'x';
                        couleurs[j] = 'z';
                        nb_mal_placees ++;
                    }
            }
        }
                cout<<combinaison<<endl;
                cout<<nb_mal_placees<<endl;
}

[kaitlyn]

C'est très bien, cependant sur les lignes 6 et 7 ajoute un const au début et vois ce qui se passe. Ensuite il faudra regarder l'algorithme de plus près mais sache déjà que std::string te propose une fonction membre qui peut faire une bonne partie du travail pour toi : https://www.cplusplus.com/reference/string/string/find/

Edit:

Au temps pour moi. En lisant finalement ton code je comprends pourquoi tu modifies tes chaînes. Donc je n'ai rien dit sinon bravo.