Corrigé des 31 exercices sur les algorithmes et programmes en seconde à télécharger en PDF

Donc, a) La valeur saisie est convertie par int( ) : \(x\) est une variable de type entier (int).

b) Le programme calcule successivement \(4x\), puis \(4x+1\), puis le carré.

c) En suivant les affectations : \(f(x)=(4x+1)^2\) (que l’on peut développer en \(16x^2+8x+1\)).

Enfin, Fonctionnement. L’algorithme demande une chaîne de caractères \(C\) non vide. De plus, il range dans \(\ell\) le nombre de caractères de \(C\) : \(\ell\) est donc la position du dernier caractère. Ensuite, il extrait ensuite de \(C\) la sous-chaîne qui commence au caractère numéro \(\ell\) et qui contient 1 caractère, et l’affiche.

De même, exemple. Avec \(C=\) « algorithme » : \(\ell=10\) et Sch(« algorithme », 10, 1) = « e ».

Ainsi, rôle. L’algorithme affiche le dernier caractère de la chaîne saisie. Par ailleurs, en Python, on écrirait simplement C[len(C)-1] ou C[-1] (attention, en Python la numérotation commence à 0).

Ensuite, a) Jusqu’à 50 photocopies, chacune coûte 0,15 € : \(\text{Prix}=0{,}15\times N\). En outre, Au-delà, les 50 premières coûtent \(50\times0{,}15=7{,}50\) € et chacune des \(N-50\) suivantes coûte 0,10 €.

Puis, ligne ① : Prix=0.15*N
Ligne ② : Prix=0.15*50+0.10*(N-50) (soit Prix=7.5+0.1*(N-50))

b) Le programme complet :

Par ailleurs, print(« Entrer N : »)
N=int(input())
if N<=50:
    Prix=0.15*N
else:
    Prix=0.15*50+0.10*(N-50)
print(« Prix= »,Prix)

Toutefois, c) Contrôles : pour \(N=30\), \(30\times0{,}15=4{,}50\) € ; pour \(N=50\), \(7{,}50\) € ; pour \(N=80\), \(7{,}50+30\times0{,}10=10{,}50\) €. Remarque : si l’on comprend que toutes les copies passent à 0,10 € au-delà de 50, la ligne ② devient Prix=0.10*N ; mais alors 51 copies (5,10 €) coûteraient moins cher que 50 (7,50 €), ce qui est peu vraisemblable.

a) Durée = distance ÷ vitesse.

\[ t_1=\frac{5}{15}=\frac{1}{3}\text{ h}=20\text{ min} \qquad t_2=\frac{7-5}{12}=\frac{1}{6}\text{ h}=10\text{ min} \]

Louise met 30 minutes au total.

Puis, b) À 15 km/h, on parcourt \(\frac{15}{60}=0{,}25\) km par minute ; à 12 km/h, \(\frac{12}{60}=0{,}2\) km par minute. Donc :

• si \(0\leqslant t\leqslant20\) : \(d(t)=0{,}25\,t\) ;
• si \(20\lt t\leqslant30\) : \(d(t)=5+0{,}2\,(t-20)\) ;
• Par ailleurs, si \(t\gt30\) : la course est finie, \(d(t)=7\).

Toutefois, t=float(input(« t en minutes : « ))
if t<=20:
    d=0.25*t
elif t<=30:
    d=5+0.2*(t-20)
else:
    d=7
print(« d(t) = »,d, »km »)

Par exemple, pour \(t=25\) min, le programme affiche \(5+0{,}2\times5=6\) km.

Notamment, a) On suit l’évolution de \(S\) pour \(n=5\) :

Donc, le résultat affiché est 55.

Car b) À chaque tour, on ajoute \(i^2\) à \(S\). Puis l’algorithme calcule donc la somme des carrés des entiers de 1 à \(n\) : \(S=1^2+2^2+\dots+n^2\).

Par ailleurs, on traduit les trois cas par une instruction conditionnelle à trois branches :

Donc, def f(x):
    if x<=0:
        return x**2
    elif x<=1:
        return x
    else:
        return -2*x+3

