En tête general

© Copyright Franck CHEVRIER 2019-2022 https://www.python-lycee.com.
Les activités partagées sur Capytale sont sous licence Creative Commons.

Pour exécuter une saisie Python, sélectionner la cellule et valider avec SHIFT+Entrée.

Lancers d'une pièce (corrigé)¶

On propose à un joueur de lancer trois fois d’affilée une pièce de monnaie équilibrée.

La règle du jeu est la suivante :

s’il obtient trois piles, il gagne la partie ;

s’il obtient deux piles exactement, la partie est nulle ;

dans tous les autres cas, il perd la partie.

1. Ecrire une fonction Python piece qui simule le lancer d’une pièce de monnaie, et renvoie 1 (ou True) si le résultat est pile et 0 (ou False) sinon.

Aide Python : A l’aide de l’appel from random import randint, on peut utiliser l’instruction randint(a,b) qui renvoie aléatoirement un entier compris entre a et b.

In [1]:

from random import randint

def piece():
    return randint(0,1)

In [2]:

piece()

Out[2]:

2. Effectuer les instructions suivantes, et expliquer leur lien avec la situation étudiée.

In [3]:

lancers=[ piece() for k in range(3) ]
lancers

Out[3]:

[0, 1, 0]

In [4]:

sum(lancers)

Out[4]:

3. On considère la fonction Python jeux ci-dessous, qui reçoit un entier N en argument et qui renvoie une liste de trois valeurs.

Indiquer ce que représentent, dans le cadre de l’énoncé, cet entier N et les trois valeurs de la liste renvoyée.

In [5]:

def jeux(N):

    res=[0,0,0]
    
    for i in range(N):
        
        lancers=[piece() for k in range(3)]
        nb_piles=sum(lancers)
        
        if nb_piles==3:
            res[0]=res[0]+1
        elif nb_piles==2:
            res[1]=res[1]+1
        else:
            res[2]=res[2]+1
    
    return res

In [6]:

jeux(1000)

Out[6]:

[125, 391, 484]

L’organisateur du jeu demande une mise de 1€ pour participer au jeu.
Si le joueur gagne, il reçoit 4€, et si la partie est nulle, il est remboursé de sa mise.

4. Ecrire une fonction gain_algebrique qui reçoit en argument une liste L (qui sera fournie par la fonction jeux) et qui renvoie le gain algébrique du joueur (le gain algébrique du joueur s’obtient en soustrayant la mise du joueur à la somme qu’il reçoit).

In [7]:

def gain_algebrique(L):
    return L[0]*3+L[1]*0+L[2]*(-1)

In [8]:

gain_algebrique(jeux(1000))

Out[8]:

-165

5. Dans cette question, on suppose que L est une liste générée par la fonction jeux. Que représente le résultat de la saisie ci-dessous?

In [9]:

L=jeux(1000)
sum(L)

Out[9]:

Tester la fonction gm ci-dessous. Que représente le résultat de la saisie proposée ?

In [10]:

def gm(L):
    return gain_algebrique(L)/sum(L)

gm(L)

Out[10]:

-0.072

Tester avec $10$, $100$ puis $10000$ parties. Le jeu semble-t-il favorable au joueur ?

In [11]:

gm(jeux(10)) , gm(jeux(100)) , gm(jeux(10000))

Out[11]:

(0.3, -0.16, -0.1189)

6. Calculer les probabilités que le joueur gagne, que la partie soit nulle, puis que le joueur perde.

Stocker ces $3$ valeurs, dans cet ordre, dans une liste nommée Proba.

Calculer la valeur gm(Proba) et indiquer la valeur obtenue.

In [12]:

# Créer la liste Proba
Proba=[1/8,3/8,1/2] 

In [13]:

# Exécuter la cellule pour effectuer l'appel à la fonction gm
gm(Proba)

Out[13]:

-0.125

7. Ecrire une fonction Python ecart qui reçoit en argument la liste L de répartition des résultats d’une série de parties et renvoie l’écart entre le gain moyen de ces parties et la valeur gm(Proba).

In [14]:

def ecart(L):
    return gm(L)-gm(Proba)

Tester pour des listes de longueur $100$,$10000$,$100000$,$1000000$… Que constate-t-on ?

In [15]:

ecart(jeux(100)) , ecart(jeux(10000)) , ecart(jeux(100000)) , ecart(jeux(1000000))

Out[15]:

(0.20500000000000002, -0.01730000000000001, 0.004470000000000002, -0.0023350000000000037)

Bernoulli

Jacques Bernoulli (1654-1705) est le premier a avoir démontré la loi des grands nombres.