Mathématice, intégration des Tice dans l'enseignement des mathématiques  
Sommaire > N° 1 - Septembre 2006 > Articles publiés en avance > Séquences d’algorithmique en mathématique en (...)

Séquences d’algorithmique en mathématique en Python 3, de la seconde à la terminale
Moteur de recherche

I – Présentation générale

- Ces séquences sont construites pour mettre en œuvre l’algorithmique en mathématiques, telle qu’elle est prévue aux programmes de la seconde à la terminale.
- L’activité d’algorithmique telle qu’elle apparaît à travers les exercices du baccalauréat consiste à lire et interpréter un algorithme écrit en "langage naturel", à modifier ou compléter un algorithme donné pour qu’il réalise une tâche particulière, à corriger un algorithme qui contient une erreur, à choisir parmi plusieurs algorithmes celui que réalise une tâche demandée.
- Les activités que je propose s’inscrivent toutes dans ce cadre, il n’est pas possible avec le peu d’heures consacrées à l’algorithmique, compte tenu de la difficulté du langage de programmation utilisé, d’aller au delà de ce type d’activité.
- Chaque séquence est présentée par une introduction détaillant son contenu puis est suivie par des fiches élèves comprenant les instructions pour réaliser le travail à effectuer.
- Les fichiers dont le nom se termine par ..._Elev.py sont les fichiers destinés à servir de support au travail des élèves afin d’éviter de perdre du temps sur la saisie des lignes de codes. Les fichiers dont le nom se termine par ...0.py sont les fichiers contenant l’intégralité des lignes de codes demandées lors des activités, plus parfois, quelques traces des recherches que j’ai effectuées lors de l’élaboration des algorithmes. Ces fichiers sont à ouvrir avec un environnement de programmation permettant de numéroter les lignes de commandes, d’avoir un coloration syntaxique et l’indentation automatique, au minimum. (Spyder, Pyza, Gedit, ...)
- La numérotation indiquée dans les introductions correspond à celle des fichiers enseignants dont les noms se terminent par ...0.py ; la numérotation indiquée dans les fiches élèves correspond à celle des fichiers dont les noms se terminent par ...0_Elev.py.
- Les activités sont de difficulté progressives au fur et à mesure de l’avancée dans les fiches. Les premières activités sont guidées par l’enseignant, les suivantes sont prévues pour être faites en autonomie.
- L’élève demande à l’enseignant de valider une activité avant de passer à la suivante.
- Les prolongement sont prévus pour les élèves ayant terminé en avance les activités prévues dans la séance et peuvent aller un peu au delà des exigence des programmes en proposant la recherche d’algorithmes nouveaux, basés cependant sur ceux vus précédemment.
- Le nombre de fiche à faire pendant la séance d’informatique est à adapter en fonction du niveau de la classe.
- Les fiches peuvent être rendues et notées à chaque séance.

  • Concernant le code Python j’ai fait le choix de limiter autant que faire se peut l’utilisation des bibliothèques spécialisées afin d’éviter l’effet "boite noire", vu que leur documentation est souvent sommaire et pas facile d’accès.
    La diversité des thèmes abordés dans les séquences montrent que l’on peut couvrir un grand éventail des notions du programme de mathématique, en les illustrant de façon rigoureuse et ludique, avec des outils de base de la programmation en Python.
    J’ai fait aussi le choix, autant que faire se peut, et selon une saine pratique mathématique, lors de l’utilisation d’une bibliothèque, de n’importer que la ou les fonctions nécessaires et suffisantes pour le bon fonctionnement de l’algorithme.
  • Les séquences sont :
    A) La notion de fonction en seconde générale.
    B) Un marche aléatoire : La rencontre du loup et de l’agneau (APMEP – Bulletins verts n° 515 p. 401-406 et n° 516 p. 637-639). Une version est présentée en langage R.
    C) Le paradoxe d’un duc de Toscane – Parier sur la somme des points de 3 dés.
    D) Intégration numérique – Méthode des petits et des grands rectangles – Bac S Polynésie juin 2013 – Exercice 1 questions 2.a. et 2.b.
    E) Un intervalle de fluctuation d’une variable binomiale, en première S.
    F) Une autre marche aléatoire : Le robot TOM – Bac S Antilles Guyane septembre 2013 – Exercice 4 questions 1. et 2.

- Je vais introduire chacune des séquences en détaillant un des algorithmes de sa progression, qui n’est pas forcément le premier mais qui illustre un des aspects de la thématique abordée dans la séquence.
- Le tableau suivant organise le récapitulatif des différents fichiers utilisés.