Le elif n’est examiné que si \(x\gt0\) : la condition x<=1 correspond donc bien au cas \(0\lt x\leqslant1\). Tests : \(f(-2)=4\), \(f(0{,}5)=0{,}5\), \(f(3)=-3\).

a) Rôle des variables :

• Car n est un compteur : il vaut 0 au départ et augmente de 1 à chaque « Pile » ; à la fin, il contient le nombre de Pile obtenus ;
• Par exemple, i est la variable de la boucle : elle prend les valeurs 1, 2, …, 100 et compte les lancers ;
• Donc, x est un nombre aléatoire de \([0\,;1[\) tiré à chaque lancer ; x<0.5 arrive avec une probabilité \(\frac{1}{2}\) et représente « Pile ».

En effet, b) Il suffit d’englober la simulation dans une seconde boucle qui se répète M fois (et de remettre n à 0 à chaque simulation) :

Car from random import random
M=int(input(« M = « ))
for k in range(1,M+1):
    n=0
    for i in range(1,101):
        x=random()
        if x<0.5:
            n=n+1
    print(« simulation »,k, »: n= »,n)

a) Pour chaque entier \(k\) de 1 à \(N\), on ajoute 1 à \(x\) lorsque \(k\) divise \(N\). Ensuite, la fonction renvoie donc le nombre de diviseurs de \(N\). Par exemple, diviseurs(12) = 6 (1, 2, 3, 4, 6, 12).

Enfin, b) On réutilise cette fonction dans une boucle de 1 à 100 (en Python, « \(k\) divise \(N\) » s’écrit N%k==0) :

Par ailleurs, def diviseurs(N):
    x=0
    for k in range(1,N+1):
        if N%k==0:
            x=x+1
    return x
for n in range(1,101):
    if diviseurs(n)>=10:
        print(n)

Le programme affiche 48, 60, 72, 80, 84, 90 et 96 (par exemple 60 a 12 diviseurs : 1, 2, 3, 4, 5, 6, 10, 12, 15, 20, 30, 60).

Par ailleurs, a) \(x\) est converti par int( ) : c’est un entier.

b) Le programme calcule \(x^2\), puis \(-x^2+3x\), puis \(-x^2+3x+4\).

• \(x=1\) : \(y=1\), puis \(-1+3=2\), puis \(2+4=\) 6 ;
• \(x=-2\) : \(y=4\), puis \(-4-6=-10\), puis −6 ;
• \(x=12\) : \(y=144\), puis \(-144+36=-108\), puis −104.

Puis, c) Attention à la ligne y=-y+3*x : c’est l’opposé de \(y\) qui est utilisé. Puis on obtient \(f(x)=-x^2+3x+4\).

Cependant, a) Pour \(n=4\), la boucle prend \(j=1,2,3,4\) (range(1,n+1) s’arrête avant \(n+1\)) :

\[ S=0+2+4+6+8=20 \]

Le programme affiche S= 20.

De même, b) Le programme ajoute \(2j\) pour \(j\) allant de 1 à \(n\) : il calcule la somme des \(n\) premiers nombres pairs non nuls, \(S=2+4+\dots+2n\). Toutefois, comme \(1+2+\dots+n=\frac{n(n+1)}{2}\), on a \(S=n(n+1)\) ; pour \(n=4\), \(4\times5=20\).

a) Au départ, \(S\) vaut 0. À chacun des 10 passages dans la boucle, ALGOBOX_ALEA_ENT(1,6) tire au hasard un entier \(x\) entre 1 et 6 (le résultat d’un lancer de dé), puis on ajoute \(x\) à \(S\). En effet, de plus, la variable \(S\) joue le rôle d’un accumulateur : à la fin, elle contient la somme des résultats des 10 lancers.

En outre, le même programme en Python :

Notamment, from random import randint
S=0
for k in range(1,11):
    x=randint(1,6)
    S=S+x
print(S)

Puis, b) Chaque lancer donne au plus 6. Ensuite, la somme est donc au plus \(10\times6=60\), valeur atteinte lorsque les 10 lancers donnent tous 6 (cas rare mais possible). Par ailleurs, la plus grande valeur affichée est 60 (et la plus petite est \(10\times1=10\)).

