Spécialité maths, Première • Exercices corrigés à Montréal

Fiche de révision : Python en spécialité maths (Première)

Les questions d'algorithmique de la spécialité maths ne testent pas la connaissance de Python : elles testent la compréhension du chapitre de maths qu'elles mettent en scène. Une recherche de seuil est une question sur les suites, un balayage est une question sur la continuité, la méthode d'Euler est une question sur le nombre dérivé.

Cette fiche ne redit pas la syntaxe du langage. Elle montre les huit endroits où les copies se trompent, le code exact à recopier pour chacun, l'arbre qui dit quelle boucle employer selon la question, et un programme de résolution approchée décortiqué étape par étape.

Le fil du chapitre

Un programme ne se lit pas comme une formule : il S'EXÉCUTE, ligne après ligne, et l'ordre des instructions décide du résultat. Les points se perdent toujours au même endroit : le compteur incrémenté au mauvais moment, la boucle choisie avant de savoir si le nombre de tours est connu, et l'égalité de deux décimaux testée avec un signe égal.

Ce chapitre fait partie de Spécialité mathématiques en Première

Avant ce chapitre

Cette fiche suppose ces notions acquises. Si une méthode ci-dessous reste opaque, c'est presque toujours l'une d'elles qui manque, pas la fiche.

Algorithmique et PythonSeconde Fiche

Remonter plus loin : la chaîne complète (4 chapitres) ↓

Le chemin de remédiation, du plus ancien au plus proche. Un élève qui reprend ce chapitre de zéro le reprend dans cet ordre.

L'essentiel

for ou while : la question à poser avant d'écrire une ligne

• Le nombre de tours est CONNU à l'avance : boucle bornée, `for k in range(n)`. C'est le cas d'une somme de $n$ termes, d'un calcul de $u_{n}$ pour un $n$ donné, d'un parcours de liste.
• Le nombre de tours est INCONNU et dépend d'une condition : boucle non bornée, `while condition`. C'est le cas d'un seuil, d'un balayage, d'une recherche du premier rang qui vérifie quelque chose.
• `range(n)` produit les entiers de $0$ à $n-1$ , donc $n$ valeurs et pas $n+1$ . `range(1, n+1)` produit ceux de $1$ à $n$ .
• Une boucle `while` doit contenir une instruction qui fait PROGRESSER la condition vers sa fin, sinon elle ne s'arrête jamais.

En contrôle, la question « à partir de quel rang » appelle toujours un `while`, et la question « calculer $u_{20}$ » toujours un `for`. Le mot de l'énoncé décide, pas le goût.

Un programme explore, il ne résout pas

• Le balayage teste les valeurs une par une, avec un pas fixé, et s'arrête à la première qui convient. Il ne donne jamais la valeur exacte, seulement un ENCADREMENT.
• L'amplitude de cet encadrement est exactement le PAS choisi : un pas de $0{,}01$ donne un encadrement d'amplitude $0{,}01$ .
• Le programme renvoie donc deux nombres, la dernière valeur qui ne convenait pas et la première qui convient. Une seule des deux ne répond pas à la question.
• Le principe fonctionne parce que la fonction change de signe entre les deux : c'est le théorème des valeurs intermédiaires, appliqué sans être nommé.

Le balayage teste

x=0

, puis

0{,}5

, puis

1

... Le signe change entre

2

2{,}5

: le programme s'arrête là et renvoie cet encadrement, jamais la valeur exacte

\sqrt{5}\approx 2{,}236

Diviser le pas par $10$ multiplie par $10$ le nombre de tours, donc le temps de calcul. C'est pourquoi la dichotomie existe, même si elle n'est pas au programme de Première.

return, print, et l'ordre des instructions

• `return` RENVOIE une valeur exploitable : `x = f(2)` place le résultat dans `x`. `print` se contente d'AFFICHER, et une fonction sans `return` renvoie `None`.
• `return` termine immédiatement la fonction : tout ce qui suit dans le corps n'est jamais exécuté, et un `return` placé dans la boucle l'interrompt au premier tour.
• Dans une recherche de seuil, l'ordre des deux lignes du corps décide du résultat : on met à jour la valeur, PUIS on incrémente le compteur.
• L'indentation est une instruction : une ligne moins indentée sort de la boucle et n'est exécutée qu'une seule fois, à la fin.

