Exercices corrigés : Python en spécialité maths et en sciences (Première)

a) On applique la relation trois fois : $u_1=0{,}8\times 2+3=4{,}6$, puis $u_2=0{,}8\times 4{,}6+3=3{,}68+3=6{,}68$, puis $u_3=0{,}8\times 6{,}68+3=5{,}344+3=8{,}344$. La boucle `for k in range(3)` effectue exactement trois mises à jour, donc `terme(3)` renvoie $8{,}344$. La variable de boucle `k` ne sert à rien d'autre qu'à compter : c'est normal, la relation de récurrence ne dépend pas de $n$.

b) Elle renvoie $4{,}6$, c'est-à-dire $u_1$. L'instruction `return` ne se contente pas de renvoyer une valeur, elle INTERROMPT immédiatement la fonction : dès la fin du premier tour, tout s'arrête. C'est l'erreur la plus fréquente sur ce type de programme, et elle est silencieuse, puisque $4{,}6$ est une valeur parfaitement plausible. Le `return` d'une fonction de calcul itératif se place toujours APRÈS la boucle, au même niveau d'indentation que le `for`.

c) Il renvoie $2$, c'est-à-dire $u_0$. La boucle `range(0)` est vide, donc aucune mise à jour n'a lieu et la fonction renvoie la valeur d'initialisation. Ce comportement est exactement celui que l'on veut, et il illustre un principe utile : une boucle qui tourne zéro fois n'est pas une erreur, c'est le cas de base traité gratuitement.

d) Si la suite converge vers un réel $L$, alors en passant à la limite dans la relation on obtient $L=0{,}8L+3$, donc $0{,}2L=3$ et $L=15$. On le démontre proprement en posant $v_n=u_n-15$ : alors $v_{n+1}=u_{n+1}-15=0{,}8u_n+3-15=0{,}8(u_n-15)=0{,}8v_n$. La suite $(v_n)$ est donc GÉOMÉTRIQUE de raison $0{,}8$ et de premier terme $v_0=2-15=-13$, d'où $u_n=15-13\times 0{,}8^{\,n}$. Comme $0<0{,}8<1$, le terme $0{,}8^{\,n}$ tend vers $0$ et $u_n$ tend vers $15$ en croissant, sans jamais l'atteindre.

Le fil de la série commence ici : la boucle produit des NOMBRES, le calcul produit une FORMULE. On vérifie la formule sur les nombres, ici $u_3=15-13\times 0{,}512=15-6{,}656=8{,}344$ ✓, et c'est ensuite la formule qui permet de répondre à toutes les questions de limite et de seuil.

def terme(n):
    u = 2
    for k in range(n):
        u = 0.8*u + 3
    return u

a) `u = 2` puis `n = 0` puis `while u <= 14.9:` puis ` u = 0.8*u + 3` puis ` n = n + 1` puis `print(n)`. Les deux instructions du corps sont indissociables : la mise à jour du terme et le comptage du rang doivent avancer ENSEMBLE, sans quoi le rang affiché ne correspond pas au terme calculé.

b) Le programme affiche $22$. En effet $u_{21}=15-13\times 0{,}8^{21}\approx 15-13\times 0{,}009223\approx 14{,}8801$, encore sous le seuil, tandis que $u_{22}=15-13\times 0{,}8^{22}\approx 15-13\times 0{,}007379\approx 14{,}9041$, qui le dépasse. Donner ces deux valeurs est indispensable : un rang de seuil ne se justifie jamais par le seul affichage du programme.

c) On résout $15-13\times 0{,}8^{\,n}>14{,}9$, soit $13\times 0{,}8^{\,n}<0{,}1$, soit $0{,}8^{\,n}<\frac{1}{130}\approx 0{,}00769$. La suite $\left(0{,}8^{\,n}\right)$ est géométrique de raison comprise entre $0$ et $1$, donc strictement DÉCROISSANTE : dès qu'un rang convient, tous les suivants conviennent. La calculatrice donne $0{,}8^{21}\approx 0{,}00922$, encore trop grand, et $0{,}8^{22}\approx 0{,}00738$, qui convient. Le premier entier convenable est donc $n=22$ ✓. C'est la décroissance qui fait de ce rang le SEUIL : sans elle, un rang convenable pourrait être suivi d'un rang qui ne convient plus.