Ensuite, a) Le prix comprend 50 € fixes plus le prix des kilomètres.

• Si \(x\leqslant100\) : tous les kilomètres sont à 0,25 €, donc \(m=50+0{,}25x\).
• Sinon : les 100 premiers kilomètres coûtent \(100\times0{,}25=25\) €, et les \(x-100\) suivants coûtent 0,35 € chacun, donc \(m=50+25+0{,}35(x-100)=75+0{,}35(x-100)\).

b) Programme en Python :

Enfin, x=int(input(« Nombre de km : « ))
if x<=100:
    m=50+0.25*x
else:
    m=75+0.35*(x-100)
print(« Montant : »,m, »euros »)

c) Tests :

• \(x=80\) : \(m=50+0{,}25\times80=\) 70 € ;
• \(x=100\) : \(m=50+25=\) 75 € ;
• \(x=150\) : \(m=75+0{,}35\times50=\) 92,50 € ;
• \(x=300\) : \(m=75+0{,}35\times200=\) 145 €.

On vérifie que les deux formules donnent bien le même prix à la limite : pour \(x=100\), la seconde donne aussi \(75+0=75\) €.

Par exemple, a) La distance entre deux points d’une droite graduée est la différence entre la plus grande abscisse et la plus petite :

• si \(a\leqslant b\), \(AB=b-a\) ;
• si \(a\gt b\), \(AB=a-b\).

Car dans les deux cas, \(AB=|b-a|\) (valeur absolue de la différence). Alors, exemple : A d’abscisse \(-3\) et B d’abscisse 5 donnent \(AB=|5-(-3)|=8\).

Car b) Algorithme de la fonction :

Fonction distance(a, b)
    Si a ≤ b alors d prend la valeur b − a
    Sinon d prend la valeur a − b
    Renvoyer d

En Python :

Cependant, def distance(a,b):
    if a<=b:
        return b-a
    else:
        return a-b

On peut aussi écrire directement return abs(b-a). Ensuite, tests : distance(−3, 5) renvoie 8 ; distance(7, 2) renvoie 5.

Ainsi, sur la figure, \(a=BC\) est le côté opposé au sommet A, \(b=AC\) et \(c=AB\). Ainsi, Si le triangle est rectangle en A, son hypoténuse est [BC].

D’après le théorème de Pythagore et sa réciproque : ABC est rectangle en A si et seulement si \(BC^2=AB^2+AC^2\), c’est-à-dire \(a^2=b^2+c^2\).

Fonction H(a, b, c)
    Si a² = b² + c² alors renvoyer « Vrai »
    Sinon renvoyer « Faux »

En Python :

En outre, def H(a,b,c):
    if a*a==b*b+c*c:
        return « Vrai »
    else:
        return « Faux »

Tests : H(5, 4, 3) renvoie « Vrai » car \(25=16+9\) ; H(5, 4, 2) renvoie « Faux » car \(25\neq16+4\) ; H(3, 4, 5) renvoie « Faux » : ce triangle est rectangle, mais en C, pas en A.

Remarque : avec des longueurs décimales, l’ordinateur fait des arrondis et le test == peut échouer à tort ; on remplace alors la condition par abs(a*a-b*b-c*c)<0.000001.

De même, a) La base est un disque de rayon R : son aire est \(S=\pi\times R^2\). Puis le volume d’un cylindre est l’aire de la base multipliée par la hauteur : \(V=S\times h\).

Toutefois, b) Programme en Python (la constante \(\pi\) s’obtient avec pi du module math) :

Par ailleurs, from math import pi
R=float(input(« R = « ))
h=float(input(« h = « ))
S=pi*R**2
V=S*h
print(« V = »,V)

c) Contrôles :

• \(R=1\), \(h=1\) : \(V=\pi\approx\) 3,14 cm³ ;
• Toutefois, \(R=2\), \(h=5\) : \(V=\pi\times4\times5=20\pi\approx\) 62,83 cm³ ;
• \(R=3\), \(h=10\) : \(V=90\pi\approx\) 282,74 cm³.