Le contrôle mental le plus rentable : exécuter le programme à la main sur deux ou trois tours, en écrivant les valeurs des variables dans un tableau. Trente secondes, et la plupart des erreurs apparaissent.

Les décimaux ne sont pas exacts en machine

• Un décimal est stocké de façon APPROCHÉE : `0.1 + 0.2` ne vaut pas exactement `0.3`, et l'écart, de l'ordre de $10^{-17}$ , suffit à faire échouer un test d'égalité.
• Une condition d'arrêt s'écrit donc toujours avec une INÉGALITÉ, jamais avec `==`. On écrit `while x*x < 5`, jamais `while x*x != 5`.
• Une somme de nombreux petits pas accumule ces écarts : après cent additions de $0{,}01$ , la valeur obtenue n'est pas exactement $1$ .
• Le nombre dérivé approché $\frac{f(a+h)-f(a)}{h}$ se dégrade quand $h$ devient TROP petit : la soustraction de deux nombres presque égaux perd les décimales significatives.

Ces limites ne sont pas des défauts de Python, elles sont communes à toutes les machines et à toutes les calculatrices. L'énoncé les évoque souvent sous la forme « expliquer ce résultat surprenant ».

Les pièges qui coûtent des points

Les erreurs ci-dessous sont celles que je corrige le plus souvent en séance. Chacune coûte des points sur une copie, même quand le raisonnement est juste.

1. Écrire `print` là où l'énoncé demande une fonction qui renvoie

1 point sur 3, et toute question qui réutilise le résultat devient impossible

Ce qu'il ne faut pas écrire

`def seuil(S):` puis, dans le corps, `print(n)` à la place de `return n`.

Ce qu'il faut écrire

`def seuil(S):` puis `return n`. La fonction renvoie alors une valeur utilisable : `r = seuil(290)` place $11$ dans `r`.

Pourquoi : Une fonction qui se contente d'afficher renvoie `None`. Le repère : si l'énoncé écrit « la fonction renvoie », il faut `return`; s'il écrit « le programme affiche », `print` convient.

2. Incrémenter le compteur avant la mise à jour de la valeur

1 point, et la réponse numérique est décalée d'un rang

Ce qu'il ne faut pas écrire

`while u < S:` puis `n = n + 1` puis `u = 0.8 * u + 60`.

Ce qu'il faut écrire

`while u < S:` puis `u = 0.8 * u + 60` puis `n = n + 1`. On met à jour la valeur, PUIS on compte le tour qu'on vient de faire.

Pourquoi : Le compteur doit toujours mesurer le nombre de mises à jour DÉJÀ effectuées. Inversé, il compte un tour qui n'a pas encore eu lieu, et le rang renvoyé est celui d'avant le dépassement.

3. Choisir une boucle bornée quand le nombre de tours est inconnu

1 point de méthode, et le programme est faux pour certaines valeurs du seuil

Ce qu'il ne faut pas écrire

`for k in range(100):` pour chercher le premier rang où la suite dépasse un seuil.

Ce qu'il faut écrire

`while u < S:` : le nombre de tours dépend de la condition, donc il n'est pas connu à l'avance. Une boucle bornée à $100$ ne répond pas à la question et échoue si le seuil vient plus tard.

Pourquoi : Le choix de la boucle est la première chose que le correcteur regarde. La question « à partir de quel rang », « au bout de combien de temps », « le plus petit entier tel que » appelle toujours un `while`.

4. Tester l'égalité de deux décimaux

toute la question : le programme tourne indéfiniment

Ce qu'il ne faut pas écrire

`while x * x != 5:` pour approcher la racine de $5$ .

Ce qu'il faut écrire

`while x * x < 5:` : les décimaux étant approchés en machine, `x * x` ne vaudra jamais exactement $5$ et la boucle ne s'arrêterait pas.