d) Elle se termine parce que $0{,}8^{\,n}$ tend vers $0$, donc $u_n$ tend vers $15$ : la suite finit par franchir n'importe quel seuil strictement inférieur à $15$. Avec un seuil égal à $15$, la boucle ne s'arrêterait JAMAIS, car $u_n=15-13\times 0{,}8^{\,n}$ reste strictement inférieur à $15$ pour tout $n$. Une suite convergente ne dépasse pas sa limite : c'est le piège classique de la boucle `while` en analyse, et il ne se voit pas à la lecture du programme, seulement en connaissant la limite.

Le fil : le programme donne le rang, la forme explicite et la décroissance le démontrent, et les deux doivent coïncider. Quand ils diffèrent d'une unité, l'erreur est presque toujours un `<` écrit à la place d'un `<=` dans la condition d'arrêt.

u = 2
n = 0
while u <= 14.9:
    u = 0.8*u + 3
    n = n + 1
print(n)

a) La boucle ajoute dix termes, de $k=1$ à $k=10$, puisque `range(1, 11)` s'arrête à $10$ inclus. La fonction renvoie environ $2641{,}36$ dollars. La ligne `s = s + 200*1.05**k` est le motif de l'ACCUMULATEUR : une variable qui part de zéro et à laquelle on ajoute un terme par tour, la division ou la conclusion venant après la boucle.

b) C'est la somme des termes d'une suite géométrique de premier terme $210$ et de raison $1{,}05$, comptant $n$ termes : $S_n=210\times\frac{1{,}05^{\,n}-1}{1{,}05-1}=4200\left(1{,}05^{\,n}-1\right)$. Pour $n=10$ : $1{,}05^{10}\approx 1{,}62889$, donc $S_{10}\approx 4200\times 0{,}62889\approx 2641{,}36$ dollars, ce qui coïncide avec l'affichage ✓. Comparaison instructive : si les versements avaient lieu en FIN d'année, la somme partirait de $k=0$ et vaudrait $200\times\frac{1{,}05^{10}-1}{0{,}05}\approx 2515{,}58$ dollars, soit $125{,}78$ dollars de moins. Un décalage d'un seul indice se paie donc en argent réel, et c'est exactement ce que la comparaison programme contre formule permet de détecter.

c) Il ajoute $200$ dollars qui ne correspondent à aucun versement rémunéré : son résultat est trop grand de exactement $200$ dollars, soit $2841{,}36$ au lieu de $2641{,}36$. L'initialisation d'un accumulateur de somme est toujours $0$, comme celle d'un accumulateur de produit est toujours $1$ : c'est l'élément neutre de l'opération que l'on répète.

d) `s = 0` puis `n = 0` puis `while s <= 5000:` puis ` n = n + 1` puis ` s = s + 200*1.05**n` puis `print(n)`. Le programme affiche $17$. Par le calcul : $4200(1{,}05^{\,n}-1)>5000$ équivaut à $1{,}05^{\,n}>1+\frac{5000}{4200}\approx 2{,}1905$, et la suite $\left(1{,}05^{\,n}\right)$ est croissante : $1{,}05^{16}\approx 2{,}1829$ ne suffit pas, $1{,}05^{17}\approx 2{,}2920$ convient, d'où $n=17$ ✓. On vérifie : $S_{16}\approx 4968{,}07$ dollars et $S_{17}\approx 5426{,}48$ dollars.

Le fil : dès qu'une somme apparaît, deux écritures coexistent, la boucle et la formule. La formule est indispensable pour les seuils, la boucle sert de contrôle, et le seul vrai danger est l'indice de départ.

s = 0
n = 0
while s <= 5000:
    n = n + 1
    s = s + 200*1.05**n
print(n)

