Algorithmie le retour

[Spinoza]

Bonjour à tous,

Je reviens vous voir afin d'avoir de l'aide sur un algorithme que j'ai à construire !
Je dois implanter sous Algobox un algorithme qui réalise 1000 fois 3 lancers de dé consécutifs et qui compte le nombre de 6
L'algorithme doit afficher :
Le nombre de fois 0 durant les 1000 lancers
Le nombre de fois 1
Le nombre de fois 2
Le nombre de fois 3

Je pensais commencer par une boucle Pour N allant de 1 à 1000
Utiliser la variable aléatoire mais je sèche un peu dans la construction ...

Merci d'avance
Spinoza

[C.Ret]

Bonsoir,

Alors voyons quelles sont les variables dont nous pourrions avoir besion ?

N le nombre total d'expérimentations (ici chaque expérience consiste à lancer trois dés).

D1,D2 et D3 les faces des trois dés que l'on lance à chaque expérimentation.

S0, S1, S2 et S3 les compteurs de face 6 où :
S0 compte le nombre de tirage des trois dés où l'on a obtenu aucun 6,
S1 compte le nombre de tirage des trois dés où un seul 6 a été observé,
S2 compte le nombre de tirage des trois dés où deux 6 ont été observés,
S3 compte le nombre de tirage des trois dés où trois 6 ont été observés.



Initialement les quatre compteur sont à zéro.

Les N=1000 expérimentation seront reproduites de façon identique. Une boucle sera donc appropriés.

A l'intérieur de cette boucle il va falloir faire un certains nombre de choses.
A priori il va falloir tirer au hasard les face des dés.
C'est à dire que D1,D2 et D3 doivent prendre (au hasard) une valeur indiquant la face du dé.

Quelles sont les valeur authorisées ?

[Spinoza]

Je me suis trompée dans une partie de l'énoncé C.Ret :
Au final, doit apparaitre uniquement le nombre de 6 dans la série des 3 lancers : soit 3 six, soit 2, soit 1 ou aucun ...

[hammana]

Je me suis trompée dans une partie de l'énoncé C.Ret :
Au final, doit apparaitre uniquement le nombre de 6 dans la série des 3 lancers : soit 3 six, soit 2, soit 1 ou aucun ...

Il faut d'abord définir quatre variables p.ex

Code: Tout sélectionner

n0 pour compter le nombre de fois où il n'y a eu aucun 6
n1    "               "                il y a eu 1 fois 6
n2   pour  2 fois 6
n3   pour 3 fois 6

On devra vérifier à la fin que n0+n1+n2+n3=1000

Puis faire une boucle qui se répèrte 1000 fois
A l'intérieur de chaque boucle faire apparaître 3 nombres aléatoires compris entre 1 et 6 inclus, compter combien de ces nombres sont égaux à 6 et ajouter 1 à la variable appropriée (n0, n1, n2 ou n3)

[C.Ret]

Je me suis trompée dans une partie de l'énoncé C.Ret :
Au final, doit apparaitre uniquement le nombre de 6 dans la série des 3 lancers : soit 3 six, soit 2, soit 1 ou aucun ...

C'est bien ainsi que j'avais compris la chose:
Au cours des 10000 lancé des trois dé, on compte le nombre de fois que l'on voit apparaitre aucun 6, deux 6 ou trois 6 (respectivement les compteurs S0, S1, S2 et S3)

Grosso-modo, la structure de l'algorithme sera :

Code: Tout sélectionner

Pour chacun des N lancés :
  - Simuler le jet de trois dés (D1, D2 et D3)
  - Compter le nombre F de 6 obtenus (on aura donc F=0 ou 1 ou 2 ou 3)
  - Incrémenter le compteur S(F) : C'est à dire S(0) si F=0, S(1) si F=1 etc...


[C.Ret]

A tout hasard, je donne ci-dessous un programme ALGOBOX possible pour l'algorithme demandé :

Code: Tout sélectionner

VARIABLES
  NbT EST_DU_TYPE NOMBRE   // Nombre de tirage
  Aff EST_DU_TYPE NOMBRE   // Drapeau pour affichage détails
  N EST_DU_TYPE LISTE      // N[0 à 3] nombre de fois qu'il y a eut 0,1,2 ou 3 face(s) 6
  D EST_DU_TYPE NOMBRE     // D face des dés D1 à D3
  NbF6 EST_DU_TYPE NOMBRE  // Nombre de face 6 sur les trois dés

  i EST_DU_TYPE NOMBRE     // variables outils pour les boucles
  j EST_DU_TYPE NOMBRE

