Tirage aléatoire de dés

[Résolu]
Signaler
Messages postés
61
Date d'inscription
dimanche 3 décembre 2006
Statut
Membre
Dernière intervention
21 juillet 2010
-
Messages postés
198
Date d'inscription
vendredi 4 avril 2003
Statut
Membre
Dernière intervention
18 mars 2011
-
   Bonjour tout le monde et tout d'abord bravo pour ce site.

   Je dois faire un programme  où on souhaite simuler N tirages simultanés de deux dés et relever pour chaque tirage la somme des dés et j'ai malheureusement des difficultés à y parvenir.

   L'objectif est de simuler N lancés (10,100,1000 ou 10000) de deux dés, de calculer le nombre d'occurences de chaque sommes (nb de fois où on obtient 2,3,...,12) et de représenter ces occurences sur un histogramme.

   J'ai malheureusement du mal pour faire ce programme :( .Je ne sais pas comment m'y prendre pour effectuer deux tirages aléatoires simultaner de dés et aussi comment afficher les résultats obtenus dans un histogramme.

   J'aimerais un peu d'aide et des explications de votre part si celà ne vous dérange pas et je vous remercie d'avance.

Bonne continuation à tous ^^

Ps: J'ai essayé de rechercher des sujets similaires mais malheureusement celà ne m'a pas permis d'avancer dans mon problème

10 réponses

Messages postés
1787
Date d'inscription
lundi 22 novembre 2004
Statut
Membre
Dernière intervention
31 janvier 2009
2
Euh
Là je m'excuse mais c'est totalement hors sujet
Je vois pas pourquoi on ne mettrai pas de doublon dans le lancement de dés
Un dé ça reste un dé...

int des1 = (rand() % 6) + 1;   //Chiffres en 1 et 6
int des2 = (rand() % 6) + 1;   //Pareil

tabOfOccurrence[des1 + des2 - 2]++;

répéter cette opération autant de fois que tu veux lancer les 2 dés.
Biensur ne pas oublier d'initialiser tabOfOccurrence à 0. ( c'est un tableau de 11 entier parce que les sommes possibles sont 2, 3, 4, ..., 11, 12

Ensuite en ce qui concerne l'histogramme, si t'arrive pas à simuler un lancer de dés, j'pense qu'il est pas convenable d'y songer pour l'instant.

La seule chose dont tu peux être sur, c'est qu'il aura toujours la même forme pour un nombre de lancé très grand.                             *       *
                                                      *       *  
                                             *       *       *       *
                                             *       *       *       *
                                     *      *       *       *       *        
                                     *      *       *       *       *         *   
                             *      *      *       *       *       *         *      
                     *      *      *      *       *       *       *         *       *
             *      *      *      *      *       *       *       *         *       *         *
             2      3      4      5      6       7       8        9       10     11       12
