Vous êtes sur la page 1sur 8

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.

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 prob-
able 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 signicatif

• on va construire, progressivement, un algorithme permettant de réaliser ces simulations


et le traduire dans un langage de programmation

• on pourra enn valider l'interprétation de la simulation par un calcul d'intervalles de


conance

1
2 Construction progressive de l'algorithme

algorithme 1
simulation du lancer d'un dé (utilisation d'une fonction aléatoire ; achage du résultat)

algorithme 2
simulation de N lancers (entrée du nombre de simulations ; boucle pour)
n ←N
pour i de 1 à n faire
simuler un lancer de dé et mettre le résultat dans r
Acher r
algorithme 3
simulation de N lancers d'un dé et calcul de la somme S des points obtenus (variable
 cumulative 1 )

n ←N
S←0
pour i de 1 à n faire
simuler un lancer de dé et mettre le résultat dans r
S ←S+r
Acher S

algorithme 4
simulation d'une expérience aléatoire, calcul de la somme des points obtenus, mémorisa-
tion de l'occurence de la somme obtenue dans un tableau d'eectifs (notion de tableau)
et achage du tableau d'eectifs

n ←N
S←0
pour i de 1 à 36 faire
T [i] ← 0
pour i de 1 à n faire
simuler un lancer de dé et mettre le résultat dans r
S ←S+r
T [S] ← T [S] + 1
pour i de 1 à 36 faire
Acher T [i]

1 cequalicatif est là pour attirer l'attention sur une diculté pédagogique, observée en série L, liée
à l'instruction S ← S + r, qui va à l'encontre de la convention utilisée en mathématiques et qui veut
qu'une même lettre ne puisse représenter deux valeurs diérentes

2
algorithme 5
simulation de K expériences aléatoires, calcul de la somme des points obtenus, mémori-
sation dans un tableau d'eectifs et achage du tableau d'eectifs

k ←K
pour i de 1 à 36 faire
T [i] ← 0
pour j de 1 à k faire
simuler un lancer de dé et mettre le résultat dans n
S←0
pour
i de 1 à n faire
simuler un lancer de dé et mettre le résultat dans r
S ←S+r
T [S] ← T [S] + 1
pour i de 1 à 36 faire
Acher T [i]

algorithme 5 (variante)
algorithme 5 avec achage des fréquences