Fichiers de présentation et de consignes et fiches élèvesFichiers Python élèves (algorithmes à compléter ou à corriger)Fichiers Python propositions de solutions
A) Notions de fonction en seconde :
Fonctions2nde-Docu-Elev.odt
FonctionAffinePosi2nde0_Elev.py
FonctionGenePosi2nde0_Elev.py
FonctionAffinePosi2nde0.py
FonctionGenePosi2nde0.py
B) Marche aléatoire (APMEP – Bulletins verts n° 515 et n° 516) :
LeLoupEtLAgneau-Docu-Elev.odt
LoupAgneau0_Elev.py LoupAgneau0.py
C) Paradoxe probabiliste au jeu de dés :
DucToscane-Docu-Elev.odt
JeuDeDe0_Elev.py JeuDeDe0.py
D) Intégration numérique méthode des rectangles (Bac S Polynésie juin 2013) :
IntegrationNumeriqueDarboux-Docu-Elev.odt
Darboux0_Elev.py Darboux0.py
E) L’intervalle de fluctuation d’une variable binomiale selon la méthode du document ressource de première S :
IF-Bino-1ere-Docu-Elev.odt
BinoDistribEtIF_Elev.py BinoDistribEtIF0_0.py
F) Une marche aléatoire dans un sujet de bac (Bac S Antilles Guyane septembre 2013) :
Il n’y a pas encore de fiche élève ni de fichier Python élève.
RoboTom0.py

Vous pouvez télécharger l’ensemble de ces fichiers en une seule fois à l’aide du dossier zip ci-dessous :

Zip - 538.6 ko
Fiches à télécharger

II – Quelques thématiques abordées dans les 5 séquences

A – La notion de fonction en seconde générale.

- Il s’agit de représenter les points de la droite Df, situés "au dessus" de la droite Dk d’équation y = k, de couleur différents de ceux situés "au dessous" de la droite d’équation y = k.
- Pour compléter le tableau de la position de Df par rapport à la droite Dk il faut trouver leur point de rencontre. On peut utiliser à nouveau la fonction Python pour trouver un solution approchée. La solution exacte sera donnée par la résolution d’une équation.
- La séquence développe des algorithmes illustrant les positions respectives de deux droites puis de deux courbes, support de résolutions graphiques de f > g.

  1. "Les points illustrant f inférieure à k sont en bleu,"
  2. " les points illustrant f supérieure à k sont en vert"
  3. def PosikAffine4(k = 4, m = 3, p = 2, a =3, b = 2,
  4. nbpoints = 200):
  5. import numpy as np
  6. import matplotlib.pyplot as plt
  7. def f(x):
  8. return m * x + p
  9. x = np.linspace(a, b, nbpoints)
  10. y = f(x)
  11. couleur = ('green', 'blue')
  12. signy = (y < k) * 1
  13. scy = [couleur[i] for i in signy]
  14. plt.figure()
  15. plt.scatter(x, y, s = 15, marker = 'o', color = scy,
  16. edgecolors = 'none')
  17. plt.plot(x, [k] * nbpoints, 'r-')
  18. plt.title('Représentation graphique de la fonction affine f')
  19. plt.xlabel('Abscisses X')
  20. plt.ylabel('Ordonnées Y')
  21. plt.text((min(x) + max(x)) / 2, max(y),
  22. 'f inférieure à k en bleu\nf supérieure à k en vert',
  23. verticalalignment = 'top', horizontalalignment = 'center')
  24. plt.grid()
  25. plt.show()

Télécharger

Utiliser la fonction Python PosikAffine4(...) pour placer f < k et f > k dans les tableaux suivants :

g(x) = 3x + 2 ; Dg = [—3 ; 2]
g < 4 ; g > 4

Cliquez pour agrandir

* Le code commenté de la séquence se trouve dans le fichier FonctionAffinePosi2nde0.py. La fonction Python PosikAffine4 se trouve lignes 80 à 99. Le code des fiches élèves se trouve dans le fichier FonctionAffinePosi2nde0_Elev.py.

B) La rencontre du loup et de l’agneau (1/2)