Pourquoi : `0.1 + 0.2` ne vaut pas exactement `0.3` en machine, l'écart étant de l'ordre de $10^{-17}$ . Une condition d'arrêt se compare donc toujours avec une inégalité.

5. Sortir une instruction de la boucle par une indentation

toute la question, et le programme donne $1$ quel que soit le seuil

Ce qu'il ne faut pas écrire

Le `n = n + 1` écrit au même niveau que le `while`, donc exécuté une seule fois, après la boucle.

Ce qu'il faut écrire

Toutes les instructions du corps de la boucle sont indentées du même nombre d'espaces, sous le `while`. L'indentation n'est pas de la présentation, c'est de la syntaxe.

Pourquoi : En Python, l'appartenance d'une ligne à un bloc se lit uniquement sur son décalage. Une ligne sortie de la boucle s'exécute une seule fois : le compteur reste bloqué à $1$ .

6. Se tromper d'un tour avec `range`

1 point, et la somme est amputée de son dernier terme

Ce qu'il ne faut pas écrire

`for k in range(10):` pour calculer la somme des termes $u_{0}$ à $u_{10}$ .

Ce qu'il faut écrire

`for k in range(11):` : `range(11)` produit les entiers de $0$ à $10$ , soit onze valeurs, autant que de termes à additionner.

Pourquoi : `range(n)` s'arrête à $n-1$ et produit $n$ valeurs. Le comptage est le même qu'en mathématiques : de $u_{0}$ à $u_{10}$ il y a onze termes, pas dix.

7. Prendre un pas trop petit pour approcher un nombre dérivé

toute la question d'interprétation, qui vaut souvent 2 points

Ce qu'il ne faut pas écrire

« Plus $h$ est petit, plus le taux d'accroissement est précis, donc je prends $h=10^{-16}$ . »

Ce qu'il faut écrire

« La précision s'améliore jusqu'à $h\approx 10^{-8}$ , puis se DÉGRADE : la soustraction de deux nombres presque égaux perd les décimales significatives. Avec $h=10^{-16}$ , le taux vaut $0$ au lieu de $2$ . »

En abscisse le logarithme du pas, en ordonnée celui de l'erreur commise sur

f'(1)=2

. L'erreur descend jusqu'à

h=10^{-8}

, puis REMONTE : un pas trop petit dégrade le résultat.

Pourquoi : Deux erreurs se combattent : celle du modèle, qui diminue avec $h$ , et celle de la machine, qui augmente quand $h$ diminue. Leur somme est minimale pour un $h$ intermédiaire, et cet arbitrage est exactement ce que l'exercice fait découvrir.

8. Croire que la méthode d'Euler donne la solution exacte

1 point d'interprétation, et souvent la question de comparaison qui suit

Ce qu'il ne faut pas écrire

« Le programme d'Euler donne $N(5)=32{,}8$ , donc la quantité restante après cinq jours est $32{,}8$ . »

Ce qu'il faut écrire

« La méthode d'Euler donne une valeur APPROCHÉE, ici $32{,}8$ contre $36{,}8$ pour le modèle continu. L'écart vient du pas de calcul, et il diminue quand le pas diminue. »

Les cercles sont les valeurs calculées par Euler avec un pas de

1

, la courbe est le modèle continu. L'écart se creuse d'un pas au suivant et va toujours dans le même sens.

Pourquoi : Euler remplace la courbe par une suite de segments : à chaque pas, on suppose la pente constante alors qu'elle varie. L'écart s'accumule d'un pas au suivant, toujours dans le même sens pour une décroissance.

9. Oublier d'initialiser une variable avant la boucle

toute la question : le programme s'arrête sur une erreur dès la première ligne du `while`

Ce qu'il ne faut pas écrire

`while u < S:` écrit sans avoir donné de valeur de départ à `u` ni à `n`.

Ce qu'il faut écrire

`u = 200` puis `n = 0`, AVANT la boucle. Toute variable modifiée dans une boucle doit exister avant d'y entrer.