Cependant, on exprime chaque variable en fonction de \(a\) :

\[ \begin{aligned} b &= a^2 \\ c &= a-b=a-a^2 \\ d &= 2c \\ e &= d-c+b=2c-c+b=c+b=(a-a^2)+a^2=a \end{aligned} \]

La fonction nombre renvoie donc toujours \(a\) lui-même. Vérification avec \(a=2\) : \(b=4\), \(c=-2\), \(d=-4\), \(e=-4-(-2)+4=2\).

• Par exemple, nombre(2) \(=2\) : le plus petit ensemble est \(\mathbb{N}\) ;
• Puis, nombre(−4) \(=-4\) : entier négatif, le plus petit ensemble est \(\mathbb{Z}\) ;
• De même, nombre(\(\sqrt2\)) \(=\sqrt2\) : c’est un irrationnel, le plus petit ensemble est \(\mathbb{R}\).

Le script calcule \(b=\frac{a}{2}\), puis \(c=3+\frac{a}{2}\), puis \(d=\sqrt{3+\frac{a}{2}}\).

a. \(b=1{,}5\), \(c=4{,}5\), \(d=\sqrt{4{,}5}\approx2{,}121\). Ensuite, comme \(2^2=4\) et \(3^2=9\), \(\sqrt{4{,}5}\) est strictement entre 2 et 3 : nombre(3) n’est pas un entier.

b. \(b=6\), \(c=9\), \(d=\sqrt9=3\) : nombre(12) est un entier (Python affiche 3.0, car sqrt renvoie un flottant, mais la valeur est bien l’entier 3).

Ensuite, c. \(b=-2\), \(c=1\), \(d=\sqrt1=1\) : nombre(−4) est un entier (affiché 1.0).

d. \(b=-6\), \(c=3-6=-3\). Ensuite, la racine carrée d’un nombre négatif n’existe pas : Python s’arrête sur un message d’erreur (ValueError: math domain error) et n’affiche aucun résultat.

Expression de \(e\) en fonction de \(a\) : \(b=-a\), \(c=b^2=a^2\), \(d=-2c=-2a^2\), donc \(e=-2a^2+|a|\).

• Ainsi, \(a=-2\) : \(b=2\), \(c=4\), \(d=-8\), \(e=-8+|-2|=-8+2=-6\in\mathbb{Z}\) : la fonction affiche « entier ».
• Également, \(a=3\) : \(b=-3\), \(c=9\), \(d=-18\), \(e=-18+3=-15\in\mathbb{Z}\) : la fonction affiche « entier ».
• Notamment, \(a=\sqrt2\) : \(b=-\sqrt2\), \(c=(-\sqrt2)^2=2\), \(d=-4\), \(e=-4+\sqrt2\approx-2{,}586\). Également, comme \(\sqrt2\) est irrationnel, \(-4+\sqrt2\) n’est pas un entier : la fonction affiche « pas entier. »

a. À chaque tour de la boucle while, \(a\) est remplacé par son carré et \(N\) augmente de 1 ; on s’arrête dès que \(a\lt0{,}1\).

Donc compteur(0.9) = 5.

Pour \(a=0{,}1\) : la condition \(0{,}1\geqslant0{,}1\) est vraie, donc on fait un tour : \(a=0{,}01\) et \(N=1\). Ensuite \(0{,}01\lt0{,}1\) : arrêt. Donc compteur(0.1) = 1.

b. Après \(N\) tours, \(a\) a été élevé au carré \(N\) fois : il vaut \(a^{2^N}\) (par exemple \(a^2\), puis \(a^4\), puis \(a^8\)…). Par ailleurs, comme \(0\lt a\lt1\), ces nombres diminuent. Puis le programme renvoie donc le nombre de fois qu’il faut élever \(a\) au carré pour obtenir un nombre strictement inférieur à 0,1, c’est-à-dire le plus petit entier \(N\) tel que \(a^{2^N}\lt0{,}1\).

