Exercices corrigés : Algorithmique et Python — Terminale STI2D

Correction détaillée

1. 1

   On utilise un ACCUMULATEUR : une variable initialisée à $0$0, à laquelle on ajoute chaque élément.

2. 2

   $$\text{def somme(L):}$$def somme(L):$$\text{S = 0}$$S = 0$$\text{for x in L:}$$for x in L:$$\text{S = S + x}$$S = S + x$$\text{return S}$$return S

3. 3

   Trace : $S=0$S = 0, puis $120$120, puis $255$255, puis $353$353, puis $495$495, puis $600$600.

4. 4

   La fonction renvoie $600$600 : la production totale des cinq jours.

5. 5

   Deux points de vigilance : $\text{S = 0}$S = 0 doit être AVANT la boucle, et $\text{return S}$return S APRÈS.

Rappel de cours : Somme d'une liste : accumulateur initialisé à $0$0 avant la boucle, renvoyé après.

Erreur fréquente : Placer $\text{return S}$return S dans la boucle : la fonction s'arrêterait au premier élément et renverrait $120$120.

Correction détaillée

1. 1

   On part d'une liste contenant le premier terme et on ajoute les suivants avec $\text{append}$append.

2. 2

   $$\text{def termes():}$$def termes():$$\text{L = [120]}$$L = [120]$$\text{u = 120}$$u = 120$$\text{for k in range(5):}$$for k in range(5):$$\text{u = u + 8}$$u = u + 8$$\text{L.append(u)}$$L.append(u)$$\text{return L}$$return L

3. 3

   La liste contient déjà $u_1$u₁, et la boucle ajoute $5$5 termes : au total $6$6 termes ✔.

4. 4

   Résultat : $\text{[120, 128, 136, 144, 152, 160]}$[120, 128, 136, 144, 152, 160].

5. 5

   Contrôle par la formule : $u_6=120+5\times 8=160$u₆ = 120 + 5× 8 = 160 ✔.

Rappel de cours : $\text{L.append(u)}$L.append(u) ajoute $\text{u}$u en fin de liste. Attention au nombre de tours quand le premier terme y est déjà.

Erreur fréquente : Boucler $6$6 fois : la liste contiendrait $7$7 termes, soit un de trop.

Correction détaillée

1. 1

   $$\text{def somme(n):}$$def somme(n):$$\text{S = 0}$$S = 0$$\text{for k in range(1, n+1):}$$for k in range(1, n+1):$$\text{S = S + k}$$S = S + k$$\text{return S}$$return S

2. 2

   Le $\text{range(1, n+1)}$range(1, n+1) parcourt $1$1, $2$2, …, $n$n : la borne de droite est EXCLUE, d'où le $+1$+1.

3. 3

   Pour $n=100$n = 100, la fonction renvoie $5050$5 050.

4. 4

   Vérification par la formule : $\frac{100\times 101}{2}=5050$(100× 101)/2 = 5 050 ✔.

5. 5

   Comparaison des deux approches : la formule est instantanée, la boucle effectue $100$100 additions.

   Sur $n=10^9$n = 10⁹, seule la formule reste utilisable.

Rappel de cours : $\text{range(a, b)}$range(a, b) s'arrête à $b-1$b-1 : pour aller jusqu'à $n$n, on écrit $\text{range(1, n+1)}$range(1, n+1).

Erreur fréquente : Écrire $\text{range(1, n)}$range(1, n) : la somme s'arrêterait à $n-1$n-1 et vaudrait $4950$4 950 pour $n=100$n = 100.

Correction détaillée

1. 1

   À chaque tour, $\text{x}$x avance de $+1$+1 ou recule de $-1$-1, avec la même probabilité.

   C'est une MARCHE ALÉATOIRE sur une droite.

2. 2

   À la fin, $\text{x}$x représente la position atteinte après $4$4 pas, en partant de $0$0.

3. 3

   Si $k$k pas sont vers la droite et $4-k$4 - k vers la gauche, alors $\text{x}=k-(4-k)=2k-4$x = k - (4-k) = 2k - 4.

4. 4

   Pour $k=0$k = 0 à $4$4, les positions possibles sont $-4$-4, $-2$-2, $0$0, $2$2, $4$4.

5. 5

   Les positions IMPAIRES sont impossibles : avec un nombre pair de pas, la position finale est toujours paire.

6. 6

   Remarque : le nombre $k$k de pas vers la droite suit une loi binomiale $\mathcal{B}(4;0,5)$B (4 ; 0,5), de répartition $1$1-$4$4-$6$6-$4$4-$1$1 sur $16$16.

   La position $0$0 est donc la plus probable ($\frac{6}{16}$6/16).

Rappel de cours : Marche aléatoire : à chaque pas $\pm 1$± 1. Après $n$n pas, la position vaut $2k-n$2k - n où $k$k est le nombre de pas positifs.

Erreur fréquente : Croire que toutes les positions entre $-4$-4 et $4$4 sont possibles : seules les valeurs de même parité que $n$n le sont.

Correction détaillée