a) On a $f(1)=1-2=-1$. Pour $h=0{,}1$ : $f(1{,}1)=1{,}331-2{,}2=-0{,}869$, donc $T=\frac{-0{,}869+1}{0{,}1}=1{,}310$. Pour $h=0{,}01$ : $f(1{,}01)=1{,}030301-2{,}02=-0{,}989699$, donc $T=1{,}030$. Pour $h=0{,}001$ : $T=1{,}003$. Les valeurs se rapprochent visiblement de $1$.

b) On développe : $f(1+h)=(1+h)^3-2(1+h)=1+3h+3h^2+h^3-2-2h=-1+h+3h^2+h^3$. En retranchant $f(1)=-1$ il reste $h+3h^2+h^3$, et en divisant par $h$, qui est non nul, on obtient $T(h)=1+3h+h^2$. La limite quand $h$ tend vers $0$ vaut donc $1$. Cette écriture explique les chiffres observés : pour $h=0{,}1$ on lit $1+0{,}3+0{,}01=1{,}31$ ✓, et l'erreur est de l'ordre de $3h$, ce qui se voit à l'oeil sur la colonne des résultats.

c) $f'(x)=3x^2-2$, donc $f'(1)=3-2=1$, ce qui confirme la limite. La tangente en $1$ a pour équation $y=f'(1)(x-1)+f(1)$, soit $y=(x-1)-1$, c'est-à-dire $y=x-2$. Le taux d'accroissement est le coefficient directeur de la SÉCANTE passant par les points d'abscisses $1$ et $1+h$ ; quand $h$ diminue, cette sécante bascule vers la tangente, et le nombre dérivé est la position limite de sa pente.

d) Parce qu'en machine $1+10^{-17}$ est arrondi à $1$ exactement : les nombres flottants ne retiennent qu'une quinzaine de chiffres significatifs, et un $1$ suivi de dix-sept zéros puis d'un $1$ ne tient pas. Le numérateur $f(1+h)-f(1)$ devient donc $0$, et le quotient vaut $0$ au lieu de $1$. Il y a deux erreurs qui se combattent : si $h$ est trop GRAND, l'approximation mathématique est mauvaise, de l'ordre de $3h$ ; si $h$ est trop PETIT, la soustraction de deux nombres presque égaux détruit les chiffres significatifs. Le compromis se situe vers $h=10^{-6}$ à $10^{-8}$. C'est un fait important : contrairement à l'intuition, diminuer indéfiniment le pas ne rend pas le résultat plus juste.

Le fil : la limite mathématique et le calcul en machine ne coïncident que dans une fenêtre. Le programme montre la convergence, la factorisation la démontre, et la représentation des flottants explique pourquoi la table s'arrête de progresser.

a) `def nb_racines(a, b, c):` puis ` d = b*b - 4*a*c` puis ` if d > 0:` puis ` return 2` puis ` elif d == 0:` puis ` return 1` puis ` else:` puis ` return 0`. L'ordre des tests importe : écrire `if d >= 0: return 2` fusionnerait à tort le cas de la racine double avec celui des deux racines distinctes.

b) Pour $x^2-4x+4$ : $\Delta=16-16=0$, la fonction renvoie $1$. L'équation admet la racine double $x=\frac{4}{2}=2$, ce que confirme la factorisation $(x-2)^2$. Pour $2x^2+x+3$ : $\Delta=1-24=-23<0$, la fonction renvoie $0$ et la parabole ne coupe pas l'axe des abscisses. Pour $x^2-5x+6$ : $\Delta=25-24=1>0$, la fonction renvoie $2$, et les racines sont $\frac{5-1}{2}=2$ et $\frac{5+1}{2}=3$.

c) Elle calcule $\Delta=3^2-0=9>0$ et renvoie $2$. C'est faux : avec $a=0$ l'équation n'est pas du second degré, elle s'écrit $3x-6=0$ et n'a qu'UNE solution, $x=2$. La formule du discriminant n'a de sens que pour $a\ne 0$, hypothèse que le programme ne vérifie pas. On corrige en plaçant un test en tête : ` if a == 0:` puis ` if b == 0:` puis ` return 0` puis ` return 1`. Ce cas $a=0$ est régulièrement introduit en contrôle par un paramètre, par exemple $(m-1)x^2+3x-6=0$ avec $m=1$, et l'oublier coûte tous les points de la question.