1. Avec \(n=2\) et \(p=0{,}01\), on part de \(u=2\) et on recalcule \(u\) tant que \(u-\sqrt2\gt0{,}01\) (\(\sqrt2\approx1{,}41421\)).

• Alors, \(u=2\) : \(u-\sqrt2\approx0{,}586\gt0{,}01\), on continue : \(u=\frac12\left(2+\frac22\right)=1{,}5\).
• Enfin, \(u=1{,}5\) : \(u-\sqrt2\approx0{,}086\gt0{,}01\), on continue : \(u=\frac12\left(1{,}5+\frac{2}{1{,}5}\right)=\frac{17}{12}\approx1{,}417\).
• De même, \(u\approx1{,}417\) : \(u-\sqrt2\approx0{,}002\lt0{,}01\) : la boucle s’arrête.

Ainsi, l’algorithme affiche \(u=\frac{17}{12}\approx\) 1,417 (Python affiche 1.4166666666666665), valeur approchée de \(\sqrt2\) à 0,01 près.

Ensuite, 2. val_app(3, 0.0001) : \(\sqrt3\approx1{,}7320508\).

En outre, comme \(0{,}000092\lt0{,}0001\), la boucle s’arrête : l’affichage est 1.7321428571428572 (c’est \(\frac{97}{56}\)).

Également, 3. val_app(7, 0.00001) : \(\sqrt7\approx2{,}6457513\).

À l’avant-dernière étape, \(0{,}0000157\gt0{,}00001\) : il faut encore un tour. De plus, l’affichage est 2.6457513111113693.

Le script calcule \(p\), le nombre formé par les quatre chiffres, puis le reste \(k\) de la division euclidienne de \(p\) par la somme des chiffres \(a+b+c+d\) (en Python, % donne le reste). Si ce reste a un seul chiffre, c’est le résultat ; sinon on garde son chiffre des unités (k%10).

a. Code 2020 : \(p=2020\) et \(a+b+c+d=2+0+2+0=4\). Or \(2020=4\times505+0\), donc \(k=0\lt10\) et \(s=0\). Ensuite, le nombre généré est 0.

b. Code 1789 : \(p=1789\) et \(1+7+8+9=25\). Or \(1789=25\times71+14\), donc \(k=14\). Comme \(14\geqslant10\), \(s=14\,\%\,10=4\). Par ailleurs, le nombre généré est 4.

c. Pour le code 0000, la somme des chiffres vaut \(0\) : il faudrait calculer le reste de la division de \(p\) par 0, ce qui est impossible (Python déclencherait l’erreur ZeroDivisionError). Puis la méthode de M. Galois ne peut donc pas s’appliquer : l’ordinateur ne doit pas proposer 0000.

Remarque : dans le script tel qu’il est écrit, pour 0000 on a \(s=p=0\lt10\), donc la boucle while n’est jamais exécutée et la fonction renvoie 0 sans faire de division. Mais ce 0 ne provient pas du calcul prévu : le code 0000 n’a pas de sens pour cette méthode.

On exécute l’algorithme pas à pas pour chaque argument, en respectant l’ordre des instructions : \( b = a^2 \), puis \( c = a – b \), puis \( d = 2c \), puis \( e = d – c + b \).

Attention au signe dans \( d – c \) : on soustrait \( c \), donc si \( c = -20 \), on ajoute 20.

On range ensuite chaque résultat dans le plus petit ensemble de nombres qui le contient (\( \mathbb{N} \subset \mathbb{Z} \subset \mathbb{D} \subset \mathbb{Q} \subset \mathbb{R} \)) :

• nombre(2) = 2 est un entier positif : \( 2 \in \mathbb{N} \) ;
• nombre(−4) = −4 est un entier négatif : \( -4 \in \mathbb{Z} \) ;
• nombre(\( \sqrt{2} \)) = \( \sqrt{2} \) est irrationnel : \( \sqrt{2} \in \mathbb{R} \).

On remarque que la fonction renvoie à chaque fois le nombre de départ (on le démontre dans l’exercice 28).