DEBUT_ALGORITHME
 
  //  Initialise Compteurs et demande nombre de tirages
 
  AFFICHER "ENTER Nombre de Tirages :"
  LIRE NbT
  SI (NbT  200) ALORS
        DEBUT_SI
        Aff PREND_LA_VALEUR 0
        FIN_SI
        SINON
          DEBUT_SINON
          AFFICHER "ENTRER 1 pour afficher chaque tirage :"
          LIRE Aff
          FIN_SINON
      FIN_SINON
  POUR j ALLANT_DE 0 A 3
    DEBUT_POUR
    N[j] PREND_LA_VALEUR 0
    FIN_POUR
 
  //   Répète NbT fois les tirage
 
  POUR i ALLANT_DE 1 A NbT
    DEBUT_POUR
    NbF6 PREND_LA_VALEUR 0   
    SI (Aff == 1) ALORS
      DEBUT_SI
      AFFICHER i
      AFFICHER ". TIRAGE: Face"
      FIN_SI

    //   Effectue un tirage pour chacun des trois dés

    POUR j ALLANT_DE 1 A 3
      DEBUT_POUR
      D PREND_LA_VALEUR ALGOBOX_ALEA_ENT(1,6)
      SI (D==6) ALORS
        DEBUT_SI
        NbF6 PREND_LA_VALEUR NbF6+1
        FIN_SI
      SI (Aff == 1) ALORS
        DEBUT_SI
        AFFICHER "  D"
        AFFICHER j
        AFFICHER "="
        AFFICHER D
        FIN_SI
    FIN_POUR
    N[NbF6] PREND_LA_VALEUR N[NbF6]+1
    SI (Aff == 1) ALORS
      DEBUT_SI
      AFFICHER "   Nb Face 6 ="
      AFFICHER* NbF6
      FIN_SI
  FIN_POUR
 
  // Affiche les résultats
 
  POUR j ALLANT_DE 0 A 3
    DEBUT_POUR
    AFFICHER "Nombre de tirages avec "
    AFFICHER j
    SI (j > 1) ALORS
      DEBUT_SI
      AFFICHER " faces six: "
      FIN_SI
      SINON
        DEBUT_SINON
        AFFICHER " face  six: "
        FIN_SINON
    AFFICHER* N[j]
    FIN_POUR
FIN_ALGORITHME


P.S. La variable Aff sert uniquement à permettre d'afficher ou non le détail de chacun des tirages.
En dessous de 30 tirage les détails sont affichés systématiquement, au-dessus de 200 ils sont masqué. Entre 30 et 200 itérations, l'utilisateur peut choisir; en saisissant 1 , il permet l'affichage.



Plus j'utilise cet environnement Algo-Box, plus je me rends compte qu'il n'est pas adapté, maladroit et très peu pédagogique.

Par exemple, je ne comprends pas à quoi sert d'imposer une zone de déclaration des variables s'il n'existe pas de déclaration des bornes d'une liste et aucune vérification lors des validations du code ou des tests. Par exemple, il pourrait au moins y avoir un message qui explique pourquoi l'utilisation d'un membre d'une liste non initialisée donne une erreur.

De plus, le vérificateur ne vérifie pas la syntaxe dans les expressions de calculs ou de tests ...

Bref, c'est vraiment une très mauvaise idée d'utiliser cet environnement.

Il serait bien plus efficace et utile pour les élèves de demander de dessiner des organigrammes et écrire les algorithmes en language naturel.

S'il s'agit d'initier les élèves à la programmation, alors pourquoi ne pas utiliser un vrai language de programmation ? Ils ne perdraient pas leur temps à apprendre à programmer sous un si mauvais environnement et avec un language de programmation obsolette et un environnment aussi incomplet.

[Dlzlogic]

Bonjour C.Ret,
Cet algorithme aborde un sujet très délicat : la simulation de tirage aléatoire.
Je me garde bien d'intervenir, mais je sais que LeJeu a fait beaucoup de simulations. Il en connait aussi un bout à propos des générateurs fiables ou pas.
+1 pour l'analyse concernant Algobox.

[Sylviel]

Non l'algo n'aborde pas un "sujet très délicat", il demande d'utiliser un générateur de nombre pseudo-aléatoire qui est considéré parfait pour les besoins de l'exercice. L'exercice se concentrant sur le fait d'écrire un simple algorithme de comptage.

[C.Ret]

Oui, merci Sylviel j'allais justement répondre que le problème était d'écrire un algorithme de comptage.

Le générateur de nombre aléatoire est effectivement bien approprié (j'utilise celui fournit par AlgoBox dont l'utilisation est très simple car on indique directement les bornes; le tirage tire aléatoirement une valeur entière entre ces deux bornes. Notons qu'elles sont incluses dans l'interval et donc un dé de six faces est facilemetn simulé par :

D PREND_LA_VALEUR ALGOBOX_ALEA_ENT(1,6)


Et comme le dit très bien Sylviel, ce générateur est parfait pour l'excercice. Il n'y a d'ailleurs pas à s'en soucier; nulle part il n'est demandé que la simulation ne suive un quelconque contrainte.

Par contre, la question est interessante.
Après NbT tirages des trois dés (supposés parfait), quelles sont les proportions attendues de tirages où apparait respectivement aucun (0), une seule, deux ou trois fois la face six sur les trois dés ?