Exercices corrigés : Algorithmique et Python — Première STI2D

Correction détaillée

1. 1

   Une affectation $\text{x = ...}$x = ... calcule d'abord le membre de DROITE, puis range le résultat dans la variable de gauche.

   L'ancienne valeur est perdue.

2. 2

   Après $\text{a = 5}$a = 5 : $\text{a}$a vaut $5$5.

3. 3

   Après $\text{b = 12}$b = 12 : $\text{a}=5$a = 5 et $\text{b}=12$b = 12.

4. 4

   $\text{a = a + b}$a = a + b : on calcule $5+12=17$5 + 12 = 17, puis on range $17$17 dans $\text{a}$a.

   Donc $\text{a}=17$a = 17 et $\text{b}=12$b = 12.

5. 5

   $\text{b = a - b}$b = a - b : on calcule $17-12=5$17 - 12 = 5 avec les valeurs ACTUELLES, puis on range $5$5 dans $\text{b}$b.

   Donc $\text{a}=17$a = 17 et $\text{b}=5$b = 5.

6. 6

   Remarque : $\text{b}$b a pris l'ancienne valeur de $\text{a}$a.

   Ces deux lignes sont le début de l'astuce classique d'échange de deux variables sans variable auxiliaire.

Rappel de cours : $\text{x = expression}$x = expression n'est pas une égalité mathématique : c'est une AFFECTATION, qui écrase l'ancienne valeur.

Erreur fréquente : Utiliser l'ancienne valeur de $\text{a}$a ($5$5) dans la dernière ligne : à ce moment $\text{a}$a vaut déjà $17$17.

Correction détaillée

1. 1

   La fonction calcule $3x-7$3x - 7 et renvoie le résultat.

2. 2

   $\text{f(4)}$f(4) : $3\times 4-7=12-7=5$3 × 4 - 7 = 12 - 7 = 5.

3. 3

   $\text{f(0)}$f(0) : $3\times 0-7=-7$3 × 0 - 7 = -7.

4. 4

   $\text{f(-2)}$f(-2) : $3\times (-2)-7=-6-7=-13$3 × (-2) - 7 = -6 - 7 = -13.

5. 5

   Pour la dernière question, on résout l'équation $3x-7=20$3x - 7 = 20.

6. 6

   $3x=27$3x = 27, donc $x=9$x = 9.

7. 7

   Contrôle : $\text{f(9)}$f(9) renvoie $3\times 9-7=20$3 × 9 - 7 = 20 ✔.

Rappel de cours : Une fonction Python est l'exact équivalent d'une fonction mathématique : $\text{f(x)}$f(x) c'est $f(x)$f(x).

Erreur fréquente : Oublier les parenthèses mentales sur les négatifs : $3\times (-2)$3 × (-2) vaut $-6$-6, et non $-3\times 2-7=-13$-3 × 2 - 7 = -13 par hasard juste ici.

Correction détaillée

1. 1

   Convertir des bars en pascals, c'est multiplier par $100000$100 000.

2. 2

   $$\text{def enPascals(p):}$$def enPascals(p):$$\text{return 100000 * p}$$return 100000 * p

3. 3

   Contrôle : $\text{enPascals(2.5)}$enPascals(2.5) renvoie $250000$250 000 Pa, ce qui est correct pour $2,5$2,5 bars ✔.

4. 4

   La conversion inverse divise par $100000$100 000 :$$\text{def enBars(q):}$$def enBars(q):$$\text{return q / 100000}$$return q / 100000

5. 5

   Contrôle croisé : $\text{enBars(enPascals(2.5))}$enBars(enPascals(2.5)) renvoie $2,5$2,5 ✔.

   Les deux fonctions se défont l'une l'autre.

6. 6

   Détail d'écriture : en Python, le séparateur décimal est le POINT ($\text{2.5}$2.5), et jamais la virgule — $\text{f(2,5)}$f(2,5) serait interprété comme deux arguments.

Rappel de cours : Sans $\text{return}$return, une fonction ne renvoie rien ($\text{None}$None) : l'affichage par $\text{print}$print n'est pas un retour de valeur.

Erreur fréquente : Écrire la virgule décimale : $\text{2,5}$2,5 n'est pas un nombre en Python. On écrit $\text{2.5}$2.5.

Correction détaillée

1. 1

   $\text{range(1, 6)}$range(1, 6) parcourt $1$1, $2$2, $3$3, $4$4, $5$5 : la borne de droite est EXCLUE.

2. 2

   Avant la boucle : $\text{S}=0$S = 0.

3. 3

   $k=1$k = 1 : $\text{S}=0+1=1$S = 0 + 1 = 1.

4. 4

   $k=2$k = 2 : $\text{S}=1+2=3$S = 1 + 2 = 3.