- L’agneau est placé au départ en (0 ; 0) et le loup en (n ; n) et ils se déplacent, sur les lignes d’un quadrillage (0 ; n)×(0 ; n). Pour se déplacer l’agneau et le loup lancent à tour de rôle une pièce de monnaie à deux faces distinctes équilibrées. Si elle tombe sur pile l’agneau se déplace de 1 en x ou le loup de –1 en x sinon l’agneau se déplace de 1 en y ou le loup de –1 en y. Il s’agit de simuler des marches aléatoires permettant d’estimer la probabilité de rencontre.
- L’objectif de l’algorithme présenté est la simulation et la représentation graphique d’une marche aléatoire de n déplacements du loup et de l’agneau sur les lignes d’un quadrillage (0 ; n)×(0 ; n) et le repérage d’une éventuelle rencontre.
- La séquence développe des algorithmes permettant d’obtenir une fréquence de rencontre puis une cartographie des lieux de rencontre avec leur fréquence.

Cliquez pour agrandir
  1. def LA4(n = 5):
  2. from random import sample
  3. from matplotlib import pyplot as plt
  4. piece = ('pile', 'face')
  5. posisAgnX = [0] ; posisAgnY = [0]
  6. posisLoupX = [n] ; posisLoupY = [n]
  7. rencontre = 0
  8. for i in range(0, n):
  9. tirAgn = sample(piece, 1)
  10. depAgn = int(tirAgn[0] == 'pile')
  11. if (depAgn == 1):
  12. posisAgnX.append(posisAgnX[-1] + 1)
  13. posisAgnY.append(posisAgnY[-1])
  14. else:
  15. posisAgnY.append(posisAgnY[-1] + 1)
  16. posisAgnX.append(posisAgnX[-1])
  17. tirLoup = sample(piece, 1)
  18. depLoup = int(tirLoup[0] == 'pile')
  19. if (depLoup == 1):
  20. posisLoupX.append(posisLoupX[-1] - 1)
  21. posisLoupY.append(posisLoupY[-1])
  22. else:
  23. posisLoupY.append(posisLoupY[-1] - 1)
  24. posisLoupX.append(posisLoupX[-1])
  25. if ((posisAgnX[-1] == posisLoupX[-1]) & (posisAgnY[-1] == posisLoupY[-1])):
  26. rencontre = 1
  27. print('Rencontre en (', posisAgnX[-1], ';', posisAgnY[-1], ')')
  28. else:
  29. print('Pas de rencontre')

Télécharger

B) La rencontre du loup et de l’agneau (2/2 suite de l’algorithme, la partie représentation graphique)

  1. plt.figure()
  2. plt.plot([0, n], [0, n], ls = 'none')
  3. plt.xticks(range(n + 1)) ; plt.yticks(range(n + 1))
  4. plt.plot(posisAgnX, posisAgnY, 'bo-')
  5. plt.plot(posisLoupX, posisLoupY, 'gx--')
  6. plt.text(0.1, 0, 'DÉPART AGNEAU', va = 'bottom',
  7. ha = 'left', color = 'blue', rotation = 0)
  8. plt.text(n - .1, n - .1, 'DÉPART LOUP', va = 'top',
  9. ha = 'right', color = 'green', rotation = 0)
  10. if rencontre == 1:
  11. plt.plot(posisAgnX[n], posisAgnY[n], marker = '*',
  12. markerfacecolor = 'red', markersize = 10)
  13. plt.text(posisAgnX[n], posisAgnY[n] - .1, 'RENCONTRE',
  14. va = 'top', ha = 'center', color = 'red')
  15. plt.grid()
  16. plt.show()

Télécharger

* Le code commenté de la séquence se trouve dans le fichier LoupAgneau0.py. La fonction Python LA4 se trouve lignes 173 à 217. Le code des fiches élèves se trouve dans le fichier LoupAgneau0_Elev.py.