d) `def racines(a, b, c):` puis ` d = b*b - 4*a*c` puis ` if d > 0:` puis ` print((-b - sqrt(d))/(2*a), (-b + sqrt(d))/(2*a))` puis ` elif d == 0:` puis ` print(-b/(2*a))`, la fonction `sqrt` étant importée du module `math`. On n'écrit jamais `sqrt(d)` avant de savoir que $d\ge 0$ : la racine carrée d'un nombre négatif provoque une erreur qui interrompt le programme. Le test doit donc précéder le calcul, et non l'inverse.

Le fil : un programme de second degré est un arbre de cas, et chaque branche correspond à une phrase du cours. Les deux cas que l'on oublie sont toujours les mêmes, la racine double et le coefficient $a$ nul.

def nb_racines(a, b, c):
    if a == 0:
        if b == 0:
            return 0
        return 1
    d = b*b - 4*a*c
    if d > 0:
        return 2
    elif d == 0:
        return 1
    else:
        return 0

a) `E = 0` puis `for i in range(len(x)):` puis ` E = E + x[i]*p[i]` puis `print(E)`. On obtient $E(X)=0\times 0{,}1+1\times 0{,}3+2\times 0{,}4+3\times 0{,}2=0+0{,}3+0{,}8+0{,}6=1{,}7$. La boucle parcourt les INDICES et non les valeurs, parce qu'il faut avancer simultanément dans les deux listes : c'est la structure à connaître dès que deux tableaux se correspondent terme à terme.

b) `E2 = 0` puis `for i in range(len(x)):` puis ` E2 = E2 + x[i]*x[i]*p[i]`, puis `V = E2 - E*E` et `print(V, sqrt(V))`. On a $E(X^2)=0\times 0{,}1+1\times 0{,}3+4\times 0{,}4+9\times 0{,}2=0{,}3+1{,}6+1{,}8=3{,}7$, donc $V(X)=3{,}7-1{,}7^2=3{,}7-2{,}89=0{,}81$ et $\sigma=\sqrt{0{,}81}=0{,}9$. Attention à la place des carrés : dans $E(X^2)$ on élève les VALEURS au carré avant de multiplier par les probabilités, alors que dans $E(X)^2$ on élève au carré le résultat final. Les deux ne sont jamais égaux dès que $X$ n'est pas constante, et leur différence est précisément la variance.

c) `def loi_valide(p):` puis ` s = 0` puis ` for q in p:` puis ` if q < 0:` puis ` return False` puis ` s = s + q` puis ` return abs(s - 1) < 1e-9`. On n'écrit pas `s == 1` parce que la somme $0{,}1+0{,}3+0{,}4+0{,}2$ ne vaut pas exactement $1$ en machine : ces décimaux n'ont pas d'écriture finie en base deux, et la somme obtenue diffère de $1$ d'environ $10^{-16}$. Le test d'égalité renverrait `False` pour une loi pourtant parfaitement valide. On teste donc un ÉCART, jamais une égalité, et l'on n'oublie pas la seconde condition d'une loi de probabilité : toutes les valeurs doivent être positives.

d) Oui, c'est compatible. La loi des grands nombres dit que la moyenne observée sur un grand nombre de répétitions se rapproche de l'espérance : $1{,}72$ est très proche de $1{,}7$, l'écart de $0{,}02$ est de l'ordre de $\frac{\sigma}{\sqrt{n}}=\frac{0{,}9}{100}=0{,}009$ à quelques unités près, ce qui est banal. En revanche $E(X)=1{,}7$ n'est PAS une valeur prise par $X$, qui ne prend que des entiers : l'espérance est la moyenne pondérée théorique, pas un résultat possible de l'expérience. C'est la même chose que le nombre moyen d'enfants par famille.

Le fil : deux listes qui se correspondent se parcourent par les indices, et toute vérification numérique se fait avec une inégalité. Ces deux réflexes valent pour les probabilités comme pour les mesures de sciences.

E = 0
E2 = 0
for i in range(len(x)):
    E = E + x[i]*p[i]
    E2 = E2 + x[i]*x[i]*p[i]
V = E2 - E*E
print(E, V, sqrt(V))