5. 5

   $k=3$k = 3 : $\text{S}=3+3=6$S = 3 + 3 = 6.

6. 6

   $k=4$k = 4 : $\text{S}=6+4=10$S = 6 + 4 = 10.

7. 7

   $k=5$k = 5 : $\text{S}=10+5=15$S = 10 + 5 = 15.

8. 8

   À la fin, $\text{S}=15$S = 15, c'est-à-dire $1+2+3+4+5$1 + 2 + 3 + 4 + 5.

9. 9

   $\text{S}$S est un ACCUMULATEUR : une variable initialisée à $0$0 qui reçoit une contribution à chaque tour.

Rappel de cours : $\text{range(a, b)}$range(a, b) parcourt $a$a, $a+1$a+1, …, $b-1$b-1 : la borne supérieure est exclue.

Erreur fréquente : Croire que $\text{range(1, 6)}$range(1, 6) inclut $6$6 : on annoncerait $21$21 au lieu de $15$15.

Correction détaillée

1. 1

   $\text{controle(120.1)}$controle(120.1) : $120,1\ge 119,6$120,1 ≥ 119,6 est vrai ET $120,1\le 120,4$120,1 ≤ 120,4 est vrai, donc la fonction renvoie « conforme ».

2. 2

   $\text{controle(119.4)}$controle(119.4) : $119,4\ge 119,6$119,4 ≥ 119,6 est FAUX, la condition globale est fausse, donc « rebut ».

3. 3

   $\text{controle(120.4)}$controle(120.4) : $120,4\le 120,4$120,4 ≤ 120,4 est vrai (inégalité LARGE), donc « conforme ».

   La borne est incluse, conformément à la tolérance.

4. 4

   Python accepte l'écriture directe d'un encadrement :$$\text{if 119.6 <= L <= 120.4:}$$if 119.6 <= L <= 120.4:

5. 5

   Cette forme est plus lisible et strictement équivalente à la conjonction avec $\text{and}$and.

6. 6

   Attention à ne pas utiliser $\text{or}$or : avec $\text{if L >= 119.6 or L <= 120.4}$if L >= 119.6 or L <= 120.4, la condition serait vraie pour TOUTE valeur, et toutes les pièces seraient déclarées conformes.

Rappel de cours : $\text{and}$and exige les deux conditions · $\text{or}$or en exige au moins une. Un encadrement se traduit toujours par $\text{and}$and.