B) La rencontre du loup et de l’agneau, l’algorithme en langage R

  1. # SIMULATION D'UNE MARCHE ALÉATOIRE ET REPRÉSENTATION DE SON GRAPHIQUE
  2. LLELA11 <- function(N = 4){
  3. # INITIALISATION DES POSITIONS DU LOUP ET DE L'AGNEAU ET CRÉATION DE LA PIÈCE
  4. piece <- c("F", "P")
  5. DepAX <- 1 ; DepAY <- 1 ; DepLX <- N + 1 ; DepLY <- N + 1
  6. # CALCULS DES N DÉPLACEMENTS ET DES N POSITIONS DANS DES VECTEURS
  7. Piece_Agneau <- sample(piece, N, replace = TRUE)
  8. DeplaceAgneauX <- (Piece_Agneau == "P") * 1
  9. DeplaceAgneauY <- (Piece_Agneau == "F") * 1
  10. PositionsAX <- c(DepAX, cumsum(DeplaceAgneauX) + DepAX)
  11. PositionsAY <- c(DepAY, cumsum(DeplaceAgneauY) + DepAY)
  12. Piece_Loup <- sample(piece, N, replace = TRUE)
  13. DeplaceLoupX <- -(Piece_Loup == "P")
  14. DeplaceLoupY <- -(Piece_Loup == "F")
  15. PositionsLX <- c(DepLX, cumsum(DeplaceLoupX) + DepLX)
  16. PositionsLY <- c(DepLY, cumsum(DeplaceLoupY) + DepLY)
  17. # GRAPHIQUE DE LA MARCHE ALÉATOIRE
  18. plot(c(1, N + 1), c(1, N + 1), xlab = NA, ylab = NA) ; grid(col = "grey30")
  19. text(c(1, N + 1), c(1, N + 1), c("AGNEAU", "LOUP"),
  20. cex = .6, pos = c(3, 1), col = c("blue", "green3"))
  21. points(PositionsAX, PositionsAY, pch = 19, cex = .7, col = "blue")
  22. lines(PositionsAX, PositionsAY, col = "blue")
  23. points(PositionsLX, PositionsLY, pch = 19, cex = .7, col = "green3")
  24. lines(PositionsLX, PositionsLY, col = "green3")
  25. # MARQUAGE DU POINT DE LA RENCONTRE ET AFFICHAGE D'UN MESSAGE RENCONTRE OU PAS DE RENCONTRE
  26. if(sum(((PositionsAX == PositionsLX) & (PositionsAY == PositionsLY))) == 1) {
  27. points(PositionsLX[N + 1], PositionsLY[N + 1], pch = 8, cex = 2, col = "red")
  28. paste("Rencontre en (", PositionsLX[N + 1]," ; ", PositionsLY[N + 1], ")")
  29. } else {
  30. "Pas de rencontre"
  31. }
  32. }

Télécharger

C) Le paradoxe d’un duc de Toscane – Parier sur la somme des points de 3 dés

C.1. Distribution simulée de la variable aléatoire S3d somme des points de 3 dés

- Il s’agit de simuler la somme obtenue en lançant 3 dés à 6 faces équilibrées. On obtient ainsi une distribution simulée de la variable aléatoire S3d somme des valeurs de 3 dés sur laquelle on lira une estimation des probabilités d’obtenir 9 et de la probabilité d’obtenir 10.
- L’algorithme présenté construit le tableau des effectifs et des fréquence de S3d et le diagramme en barres de la distribution simulée.

  1. def S3d_1(nbsim):
  2. from random import randint
  3. from matplotlib import pyplot as plt
  4. serieEffectifs = [0] * 16
  5. for n in range(nbsim):
  6. de1 = randint(1, 6)
  7. de2 = randint(1, 6)
  8. de3 = randint(1, 6)
  9. troisDes = de1 + de2 + de3
  10. serieEffectifs[troisDes - 3] += 1
  11. tabloEffec = dict(zip(range(3, 19), serieEffectifs))
  12. serieFreq = [round(serieEffectifs[i] / nbsim, 4) for i in range(16)]
  13. tabloFreq = dict(zip(range(3, 19), serieFreq))
  14. print(tabloEffec)
  15. print(tabloFreq)
  16. "-----Le graphique en barres du tableau des fréquences simulées-----"
  17. x = range(3, 19)
  18. plt.figure()
  19. plt.bar(x, serieFreq, color = 'green') ; plt.xticks(x)
  20. plt.title("DISTRIBUTION SIMULÉE DE LA VARIABLE S3d")
  21. plt.xlabel("VALEURS DE S3d SOMME DES TROIS CHIFFRES OBTENUS")
  22. plt.ylabel("FRÉQUENCE SIMULÉE")
  23. plt.grid()
  24. plt.show()

Télécharger

Le tableau des fréquences calculées à partir de 5000 simulations :

3 : 0.0054, 4 : 0.0154, 5 : 0.025,
6:0.0508, 7 : 0.0686, 8 : 0.1074,
9 : 0.1172, 10 : 0.1236, 11 : 0.1108,
12 : 0.1236, 13 : 0.0934, 14 : 0.0668,
15 : 0.0438, 16 : 0.0286, 17 : 0.0146,
18 : 0.005


Cliquez pour agrandir

