Un algorithme de simulation pour résoudre un problème de
probabilités
1. L'expérience
On considère l'expérience aléatoire suivante : dans un premier temps on lance un dé puis, dans un deuxième temps, on relance autant de dés que l'indique le résultat obtenu à l'issue du premier lancer.
On observe la somme des points obtenus. Par exemple :
le résultat du premier lancer est 4 ; on relance donc quatre dés. La somme des points obtenus est 15. Si le premier dé donne 1, on relance 1 dé et la « somme » peut être 1 ou 2 ou 3 ou 4 ou 5 ou 6 ;
Si le premier dé donne 2, on relance 2 dés et la somme peut être 2 ou 3 ou 4, et ainsi de suite jusqu'à ...; Si le premier dé donne 3, on relance 3 dés et la somme obtenue est un entier compris entre ... et ...; Si le premier dé donne 4, la somme obtenue est un entier compris entre ... et ...;
Si le premier dé donne 5, la somme obtenue est un entier compris entre ... et ...; Si le premier dé donne 6, la somme obtenue est un entier compris entre ... et ...
Le résultat de cette expérience n'étant pas connu à l'avance, on dit qu'il s'agit d'une « expérience aléatoire ».
Question : quelle est, parmi toutes les sommes possibles, celle qui est la plus probable ?
• le protocole de cette expérience aléatoire est simple mais la résolution, par le calcul, de la question posée est très au-delà des exigences de la classe de seconde
• on peut envisager une approche fréquentiste pour déterminer l'issue la plus probable et réaliser une simulation
• compte tenu du nombre d'issues possibles (36), il faudra réaliser un grand nombre de simulations pour obtenir un résultat significatif
• on va construire, progressivement, un algorithme permettant de réaliser ces simulations et le traduire dans un langage de programmation
2. Construction progressive de l'algorithme
algorithme 1
Simulation du lancer d'un dé
Compléter l'algorithme suivant et le programmer en Python 3. Algorithme en langage naturel
Variables : r : entier
début algo1
Traitement : r ← un nombre entier pseudo-aléatoire entre 1 et 6 Sortie : afficher r
fin algo1
Programme en Python 3
Dans la fenêtre d'édition, on écrit la procédure :
Dans la fenêtre d'interprétation, on lance le programme :
algorithme 2
Simulation de n lancers (ce qui sert à modéliser en fait le lancer de n dés)
Compléter l'algorithme 1 de façon à ce que l'utilisateur puisse saisir le nombre n de lancers et que l'algorithme affiche à chaque fois le résultat du lancer.
Algorithme en langage naturel, à corriger et compléter... (l'une des sortie est mal placée : barrer la ligne mal placée... ; compléter les pointillés)
Variables : n, r, i : entiers
début algo2
Entrée : saisir …..
Traitement : pour i allant de 1 à n faire
…... Sortie : afficher r finpour Sortie : afficher r fin algo2 Programme en Python 3
Essayer les deux programmes de2(n) et de2b() : il font la même chose ! 2/4
algorithme 3
Simulation de n lancers d'un dé et calcul de la somme s des points obtenus
Algorithme en langage naturel, à compléter... (l'une des sortie est mal placée : barrer la ligne mal placée... ; compléter les pointillés)
Variables : n, r, i, s : entiers
début algo3
Entrée : saisir …..
Traitement : s ← ... # initialisation de s
pour i allant de 1 à n faire
…...
s ← ... # mise à jour de s à chaque passage dans la boucle Sortie : afficher s
finpour Sortie : afficher s
fin algo3
Test !
Mettre en œuvre l'algorithme en complétant le tableau suivant avec n=4 et en utilisant un simulateur de lancers de dés (http://www.bgfl.org/bgfl/custom/resources_ftp/client_ftp/ks1/maths/dice/six.htm)
i r s
initialisation
1er passage dans la boucle
2e passage dans la boucle
3e passage dans la boucle
4e passage dans la boucle
Affichage : …...
Programme en Python 3 (à faire...)
Remarque : s est appelée une variable « cumulative », car elle est augmentée, à chaque passage dans la boucle, de la valeur du résultat r obtenu lors de ce passage.
L'instruction s ← 0, écrite en début d'algorithme sert à « initialiser » la variable.
algorithme 4
Simulation d'une expérience
Supposons, à cette étape, que la valeur n obtenue par le premier dé est connue (elle sera saisie par l'utilisateur, comme dans l'algorithme 3).
L'algorithme 3 permet de calculer la somme s des n dés lancés dans le deuxième temps de l'expérience. Il s'agit de construire un tableau d'effectifs et de « ranger » la valeur de s dans ce tableau :
Par exemple, au début de l'expérience, aucune des sommes de 1 à 36 n'a été obtenue :
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
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
Si le jet du premier dé donne 4 (n=4) et qu'ensuite le jet des quatre dés donne une somme de 15 (s=15), le tableau devient :
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
0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
Algorithme en langage naturel, à compléter... Variables : n, r, i, s, t : entiers
T : liste
début algo4
Entrée : saisir n
Traitement : pour t allant de 1 à 36 faire # initialisation de T T[t] ← 0
finpour
…... # simulation de n lancers d'un dé et calcul de
…... la somme s des points obtenus (algo3) …...
…...
…...
T[s] ← T[s]+1 # rangement de la valeur s dans la liste T
Sortie : afficher T fin algo4
Programme en Python 3
algorithme 5
Simulation de k expériences
Algorithme en langage naturel, à compléter... Variables : n, r, i, s, t, k, j : entiers
T : liste
début algo5
Entrée : saisir k
Traitement : pour t allant de 1 à 36 faire T[t] ← 0
finpour
pour j allant de 1 à k faire
n ← un nombre entier pseudo-aléatoire entre 1 et 6 # simulation du lancer du 1er dé, qui détermine le nombre de dés à lancer pour déterminer la somme s ← 0
pour i allant de 1 à n faire #
…... # simulation de n lancers d'un dé et
calcul de la somme s des points
…... obtenus finpour
T[s] ← T[s]+1 # rangement de la valeur s dans la liste T finpour
Sortie : afficher T fin algo5
Programme en Python 3 (à faire...)