Erreur fréquente : Confondre $\text{=}$= (affectation) et $\text{==}$== (test d'égalité) dans une condition : Python renvoie une erreur de syntaxe.

Correction détaillée

1. 1

   On parcourt la liste et on incrémente un compteur à chaque valeur hors tolérance.

2. 2

   $$\text{def horsTolerance(L):}$$def horsTolerance(L):$$\text{c = 0}$$c = 0$$\text{for x in L:}$$for x in L:$$\text{if x < 119.6 or x > 120.4:}$$if x < 119.6 or x > 120.4:$$\text{c = c + 1}$$c = c + 1$$\text{return c}$$return c

3. 3

   Ici la condition utilise $\text{or}$or : être hors tolérance, c'est être trop petit OU trop grand.

4. 4

   Examen des valeurs : $120,1$120,1 est dans la tolérance ; $119,4<119,6$119,4 < 119,6 $\to$→ hors tolérance ($\text{c}=1$c = 1).

5. 5

   $120,3$120,3 est dans la tolérance ; $120,7>120,4$120,7 > 120,4 $\to$→ hors tolérance ($\text{c}=2$c = 2).

6. 6

   $119,9$119,9 est dans la tolérance ; $120,4$120,4 est exactement à la borne, donc DANS la tolérance.

7. 7

   La fonction renvoie $\text{c}=2$c = 2.

8. 8

   Remarque : $\text{for x in L}$for x in L parcourt directement les VALEURS de la liste.

   On aurait pu écrire $\text{for i in range(len(L))}$for i in range(len(L)) et utiliser $\text{L[i]}$L[i], mais c'est plus lourd.

Rappel de cours : Un COMPTEUR s'initialise à $0$0 avant la boucle et s'incrémente de $1$1 dans le $\text{if}$if.

Erreur fréquente : Initialiser $\text{c = 0}$c = 0 À L'INTÉRIEUR de la boucle : le compteur repartirait de zéro à chaque tour et ne pourrait jamais dépasser $1$1.

Correction détaillée

1. 1

   On additionne toutes les valeurs avec un accumulateur, puis on divise par le nombre de valeurs.

2. 2

   $$\text{def moyenne(L):}$$def moyenne(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 / len(L)}$$return S / len(L)

3. 3

   $\text{len(L)}$len(L) donne le nombre d'éléments de la liste, ici $5$5.

4. 4

   Trace de l'accumulateur : $0\to 22\to 63\to 121\to 200\to 300$0 → 22 → 63 → 121 → 200 → 300.

5. 5

   Division finale : $\frac{300}{5}=60$300/5 = 60.

6. 6

   La fonction renvoie $60$60, ce qui est bien la moyenne de ces cinq mesures ✔.

7. 7

   Point important : la division est APRÈS la boucle.

   Placée à l'intérieur, elle diviserait des sommes partielles et le résultat n'aurait aucun sens.

Rappel de cours : Structure d'un calcul de moyenne : accumuler DANS la boucle, diviser APRÈS la boucle.

Erreur fréquente : Diviser par $\text{len(L)}$len(L) à chaque tour, ou oublier la division et renvoyer la somme $300$300.

Correction détaillée

1. 1

   Principe : on retient une valeur « championne », initialisée au PREMIER élément, et on la remplace dès qu'on trouve mieux.

2. 2

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

3. 3

   Initialisation : $\text{m}=\text{L[0]}=14$m = L[0] = 14.

4. 4

   $x=14$x = 14 : pas plus grand, $\text{m}$m reste $14$14.

   $x=9$x = 9 : non, $\text{m}=14$m = 14.

5. 5

   $x=23$x = 23 : plus grand, donc $\text{m}=23$m = 23.

6. 6

   $x=23$x = 23 à nouveau : $23>23$23 > 23 est FAUX, $\text{m}$m reste $23$23 (ce qui ne change rien).

7. 7

   $x=7$x = 7 puis $x=19$x = 19 : pas plus grands.

   La fonction renvoie $23$23 ✔.

8. 8

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

   Parce qu'avec une liste de valeurs négatives (par exemple des écarts de réglage), l'initialisation à $0$0 renverrait $0$0, qui n'appartient même pas à la liste.

Rappel de cours : Recherche de maximum : initialiser au premier élément de la liste, jamais à $0$0.

Erreur fréquente : Écrire $\text{if x > m: return x}$if x > m: return x : la fonction s'arrêterait au premier élément supérieur à $\text{L[0]}$L[0], sans finir le parcours.

Correction détaillée

1. 1

   Le nombre d'itérations est inconnu à l'avance : c'est un cas de boucle $\text{while}$while.

2. 2

   $$\text{def duree():}$$def duree():$$\text{v = 30000}$$v = 30000$$\text{n = 0}$$n = 0$$\text{while v >= 15000:}$$while v >= 15000:$$\text{v = 0.92 * v}$$v = 0.92 * v$$\text{n = n + 1}$$n = n + 1$$\text{return n}$$return n

3. 3

   Trace : $n=1\to v=27600$n = 1 → v = 27 600 ; $n=2\to v=25392$n = 2 → v = 25 392 ; $n=3\to v\approx 23360,6$n = 3 → v ≈ 23 360,6 ; $n=4\to v\approx 21491,8$n = 4 → v ≈ 21 491,8.

4. 4

   Puis $n=5\to v\approx 19772,5$n = 5 → v ≈ 19 772,5 ; $n=6\to v\approx 18190,7$n = 6 → v ≈ 18 190,7 ; $n=7\to v\approx 16735,5$n = 7 → v ≈ 16 735,5 ; $n=8\to v\approx 15396,6$n = 8 → v ≈ 15 396,6.

5. 5

   $15396,6$15 396,6 est encore $\ge 15000$≥ 15 000 : la boucle continue.

   $n=9\to v\approx 14164,9$n = 9 → v ≈ 14 164,9, cette fois inférieur à $15000$15 000 : la boucle s'arrête.

6. 6

   La fonction renvoie $9$9 : il faut $9$9 ans pour que la machine vaille moins de $15000$15 000 €.

7. 7

   Contrôle par le calcul direct : $30000\times 0,92^8\approx 15396$30 000 × 0,92⁸ ≈ 15 396 et $30000\times 0,92^9\approx 14165$30 000 × 0,92⁹ ≈ 14 165 ✔.

Rappel de cours : $\text{while}$while : nombre d'itérations inconnu, arrêt sur CONDITION · $\text{for}$for : nombre d'itérations fixé d'avance.

Erreur fréquente : Incrémenter $\text{n}$n avant de modifier $\text{v}$v n'a pas d'importance ici, mais oublier $\text{n = n + 1}$n = n + 1 provoque une boucle infinie… et un programme qui ne rend jamais la main.

Correction détaillée

1. 1

   $\text{range(4)}$range(4) parcourt $0$0, $1$1, $2$2, $3$3 : la boucle tourne $4$4 fois.

2. 2

   Départ : $\text{u}=2$u = 2.

3. 3

   Tour 1 : $\text{u}=3\times 2-1=5$u = 3 × 2 - 1 = 5.

4. 4

   Tour 2 : $\text{u}=3\times 5-1=14$u = 3 × 5 - 1 = 14.

5. 5

   Tour 3 : $\text{u}=3\times 14-1=41$u = 3 × 14 - 1 = 41.

6. 6

   Tour 4 : $\text{u}=3\times 41-1=122$u = 3 × 41 - 1 = 122.

7. 7

   À la fin, $\text{u}=122$u = 122.

8. 8

   Ce programme calcule les termes de la suite définie par $u_0=2$u₀ = 2 et $u_{n+1}=3u_n-1$uₙ₊₁ = 3uₙ - 1 : la variable $\text{u}$u contient $u_4$u₄ à la sortie.

9. 9

   Noter que la variable de boucle $\text{i}$i n'apparaît pas dans le calcul : elle ne sert qu'à COMPTER les répétitions.

Rappel de cours : $\text{range(n)}$range(n) parcourt $0$0 à $n-1$n-1, donc $n$n valeurs : la boucle tourne $n$n fois.

Erreur fréquente : Compter $5$5 tours pour $\text{range(4)}$range(4) : on obtiendrait $365$365 au lieu de $122$122.

Correction détaillée

1. 1

   Le pas n'étant pas entier, on ne peut pas le mettre directement dans $\text{range}$range (qui n'accepte que des entiers).

   On boucle sur un compteur entier et on reconstruit $x$x.