* Le code commenté de la séquence se trouve dans le fichier JeuDeDe0.py. La fonction Python S3d_1 se trouve lignes 45 à 68. Le code des fiches élèves se trouve dans le fichier JeuDeDe0_Elev.py.

C.2. Distribution de probabilité de la variable aléatoire S3d somme des points de 3 dés

- L’algorithme construit l’univers des sommes obtenues avec tous les triplets possibles. La distribution de probabilité est le tableau des fréquences des valeurs de cet univers. Le paradoxe est levé, on connaît maintenant la probabilité d’obtenir 9 et la probabilité d’obtenir 10.
- La définition en compréhension des tuples est une outil très efficace. Dans les cas où l’on peut utiliser des tuples à la place des listes cela permet d’économiser de la ressource.

  1. def probaS3d():
  2. from matplotlib import pyplot as plt
  3. UnivS3d = tuple(i + j + k for i in range(1, 7) for j in range(1, 7)
  4. for k in range(1, 7))
  5. cardUniversS3d = len(UnivS3d)
  6. listeEff = [0] * 16
  7. for k in range(cardUniversS3d):
  8. listeEff[UnivS3d[k] - 3] += 1
  9. Proba = [round(listeEff[i] / cardUniversS3d, 4) for i in range(16)]
  10. tabloProba = dict(zip(range(3, 19), Proba))
  11. print(tabloProba)
  12. x = range(3, 19)
  13. plt.figure()
  14. plt.bar(x, Proba) ; plt.xticks(x)
  15. plt.title("DISTRIBUTION DE PROBABILITÉ DE LA VARIABLE S3d")
  16. plt.xlabel("VALEURS DE S3d SOMME DES TROIS CHIFFRES OBTENUS")
  17. plt.ylabel("PROBABILITÉ")
  18. plt.grid()
  19. plt.show()

Télécharger

Distribution de probabilité de S3d :
3 : 0.0046, 4 : 0.0139, 5 : 0.0278,
6 : 0.0463, 7 : 0.0694, 8 : 0.0972,
9 : 0.1157, 10 : 0.125, 11 : 0.125,
12 : 0.1157, 13 : 0.0972, 14 : 0.0694,
15 : 0.0463, 16 : 0.0278, 17 : 0.0139,
18 : 0.0046


Cliquez pour agrandir

* Le code commenté de la séquence se trouve dans le fichier JeuDeDe0.py. La fonction Python probaS3d_1 se trouve lignes 104 à 121. Le code des fiches élèves se trouve dans le fichier JeuDeDe0_Elev.py.

D) Intégration numérique – Méthode des petits et des grands rectangles – Bac S Polynésie juin 2013 – Exercice 1 questions 2.a. et 2.b.

- L’algorithme de l’exercice consiste à calculer une approximation numérique de l’intégrale $ {\int_{0}^{1}\left ( x+2 \right )e^{-x}dx}$ par l’aire de 4 grands rectangles, puis il est demandé de généraliser l’algorithme à N grands rectangles.
- L’algorithme présenté généralise celui du bac, à N grands rectangle, sur un intervalle [a ; b] sur lequel f est gentiment continue, positive, strictement décroissante. De plus il fait la représentation graphique de la fonction et des N grands rectangles.
- Des prolongements proposent d’étendre l’algorithme aux petits rectangles puis à aux fonctions strictement croissantes ...

Cliquez pour agrandir

  1. from math import exp
  2. def f(x):
  3. return((x + 2) * exp(-x))
  4.  
  5. def aireGRNab(N = 6, a = 0, b = 2):
  6. import matplotlib.pyplot as plt
  7. pas = (b - a) / N
  8. tupleX = tuple(a + pas * i for i in range(N + 1))
  9. tupleY = tuple(f(i) for i in tupleX)
  10. airetotGran = 0
  11. plt.figure()
  12. plt.plot(tupleX, tupleY, 'r-')
  13. for i in range(N):
  14. plt.fill((tupleX[i], tupleX[i], tupleX[i + 1], tupleX[i + 1]), (0, tupleY[i], tupleY[i], 0),
  15. alpha = 0.5, fill = False, hatch = '//', color = 'green')
  16. airetotGran = airetotGran + (pas * tupleY[i])
  17. plt.title('Aire grands rectangles = ' + str(round(airetotGran, 4)))
  18. plt.xlabel('X')
  19. plt.ylabel('f(X)')
  20. plt.axis('equal')
  21. plt.grid()
  22. plt.show()

Télécharger