a) On part de $k=100$, ce qui correspond à $x=1$, on avance tant que $f$ reste négative, et l'on affiche l'encadrement final : `k = 100`, puis `while f(k/100) < 0:`, puis `print((k-1)/100, k/100)`. Le balayage se fait sur un ENTIER $k$ et non directement sur $x$, pour la raison vue en Seconde : additionner $0{,}01$ des centaines de fois accumule les erreurs d'arrondi, alors qu'une division unique n'en accumule aucune.

b) La boucle s'arrête à $k=122$, donc $1{,}21<\alpha<1{,}22$. Les deux valeurs qui le justifient sont $f(1{,}21)=1{,}771561+1{,}21-3=-0{,}018439$, encore négative, et $f(1{,}22)=1{,}815848+1{,}22-3=0{,}035848$, devenue positive. La fonction change donc de signe entre ces deux abscisses. Une valeur plus fine, $f(1{,}213)\approx -0{,}00223$, montre que $\alpha\approx 1{,}2134$.

c) La fonction $f$ est dérivable sur $\mathbb{R}$ avec $f'(x)=3x^2+1$. Comme $3x^2\ge 0$, on a $f'(x)\ge 1>0$ pour tout réel $x$ : $f$ est STRICTEMENT CROISSANTE sur $\mathbb{R}$. Elle prend donc au plus une fois chaque valeur, en particulier la valeur $0$, ce qui donne l'unicité. L'existence vient du changement de signe entre $f(1)=-1$ et $f(2)=7$. Le programme, lui, ne démontre rien de tout cela : il trouve UNE solution, et rien dans son affichage ne dit qu'il n'y en a pas d'autres ailleurs.

d) Elle part de $k=100$ et s'arrête à $k=122$, donc elle effectue $22$ tours. Pour un encadrement au millième, on balaierait avec $k/1000$ à partir de $k=1000$ jusqu'à $k=1214$, soit $214$ tours : diviser le pas par dix multiplie par dix le nombre de tours pour une décimale de plus. C'est le défaut du balayage, et c'est pourquoi on lui préfère la dichotomie quand la précision demandée est grande : celle-ci divise l'intervalle par deux à chaque tour et gagne une décimale toutes les trois ou quatre étapes.

Le fil : le programme FOURNIT un encadrement, le calcul de la dérivée DÉMONTRE qu'il n'y a rien d'autre à chercher. Une question de contrôle qui demande de justifier l'unicité attend le tableau de variations, jamais la sortie du programme.

def f(x):
    return x**3 + x - 3

k = 100
while f(k/100) < 0:
    k = k + 1
print((k-1)/100, k/100)

a) FAUX. Pour $h=0$, le quotient n'existe pas : son dénominateur est nul. Le nombre dérivé est une LIMITE, c'est-à-dire la valeur dont le taux se rapproche autant qu'on veut quand $h$ tend vers $0$, sans jamais y être évalué. Version correcte : « $f'(a)$ est la limite du taux d'accroissement quand $h$ tend vers $0$ ». La différence est visible sur l'exercice 4 : le taux vaut $1+3h+h^2$, expression qui a bien une valeur en $0$, mais seulement APRÈS simplification par $h$, opération licite uniquement pour $h\ne 0$.

b) FAUX. Si $\Delta=0$, l'équation admet UNE racine, dite double, $x_0=-\frac{b}{2a}$ : la parabole est tangente à l'axe des abscisses et ne le coupe qu'en un point. Version correcte : « on teste $\Delta>0$ pour deux racines, puis $\Delta=0$ pour une racine double, puis $\Delta<0$ pour aucune ». Dire qu'une racine double « compte pour deux » a un sens en factorisation, $ax^2+bx+c=a(x-x_0)^2$, mais pas quand on dénombre les solutions.

c) FAUX. Une suite convergente peut approcher sa limite sans jamais l'atteindre ni la dépasser. Avec $u_n=15-13\times 0{,}8^{\,n}$ de l'exercice 2, la boucle `while u < 15` ne s'arrête JAMAIS. Version correcte : « la boucle s'arrête pour tout seuil strictement inférieur à la limite, si la suite est croissante ». C'est la vérification à faire avant d'écrire tout programme de seuil : le seuil demandé est-il réellement franchi ?