ULARGE_INTEGERJokyQi=QI("Joky"
Messages postés
61
Date d'inscription
dimanche 3 décembre 2006
Statut
Membre
Dernière intervention
21 juillet 2010

J'ai oublié de préciser que ces dés sont des dés à 6 faces donc le tirage aléatoire pour un dés ne pourra comporter que des valeurs de 1 à 6
Messages postés
1137
Date d'inscription
lundi 17 novembre 2003
Statut
Membre
Dernière intervention
23 janvier 2016
24
Pour ce qui concerne les histogrammes, vu que peu d'exemple était sur ce site, tu peux t'inspirer d'une classe que j'ai faite, voir :
http://www.cppfrance.com/codes/GRAPHIQUE-BARRES-PARAMETRABLE-FIXE-OU-ANIME_40208.aspx

Pour le tirage aléatoire, un petit algo suffit :

//
// RandomArray()
// Donne une suite aléatoire sans doublon de 0 à borneSup-1
// en remplissant le tableau donné  
//


void RandomArray(unsigned* pTab, unsigned borneSup)
{
   bool bSameNum;


   for(unsigned i=0; i<borneSup; i++)
   {
        bSameNum = true;


        while( bSameNum )
        {
            pTab[i] = rand() % borneSup;
            bSameNum = false;


            for(unsigned j=0; j<i; j++)
            {
                if( pTab[j] == pTab[i] )
                {
                    bSameNum = true;
                    break;
                }
            }
        }
    }
}
Messages postés
1137
Date d'inscription
lundi 17 novembre 2003
Statut
Membre
Dernière intervention
23 janvier 2016
24
Précision : a toi d'adapter ce code, si tu appelle une fois cette fonction avec 6 en borne sup, tu auras un tab d'une suite de 0 à 5 aléatoire
(par ex 2 , 0 , 1 , 4 , 5 , 3) cela te donne déjà 6 tirages pour un dé.
Messages postés
61
Date d'inscription
dimanche 3 décembre 2006
Statut
Membre
Dernière intervention
21 juillet 2010

Ok je prend note de tout ça et je te remercie beaucoup de m'avoir aider, je vais oir ce que je peux faire avec tes informations ^^.
   Encore Merci ^^
Messages postés
2333
Date d'inscription
samedi 28 février 2004
Statut
Membre
Dernière intervention
26 juillet 2013
36
Salut:

Je ne vois pas la fonction "srand" pour initialiser le générateur les nombres pseudo-aléatoires:

#include <time.h>
// ...

srand ((unsigned) time (NULL));

// ...
Messages postés
1137
Date d'inscription
lundi 17 novembre 2003
Statut
Membre
Dernière intervention
23 janvier 2016
24
C'était juste pour montrer comment obtenir des suites aléatoires, les doublons sont bien sur possibles avec des dés. Mais il est vrai que si tu as des difficultés avec un
tirage = (rand()%6)+1;
Il faut que tu commences par le début, un bon tuto en C...
Messages postés
61
Date d'inscription
dimanche 3 décembre 2006
Statut
Membre
Dernière intervention
21 juillet 2010

   Merci Joky pour le message c'est vrai que c'est pas mal comment tu expliques et ouais pour l'histogramme je devrais obtenir une forme similaire. J'ai juste pas trop compris  "des1 + des2 -2", pourquoi on a un "-2" à la fin et aussi le "++" à la fin, après les crochet.


   J'aimerais quelques précisions stp, encore Merci ^^
Messages postés
1787
Date d'inscription
lundi 22 novembre 2004
Statut
Membre
Dernière intervention
31 janvier 2009
2
Oui et j'ai aussi oublier de déclarer mon tableau tabOfOccurrence :D
Non mais si on joue à ça on a pas fini lol, donc je laisser le srand aux soins du programmeur :)

Et sinon ptite explication

int tabOfOccurence[11] = {0,0,0,0,0,0,0,0,0,0,0};

des1 aura sa valeur comprise entre 1 et 6
des2 aura sa valeur comprise entre 1 et 6
des1 + des2 aura sa valeur comprise entre 2 et 12 ( Vu que tu veux étudier la somme )

un tableau étant indéxé à partir de 0 en C, on retire 2 à la somme...
Donc la case 0, représentera la valeur 2,
         la case 1,                     la valeur 3,
............................................................
         la case i,                       la valeur i+2
et      la case 10,                   la valeur 12
En ce qui concerne l'opérateur ++, c'est un opérateur de post incrémentation (je sais pas si on peut le dire comme ça) donc il est équivalent à i +1 <-> i i + 1 <-> i++

Et donc il faut savoir faire la différence entre ++i et i++;

Exemple :
int a;
int i = 5;

a = i++;         //a vaut 5 puis on incrémente i;   i vaut 6 maintenant
a = ++i;         //on incrémente i ( i vaut 7) et on l'affecte à a, d' où a vaut 7

Donc pour finir tu auras ton tableau d'occurrence directement sans aucun effort on peut dire...

ULARGE_INTEGERJokyQi=QI("Joky"
Messages postés
198
Date d'inscription
vendredi 4 avril 2003
Statut
Membre
Dernière intervention
18 mars 2011
1
#include <stdio.h>
#include <stdlib.h>
#include <time.h>



#define N 300
#define R ((rand() % 6) + 1)



int main(void)
{
  int i, j, t[11] = {0};
 
  srand(time(NULL));



  for(i = 0; i < N; i++)
    t[R + R - 2]++;



  for(i = 0; i < 11; i++)
  {
    printf("\n%2d ", i + 2);
    for(j = 0; j < t[i]; j++)
      printf("*");
     
    printf(" %d (%d%%)", t[i], (t[i] * 100) / N);
  } 
  printf("\n");      
  return 0;
}



Qui peut donner comme resultat:

 2 ********* 9 (3%)
 3 **************** 16 (5%)
 4 ****************** 18 (6%)
 5 ***************************** 29 (9%)
 6 ************************************ 36 (12%)
 7 ************************************************ 48 (16%)
 8 ******************************************** 44 (14%)
 9 ***************************************** 41 (13%)
10 ************************** 26 (8%)
11 *********************** 23 (7%)
12 ********** 10 (3%)