* Le code commenté de la séquence se trouve dans le fichier Darboux0.py. La fonction Python aireGRNab se trouve lignes 245 à 267. Le code des fiches élèves se trouve dans le fichier Darboux0_Elev.py.

E) Un intervalle de fluctuation d’une variable binomiale, en première S

- Cet algorithme est la mise en œuvre directe et explicite de la définition de l’intervalle de fluctuation bilatéral "symétrique" en probabilité, du document ressource. On recherche, dans la liste contenant les valeurs des probabilités cumulées croissantes de la variable aléatoire X (appelée aussi répartition de X) de distribution binomiale de paramètre n et p, la plus petite valeur strictement supérieure à (1 – seuil) / 2, puis la plus petite valeur supérieure ou égale à 1 – (1 – seuil) / 2 = (1 + seuil) / 2. Les deux valeurs de la variable X correspondant à ces probabilités cumulées sont les bornes a et b de l’intervalle de fluctuation de la variable aléatoire X, au seuil de probabilité seuil.
- L’algorithme fait la représentation graphique de la fonction de répartition de X, et y caractérise l’IF en barres vertes.
- La séquence passe en revue d’autres algorithme permettant de déterminer cet intervalle de fluctuation.

  1. def IFBino1(n = 14, p = .6, seuil = .95):
  2. from scipy.stats import binom
  3. from matplotlib import pyplot as plt
  4. x = range(n + 1)
  5. reparti = binom.cdf(x, n, p)
  6. a = min([i for i in x if reparti[i] > (1 - seuil) / 2])
  7. b = min([i for i in x if reparti[i] >= (1 + seuil) / 2])
  8. pIF = binom.cdf(b, n, p) - binom.cdf(a - 1, n, p)
  9. print("l'IF au seuil de", seuil, "de la va X est :",
  10. "[", a, ";", b, "],\n sa probabilité est", pIF)
  11. distrib = binom.pmf(x, n, p)
  12. listCoul = ['red'] * a + ['green'] * (b - a + 1) + ['red'] * (n - b)
  13. plt.figure()
  14. plt.bar(x, reparti, color = listCoul)
  15. plt.plot((0, n), ((1 - seuil) / 2, (1 - seuil) / 2), color = 'red')
  16. plt.plot((0, n), ((1 + seuil) / 2, (1 + seuil) / 2), color = 'red')
  17. plt.title("RÉPARTITION DE PROBABILITÉ")
  18. plt.xlabel("VALEURS DE LA V.A. X")
  19. plt.ylabel("PROBABILITÉS CUMULÉES CROISSANTES")
  20. plt.grid()
  21. plt.show()

Télécharger

Cliquez pour agrandir

L’IF bilatéral, symétrique en probabilité, de seuil 0,95, de la va X de loi binomiale n=14, p=0,6 est [5 ;12].

* Le code commenté de la séquence se trouve dans le fichier BinoDistribEtIF0_0.py. La fonction Python IFBino1 se trouve lignes 119 à 139. Le code des fiches élèves se trouve dans le fichier BinoDistribEtIF_Elev.py.

F) Une autre marche aléatoire : Le robot Tom – Bac S Antilles Guyane septembre 2013 – Exercice 4 questions 1. et 2.

F.1. Simulation d’une marche et représentation graphique (1/2)


- Le robot Tom se déplace sur un pont sans garde-corps, de 10 pas de long et 2 pas de large. On schématise ce pont par un rectangle dans un repère orthonormé, d’unité 1 pas.
Le robot démarre au point O(0 ; 0). Il a passé le pont lorsqu’il arrive aux points (10 ; 0) ou (10 ; 1) ou (10 ; – 1).
Il se déplace de 3 façons aléatoires exclusives, équiprobables : Soit il fait un pas "en avant"(+ 1 en x), soit un pas "en diagonale à gauche" (+ 1 en y suivi de + 1 en x), soit un pas "en diagonale à droite" (– 1 en y suivi de + 1 en x). Il tombe à l’eau lorsque (y > 1 ou y < – 1) et x < 10.
- Les algorithmes robtom1() et robtom2() du fichier RoboTom0.py mettent en œuvre l’algorithme de l’énoncé. L’algorithme robtom3_1() réalise une première représentation graphique d’une marche aléatoire sur le pont qui sera améliorée avec robtom3_1().
- L’algorithme robtom3_1() du fichier RoboTom0.py réalise la simulation d’une marche aléatoire du robot Tom et en fait la représentation graphique.
* Il n’y a pas encore de fiche élève en Python pour cette activité.