d) FAUX, cela confond espérance et mode. L'espérance est la moyenne PONDÉRÉE des valeurs, $E(X)=\sum x_i p_i$, et elle n'est en général même pas une valeur prise par $X$ : à l'exercice 6, $E(X)=1{,}7$ alors que $X$ ne prend que les entiers $0$ à $3$. La valeur la plus probable, ici $2$ avec $p=0{,}4$, s'appelle le mode. Version correcte : « l'espérance est la moyenne des valeurs pondérée par leurs probabilités ».

e) FAUX. Deux erreurs s'opposent : l'erreur de méthode, proportionnelle au pas, et l'erreur d'arrondi, qui augmente quand le pas diminue, car on soustrait des nombres de plus en plus proches. En dessous d'un certain pas, le résultat se dégrade au lieu de s'améliorer, jusqu'au cas extrême de l'exercice 4 où $1+10^{-17}$ vaut $1$. Version correcte : « il existe un pas optimal, au-delà duquel la précision machine limite le gain ».

Ces cinq erreurs se ressemblent : chacune consiste à transporter en machine une propriété mathématique exacte, ou l'inverse. L'ordinateur travaille avec des nombres approchés et un nombre fini d'étapes, ce que le cours d'analyse ne fait jamais.

a) $\mathrm{e}^{-8\times 0{,}086\,643}=\mathrm{e}^{-0{,}693\,144}\approx 0{,}5000$ : c'est bien la demi-vie de $8$ jours. Le programme s'écrit `lam = 0.086643` puis `N = 1` puis `for k in range(8):` puis ` N = N*(1 - lam*1)` puis `print(N)`. On travaille en fraction, c'est-à-dire avec $N_0=1$, ce qui évite d'avoir à choisir un nombre de noyaux et rend le résultat directement comparable à $\frac{1}{2}$.

b) Le programme affiche environ $0{,}4843$. La valeur exacte est $\frac{1}{2}$ par définition de la demi-vie, ce que confirme le modèle : $N(8)=N_{0}\,\mathrm{e}^{-8\lambda}=\frac{N_{0}}{2}$. L'écart relatif vaut $\frac{0{,}5-0{,}4843}{0{,}5}\approx 3{,}1\%$, ce qui est considérable pour une grandeur physique : la méthode d'Euler avec un pas d'un jour n'est pas utilisable ici, parce que le pas n'est pas petit devant la demi-vie.

c) On écrit `for k in range(80):` puis ` N = N*(1 - lam*0.1)`, et l'on obtient environ $0{,}4985$, soit un écart relatif de $0{,}3\%$. Diviser le pas par dix a divisé l'erreur par dix, ce qui est la signature de la méthode d'Euler : son erreur est proportionnelle au pas. Pour gagner un facteur cent sur la précision, il faut donc cent fois plus de tours de boucle, et c'est ce compromis qui décide en pratique du pas choisi.

d) Sur un pas, la méthode donne $N_k(1-\lambda\Delta t)$ alors que la solution exacte donne $N_ke^{-\lambda\Delta t}$. Or pour tout réel $x>0$ on a $1-x<e^{-x}$ : il suffit d'étudier $g(x)=e^{-x}-1+x$, dont la dérivée $g'(x)=1-e^{-x}$ est strictement positive pour $x>0$, avec $g(0)=0$, donc $g(x)>0$. En posant $x=\lambda\Delta t$, chaque pas d'Euler retire donc un peu TROP de noyaux, et ces sous-estimations se multiplient d'un pas à l'autre. La raison physique est claire : Euler applique pendant tout l'intervalle la vitesse de désintégration du DÉBUT du pas, alors que la vitesse réelle diminue à mesure que les noyaux disparaissent.

Le fil : la méthode d'Euler transforme la relation $N'=-\lambda N$ en suite géométrique de raison $1-\lambda\Delta t$, objet parfaitement connu du programme de Première. L'exponentielle est la limite de ces suites quand le pas tend vers zéro, et l'inégalité $1-x<e^{-x}$ dit dans quel sens on se trompe.