Pourquoi : La condition du `while` est évaluée avant le premier tour : elle a besoin de `u`. Les deux initialisations correspondent d'ailleurs aux deux données de l'énoncé, le premier terme et le rang de départ.

Quelle méthode choisir

Quelle boucle selon la question posée

On cherche une seule chose dans l'énoncé : le nombre de tours est-il connu avant de commencer ?

Si « calculer $u_{20}$ », « les $n$ premiers termes », « la somme des $n$ premiers » → boucle bornée `for k in range(n)`, avec un accumulateur initialisé avant

Exemple : `S = 0` puis `for k in range(11): S = S + u(k)` donne la somme de $u_{0}$ à $u_{10}$
Si « à partir de quel rang », « le plus petit entier tel que », « au bout de combien de temps » → boucle non bornée `while condition`, avec un compteur incrémenté APRÈS la mise à jour

Exemple : `while u < 290: u = 0.8*u + 60; n = n + 1` puis `return n`
Si « donner un encadrement de », « une valeur approchée à $0{,}01$ près » → balayage : `while f(x) < 0: x = x + pas`, puis renvoyer `x - pas, x`

L'amplitude de l'encadrement est exactement le pas, donc le pas se lit dans l'énoncé.
Si « compléter le tableau », « déterminer le maximum de la liste » → boucle bornée avec une variable qui retient le meilleur candidat, initialisée au premier élément
Si « modéliser l'évolution », « méthode d'Euler », « pas de temps » → boucle bornée sur le nombre de pas, avec la mise à jour $y\leftarrow y+h\,f'(y)$ à chaque tour

Exemple : une décroissance de $20\,\%$ par unité de temps donne `N = N - 0.2*N`, soit `N = 0.8*N`
Si « tester si », « déterminer le nombre de solutions » → pas de boucle du tout : un `if` avec les conditions du cours, par exemple le signe du discriminant

Exemple : `if d > 0: return 2` puis `elif d == 0: return 1` puis `else: return 0`

Aucune branche ne s'applique ? Relire la question en cherchant le mot qui décrit l'arrêt. S'il n'y en a pas, c'est un `for`; s'il y en a un, c'est un `while`.

Quelle vérification selon ce que le programme renvoie

Avant de rendre la copie, on relit le programme en se demandant ce qu'il renverrait sur un cas simple, connu à la main.

Si le programme renvoie un RANG → vérifier que la valeur au rang renvoyé franchit le seuil, et que celle du rang précédent ne le franchit pas
Si le programme renvoie un ENCADREMENT → vérifier que la fonction change de signe entre les deux bornes, et que leur écart vaut le pas

Exemple : $2{,}23^{2}=4{,}97<5$ et $2{,}24^{2}=5{,}02>5$ , avec $2{,}24-2{,}23=0{,}01$
Si le programme renvoie une SOMME → encadrer le résultat par le nombre de termes multiplié par le plus petit et par le plus grand
Si le programme renvoie une valeur APPROCHÉE d'un modèle continu → comparer à la valeur exacte quand elle est calculable, et commenter le sens de l'écart

Pour une décroissance, Euler sous-estime systématiquement. Le dire vaut le point d'interprétation.
Si le programme ne renvoie rien, ou renvoie `None` → chercher un `print` à la place d'un `return`, ou un `return` mal indenté, sorti de la fonction

Le meilleur contrôle reste l'exécution à la main : un tableau à trois colonnes, une par variable, et deux tours suffisent à voir un compteur décalé ou une initialisation manquante.

La rédaction attendue

Le correcteur coche des étapes. Les voici dans l'ordre, avec la phrase de conclusion qu'il attend mot pour mot.

Écrire une fonction demandée par l'énoncé

Quand l'utiliser : La question type : « écrire une fonction qui renvoie ... ». Elle vaut souvent trois points et se rédige toujours dans le même ordre.