Cliquez pour agrandir
  1. def robtom3_1():
  2. from random import sample
  3. from matplotlib import pyplot as plt
  4. urne = {-1, 0, 1}
  5. x, y, sortie = 0, 0, 0
  6. posisTomX = [0] ; posisTomY = [0]
  7. while y <= 1 and y >= -1 and x <= 9:
  8. n = sample(urne, 1)
  9. y = y + n[0]
  10. x = x + 1
  11. posisTomX.append(x)
  12. posisTomY.append(y)
  13. if y == -2 or y == 2:
  14. message = "TOM est tombé\nà l'eau"
  15. else:
  16. message = "TOM a passé \nle pont"
  17. sortie = 1
  18. plt.figure()
  19. plt.plot((0, 10), (-2, 2), ls = 'none') ; plt.xticks(range(11)) ; plt.yticks(range(-2, 3))
  20. plt.fill((0, 10, 10, 0), (-1, -1, 1, 1), alpha = 0.3, color = 'green')

Télécharger

F.1. Simulation d’une marche et représentation graphique (2/2)

  1. if sortie == 1:
  2. plt.plot(posisTomX, posisTomY, 'go-')
  3. plt.text(x, y, message, va = 'bottom', ha = 'center', color = 'green')
  4. else:
  5. plt.plot(posisTomX[0:x], posisTomY[0:x], 'bo-')
  6. if y < 0:
  7. plt.plot(x - 0.8, y + 0.8, marker = '*', markerfacecolor = 'red', markersize = 10)
  8. plt.text(x - 0.8, y + 0.8, message, va = 'top', ha = 'center', color = 'blue')
  9. else:
  10. plt.plot(x - 0.8, y - 0.8, marker = '*', markerfacecolor = 'red', markersize = 10)
  11. plt.text(x - 0.8, y - 0.8, message, va = 'bottom', ha = 'center', color = 'blue')
  12. plt.grid()
  13. plt.show()

Télécharger

F.2. Simulation de nbsim marches et estimation de la probabilité de passer le pont (1/2)

- Les algorithmes robtom4_*() du fichier RoboTom0.py effectuent nbsim simulations d’une marche aléatoire et calculent une estimation de la probabilité de passer le pont. Ils mettent en œuvres des stratégies différentes faisant appels à des opérateurs python variés.

  1. "Simule une marche et retourne son résultat"
  2. def robtom4_0():
  3. from random import sample
  4. x, y = 0, 0
  5. urne = {-1, 0, 1}
  6. while y <= 1 and y >= -1 and x <= 9:
  7. n = sample(urne, 1)
  8. y = y + n[0]
  9. x = x + 1
  10. if y == -2 or y == 2:
  11. passage = 0
  12. else:
  13. passage = 1
  14. return(passage)

Télécharger

F.2. Simulation de nbsim marches et estimation de la probabilité de passer le pont (2/2).

  1. "-----------------------"
  2. "Simule nbsim marches et retourne la fréquence de passage"
  3. " N'utilise pas les listes, utilise robtom4_0"
  4. def robtom4_1(nbsim = 5000):
  5. nbPassages = 0
  6. for i in range(nbsim):
  7. nbPassages = nbPassages + robtom4_0()
  8. freqPassage = nbPassages / nbsim
  9. print("Une estimation de la probabilité de passage est :", freqPassage)
  10.  
  11. "-----------------------"
  12. "Simule nbsim marches et retourne la fréquence des résultats de la marche"
  13. " Utilise les listes sans opérateur particulier, utilise robtom4_0"
  14. def robtom4_2(nbsim = 5000):
  15. tableauEffec = [0] * 2
  16. for i in range(nbsim):
  17. passage = robtom4_0()
  18. # tableauEffec[robtom4_0()] = tableauEffec[robtom4_0()] + 1
  19. tableauEffec[passage] = tableauEffec[passage] + 1
  20. freqMarche = [tableauEffec[i] / nbsim for i in range(2)]
  21. print("Tableau des fréquences des résultats de la marche :", freqMarche)
  22.  
  23. "-----------------------"
  24. "Simule nbsim marches et retourne la fréquence des résultats de la marche"
  25. "Utilise les listes ET l'opérateur particulier Counter de la bibliothèque collections, utilise robtom4_0"
  26. def robtom4_3(nbsim = 5000):
  27. from collections import Counter
  28. seriepassages = [robtom4_0() for i in range(nbsim)]
  29. tableauEffec = Counter(seriepassages)
  30. freqMarche = [tableauEffec[i] / nbsim for i in range(2)]
  31. print("Tableau des fréquences des résultats de la marche :", freqMarche)