2. 2

   $$\text{def f(x):}$$def f(x):$$\text{return x**2 - 6*x + 5}$$return x**2 - 6*x + 5$$\text{for k in range(13):}$$for k in range(13):$$\text{x = 0.5 * k}$$x = 0.5 * k$$\text{print(x, f(x))}$$print(x, f(x))

3. 3

   Pourquoi $\text{range(13)}$range(13) ?

   De $0$0 à $6$6 avec un pas de $0,5$0,5, il y a $\frac{6}{0,5}+1=13$6/0,5 + 1 = 13 valeurs (les deux bornes comprises).

4. 4

   Notation : $\text{x**2}$x**2 désigne $x^2$x² en Python (l'accent circonflexe $\text{ˆ}$\ ne désigne PAS la puissance).

5. 5

   $f(1)=1-6+5=0$f(1) = 1 - 6 + 5 = 0.

6. 6

   $f(3)=9-18+5=-4$f(3) = 9 - 18 + 5 = -4 : c'est le minimum de la fonction, au sommet de la parabole.

7. 7

   $f(5)=25-30+5=0$f(5) = 25 - 30 + 5 = 0.

8. 8

   Lecture du tableau : $f$f s'annule en $1$1 et en $5$5 (les racines), et atteint $-4$-4 en $3$3, au milieu des racines ✔.

Rappel de cours : $\text{range}$range n'accepte que des entiers : pour un pas décimal, on boucle sur $k$k et on pose $x=\text{pas}\times k$x = pas × k.

Erreur fréquente : Écrire $\text{range(0, 6, 0.5)}$range(0, 6, 0.5) : Python renvoie une erreur, le pas doit être entier.

Correction détaillée

1. 1

   Principe du balayage : on part de $x=2$x = 2 et on avance par pas de $0,01$0,01 tant que $x^2$x² reste inférieur à $5$5.

   Dès que $x^2$x² dépasse $5$5, on s'arrête.

2. 2

   $$\text{def balayage():}$$def balayage():$$\text{x = 2}$$x = 2$$\text{while x**2 < 5:}$$while x**2 < 5:$$\text{x = x + 0.01}$$x = x + 0.01$$\text{return x}$$return x

3. 3

   La fonction est croissante sur $[2;3]$[2 ; 3], ce qui garantit qu'on ne « rate » pas la solution : dès que le test échoue, on l'a dépassée.

4. 4

   Quelques valeurs : $2,23^2=4,9729<5$2,23² = 4,972 9 < 5 (on continue) ; $2,24^2=5,0176\ge 5$2,24² = 5,017 6 ≥ 5 (on s'arrête).

5. 5

   La fonction renvoie donc $x\approx 2,24$x ≈ 2,24.

6. 6

   Encadrement : $2,23<\sqrt{5}<2,24$2,23 < √(5) < 2,24.

   La valeur exacte est $\sqrt{5}\approx 2,23607$√(5) ≈ 2,236 07 ✔, bien dans cet encadrement.

7. 7

   Précision : le programme renvoie la première valeur DÉPASSANT la solution.

   Pour un encadrement, on renverrait $\text{x - 0.01}$x - 0.01 et $\text{x}$x.

8. 8

   Remarque technique : les additions répétées de $0,01$0,01 accumulent de minuscules erreurs d'arrondi binaire.

   Pour $100$100 tours c'est indifférent, mais sur des millions d'itérations on préférerait $\text{x = 2 + 0.01*k}$x = 2 + 0.01*k.

Rappel de cours : Le balayage exige une fonction MONOTONE sur l'intervalle, sinon on peut sauter par-dessus une solution.

Erreur fréquente : Utiliser $\text{while x**2 <= 5}$while x**2 <= 5 puis conclure à l'égalité : le programme ne trouve jamais la valeur exacte, seulement un encadrement.

Correction détaillée

1. 1

   On compte les $6$6 obtenus, puis on divise par le nombre de lancers.

2. 2

   $$\text{from random import randint}$$from random import randint$$\text{def frequence(N):}$$def frequence(N):$$\text{c = 0}$$c = 0$$\text{for k in range(N):}$$for k in range(N):$$\text{if randint(1, 6) == 6:}$$if randint(1, 6) == 6:$$\text{c = c + 1}$$c = c + 1$$\text{return c / N}$$return c / N

3. 3

   Attention à l'écriture du test d'égalité : $\text{==}$== et non $\text{=}$=.

4. 4

   La probabilité théorique d'obtenir $6$6 avec un dé équilibré est $\frac{1}{6}\approx 0,1667$1/6 ≈ 0,1667.

5. 5

   Pour $N$N grand, la fréquence renvoyée doit être proche de $0,1667$0,1667.

   Avec $N=100$N = 100, on peut obtenir $0,12$0,12 ou $0,21$0,21 ; avec $N=1000000$N = 1 000 000, on sera typiquement à $0,001$0,001 près.

6. 6

   C'est la loi des grands nombres à l'œuvre : la fréquence observée se rapproche de la probabilité quand le nombre d'essais augmente.

7. 7

   Remarque : deux exécutions du programme donnent des résultats DIFFÉRENTS, puisque les tirages sont aléatoires.

   Un programme de simulation ne renvoie jamais deux fois la même valeur — c'est normal, ce n'est pas un bug.

Rappel de cours : $\text{randint(a, b)}$randint(a, b) renvoie un entier entre $a$a et $b$b INCLUS (contrairement à $\text{range}$range).

Erreur fréquente : Écrire $\text{if randint(1, 6) = 6}$if randint(1, 6) = 6 : erreur de syntaxe. Le test d'égalité s'écrit avec un double signe égal.

Correction détaillée

1. 1

   $\text{append}$append ajoute un élément à la fin d'une liste.

2. 2

   $$\text{def termes():}$$def termes():$$\text{L = [500]}$$L = [500]$$\text{u = 500}$$u = 500$$\text{for k in range(7):}$$for k in range(7):$$\text{u = 0.9 * u + 30}$$u = 0.9 * u + 30$$\text{L.append(u)}$$L.append(u)$$\text{return L}$$return L

3. 3

   La liste contient déjà $u_0$u₀ au départ, et la boucle ajoute $7$7 termes : au total $8$8 termes, de $u_0$u₀ à $u_7$u₇ ✔.

4. 4

   $u_1=0,9\times 500+30=450+30=480$u₁ = 0,9 × 500 + 30 = 450 + 30 = 480.

5. 5

   $u_2=0,9\times 480+30=432+30=462$u₂ = 0,9 × 480 + 30 = 432 + 30 = 462.

6. 6

   $u_3=0,9\times 462+30=415,8+30=445,8$u₃ = 0,9 × 462 + 30 = 415,8 + 30 = 445,8.

7. 7

   Les termes décroissent : $500$500, $480$480, $462$462, $445,8$445,8, … mais de moins en moins vite (écarts $-20$-20, $-18$-18, $-16,2$-16,2).

8. 8

   Valeur d'équilibre : on cherche $\ell$ℓ tel que $\ell =0,9\ell +30$ℓ = 0,9ℓ + 30, soit $0,1\ell =30$0,1ℓ = 30 et $\ell =300$ℓ = 300.

9. 9

   La suite décroît donc vers $300$300 sans l'atteindre.

   Contrôle : $u_7\approx 404,5$u₇ ≈ 404,5, encore loin, mais $u_{30}\approx 308,5$u₃₀ ≈ 308,5.

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

Erreur fréquente : Boucler $8$8 fois alors que $u_0$u₀ est déjà présent : la liste contiendrait $9$9 termes, donc un terme de trop.

Correction détaillée

1. 1

   On combine un balayage (boucle $\text{for}$for sur un compteur entier) et une recherche de minimum (variable « championne »).

2. 2

   $$\text{def f(x):}$$def f(x):$$\text{return x**2 - 6*x + 11}$$return x**2 - 6*x + 11$$\text{def minimum():}$$def minimum():$$\text{xm = 0}$$xm = 0$$\text{m = f(0)}$$m = f(0)$$\text{for k in range(61):}$$for k in range(61):$$\text{x = 0.1 * k}$$x = 0.1 * k$$\text{if f(x) < m:}$$if f(x) < m:$$\text{m = f(x)}$$m = f(x)$$\text{xm = x}$$xm = x$$\text{return xm, m}$$return xm, m

3. 3

   Le $\text{range(61)}$range(61) couvre $x=0$x = 0 à $x=6$x = 6 par pas de $0,1$0,1, soit $61$61 valeurs (bornes comprises).

4. 4

   Il faut mémoriser DEUX informations : la plus petite valeur $\text{m}$m et l'abscisse $\text{xm}$xm où elle est atteinte.

   Les deux se mettent à jour ensemble.

5. 5

   Résultat : le programme renvoie $\text{xm}=3,0$xm = 3,0 et $\text{m}=2,0$m = 2,0.

6. 6

   Vérification par le calcul : $f(x)=x^2-6x+11=(x-3{)}^2+2$f(x) = x² - 6x + 11 = (x-3)² + 2, forme canonique qui donne un minimum de $2$2 en $x=3$x = 3 ✔.

7. 7

   Le balayage a trouvé la valeur EXACTE ici, parce que $3$3 est un multiple du pas $0,1$0,1.

   Avec un minimum en $x=3,05$x = 3,05, le balayage aurait renvoyé $3,0$3,0 ou $3,1$3,1 : la précision du résultat est limitée par le pas.

8. 8

   Remarque technique : $\text{f(x)}$f(x) est appelée deux fois par tour (dans le test et dans l'affectation).

   On peut l'éviter en stockant $\text{y = f(x)}$y = f(x) au début de la boucle — utile si le calcul est coûteux.

Rappel de cours : Recherche de minimum : on mémorise la plus petite valeur ET son abscisse, toutes deux mises à jour dans le même $\text{if}$if.

Erreur fréquente : Mettre à jour $\text{m}$m sans $\text{xm}$xm : on connaîtrait la valeur du minimum sans savoir où il est atteint.

Correction détaillée

1. 1

   Une pièce est non conforme si $\text{random() < 0.12}$random() < 0.12, ce qui se produit avec une probabilité $0,12$0,12.

2. 2

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

3. 3

   Estimation de la probabilité sur $N$N échantillons :

4. 4

   $$\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 echantillon() >= 10:}$$if echantillon() >= 10:$$\text{c = c + 1}$$c = c + 1$$\text{return c / N}$$return c / N

5. 5

   Il y a donc DEUX boucles imbriquées : la boucle interne fabrique un échantillon ($50$50 pièces), la boucle externe répète l'expérience $N$N fois.

   Avec $N=10000$N = 10 000, le programme effectue $500000$500 000 tirages.

6. 6

   Nombre moyen de pièces non conformes par échantillon : $50\times 0,12=6$50 × 0,12 = 6 pièces.

7. 7

   « Au moins $10$10 » est donc un évènement plutôt rare : il faut dépasser de $4$4 pièces la valeur attendue.

   La simulation renvoie en pratique une valeur voisine de $0,07$0,07.

8. 8

   Intérêt de la méthode : le calcul exact de cette probabilité exigerait la loi binomiale (Terminale).

   La simulation, elle, donne une estimation utilisable dès la première, sans autre outil qu'un compteur.

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

Erreur fréquente : Appeler $\text{echantillon()}$echantillon() deux fois dans le test (une fois pour comparer, une fois pour compter) : on simulerait deux échantillons différents et le résultat serait faux.

Correction détaillée

1. 1

   Bénéfice : $B(q)=60q-C(q)=60q-0,5q^2-20q-800=-0,5q^2+40q-800$B(q) = 60q - C(q) = 60q - 0,5q² - 20q - 800 = -0,5q² + 40q - 800.

2. 2

   $$\text{def B(q):}$$def B(q):$$\text{return -0.5*q**2 + 40*q - 800}$$return -0.5*q**2 + 40*q - 800

3. 3

   Recherche du seuil par boucle $\text{while}$while :

4. 4

   $$\text{def seuil():}$$def seuil():$$\text{q = 0}$$q = 0$$\text{while B(q) <= 0:}$$while B(q) <= 0:$$\text{q = q + 1}$$q = q + 1$$\text{return q}$$return q

5. 5

   Valeurs calculées : $B(0)=-800$B(0) = -800 ; $B(10)=-50+400-800=-450$B(10) = -50 + 400 - 800 = -450 ; $B(20)=-200+800-800=-200$B(20) = -200 + 800 - 800 = -200.

6. 6

   $B(30)=-450+1200-800=-50$B(30) = -450 + 1 200 - 800 = -50 : encore négatif.

7. 7

   $B(35)=-612,5+1400-800=-12,5$B(35) = -612,5 + 1 400 - 800 = -12,5 : toujours négatif.

8. 8

   $B(38)=-722+1520-800=-2$B(38) = -722 + 1 520 - 800 = -2 : négatif de peu.

9. 9

   $B(39)=-760,5+1560-800=-0,5$B(39) = -760,5 + 1 560 - 800 = -0,5 : encore négatif !

10. 10

    $B(40)=-800+1600-800=0$B(40) = -800 + 1 600 - 800 = 0 : nul, donc le test $\text{B(q) <= 0}$B(q) <= 0 est encore vrai, la boucle continue.

11. 11

    $B(41)=-840,5+1640-800=-0,5$B(41) = -840,5 + 1 640 - 800 = -0,5 : négatif de nouveau.

12. 12

    Ce comportement est révélateur : le maximum du bénéfice est atteint en $q=40$q = 40 (sommet de la parabole) et il vaut $0$0.

    Le bénéfice n'est donc JAMAIS strictement positif.

13. 13

    Conséquence pour le programme : la boucle $\text{while}$while ne s'arrête jamais — c'est une boucle infinie.

    Il faut donc modifier l'énoncé du problème : au mieux, l'atelier atteint l'équilibre à $40$40 pièces, et il ne peut pas dégager de bénéfice avec ce prix de vente.

14. 14

    Correction possible du programme : ajouter une borne de sécurité, $\text{while B(q) <= 0 and q < 1000}$while B(q) <= 0 and q < 1000, et tester la valeur renvoyée avant de conclure.

    Tout programme à boucle $\text{while}$while doit prévoir ce garde-fou.

Rappel de cours : Une boucle $\text{while}$while peut ne jamais s'arrêter si la condition reste vraie : on prévoit toujours une borne de sécurité.

Erreur fréquente : Faire confiance au programme sans vérifier que la solution existe. Ici l'étude mathématique (sommet de la parabole) est indispensable AVANT de lancer la boucle.

Correction détaillée

1. 1

   Déroulons le programme sur $\text{[150, 80, 200]}$[150, 80, 200].

2. 2

   Premier tour, $x=150$x = 150 : $\text{c}$c est remis à $0$0, puis $150>100$150 > 100 donc $\text{c}=1$c = 1.

   Ensuite $\text{return c}$return c est exécuté : la fonction RENVOIE $1$1 et s'arrête.

3. 3

   Le programme renvoie donc $1$1, sans même regarder les valeurs $80$80 et $200$200.

4. 4

   Première erreur : $\text{c = 0}$c = 0 est À L'INTÉRIEUR de la boucle.

   Le compteur est réinitialisé à chaque tour, il ne peut donc jamais dépasser $1$1.

5. 5

   Seconde erreur : $\text{return c}$return c est aussi dans la boucle.

   Le $\text{return}$return interrompt immédiatement la fonction, dès le premier tour.

6. 6

   Programme corrigé : les deux lignes doivent sortir de la boucle, l'une AVANT, l'autre APRÈS.

7. 7

   $$\text{def compte(L):}$$def compte(L):$$\text{c = 0}$$c = 0$$\text{for x in L:}$$for x in L:$$\text{if x > 100:}$$if x > 100:$$\text{c = c + 1}$$c = c + 1$$\text{return c}$$return c

8. 8

   Vérification : $x=150\to \text{c}=1$x = 150 → c = 1 ; $x=80\to$x = 80 → pas de changement ; $x=200\to \text{c}=2$x = 200 → c = 2.

   La fonction renvoie $2$2 ✔, ce qui est bien le nombre de valeurs supérieures à $100$100.

9. 9

   Méthode générale : en Python, la STRUCTURE est portée par l'indentation.

   Un décalage de quatre espaces change complètement le sens du programme — c'est la source d'erreur la plus fréquente au bac.

Rappel de cours : Initialiser AVANT la boucle, renvoyer APRÈS la boucle. En Python, c'est l'indentation qui le dit.

Erreur fréquente : Ne corriger qu'une des deux erreurs : en sortant seulement $\text{return}$return, le compteur resterait remis à zéro et la fonction renverrait $0$0 ou $1$1.

Correction détaillée

1. 1

   Le point moyen a pour coordonnées les deux moyennes.

2. 2

   $$\text{def pointMoyen(X, Y):}$$def pointMoyen(X, Y):$$\text{sx = 0}$$sx = 0$$\text{sy = 0}$$sy = 0$$\text{for i in range(len(X)):}$$for i in range(len(X)):$$\text{sx = sx + X[i]}$$sx = sx + X[i]$$\text{sy = sy + Y[i]}$$sy = sy + Y[i]$$\text{n = len(X)}$$n = len(X)$$\text{return sx/n, sy/n}$$return sx/n, sy/n

3. 3

   Ici on boucle sur les INDICES ($\text{range(len(X))}$range(len(X))) et non sur les valeurs, car il faut avancer dans les deux listes en parallèle.

4. 4

   Application : $\text{sx}=1+2+3+4+5=15$sx = 1+2+3+4+5 = 15 et $\text{sy}=22+41+58+79+100=300$sy = 22+41+58+79+100 = 300, avec $n=5$n = 5.

5. 5

   La fonction renvoie $\left(\frac{15}{5};\frac{300}{5}\right)=(3;60)$(15/5 ; 300/5) = (3 ; 60) : le point moyen est $G(3;60)$G(3 ; 60) ✔.

6. 6

   Somme des carrés des résidus pour une droite donnée :

7. 7

   $$\text{def residus(X, Y, a, b):}$$def residus(X, Y, a, b):$$\text{S = 0}$$S = 0$$\text{for i in range(len(X)):}$$for i in range(len(X)):$$\text{r = Y[i] - (a*X[i] + b)}$$r = Y[i] - (a*X[i] + b)$$\text{S = S + r**2}$$S = S + r**2$$\text{return S}$$return S

8. 8

   Avec l'ajustement $a=19,4$a = 19,4 et $b=1,8$b = 1,8, les résidus valent $+0,8$+0,8 ; $+0,4$+0,4 ; $-2$-2 ; $-0,4$-0,4 ; $+1,2$+1,2, donc $\text{S}=0,64+0,16+4+0,16+1,44=6,4$S = 0,64 + 0,16 + 4 + 0,16 + 1,44 = 6,4.

9. 9

   Avec la droite des points extrêmes $a=19,5$a = 19,5 et $b=2,5$b = 2,5, on obtiendrait $\text{S}=11,5$S = 11,5 : plus grand, donc moins bon ajustement.

10. 10

    Ce programme permet ainsi de COMPARER numériquement deux droites — c'est exactement le critère des moindres carrés.

Rappel de cours : Pour parcourir deux listes en parallèle, on boucle sur les INDICES : $\text{for i in range(len(X))}$for i in range(len(X)).

Erreur fréquente : Oublier les parenthèses dans $\text{Y[i] - (a*X[i] + b)}$Y[i] - (a*X[i] + b) : sans elles, le $\text{b}$b serait ajouté au lieu d'être retranché, et tous les résidus seraient faux.

Correction détaillée

1. 1

   Simulation d'un échantillon et calcul de sa fréquence :

2. 2

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

3. 3

   Écart maximal sur $100$100 échantillons : on garde le plus grand écart rencontré, en valeur absolue.

4. 4

   $$\text{def ecartMax(n):}$$def ecartMax(n):$$\text{m = 0}$$m = 0$$\text{for k in range(100):}$$for k in range(100):$$\text{e = abs(frequence(n) - 0.2)}$$e = abs(frequence(n) - 0.2)$$\text{if e > m:}$$if e > m:$$\text{m = e}$$m = e$$\text{return m}$$return m

5. 5

   Ici l'initialisation $\text{m = 0}$m = 0 est légitime : un écart en valeur absolue est toujours positif ou nul, donc $0$0 ne peut pas être dépassé par le bas.

6. 6

   Avec $n=20$n = 20, le programme renvoie typiquement un écart maximal de l'ordre de $0,20$0,20 à $0,25$0,25 : certains échantillons donnent $0$0 ou $0,40$0,40 de fréquence, très loin de $0,2$0,2.

7. 7

   Avec $n=500$n = 500, l'écart maximal tombe à environ $0,05$0,05 : toutes les fréquences observées restent dans $[0,15;0,25]$[0,15 ; 0,25].

8. 8

   Conclusion : la fluctuation d'échantillonnage DIMINUE quand la taille de l'échantillon augmente.

   En multipliant $n$n par $25$25 (de $20$20 à $500$500), on divise l'amplitude des écarts par environ $5$5 — c'est-à-dire par $\sqrt{25}$√(25).

9. 9

   Conséquence pratique en contrôle qualité : un échantillon de $20$20 pièces ne permet de conclure à peu près rien sur la proportion réelle ; il faut des centaines de pièces pour l'estimer sérieusement.

Rappel de cours : La fluctuation d'échantillonnage décroît quand $n$n croît : multiplier $n$n par $4$4 divise environ par $2$2 l'amplitude des écarts.

Erreur fréquente : Comparer des écarts obtenus sur des NOMBRES de pièces plutôt que sur des FRÉQUENCES : $4$4 pièces d'écart sur $20$20 et sur $500$500 n'ont pas du tout la même signification.