1 Recopier la signature exactement telle que l'énoncé la donne, y compris le nom des paramètres. Les changer coûte un point pour rien.
2 Initialiser TOUTES les variables du corps avant la boucle, en reprenant les données de l'énoncé.
3 Choisir la boucle : `for` si le nombre de tours est connu, `while` sinon, et l'écrire avec sa condition complète.
4 Écrire le corps de la boucle en respectant l'ORDRE : d'abord la mise à jour de la valeur, ensuite celle du compteur.
5 Placer le `return` en dehors de la boucle, au même niveau d'indentation que le `while` ou le `for`.
6 Vérifier à la main sur un cas simple, et écrire cette vérification à côté du programme.

Phrase de conclusion

La fonction `seuil(S)` renvoie le plus petit entier $n$ tel que $u_{n}\ge S$ ; pour $S=290$ elle renvoie $11$ , ce qui est cohérent avec $u_{10}\approx 289{,}3$ et $u_{11}\approx 291{,}4$ .

Le piège : Placer le `return` à l'intérieur de la boucle. La fonction s'arrête alors au premier tour et renvoie toujours $1$ , quel que soit le seuil demandé.

Barème : 0,5 point pour les initialisations, 1 point pour la boucle et sa condition, 1 point pour le corps dans le bon ordre, 0,5 point pour le `return` bien placé.

Interpréter le résultat d'un programme

Quand l'utiliser : La question qui suit toujours l'écriture du programme : « interpréter », « que représente le nombre renvoyé », « commenter ce résultat ».

1 Redire ce que la variable renvoyée représente dans le contexte de l'énoncé, avec son unité.
2 Donner la valeur numérique obtenue, arrondie comme l'énoncé le demande.
3 Encadrer la réponse par les deux valeurs voisines quand il s'agit d'un rang ou d'un encadrement.
4 Dire si la valeur est exacte ou APPROCHÉE, et pourquoi : pas de balayage, pas d'Euler, arrondi machine.
5 Conclure par une phrase en français qui répond à la question posée, pas au calcul effectué.

Phrase de conclusion

Le programme renvoie $11$ : c'est au bout de onze années que la population dépasse $290$ individus pour la première fois, puisque $u_{10}\approx 289{,}3<290$ et $u_{11}\approx 291{,}4\ge 290$ .

Le piège : Recopier la valeur renvoyée sans l'interpréter. Un nombre seul ne répond à aucune question : le point est donné à la phrase, pas au chiffre.

Barème : 0,5 point pour la valeur, 0,5 point pour les deux valeurs encadrantes, 1 point pour la phrase d'interprétation avec l'unité.

Vérifier avant de rendre

Cinq minutes de vérification récupèrent plus de points qu'un exercice de plus commencé à la hâte.

Exécuter le programme à la main sur deux tours

Faire un tableau avec une colonne par variable et une ligne par tour, et le remplir. Deux tours suffisent à révéler un compteur décalé ou une initialisation manquante.

Un tableau où `n` vaut déjà $1$ alors que `u` n'a pas encore changé : le compteur est incrémenté avant la mise à jour, donc le résultat sera décalé d'un rang.
Vérifier le rang renvoyé par ses deux voisins

Calculer la suite au rang renvoyé et au rang précédent. Le premier doit franchir le seuil, le second non. Deux calculs à la calculatrice.

$u_{11}\approx 291{,}4\ge 290$ et $u_{10}\approx 289{,}3<290$ : le rang $11$ est bien le plus petit.
Contrôler qu'un encadrement a l'amplitude du pas

Soustraire les deux bornes renvoyées. L'écart doit valoir exactement le pas passé au programme, sinon le `return` renvoie deux fois la même variable ou une borne fausse.

Un encadrement $\left[2{,}23\ ;\ 2{,}25\right]$ pour un pas de $0{,}01$ : l'amplitude est double, donc `x - pas` a été écrit `x - 2*pas`.
Comparer une valeur approchée à la valeur exacte

Quand le modèle continu est calculable, calculer les deux et commenter l'écart. Pour une décroissance, Euler donne toujours une valeur plus petite.