1. 1

   Le tirage étant uniforme sur $[0;1[$[0 ; 1[, la probabilité que $\text{random()}$random() soit inférieur à $0,12$0,12 vaut exactement $0,12$0,12.

2. 2

   On teste donc $\text{random() < 0.12}$random() < 0.12.

3. 3

   $$\text{from random import random}$$from random import random$$\text{def essai():}$$def essai():$$\text{if random() < 0.12:}$$if random() < 0.12:$$\text{return 1}$$return 1$$\text{return 0}$$return 0

4. 4

   Le $\text{return 0}$return 0 final n'a pas besoin de $\text{else}$else : il n'est atteint que si le test a échoué.

5. 5

   Pour une probabilité $0,5$0,5, on peut aussi utiliser $\text{randint(0, 1) == 1}$randint(0, 1) == 1, qui donne $0$0 ou $1$1 de façon équiprobable.

6. 6

   À retenir : $\text{random()}$random() sert pour une probabilité quelconque, $\text{randint}$randint pour des issues entières équiprobables.

Rappel de cours : $\text{random() < p}$random() < p simule un succès de probabilité $p$p · $\text{randint(a, b)}$randint(a, b) renvoie un entier de $a$a à $b$b INCLUS.

Erreur fréquente : Écrire $\text{random() < 12}$random() < 12 : la condition serait toujours vraie, puisque $\text{random()}$random() renvoie un nombre inférieur à $1$1.

Correction détaillée

1. 1

   On accumule les versements, en multipliant le versement courant par $1,06$1,06 à chaque tour.

2. 2

   $$\text{def total(n):}$$def total(n):$$\text{v = 2000}$$v = 2000$$\text{S = 0}$$S = 0$$\text{for k in range(n):}$$for k in range(n):$$\text{S = S + v}$$S = S + v$$\text{v = 1.06 * v}$$v = 1.06 * v$$\text{return S}$$return S

3. 3

   L'ordre des deux lignes compte : on ajoute d'abord le versement de l'année, PUIS on le fait croître pour l'année suivante.

4. 4

   Trace pour $n=4$n = 4 : $S=2000$S = 2 000 puis $v=2120$v = 2 120 ; $S=4120$S = 4 120 puis $v=2247,2$v = 2 247,2 ; $S=6367,2$S = 6 367,2 puis $v=2382,03$v = 2 382,03 ; $S=8749,23$S = 8 749,23.

5. 5

   La fonction renvoie environ $8749,23$8 749,23 €.

6. 6

   Contrôle par la formule : $S=2000\times \frac{1-1,06^4}{1-1,06}$S = 2 000×(1 - 1,06⁴)/(1 - 1,06).

   Or $1,06^4\approx 1,262477$1,06⁴ ≈ 1,262 477, donc $S\approx 2000\times \frac{-0,262477}{-0,06}\approx 8749,2$S ≈ 2 000×(-0,262 477)/(-0,06) ≈ 8 749,2 € ✔.

Rappel de cours : Deux variables : $\text{v}$v pour le terme courant, $\text{S}$S pour le cumul. On ajoute avant de faire évoluer le terme.

Erreur fréquente : Inverser les deux lignes : on ajouterait le versement de l'année suivante dès le premier tour, et le total serait trop élevé de $6\%$6%.

Correction détaillée

1. 1

   Principe : la ligne suivante commence et finit par $1$1, et chaque terme intérieur est la somme de deux termes consécutifs de la ligne précédente.

2. 2

   $$\text{def suivante(L):}$$def suivante(L):$$\text{M = [1]}$$M = [1]$$\text{for i in range(len(L) - 1):}$$for i in range(len(L) - 1):$$\text{M.append(L[i] + L[i+1])}$$M.append(L[i] + L[i+1])$$\text{M.append(1)}$$M.append(1)$$\text{return M}$$return M

3. 3

   La boucle tourne $\text{len(L) - 1}$len(L) - 1 fois, soit $4$4 fois pour une ligne de $5$5 termes : cela produit les $4$4 termes intérieurs.

4. 4

   Application : $L[0]+L[1]=1+4=5$L[0] + L[1] = 1 + 4 = 5 ; $L[1]+L[2]=4+6=10$L[1]+L[2] = 4+6 = 10 ; $L[2]+L[3]=6+4=10$L[2]+L[3] = 6+4 = 10 ; $L[3]+L[4]=4+1=5$L[3]+L[4] = 4+1 = 5.

5. 5

   Avec les deux $1$1 ajoutés : $\text{[1, 5, 10, 10, 5, 1]}$[1, 5, 10, 10, 5, 1] ✔ C'est bien la ligne $n=5$n = 5.

6. 6

   Contrôle : la ligne obtenue compte $6$6 termes, soit un de plus que la précédente ✔ et sa somme vaut $32=2^5$32 = 2⁵ ✔.

Rappel de cours : $\left(\genfrac{}{}{0ex}{}{n}{k}\right)=\left(\genfrac{}{}{0ex}{}{n-1}{k-1}\right)+\left(\genfrac{}{}{0ex}{}{n-1}{k}\right)$C(n, k) = C(n-1, k-1) + C(n-1, k) : c'est exactement ce que fait $\text{L[i] + L[i+1]}$L[i] + L[i+1].

Erreur fréquente : Boucler $\text{range(len(L))}$range(len(L)) : à la dernière itération, $\text{L[i+1]}$L[i+1] sortirait de la liste et Python renverrait une erreur d'indice.

Correction détaillée

1. 1

   Moyenne : on accumule puis on divise APRÈS la boucle.

2. 2

   $$\text{def moyenne(T):}$$def moyenne(T):$$\text{S = 0}$$S = 0$$\text{for x in T:}$$for x in T:$$\text{S = S + x}$$S = S + x$$\text{return S / len(T)}$$return S / len(T)

3. 3

   Maximum : on retient une valeur « championne », initialisée au premier élément.

4. 4

   $$\text{def maximum(T):}$$def maximum(T):$$\text{m = T[0]}$$m = T[0]$$\text{for x in T:}$$for x in T:$$\text{if x > m:}$$if x > m:$$\text{m = x}$$m = x$$\text{return m}$$return m

5. 5

   Application : somme $=62+68+71+65+74+69=409$= 62+68+71+65+74+69 = 409, donc moyenne $=\frac{409}{6}\approx 68,17$= 409/6 ≈ 68,17 °C.

6. 6

   Maximum : la championne passe de $62$62 à $68$68, puis $71$71, puis $74$74 — et reste à $74$74.

   La fonction renvoie $74$74 °C.

7. 7

   Pourquoi initialiser à $\text{T[0]}$T[0] et non à $0$0 ?

   Parce qu'avec des relevés négatifs (des écarts, par exemple), l'initialisation à $0$0 renverrait $0$0, qui n'est pas dans la liste.

Rappel de cours : Accumuler DANS la boucle, diviser APRÈS · maximum : initialiser au premier élément de la liste.

Erreur fréquente : Diviser par $\text{len(T)}$len(T) à chaque tour : on calculerait des moyennes partielles sans signification.

Correction détaillée

1. 1

   $$\text{from random import random}$$from random import random$$\text{def prelevement():}$$def prelevement():$$\text{c = 0}$$c = 0$$\text{for k in range(10):}$$for k in range(10):$$\text{if random() < 0.07:}$$if random() < 0.07:$$\text{c = c + 1}$$c = c + 1$$\text{return c}$$return c

2. 2

   $$\text{def estimation(N):}$$def estimation(N):$$\text{c = 0}$$c = 0$$\text{for k in range(N):}$$for k in range(N):$$\text{if prelevement() >= 1:}$$if prelevement() >= 1:$$\text{c = c + 1}$$c = c + 1$$\text{return c / N}$$return c / N

3. 3

   Valeur théorique : le nombre de non conformes suit $\mathcal{B}(10;0,07)$B (10 ; 0,07), donc $P(X\ge 1)=1-0,93^{10}$P(X ≥ 1) = 1 - 0,93¹⁰.

4. 4

   $0,93^{10}\approx 0,48398$0,93¹⁰ ≈ 0,483 98, donc $P(X\ge 1)\approx 0,516$P(X≥ 1) ≈ 0,516.

5. 5

   La simulation doit donc renvoyer une valeur proche de $0,52$0,52.

   Avec $N=100$N = 100, on obtiendra typiquement entre $0,42$0,42 et $0,62$0,62 ; avec $N=100000$N = 100 000, on sera à $0,005$0,005 près.

6. 6

   Deux exécutions donnent des résultats DIFFÉRENTS : c'est normal pour une simulation, ce n'est pas un défaut du programme.

Rappel de cours : Monte-Carlo : on répète l'expérience un grand nombre de fois, la FRÉQUENCE observée estime la probabilité.

Erreur fréquente : Appeler $\text{prelevement()}$prelevement() deux fois dans une même condition : on simulerait deux prélèvements différents et le résultat serait faux.

Correction détaillée

1. 1

   Deux variables à faire évoluer : la production du mois et le cumul.

2. 2

   $$\text{def mois():}$$def mois():$$\text{p = 500}$$p = 500$$\text{S = 0}$$S = 0$$\text{n = 0}$$n = 0$$\text{while S <= 10000:}$$while S <= 10000:$$\text{S = S + p}$$S = S + p$$\text{p = 1.04 * p}$$p = 1.04 * p$$\text{n = n + 1}$$n = n + 1$$\text{return n}$$return n

3. 3

   Trace : $n=1$n = 1 donne $S=500$S = 500 et $p=520$p = 520 ; $n=2$n = 2 donne $S=1020$S = 1 020 et $p=540,8$p = 540,8 ; $n=3$n = 3 donne $S=1560,8$S = 1 560,8 et $p\approx 562,43$p ≈ 562,43 ; $n=4$n = 4 donne $S\approx 2123,23$S ≈ 2 123,23.

4. 4

   Le cumul croît d'environ $500$500 à $600$600 par mois : il faudra donc une quinzaine de mois.

5. 5

   Calcul par la formule : $S_n=500\times \frac{1-1,04^n}{1-1,04}=12500\left(1,04^n-1\right)$Sₙ = 500×(1 - 1,04^(n))/(1 - 1,04) = 12 500(1,04^(n) - 1).

6. 6

   Condition $S_n>10000$Sₙ > 10 000 : $1,04^n>1,8$1,04^(n) > 1,8, donc $n>\frac{\log 1,8}{\log 1,04}\approx 14,99$n > (log 1,8)/(log 1,04) ≈ 14,99.

7. 7

   Le programme renvoie donc $15$15 : le cumul dépasse $10000$10 000 pièces au 15ᵉ mois.

8. 8

   Contrôle : $S_{15}=12500(1,04^{15}-1)\approx 12500\times 0,80094\approx 10011,8$S₁₅ = 12 500(1,04¹⁵ - 1) ≈ 12 500 × 0,800 94 ≈ 10 011,8 ✔ et $S_{14}\approx 9146$S₁₄ ≈ 9 146 ✔.

Rappel de cours : Cumul avec seuil : boucle $\text{while}$while, deux variables (terme courant et cumul) et un compteur.

Erreur fréquente : Oublier $\text{n = n + 1}$n = n + 1 : la boucle s'exécuterait correctement mais renverrait $0$0 — ou tournerait indéfiniment si l'on oubliait aussi la mise à jour de $\text{S}$S.

Correction détaillée

1. 1

   On réutilise le principe de la ligne suivante, en mémorisant toutes les lignes.

2. 2

   $$\text{def pascal(n):}$$def pascal(n):$$\text{T = [[1]]}$$T = [[1]]$$\text{for i in range(1, n):}$$for i in range(1, n):$$\text{L = T[i-1]}$$L = T[i-1]$$\text{M = [1]}$$M = [1]$$\text{for j in range(len(L) - 1):}$$for j in range(len(L) - 1):$$\text{M.append(L[j] + L[j+1])}$$M.append(L[j] + L[j+1])$$\text{M.append(1)}$$M.append(1)$$\text{T.append(M)}$$T.append(M)$$\text{return T}$$return T

3. 3

   Pour $n=5$n = 5, la fonction renvoie $\text{[[1], [1,1], [1,2,1], [1,3,3,1], [1,4,6,4,1]]}$[[1], [1,1], [1,2,1], [1,3,3,1], [1,4,6,4,1]].

4. 4

   Les lignes correspondent à $n=0$n = 0 à $n=4$n = 4 : la ligne d'indice $i$i contient les coefficients $\left(\genfrac{}{}{0ex}{}{i}{k}\right)$C(i, k).

5. 5

   Pour $\left(\genfrac{}{}{0ex}{}{4}{2}\right)$C(4, 2) : c'est le terme d'indice $2$2 de la ligne d'indice $4$4, soit $\text{T[4][2]}=6$T[4][2] = 6 ✔.

6. 6

   Attention aux indices : $\text{pascal(5)}$pascal(5) donne les lignes $0$0 à $4$4.

   Pour disposer de $\left(\genfrac{}{}{0ex}{}{n}{k}\right)$C(n, k), il faut donc appeler $\text{pascal(n+1)}$pascal(n+1).

7. 7

   Contrôle : $\text{T[4]}$T[4] a $5$5 éléments, de somme $16=2^4$16 = 2⁴ ✔.

Rappel de cours : Une liste de listes s'indexe deux fois : $\text{T[i][j]}$T[i][j] est le terme $j$j de la ligne $i$i, et vaut $\left(\genfrac{}{}{0ex}{}{i}{j}\right)$C(i, j).

Erreur fréquente : Appeler $\text{pascal(4)}$pascal(4) pour obtenir $\left(\genfrac{}{}{0ex}{}{4}{2}\right)$C(4, 2) : la dernière ligne serait celle de $n=3$n = 3, et $\text{T[4]}$T[4] provoquerait une erreur d'indice.

Correction détaillée

1. 1

   On part de $\left(\genfrac{}{}{0ex}{}{n}{0}\right)=1$C(n, 0) = 1 et l'on applique la relation $k$k fois.

2. 2

   $$\text{def coeff(n, k):}$$def coeff(n, k):$$\text{c = 1}$$c = 1$$\text{for i in range(1, k+1):}$$for i in range(1, k+1):$$\text{c = c * (n - i + 1) / i}$$c = c * (n - i + 1) / i$$\text{return c}$$return c

3. 3

   Trace pour $n=6$n = 6 et $k=3$k = 3 : $c=1$c = 1.

4. 4

   $i=1$i = 1 : $c=1\times \frac{6}{1}=6$c = 1 × 6/1 = 6.

5. 5

   $i=2$i = 2 : $c=6\times \frac{5}{2}=15$c = 6×5/2 = 15.

6. 6

   $i=3$i = 3 : $c=15\times \frac{4}{3}=20$c = 15×4/3 = 20.

7. 7

   La fonction renvoie $20$20.

8. 8

   Vérification sur le triangle : la ligne $n=6$n = 6 est $1615201561$1 6 15 20 15 6 1, et son terme d'indice $3$3 vaut bien $20$20 ✔.

9. 9

   Avantage de cette méthode : elle ne demande que $k$k multiplications, là où le triangle complet exige de construire $n$n lignes.

   Pour $\left(\genfrac{}{}{0ex}{}{50}{2}\right)$C(50, 2), c'est deux opérations contre cinquante lignes.

Rappel de cours : $\left(\genfrac{}{}{0ex}{}{n}{k}\right)=\frac{n(n-1)\cdots (n-k+1)}{1\times 2\times \cdots \times k}$C(n, k) = (n(n-1)…(n-k+1))/(1× 2×…× k) : on alterne multiplications et divisions pour rester sur de petits nombres.

Erreur fréquente : Faire toutes les multiplications avant les divisions : sur de grands $n$n, les produits deviennent énormes et les erreurs d'arrondi apparaissent.

Correction détaillée

1. 1

   Une réalisation de $X$X s'obtient en comptant les succès sur $5$5 épreuves de probabilité $0,2$0,2.

2. 2

   $$\text{from random import random}$$from random import random$$\text{def realisation():}$$def realisation():$$\text{c = 0}$$c = 0$$\text{for k in range(5):}$$for k in range(5):$$\text{if random() < 0.2:}$$if random() < 0.2:$$\text{c = c + 1}$$c = c + 1$$\text{return c}$$return c

3. 3

   $$\text{def estime(N):}$$def estime(N):$$\text{c = 0}$$c = 0$$\text{for k in range(N):}$$for k in range(N):$$\text{if realisation() == 2:}$$if realisation() == 2:$$\text{c = c + 1}$$c = c + 1$$\text{return c / N}$$return c / N

4. 4

   Noter le test $\text{== 2}$== 2 (égalité stricte) et non $\text{>= 2}$>= 2 : on veut $P(X=2)$P(X = 2), pas $P(X\ge 2)$P(X≥ 2).

5. 5

   Valeur théorique : $P(X=2)=\left(\genfrac{}{}{0ex}{}{5}{2}\right)\times 0,2^2\times 0,8^3=10\times 0,04\times 0,512=0,2048$P(X = 2) = C(5, 2) × 0,2²× 0,8³ = 10× 0,04× 0,512 = 0,204 8.

6. 6

   La simulation doit donc renvoyer une valeur proche de $0,205$0,205.

7. 7

   Ordre de grandeur de l'écart : avec $N=1000$N = 1 000, on obtient typiquement entre $0,18$0,18 et $0,23$0,23 ; avec $N=1000000$N = 1 000 000, on est à $0,001$0,001 près.

Rappel de cours : Simuler une loi binomiale : on répète $n$n épreuves de Bernoulli et l'on COMPTE les succès.

Erreur fréquente : Tester $\text{>= 2}$>= 2 au lieu de $\text{== 2}$== 2 : on estimerait $P(X\ge 2)\approx 0,263$P(X ≥ 2) ≈ 0,263, une autre probabilité.

Correction détaillée

1. 1

   $$\text{from random import randint}$$from random import randint$$\text{def marche(n):}$$def marche(n):$$\text{x = 0}$$x = 0$$\text{for k in range(n):}$$for k in range(n):$$\text{if randint(0, 1) == 1:}$$if randint(0, 1) == 1:$$\text{x = x + 1}$$x = x + 1$$\text{else:}$$else:$$\text{x = x - 1}$$x = x - 1$$\text{return x}$$return x

2. 2

   $$\text{def moyenne(n, N):}$$def moyenne(n, N):$$\text{S = 0}$$S = 0$$\text{for k in range(N):}$$for k in range(N):$$\text{S = S + marche(n)}$$S = S + marche(n)$$\text{return S / N}$$return S / N

3. 3

   La position moyenne doit tendre vers $0$0 : les pas $+1$+1 et $-1$-1 étant équiprobables, ils se compensent en moyenne.

4. 4

   En revanche la DISTANCE moyenne à l'origine n'est pas nulle : il suffit de remplacer $\text{marche(n)}$marche(n) par $\text{abs(marche(n))}$abs(marche(n)) pour l'estimer.

5. 5

   Pour $n=100$n = 100, cette distance moyenne vaut environ $8$8 mètres — de l'ordre de $\sqrt{n}=10$√(n) = 10, pas de $n=100$n = 100.

6. 6

   C'est le résultat fondamental des marches aléatoires : on s'éloigne comme $\sqrt{n}$√(n), et non proportionnellement au nombre de pas.

7. 7

   Conséquence pratique : un chariot qui dérive au hasard s'écarte lentement, mais il s'écarte — et l'écart typique quadruple quand le nombre de pas est multiplié par $16$16.

Rappel de cours : Marche aléatoire symétrique : position moyenne nulle, mais éloignement typique de l'ordre de $\sqrt{n}$√(n).

Erreur fréquente : Conclure « la position moyenne est nulle, donc le chariot reste sur place » : c'est la MOYENNE des positions qui est nulle, pas la position elle-même.

Correction détaillée

1. 1

   Le point $(x;y)$(x ; y) est dans le quart de disque si sa distance à l'origine est inférieure à $1$1, c'est-à-dire si $x^2+y^2\le 1$x² + y² ≤ 1.

2. 2

   $$\text{from random import random}$$from random import random$$\text{def aire(N):}$$def aire(N):$$\text{c = 0}$$c = 0$$\text{for k in range(N):}$$for k in range(N):$$\text{x = random()}$$x = random()$$\text{y = random()}$$y = random()$$\text{if x**2 + y**2 <= 1:}$$if x**2 + y**2 <= 1:$$\text{c = c + 1}$$c = c + 1$$\text{return c / N}$$return c / N

3. 3

   Le carré a une aire de $1$1, donc la proportion de points tombés dans le quart de disque estime directement son AIRE.

4. 4

   Or l'aire d'un quart de disque de rayon $1$1 vaut $\frac{\pi }{4}\approx 0,7854$π/4 ≈ 0,785 4.

5. 5

   La fonction doit donc renvoyer une valeur proche de $0,785$0,785.

6. 6

   Estimation de $\pi$π : il suffit de multiplier par $4$4.

   Avec $N=10000$N = 10 000, on obtient typiquement $\pi \approx 3,13$π ≈ 3,13 à $3,15$3,15.

7. 7

   Précision : la méthode de Monte-Carlo converge lentement — pour gagner un chiffre décimal, il faut multiplier $N$N par $100$100.

   Elle vaut donc surtout pour les aires qu'on ne sait pas calculer autrement.

8. 8

   Point technique : il faut deux appels distincts à $\text{random()}$random(), un pour $\text{x}$x et un pour $\text{y}$y.

   Réutiliser la même valeur ne tirerait que des points de la diagonale.

Rappel de cours : Monte-Carlo pour une aire : proportion de points tombés dans la région $\times$× aire du domaine de tirage.

Erreur fréquente : Écrire $\text{x = y = random()}$x = y = random() : les deux coordonnées seraient égales et tous les points sur la diagonale du carré.

Correction détaillée

1. 1

   $$\text{from random import randint}$$from random import randint$$\text{def rupture():}$$def rupture():$$\text{s = 50}$$s = 50$$\text{for j in range(30):}$$for j in range(30):$$\text{if randint(0, 1) == 1:}$$if randint(0, 1) == 1:$$\text{s = s + 3}$$s = s + 3$$\text{else:}$$else:$$\text{s = s - 4}$$s = s - 4$$\text{if s <= 0:}$$if s <= 0:$$\text{return 1}$$return 1$$\text{return 0}$$return 0

2. 2

   Le test $\text{if s <= 0}$if s <= 0 est placé À L'INTÉRIEUR de la boucle : une rupture même temporaire doit être détectée, pas seulement l'état final.

3. 3

   $$\text{def proba(N):}$$def proba(N):$$\text{c = 0}$$c = 0$$\text{for k in range(N):}$$for k in range(N):$$\text{c = c + rupture()}$$c = c + rupture()$$\text{return c / N}$$return c / N

4. 4

   Comme $\text{rupture()}$rupture() renvoie $0$0 ou $1$1, on peut l'ajouter directement au compteur : c'est plus court qu'un $\text{if}$if.

5. 5

   Variation moyenne journalière : $0,5\times 3+0,5\times (-4)=1,5-2=-0,5$0,5× 3 + 0,5×(-4) = 1,5 - 2 = -0,5 pièce par jour.

6. 6

   Tendance : le stock baisse en moyenne de $0,5$0,5 pièce par jour, soit $15$15 pièces sur $30$30 jours.

   Il devrait donc finir autour de $35$35 pièces.

7. 7

   Mais la tendance moyenne ne dit pas tout : les fluctuations peuvent faire descendre le stock bien plus bas.

   C'est justement ce que la simulation permet de chiffrer.

8. 8

   Ordre de grandeur : avec une baisse moyenne de $15$15 pièces et des fluctuations de l'ordre de $\sqrt{30}\times 3,5\approx 19$√(30)× 3,5 ≈ 19 pièces, une rupture est possible mais peu fréquente — la simulation donne environ $3\%$3%.

Rappel de cours : Espérance de la variation $=\sum p_i{v}_i$= Σ pᵢ vᵢ. Elle donne la TENDANCE, la simulation donne le RISQUE.

Erreur fréquente : Tester la rupture seulement à la fin des $30$30 jours : un stock passé par $-2$-2 puis remonté serait compté comme non rompu, alors que la rupture a bien eu lieu.

Correction détaillée

1. 1

   $$\text{from random import random}$$from random import random$$\text{def refus(p):}$$def refus(p):$$\text{c = 0}$$c = 0$$\text{for k in range(20):}$$for k in range(20):$$\text{if random() < p:}$$if random() < p:$$\text{c = c + 1}$$c = c + 1$$\text{if c >= 3:}$$if c >= 3:$$\text{return 1}$$return 1$$\text{return 0}$$return 0

2. 2

   Le test $\text{c >= 3}$c >= 3 est APRÈS la boucle : on compte d'abord les $20$20 pièces, puis on décide.

3. 3

   $$\text{def estimation(p, N):}$$def estimation(p, N):$$\text{c = 0}$$c = 0$$\text{for k in range(N):}$$for k in range(N):$$\text{c = c + refus(p)}$$c = c + refus(p)$$\text{return c / N}$$return c / N

4. 4

   Valeurs théoriques, par la loi binomiale $\mathcal{B}(20;p)$B (20 ; p) :

5. 5

   Pour $p=0,02$p = 0,02 : $P(X\ge 3)\approx 0,007$P(X ≥ 3) ≈ 0,007 — le programme doit renvoyer environ $0,007$0,007.

6. 6

   Pour $p=0,08$p = 0,08 : $P(X\ge 3)\approx 0,212$P(X ≥ 3) ≈ 0,212 — le programme doit renvoyer environ $0,21$0,21.

7. 7

   Conclusion : le plan refuse à tort moins de $1\%$1% des bons lots (protection du fournisseur), mais il ne détecte qu'un lot médiocre sur cinq (protection insuffisante du client).

8. 8

   Remarque sur la simulation : pour estimer une probabilité de $0,007$0,007, il faut un grand $N$N.

   Avec $N=1000$N = 1 000, on n'observerait que $7$7 refus en moyenne, ce qui est trop peu pour une estimation stable — il faut $N=100000$N = 100 000 au moins.

9. 9

   C'est une limite générale de Monte-Carlo : plus l'évènement est rare, plus il faut de simulations.

Rappel de cours : Une simulation valide un calcul théorique : les deux doivent concorder, sinon l'un des deux est faux.

Erreur fréquente : Placer le test $\text{if c >= 3}$if c >= 3 dans la boucle : le prélèvement s'arrêterait avant les $20$20 pièces, ce qui n'est pas le plan décrit (même si le verdict final serait identique ici).

Correction détaillée

1. 1

   Déroulons : à chaque tour, $\text{S}$S est REMIS À ZÉRO, puis reçoit $\text{u}$u.

2. 2

   Au dernier tour ($n=9$n = 9), $\text{u}$u vaut $3\times 2^9=1536$3× 2⁹ = 1 536, donc $\text{S}=1536$S = 1 536.

3. 3

   Le programme renvoie donc $1536$1 536 : c'est le DERNIER terme, pas la somme.

4. 4

   Erreur : $\text{S = 0}$S = 0 est à l'intérieur de la boucle.

   Il doit être AVANT, pour n'être exécuté qu'une fois.

5. 5

   Programme corrigé :

6. 6

   $$\text{def somme():}$$def somme():$$\text{u = 3}$$u = 3$$\text{S = 0}$$S = 0$$\text{for n in range(10):}$$for n in range(10):$$\text{S = S + u}$$S = S + u$$\text{u = 2 * u}$$u = 2 * u$$\text{return S}$$return S

7. 7

   Valeur exacte : $S=3+6+12+\cdots +1536$S = 3 + 6 + 12 + … + 1 536, somme de $10$10 termes géométriques de raison $2$2.

8. 8

   $S=3\times \frac{1-2^{10}}{1-2}=3\times \frac{1-1024}{-1}=3\times 1023=3069$S = 3×(1 - 2¹⁰)/(1 - 2) = 3×(1 - 1 024)/(-1) = 3× 1 023 = 3 069.

9. 9

   Le programme corrigé renvoie bien $3069$3 069.

10. 10

    Contrôle : la somme doit être légèrement inférieure au double du dernier terme ($2\times 1536=3072$2× 1 536 = 3 072) — propriété des suites géométriques de raison $2$2 ✔.

Rappel de cours : Une initialisation d'accumulateur se fait toujours AVANT la boucle. Dans la boucle, elle annule tout le cumul précédent.

Erreur fréquente : Corriger en déplaçant $\text{return}$return : ce n'est pas l'erreur ici. Le $\text{return}$return est bien placé, c'est l'initialisation qui est fautive.

Correction détaillée

1. 1

   Le domaine est contenu dans le rectangle $[0;2]\times [0;4]$[0 ; 2]×[0 ; 4], dont l'aire vaut $2\times 4=8$2× 4 = 8.

2. 2

   On tire donc $x$x dans $[0;2]$[0 ; 2] et $y$y dans $[0;4]$[0 ; 4], et l'on compte les points vérifiant $y\le x^2$y ≤ x².

3. 3

   $$\text{from random import random}$$from random import random$$\text{def aire(N):}$$def aire(N):$$\text{c = 0}$$c = 0$$\text{for k in range(N):}$$for k in range(N):$$\text{x = 2 * random()}$$x = 2 * random()$$\text{y = 4 * random()}$$y = 4 * random()$$\text{if y <= x**2:}$$if y <= x**2:$$\text{c = c + 1}$$c = c + 1$$\text{return 8 * c / N}$$return 8 * c / N

4. 4

   Le facteur $8$8 est essentiel : la fréquence $\frac{c}{N}$c/N est une PROPORTION du rectangle, qu'il faut multiplier par son aire.

5. 5

   Valeur attendue : l'aire sous $x^2$x² entre $0$0 et $2$2 vaut $\frac{2^3}{3}=\frac{8}{3}\approx 2,667$2³/3 = 8/3 ≈ 2,667 (on le verra avec le calcul intégral).

6. 6

   La proportion de points favorables doit donc valoir $\frac{8/3}{8}=\frac{1}{3}$(8/3)/8 = 1/3 : environ un point sur trois tombe sous la courbe.

7. 7

   Amélioration de la précision : augmenter $N$N.

   L'erreur décroît comme $\frac{1}{\sqrt{N}}$1/( √N ), donc gagner un facteur $10$10 de précision demande $100$100 fois plus de tirages.

8. 8

   Autre amélioration, plus astucieuse : réduire le rectangle.

   En majorant $f$f par $4$4 on ne « perd » que les deux tiers des points ; un encadrement plus serré rendrait la simulation plus efficace.

9. 9

   Contrôle de cohérence : l'estimation doit être proche de $2,67$2,67 et toujours comprise entre $0$0 et $8$8 ✔.

Rappel de cours : Monte-Carlo pour une aire : $\text{aire}\approx \text{aire du rectangle}\times \frac{\text{points sous la courbe}}{N}$aire ≈ aire du rectangle × (points sous la courbe)/N.

Erreur fréquente : Oublier de multiplier par l'aire du rectangle : on renverrait $0,333$0,333 au lieu de $2,667$2,667.

Correction détaillée

1. 1

   $$\text{def productions(n):}$$def productions(n):$$\text{L = []}$$L = []$$\text{p = 1200}$$p = 1200$$\text{for k in range(n):}$$for k in range(n):$$\text{L.append(p)}$$L.append(p)$$\text{p = 0.98 * p}$$p = 0.98 * p$$\text{return L}$$return L

2. 2

   $$\text{def mois(s):}$$def mois(s):$$\text{p = 1200}$$p = 1200$$\text{S = 0}$$S = 0$$\text{n = 0}$$n = 0$$\text{while S <= s:}$$while S <= s:$$\text{S = S + p}$$S = S + p$$\text{p = 0.98 * p}$$p = 0.98 * p$$\text{n = n + 1}$$n = n + 1$$\text{return n}$$return n

3. 3

   Calcul par la formule : $S_n=1200\times \frac{1-0,98^n}{1-0,98}=60000\left(1-0,98^n\right)$Sₙ = 1 200×(1 - 0,98^(n))/(1 - 0,98) = 60 000(1 - 0,98^(n)).

4. 4

   Condition $S_n>20000$Sₙ > 20 000 : $1-0,98^n>\frac{1}{3}$1 - 0,98^(n) > 1/3, soit $0,98^n<0,6667$0,98^(n) < 0,666 7.

5. 5

   Logarithme : $n>\frac{\log 0,6667}{\log 0,98}\approx \frac{-0,1761}{-0,008774}\approx 20,07$n > (log 0,666 7)/(log 0,98) ≈ (-0,176 1)/(-0,008 774) ≈ 20,07.

6. 6

   Le seuil est donc dépassé au 21ᵉ mois.

   Contrôle : $S_{20}=60000(1-0,98^{20})\approx 60000\times 0,3324\approx 19944$S₂₀ = 60 000(1 - 0,98²⁰) ≈ 60 000× 0,332 4 ≈ 19 944 kWh (insuffisant) et $S_{21}\approx 20745$S₂₁ ≈ 20 745 kWh ✔.

7. 7

   Cumul maximal : quand $n$n devient très grand, $0,98^n$0,98^(n) tend vers $0$0, donc $S_n$Sₙ tend vers $60000$60 000 kWh.

8. 8

   L'installation ne produira donc JAMAIS plus de $60000$60 000 kWh au total, même en la laissant fonctionner indéfiniment.

   C'est la limite d'une somme géométrique de raison inférieure à $1$1.

9. 9

   Conséquence pour le calcul de rentabilité : un objectif de $70000$70 000 kWh cumulés serait inatteignable avec ce modèle, et la boucle $\text{while}$while du programme tournerait indéfiniment — d'où l'utilité d'une borne de sécurité.

Rappel de cours : Somme géométrique de raison $0<q<1$0 < q < 1 : le cumul est BORNÉ par $\frac{u_1}{1-q}$u₁/(1-q), ici $\frac{1200}{0,02}=60000$(1 200)/0,02 = 60 000.

Erreur fréquente : Lancer la boucle $\text{while}$while avec un seuil supérieur à $60000$60 000 : elle ne s'arrêterait jamais. Tout programme à seuil mérite une borne de sécurité.