La fonction calcule successivement \( b = \frac{a}{2} \), \( c = 3 + b \) et \( d = \sqrt{c} \) (la fonction sqrt vient du module math). Ensuite, on suit les calculs pour chaque argument.

a. nombre(3) : \( b = 1{,}5 \), \( c = 4{,}5 \), \( d = \sqrt{4{,}5} \approx 2{,}121 \). Comme \( 4{,}5 \) n’est pas le carré d’un entier, nombre(3) n’est pas un entier (le script affiche 2.1213203435596424).

b. nombre(12) : \( b = 6 \), \( c = 9 \), \( d = \sqrt{9} = 3 \). nombre(12) = 3, c’est un entier. Python affiche 3.0 car sqrt renvoie toujours un nombre à virgule (type float), mais la valeur est bien l’entier 3.

c. nombre(−4) : \( b = -2 \), \( c = 3 + (-2) = 1 \), \( d = \sqrt{1} = 1 \). nombre(−4) = 1, c’est un entier (affiché 1.0).

d. nombre(−12) : \( b = -6 \), \( c = 3 + (-6) = -3 \). Puis il faudrait calculer \( \sqrt{-3} \), or la racine carrée d’un nombre négatif n’existe pas. Python s’arrête et affiche un message d’erreur :

ValueError: math domain error

On applique les instructions dans l’ordre : \( b = -a \), \( c = b^2 \), \( d = -2c \), \( e = d + |a| \), puis on teste si \( e \) est un entier relatif (\( e \in \mathbb{Z} \)).

Argument −2 :

\[ b = 2, \quad c = 2^2 = 4, \quad d = -2 \times 4 = -8, \quad e = -8 + |-2| = -8 + 2 = -6. \]

\( -6 \in \mathbb{Z} \) : la fonction affiche « entier ».

Argument 3 :

\[ b = -3, \quad c = (-3)^2 = 9, \quad d = -18, \quad e = -18 + 3 = -15. \]

\( -15 \in \mathbb{Z} \) : la fonction affiche « entier ».

Argument \( \sqrt{2} \) :

\[ b = -\sqrt{2}, \quad c = \left(-\sqrt{2}\right)^2 = 2, \quad d = -4, \quad e = -4 + \sqrt{2}. \]

\( \sqrt{2} \) est irrationnel, donc \( -4 + \sqrt{2} \approx -2{,}586 \) n’est pas un entier : la fonction affiche « pas entier. »

À chaque tour de la boucle while, tant que \( a \geqslant 0{,}1 \), on remplace \( a \) par son carré et on ajoute 1 au compteur N.

a. compteur(0.9) : on suit les valeurs.

Donc compteur(0.9) = 5.

compteur(0.1) : au départ \( a = 0{,}1 \) et la condition \( a \geqslant 0{,}1 \) est vraie (égalité). De plus, on fait un tour : \( a = 0{,}01 \) et N = 1. Ensuite \( 0{,}01 \lt 0{,}1 \), la boucle s’arrête : compteur(0.1) = 1.

b. Comme \( 0 \lt a \lt 1 \), élever au carré fait diminuer le nombre. Après N tours, \( a \) a été élevé au carré N fois. Ensuite, le programme renvoie donc le nombre de fois qu’il faut élever \( a \) au carré (successivement) pour obtenir un nombre strictement inférieur à 0,1.

La fonction choisit sa formule selon la valeur de \( x \) :

• si \( x \leqslant -1 \) : \( a = 2x – 1 \) ;
• si \( -1 \lt x \lt 4 \) : \( a = \frac{x}{3} \) ;
• si \( x \geqslant 4 \) : \( a = x^2 – 3 \) (en Python, x**2 signifie \( x^2 \)).

Il faut donc d’abord situer chaque argument, en utilisant \( \sqrt{2} \approx 1{,}41 \) et \( 3\sqrt{2} \approx 4{,}24 \).