lam = 0.086643
N = 1
for k in range(80):
    N = N*(1 - lam*0.1)
print(N)

a) `def y(x):` puis ` return -0.05*x*x + 0.8*x + 1.8`, puis `M = 0` puis `for k in range(0, 41):` puis ` if y(k/2) > M:` puis ` M = y(k/2)` puis `print(M)`. Le programme affiche $5$, atteint pour $x=8$ m. Comme d'habitude, on boucle sur l'entier $k$ et l'on pose $x=\frac{k}{2}$ ; `range(0, 41)` donne bien les $41$ abscisses de $0$ à $20$ m.

b) La dérivée vaut $y'(x)=-0{,}1x+0{,}8$, qui s'annule en $x=\frac{0{,}8}{0{,}1}=8$ m. Elle est positive avant et négative après, donc $y$ atteint son MAXIMUM en $8$ : $y(8)=-0{,}05\times 64+0{,}8\times 8+1{,}8=-3{,}2+6{,}4+1{,}8=5$ m. Le balayage donnait la même valeur, mais par chance : le sommet tombait exactement sur une abscisse balayée. Avec un pas de $0{,}7$ m, il aurait donné une valeur légèrement inférieure, et c'est pourquoi une hauteur maximale se justifie toujours par la dérivée ou par la forme canonique.

c) On résout $-0{,}05x^2+0{,}8x+1{,}8=0$. En multipliant par $-20$ : $x^2-16x-36=0$, donc $\Delta=256+144=400$ et $\sqrt{\Delta}=20$. Les racines sont $\frac{16-20}{2}=-2$ et $\frac{16+20}{2}=18$. Seule la racine positive a un sens physique : la portée est de $18$ m. La racine $-2$ correspond au point d'où serait parti le ballon s'il avait décollé du sol avec la même parabole, information sans objet ici.

d) `if y(14) > 4:` puis ` print("passe")` puis `else:` puis ` print("touche le mur")`. On calcule $y(14)=-0{,}05\times 196+0{,}8\times 14+1{,}8=-9{,}8+11{,}2+1{,}8=3{,}2$ m, ce qui est INFÉRIEUR à $4$ m : le ballon ne passe pas. On peut préciser où il aurait fallu placer le mur : résoudre $y(x)=4$ donne $-0{,}05x^2+0{,}8x-2{,}2=0$, soit $x^2-16x+44=0$, de discriminant $256-176=80$ et de racines $\frac{16\pm 4\sqrt5}{2}=8\pm 2\sqrt5$, c'est-à-dire environ $3{,}53$ m et $12{,}47$ m. Le ballon est donc au-dessus de $4$ m entre ces deux abscisses seulement, et le mur à $14$ m est trop loin de $1{,}5$ m environ.

Le fil de la série se referme ici : le balayage EXPLORE, la dérivée LOCALISE, le discriminant DÉCIDE. Un programme seul aurait répondu à d) mais n'aurait donné ni la hauteur exacte, ni la portée, ni l'intervalle de franchissement, qui sont les trois résultats attendus dans un exercice de contrôle.

def y(x):
    return -0.05*x*x + 0.8*x + 1.8

M = 0
for k in range(0, 41):
    if y(k/2) > M:
        M = y(k/2)
print(M)

if y(14) > 4:
    print("passe")
else:
    print("touche le mur")

a) La liste en compréhension calcule $u_{n}$ pour $n$ allant de $0$ à $9$, soit dix termes : L = [15, 9, 5, 3, 3, 5, 9, 15, 23, 33]. On contrôle deux termes : $u_{0}=15$ et $u_{9}=81-63+15=33$ ✓.

b) min(L) renvoie $3$, atteint aux rangs $3$ et $4$ (les indices $3$ et $4$ de la liste, qui commence à l'indice $0$). C'est cohérent avec la fonction $x\mapsto x^{2}-7x+15$, dont le sommet est en $x=3{,}5$, au milieu de $3$ et $4$, qui sont donc à égale distance du sommet.

c) On ajoute un compteur : c = 0, puis for u in L:, puis if u < 10:, puis c = c + 1, et enfin print(c). Les termes inférieurs à $10$ sont $9$, $5$, $3$, $3$, $5$ et $9$ : le programme affiche $6$. Parcourir directement les VALEURS de la liste suffit ici, puisqu'on n'a pas besoin des rangs.