k ←K
pour i de 1 à 36 faire
T [i] ← 0
pour j de 1 à k faire
simuler un lancer de dé et mettre le résultat dans n
S←0
pour
i de 1 à n faire
simuler un lancer de dé et mettre le résultat dans r
S ←S+r
T [S ← T [S] + 1
pour i de 1 à 36 faire
Acher T [i]/k

Pour pouvoir réellement exploiter cette simulation, il faut utiliser un langage de program-
mation qui permette de faire un très grand nombre de lancers en un temps acceptable.
Aussi ne parait-il pas raisonnable d'utiliser une calculatrice programmable (de type lycée)
ou le logiciel Scratch.

3 Les scripts

Les 5 algorithmes (et la variante de l'algorithme 5) décrits ci-dessus ont été programmés
à l'aide d'Algobox.
Deux programmes de la variante de l'algorithme 5 ont été réalisés avec Python (version
2.6) ; l'un d'eux fournit les résultats sous forme d'un chier texte pour une éventuelle
exploitation en classe.

3
3.1 script de l'algorithme 1

Avec Algobox
1 VARIABLES
2 r EST_DU_TYPE NOMBRE
3 DEBUT_ALGORITHME
4 r PREND_LA_VALEUR floor(random()*6)+1
5 AFFICHER "Résultat du lancer: "
6 AFFICHER r
7 FIN_ALGORITHME

3.2 script de l'algorithme 2

Avec Algobox
1 VARIABLES
2 n EST_DU_TYPE NOMBRE
3 r EST_DU_TYPE NOMBRE
4 i EST_DU_TYPE NOMBRE
5 DEBUT_ALGORITHME
6 AFFICHER "Nombre de lancers à simuler: "
7 LIRE n
8 AFFICHER n
9 POUR i ALLANT_DE 1 A n
10 DEBUT_POUR
11 r PREND_LA_VALEUR floor(random()*6)+1
12 AFFICHER "Résultat du lancer: "
13 AFFICHER r
14 FIN_POUR
15 FIN_ALGORITHME

3.3 script de l'algorithme 3

Avec Algobox
1 VARIABLES
2 n EST_DU_TYPE NOMBRE
3 r EST_DU_TYPE NOMBRE
4 S EST_DU_TYPE NOMBRE
5 i EST_DU_TYPE NOMBRE
6 DEBUT_ALGORITHME
7 //Initialisation des variables
8 AFFICHER "Nombre de lancers à simuler: "
9 LIRE n
10 AFFICHER n
11 S PREND_LA_VALEUR 0
12 //Simulation des lancers et cumul des résultats obtenus

4
13 POUR i ALLANT_DE 1 A n
14 DEBUT_POUR
15 r PREND_LA_VALEUR floor(random()*6)+1
16 S PREND_LA_VALEUR S+r
17 FIN_POUR
18 //Affichage du nombre de points obtenus
19 AFFICHER "Somme des points obtenus: "
20 AFFICHER S
21 FIN_ALGORITHME

3.4 script de l'algorithme 4

Avec Algobox
1 VARIABLES
2 n EST_DU_TYPE NOMBRE
3 r EST_DU_TYPE NOMBRE
4 S EST_DU_TYPE NOMBRE
5 i EST_DU_TYPE NOMBRE
6 Résultats EST_DU_TYPE LISTE
7 DEBUT_ALGORITHME
8 AFFICHER "Nombre de lancers (<7): "
9 LIRE n
10 AFFICHER n
11 //initialisation du tableau Résultats
12 POUR i ALLANT_DE 1 A 36
13 DEBUT_POUR
14 Résultats[i] PREND_LA_VALEUR 0
15 FIN_POUR
16 S PREND_LA_VALEUR 0
17 //simulation des n lancers et calcul de la somme des points obtenus
18 POUR i ALLANT_DE 1 A n
19 DEBUT_POUR
20 r PREND_LA_VALEUR floor(random()*6)+1
21 S PREND_LA_VALEUR S+r
22 FIN_POUR
23 Résultats[S] PREND_LA_VALEUR Résultats[S]+1
24 POUR i ALLANT_DE 1 A 36
25 DEBUT_POUR
26 AFFICHER i
27 AFFICHER ": "
28 AFFICHER Résultats[i]
29 FIN_POUR
30 FIN_ALGORITHME

3.5 script de l'algorithme 5

Avec Algobox
1 VARIABLES

5
2 N EST_DU_TYPE NOMBRE
3 i EST_DU_TYPE NOMBRE
4 S EST_DU_TYPE NOMBRE
5 Résultats EST_DU_TYPE LISTE
6 j EST_DU_TYPE NOMBRE
7 k EST_DU_TYPE NOMBRE
8 r EST_DU_TYPE NOMBRE
9 DEBUT_ALGORITHME
10 //Initialisation des variables et du tableau
11 AFFICHER "nombre d'expériences à simuler: "
12 LIRE k
13 AFFICHER k
14 POUR i ALLANT_DE 1 A 36
15 DEBUT_POUR
16 Résultats[i] PREND_LA_VALEUR 0
17 FIN_POUR
18 //Début de la simulation
19 POUR j ALLANT_DE 1 A k
20 DEBUT_POUR
21 //1er temps: lancer du premier dé
22 N PREND_LA_VALEUR floor(random()*6)+1
23 S PREND_LA_VALEUR 0
24 //2eme temps: lancer des dés
25 POUR i ALLANT_DE 1 A N
26 DEBUT_POUR
27 r PREND_LA_VALEUR floor(random()*6)+1
28 S PREND_LA_VALEUR S+r
29 FIN_POUR
30 //Mémorisation de la somme des points obtenus dans le tableau
31 Résultats[S] PREND_LA_VALEUR Résultats[S]+1
32 FIN_POUR
33 //Fin de la simulation
34 //Affichage du nombre d'apparition de chacune des sommes au cours de la simulation
35 POUR i ALLANT_DE 1 A 36
36 DEBUT_POUR
37 AFFICHER i
38 AFFICHER ": "
39 AFFICHER Résultats[i]
40 FIN_POUR
41 FIN_ALGORITHME

3.6 script de l'algorithme 5 (fréquences)

Avec Algobox
1 VARIABLES
2 N EST_DU_TYPE NOMBRE
3 i EST_DU_TYPE NOMBRE
4 S EST_DU_TYPE NOMBRE

6
5 Résultats EST_DU_TYPE LISTE
6 j EST_DU_TYPE NOMBRE
7 k EST_DU_TYPE NOMBRE
8 r EST_DU_TYPE NOMBRE
9 DEBUT_ALGORITHME
10 AFFICHER "nombre d'expériences à simuler: "
11 LIRE k
12 AFFICHER k
13 POUR i ALLANT_DE 1 A 36
14 DEBUT_POUR
15 Résultats[i] PREND_LA_VALEUR 0
16 FIN_POUR
17 POUR j ALLANT_DE 1 A k
18 DEBUT_POUR
19 N PREND_LA_VALEUR floor(random()*6)+1
20 S PREND_LA_VALEUR 0
21 POUR i ALLANT_DE 1 A N
22 DEBUT_POUR
23 r PREND_LA_VALEUR floor(random()*6)+1
24 S PREND_LA_VALEUR S+r
25 FIN_POUR
26 Résultats[S] PREND_LA_VALEUR Résultats[S]+1
27 FIN_POUR
28 POUR i ALLANT_DE 1 A 36
29 DEBUT_POUR
30 AFFICHER i
31 AFFICHER ": "
32 Résultats[i] PREND_LA_VALEUR Résultats[i]/k
33 AFFICHER Résultats[i]
34 FIN_POUR
35 FIN_ALGORITHME

Avec Python 2.6


# -*- coding: iso-8859-1 -*-
from math import *
from random import *
n=input('nombre de simulations à réaliser: ')
frequences=range(1,37,1)
for i in range(36): # initialisation du tableau de résultats
frequences[i]=0
for i in range(n): # début d'une simulation
k=randint(1,6)
s=0
for j in range(k):
s=s+randint(1,6)
frequences[s-1]=frequences[s-1]+1
for i in range(36):
frequences[i]=frequences[i]/float(n) # calcul des fréquences
print 'somme:',i+1,' fréquence:',frequences[i]

7
Le script suivant crée un chier texte pour une éventuelle utilisation en classe :

#-*- coding:Latin-1 -*-


# Ce programme permet d'obtenir les résultats de la simulation dans un fichier texte nomm
# situé dans le même répertoire.
#
from math import *
from random import *
n=input('nombre de simulations à réaliser: ')
frequences=range(1,37,1)
for i in range(36):
frequences[i]=0
## début d'une simulation
for i in range(n):
k=randint(1,6)
s=0
for j in range(k):
s=s+randint(1,6)
frequences[s-1]=frequences[s-1]+1
# écriture des fréquences dans un fichier texte
fich= open('Frequences','w')
fich.write('Nombre de simulations réalisées:'+ str(n)+' \n')
for i in range(36):
fich.write(str(i+1))
frequences[i]=frequences[i]/float(n)
fich.write(' fréquence: ')
fich.write(str(frequences[i])+' \n')
fich.close()