Euler donne $32{,}8$ à $t=5$ alors que le modèle continu donne $36{,}8$ : l'écart de $4$ vient du pas de calcul, et il diminue si on prend un pas plus petit.
S'assurer que la boucle s'arrête

Vérifier qu'une instruction du corps fait bien évoluer la variable qui apparaît dans la condition, et dans le bon sens.

Une condition `while x*x < 5` avec un corps qui ne modifie que `n` : la boucle ne s'arrête jamais, il manque la ligne `x = x + pas`.

L'exercice type décortiqué

Un encadrement de la racine de 5 par balayage, comme au contrôle

On considère la fonction $f$ définie sur $[0\ ;\ 3]$ par $f(x)=x^{2}-5$ . Elle est continue et strictement croissante sur cet intervalle, avec $f(2)=-1<0$ et $f(3)=4>0$ .

1. Compléter la fonction Python `balayage(pas)` ci-dessous, de façon qu'elle renvoie un encadrement de la solution de $f(x)=0$ d'amplitude égale à `pas`. 2. Donner l'encadrement obtenu pour un pas de $0{,}01$ , et le vérifier.

python

def balayage(pas):
    x = 2
    while x * x < 5:
        x = x + pas
    return x - pas, x

Étape 1

Initialisation : `x = 2`, parce que $f(2)=-1<0$ et que l'énoncé garantit que la solution est au-delà.

Pourquoi

On part d'une valeur dont on SAIT qu'elle ne convient pas encore. Partir de $0$ marcherait aussi mais ferait deux cents tours de plus; partir de $3$ ne marcherait pas du tout, la condition étant déjà fausse.

Étape 2

Condition : `while x * x < 5`, avec une inégalité stricte, jamais `while x * x != 5`.

Pourquoi

Les décimaux étant approchés en machine, `x * x` ne vaudra jamais exactement $5$ : avec un test d'égalité, la boucle tournerait indéfiniment. C'est le piège le plus coûteux de la question.

Étape 3

Corps : `x = x + pas`, l'unique instruction qui fait progresser la condition vers sa fin.

Pourquoi

Sans elle, la valeur testée ne change jamais et le programme ne s'arrête pas. C'est la vérification de terminaison, que le correcteur cherche explicitement.

Étape 4

Sortie : `return x - pas, x`, en dehors de la boucle, au même niveau que le `while`.

Pourquoi

À la sortie, `x` est la première valeur qui convient et `x - pas` la dernière qui ne convenait pas : ce sont exactement les deux bornes de l'encadrement. Renvoyer `x` seul ne répond qu'à la moitié de la question.

Étape 5

Pour un pas de $0{,}01$ , le programme renvoie le couple $\left(2{,}23\ ;\ 2{,}24\right)$ , donc $2{,}23\le\sqrt{5}\le 2{,}24$ .

Pourquoi

L'amplitude de l'encadrement est exactement le pas. Diviser le pas par $10$ donnerait une décimale de plus, au prix de dix fois plus de tours de boucle.

Étape 6

Vérification : $2{,}23^{2}=4{,}9729<5$ et $2{,}24^{2}=5{,}0176>5$ , et l'amplitude $2{,}24-2{,}23$ vaut bien $0{,}01$ . La valeur exacte est $\sqrt{5}\approx 2{,}236$ , bien dans l'encadrement.

Pourquoi

Trois contrôles indépendants en trente secondes : le signe de chaque borne, l'amplitude, et l'appartenance de la valeur exacte. Aucun ne demande de réexécuter le programme.

Conclusion rédigée

Le programme renvoie l'encadrement $2{,}23\le\sqrt{5}\le 2{,}24$ , d'amplitude $0{,}01$ comme demandé, et ce résultat est confirmé par le calcul des carrés des deux bornes.

L'erreur classique sur cet exercice : Écrire `return x` au lieu de `return x - pas, x`. La fonction ne renvoie alors que la borne supérieure, ce qui n'est pas un encadrement : la question demandait deux nombres et la copie n'en donne qu'un.

À savoir par cœur