• \( x = -2 \leqslant -1 \) : \( a = 2 \times (-2) – 1 = -5 \), entier négatif : \( -5 \in \mathbb{Z} \).
• \( x = \sqrt{2} \), compris entre \( -1 \) et 4 : \( a = \frac{\sqrt{2}}{3} \), irrationnel : \( \frac{\sqrt{2}}{3} \in \mathbb{R} \).
• \( x = 3\sqrt{2} \geqslant 4 \) : \( a = \left(3\sqrt{2}\right)^2 – 3 = 9 \times 2 – 3 = 15 \) : \( 15 \in \mathbb{N} \).
• \( x = \frac{1}{2} \), entre \( -1 \) et 4 : \( a = \frac{1}{2} \div 3 = \frac{1}{6} \). Son écriture décimale \( 0{,}1666\ldots \) est illimitée : \( \frac{1}{6} \in \mathbb{Q} \) (mais pas à \( \mathbb{D} \)).
• \( x = \frac{3}{2} \), entre \( -1 \) et 4 : \( a = \frac{3}{2} \div 3 = \frac{1}{2} = 0{,}5 \) : \( 0{,}5 \in \mathbb{D} \).

Remarque : Python calcule avec des valeurs approchées et affiche 15.000000000000004 pour \( 3\sqrt{2} \) ; la valeur exacte est bien 15.

a. Avec les arguments \( a = 1 \), \( b = 2 \), \( n = 0{,}1 \). À chaque tour, on calcule le milieu \( m = \frac{a + b}{2} \) : si \( m \gt \sqrt{2} \) (c’est-à-dire \( m – \sqrt{2} \gt 0 \)), le milieu devient la nouvelle borne \( b \) ; sinon il devient la nouvelle borne \( a \). Par ailleurs, on s’arrête dès que \( b – a \leqslant 0{,}1 \).

• \( b – a = 1 \gt 0{,}1 \) : \( m = 1{,}5 \gt \sqrt{2} \approx 1{,}414 \), donc \( b = 1{,}5 \).
• \( b – a = 0{,}5 \) : \( m = 1{,}25 \lt \sqrt{2} \), donc \( a = 1{,}25 \).
• \( b – a = 0{,}25 \) : \( m = 1{,}375 \lt \sqrt{2} \), donc \( a = 1{,}375 \).
• \( b – a = 0{,}125 \) : \( m = 1{,}4375 \gt \sqrt{2} \), donc \( b = 1{,}4375 \).
• \( b – a = 0{,}0625 \leqslant 0{,}1 \) : la boucle s’arrête.

Pour comparer \( m \) à \( \sqrt{2} \) sans calculatrice, on peut comparer \( m^2 \) à 2 : \( 1{,}4375^2 \approx 2{,}07 \gt 2 \) et \( 1{,}375^2 \approx 1{,}89 \lt 2 \).

Le script affiche (1.375, 1.4375).

b. À chaque étape, \( a \leqslant \sqrt{2} \leqslant b \) reste vrai. Puis l’affichage est donc un encadrement de \( \sqrt{2} \) d’amplitude inférieure ou égale à \( n = 0{,}1 \) :

\[ 1{,}375 \leqslant \sqrt{2} \leqslant 1{,}4375. \]

C’est la méthode par dichotomie : on coupe l’intervalle en deux à chaque étape.

c. Il faut :

• remplacer sqrt(2) par sqrt(7) dans le test ;
• partir d’un intervalle qui contient \( \sqrt{7} \) : comme \( 2^2 = 4 \lt 7 \lt 9 = 3^2 \), on prend \( a = 2 \) et \( b = 3 \) ;
• choisir la précision \( n = 10^{-3} = 0{,}001 \).

On appelle donc dichotomie(2, 3, 0.001) avec le test modifié ; on obtient \( 2{,}6455078125 \leqslant \sqrt{7} \leqslant 2{,}646484375 \).

Cet algorithme est le même que celui de l’exercice 22. Plutôt que de refaire les calculs pour chaque valeur, on calcule \( e \) en fonction de \( a \) (calcul littéral) :

\[ \begin{aligned} b &= a^2 \\ c &= a – a^2 \\ d &= 2(a – a^2) = 2a – 2a^2 \\ e &= d – c + b = (2a – 2a^2) – (a – a^2) + a^2 \\ &= 2a – 2a^2 – a + a^2 + a^2 \\ &= a. \end{aligned} \]