Télécharger

F.3. Estimation des probabilités de sortie en chacun des 3 points de sortie du pont (1/2)

- L’algorithme robtom5_0() du fichier RoboTom0.py effectue la simulation d’une marche aléatoire et retourne l’ordonnée du point de fin de la marche.
- L’algorithme robtom5_1() du fichier RoboTom0.py effectue nbsim simulation d’une marche aléatoire et retourne la fréquence de chacun des 3 points de passage du pont.

  1. " Simule une marche et retourne l'ordonnée du point de fin de la marche"
  2. " utilise sample de random"
  3. def robtom5_0():
  4. from random import sample
  5. x, y = 0, 0
  6. urne = {-1, 0, 1}
  7. while y <= 1 and y >= -1 and x <= 9:
  8. n = sample(urne, 1)
  9. y = y + n[0]
  10. x = x + 1
  11. return(y)
  12.  
  13. "-----------------------"
  14. " Simule nbsim marches et retourne la fréquence de chacun des 3 points de passage du pont"
  15. " utilise robtom5_0()"
  16. def robtom5_1(nbsim = 5000):
  17. tabloEffecPassage = [0] * 3
  18. for i in range(nbsim):
  19. y = robtom5_0()
  20. if y == -1:
  21. tabloEffecPassage[0] += 1
  22. if y == 0:
  23. tabloEffecPassage[1] += 1
  24. if y == 1:
  25. tabloEffecPassage[2] += 1
  26. tabloFreqPassage = [tabloEffecPassage[i] / nbsim for i in range(3)]
  27. return(tabloFreqPassage)

Télécharger

F.3. Estimation des probabilités de sortie en chacun des 3 points de sortie du pont (2/2)

- L’algorithme robtom5_2() du fichier RoboTom0.py effectue nbsim simulations d’une marche aléatoire, calcule la fréquence de chacun des 3 points de sortie du pont et en fait une représentation graphique en disques dont la surface est proportionnelle à la fréquence.

Cliquez pour agrandir


  1. " Réalise le graphique en disque illustrant la fréquence"
  2. " de chacun des trois points de passage du pont"
  3. " utilise robtom5_0(), robtom5_1() et numpy"
  4. def robtom5_2(nbsim = 5000):
  5. from matplotlib import pyplot as plt
  6. from numpy import pi
  7. from random import random
  8. tabloFreqPassage = robtom5_1(nbsim)
  9. distribRayon = [tabloFreqPassage[i] / max(tabloFreqPassage) * 40 for i in range(3)]
  10. MessageFreqPassage = ('Une estimation de la probabilité\nde passage du pont est de '
  11. + str(round(sum(tabloFreqPassage), 4)))
  12. airedisques = [pi * distribRayon[i]**2 for i in range(3)]
  13. couleurs = [random() for i in range(3)]
  14. plt.figure()
  15. plt.fill((0, 1, 1, 0), (-1, -1, 1, 1), alpha = 0.3, color = 'green')
  16. plt.scatter((1, 1, 1), (-1, 0, 1),
  17. s = airedisques, c = couleurs, alpha = .6)
  18. plt.xticks(range(3), ('', '', ''))
  19. plt.yticks(range(-2, 3), ('', -1, 0, 1, ''))
  20. for i in range(3):
  21. plt.text(1, i - 1, tabloFreqPassage[i])
  22. plt.text(0, -2, MessageFreqPassage, horizontalalignment = 'left',
  23. verticalalignment = 'bottom')
  24. plt.title('Distribution des fréquences simulées\ndes points de passage du pont')
  25. plt.ylabel('Ordonnées des points de passage')
  26. plt.grid()
  27. plt.show()

Télécharger

Vous pouvez télécharger l’ensemble des fichiers en une seule fois à l’aide du dossier zip ci-dessous :

Zip - 538.6 ko
Fiches à télécharger

Réagir à cet article
Vous souhaitez compléter cet article pour un numéro futur, réagir à son contenu, demander des précisions à l'auteur ou au comité de rédaction...
À lire aussi ici
MathémaTICE est un projet
en collaboration avec
Suivre la vie du site Flux RSS 2.0  |  Espace de rédaction  |  Nous contacter  |  Site réalisé avec: SPIP  |  N° ISSN 2109-9197