• Nombre de tours connu : `for k in range(n)`. Nombre de tours inconnu : `while condition`.
• `range(n)` produit les entiers de $0$ à $n-1$ , soit $n$ valeurs. De $u_{0}$ à $u_{10}$ , c'est `range(11)`.
• `return` renvoie, `print` affiche. Une fonction sans `return` renvoie `None`.
• Dans un seuil : on met à jour la VALEUR, puis on incrémente le compteur. Jamais l'inverse.
• Le `return` se place en dehors de la boucle. À l'intérieur, la fonction s'arrête au premier tour.
• Toute variable modifiée dans une boucle doit être initialisée AVANT la boucle.
• Une condition d'arrêt s'écrit avec une inégalité, jamais avec un test d'égalité entre décimaux.
• Un balayage renvoie un ENCADREMENT dont l'amplitude est exactement le pas, jamais une valeur exacte.

Questions fréquentes

Comment choisir entre une boucle for et une boucle while ?

On se demande si le nombre de tours est connu avant de commencer. Si oui, on prend une boucle bornée avec range. Si le nombre de tours dépend d'une condition à surveiller, comme un seuil à franchir ou un signe à changer, on prend une boucle non bornée. La question à partir de quel rang appelle toujours une boucle non bornée.

Quelle est la différence entre return et print en Python ?

Return renvoie une valeur que le reste du programme peut réutiliser, par exemple en la rangeant dans une variable. Print se contente de l'afficher à l'écran et ne renvoie rien. Une fonction dont le corps ne contient qu'un print renvoie la valeur vide, ce qui rend inutilisable toute question suivante qui s'appuie dessus.

Pourquoi ne faut-il jamais tester l'égalité de deux nombres décimaux ?

Parce que les décimaux sont stockés de façon approchée en machine. La somme de zéro virgule un et de zéro virgule deux ne vaut pas exactement zéro virgule trois, l'écart étant de l'ordre de dix puissance moins dix-sept. Un test d'égalité échoue donc presque toujours, et une boucle qui l'utilise comme condition d'arrêt ne s'arrête jamais.

Où faut-il incrémenter le compteur dans une recherche de seuil ?

Juste après la mise à jour de la valeur, à l'intérieur de la boucle. Le compteur doit mesurer le nombre de mises à jour déjà effectuées. Placé avant, il compte un tour qui n'a pas encore eu lieu et le rang renvoyé est décalé d'une unité, ce qui rend la réponse fausse même si le programme fonctionne.

Que renvoie exactement un programme de balayage ?

Un encadrement, c'est-à-dire deux nombres : la dernière valeur testée qui ne convenait pas, et la première qui convient. Leur écart est exactement le pas choisi. Le programme ne donne jamais la valeur exacte de la solution, seulement un intervalle qui la contient, et c'est cela que la question demande.

Pourquoi la méthode d'Euler ne donne-t-elle pas la bonne valeur ?

Parce qu'elle remplace la courbe par une suite de segments : à chaque pas elle suppose la pente constante alors qu'elle varie continûment. L'écart s'accumule d'un pas au suivant et va toujours dans le même sens. Diviser le pas par deux réduit l'écart, sans jamais l'annuler complètement.

Passer à la pratique

Exercices corrigés : Python en spécialité maths

Une méthode se prouve sur une copie, pas sur une fiche. La série du même chapitre reprend chacun de ces pièges dans un exercice, avec le corrigé rédigé étape par étape.

15 exercices corrigés
150 points
225 minutes

Faire les exercices

Fiche précédente Les variables aléatoires

Ce chapitre resservira dans

Les chapitres qui le réclament en amont, plus tard dans l'année ou dans les années suivantes.

Python et méthodes numériquesTerminale

Voir aussi

Toutes les fiches Tous les exercices Mathématiques Tutorat cégep

Vous cherchez un tuteur à Montréal pour ce chapitre ?

Contactez-moi pour une première séance. On reprend les points de méthode qui font perdre des points en évaluation, puis on les met à l'épreuve sur des exercices du niveau réel de l'examen.

Me contacter WhatsApp

Site par Studio Squalli