Pour tout nombre \( a \), nombre(\( a \)) = \( a \) : la fonction renvoie l’argument lui-même. Ensuite, le plus petit ensemble de nombre(\( a \)) est donc celui de \( a \) :

• nombre(2) = 2 : \( \mathbb{N} \) ;
• nombre(−4) = −4 : \( \mathbb{Z} \) ;
• nombre(\( \sqrt{2} \)) = \( \sqrt{2} \), irrationnel : \( \mathbb{R} \).

On retrouve bien les résultats obtenus pas à pas à l’exercice 22.

Même script que dans l’exercice 23. Puis on l’étudie ici de façon générale : il renvoie

\[ \text{nombre}(a) = \sqrt{3 + \frac{a}{2}}. \]

Ce nombre existe seulement si \( 3 + \frac{a}{2} \geqslant 0 \), c’est-à-dire \( a \geqslant -6 \), et c’est un entier lorsque \( 3 + \frac{a}{2} \) est un carré parfait (0, 1, 4, 9, 16…).

• a. \( 3 + \frac{3}{2} = 4{,}5 \), qui n’est pas un carré parfait : nombre(3) \( = \sqrt{4{,}5} \approx 2{,}12 \) n’est pas un entier.
• b. \( 3 + \frac{12}{2} = 9 = 3^2 \) : nombre(12) = 3, c’est un entier (Python affiche 3.0).
• c. \( 3 + \frac{-4}{2} = 1 = 1^2 \) : nombre(−4) = 1, c’est un entier (Python affiche 1.0).
• d. \( -12 \lt -6 \), donc \( 3 + \frac{-12}{2} = -3 \lt 0 \) : la racine carrée n’existe pas, Python affiche une erreur ValueError: math domain error.

Même algorithme que dans l’exercice 24. Exprimons \( e \) en fonction de \( a \) : \( b = -a \), \( c = (-a)^2 = a^2 \), \( d = -2a^2 \), donc

\[ e = -2a^2 + |a|. \]

• \( a = -2 \) : \( e = -2 \times 4 + 2 = -6 \), entier : affichage « entier ».
• \( a = 3 \) : \( e = -2 \times 9 + 3 = -15 \), entier : affichage « entier ».
• \( a = \sqrt{2} \) : \( e = -2 \times 2 + \sqrt{2} = -4 + \sqrt{2} \), qui n’est pas entier puisque \( \sqrt{2} \) est irrationnel : affichage « pas entier. »

Plus généralement, si \( a \) est un entier relatif, \( -2a^2 + |a| \) est aussi un entier : la fonction affiche toujours « entier » pour un argument entier.

Même script que dans l’exercice 25. Remarquons qu’après N passages dans la boucle, \( a \) a été élevé au carré N fois : il vaut \( a^{2^N} \) (\( a^2 \), puis \( a^4 \), puis \( a^8 \)…).

a. Pour \( a = 0{,}9 \), on cherche le premier N tel que \( 0{,}9^{2^N} \lt 0{,}1 \) :

• \( 0{,}9^2 = 0{,}81 \) ; \( 0{,}9^4 = 0{,}6561 \) ; \( 0{,}9^8 \approx 0{,}430 \) ; \( 0{,}9^{16} \approx 0{,}185 \) : toujours \( \geqslant 0{,}1 \) ;
• \( 0{,}9^{32} \approx 0{,}034 \lt 0{,}1 \) : on s’arrête après 5 passages.

compteur(0.9) = 5.

Pour \( a = 0{,}1 \) : le test a >= 0.1 est vrai au départ (\( 0{,}1 \geqslant 0{,}1 \)), donc on fait un passage : \( a = 0{,}01 \) et N = 1, puis la boucle s’arrête. compteur(0.1) = 1. (Avec le test strict a > 0.1, on aurait obtenu 0.)

b. Le programme affiche le nombre de mises au carré successives nécessaires pour que le nombre de départ, compris entre 0 et 1, devienne strictement inférieur à 0,1. Plus \( a \) est proche de 1, plus ce nombre est grand.