d) D = [-6, -4, -2, 0, 2, 4, 6, 8, 10]. En effet $u_{n+1}-u_{n}=(n+1)^{2}-7(n+1)+15-(n^{2}-7n+15)=2n+1-7=2n-6$. Les écarts forment une suite ARITHMÉTIQUE de raison $2$ : c'est la signature d'une suite du second degré. Le signe de $2n-6$ explique aussi b) : la suite décroît tant que $n<3$, stagne de $u_{3}$ à $u_{4}$, puis croît.

e) sum(L) renvoie $15+9+5+3+3+5+9+15+23+33=120$.

Une liste en compréhension est la traduction directe de « la liste des $u_{n}$ pour $n$ de $0$ à $9$ ». Les fonctions min, sum et les listes d'écarts transforment ensuite des questions de cours, minimum, sens de variation, somme, en une ligne de programme ; mais seul le calcul de $u_{n+1}-u_{n}$ justifie ce que la liste montre.

L = [n*n - 7*n + 15 for n in range(10)]
c = 0
for u in L:
    if u < 10:
        c = c + 1
print(c)
D = [L[i+1] - L[i] for i in range(9)]
print(D, sum(L))

a) L'hexagone régulier inscrit se découpe en six triangles équilatéraux de côté égal au rayon : $c_{6}=1$. Son demi-périmètre vaut $\frac{6\times 1}{2}=3$, première approximation de $\pi$, déjà connue des Babyloniens.

b) $c_{12}=\sqrt{2-\sqrt{3}}\approx\sqrt{0{,}267\,949}\approx 0{,}517\,638$. Demi-périmètre : $\frac{12\times 0{,}517\,638}{2}\approx 3{,}106$.

c) On initialise c = 1 et n = 6, puis, dans une boucle for exécutée k fois, on remplace c par sqrt(2 - sqrt(4 - c*c)) et n par 2*n ; on affiche enfin n*c/2. Avec $48$ côtés, on obtient environ $3{,}139\,35$, soit $3{,}139$ ; avec $96$ côtés, environ $3{,}141\,03$, soit $3{,}141$. C'est l'encadrement du polygone à $96$ côtés qu'avait atteint Archimède.

d) Quand $c$ devient très petit, $\sqrt{4-c^{2}}$ est extrêmement proche de $2$, et la différence $2-\sqrt{4-c^{2}}$ soustrait deux nombres presque égaux. Les flottants ne gardant qu'une quinzaine de chiffres significatifs, cette différence perd presque tous ses chiffres justes, puis vaut exactement $0$ quand $c^{2}$ devient négligeable devant $4$. C'est le même phénomène que pour le taux d'accroissement de l'exercice 4 avec un pas trop petit.

e) On multiplie par la quantité conjuguée : $\left(2-\sqrt{4-c^{2}}\right)\left(2+\sqrt{4-c^{2}}\right)=4-(4-c^{2})=c^{2}$, d'où l'égalité. Donc $c_{2n}=\sqrt{\frac{c_{n}^{2}}{2+\sqrt{4-c_{n}^{2}}}}=\frac{c_{n}}{\sqrt{2+\sqrt{4-c_{n}^{2}}}}$. Cette formule n'ADDITIONNE que des nombres positifs : plus aucune soustraction de nombres voisins, et le programme converge vers $3{,}141\,592\,653\,589\,79$ sans jamais se dégrader.

Deux formules mathématiquement égales peuvent se comporter très différemment en machine. La quantité conjuguée, outil de calcul de limites au lycée, est aussi l'outil qui réécrit une soustraction instable en une division stable : c'est un réflexe de programmeur autant que de mathématicien.

from math import sqrt

def archimede(k):
    c = 1
    n = 6
    for i in range(k):
        c = c/sqrt(2 + sqrt(4 - c*c))
        n = 2*n
    return n*c/2

print(archimede(3), archimede(4))