Exercices corrigés : algorithmique et programmation Python (Seconde)

a) On suit l'exécution LIGNE PAR LIGNE, en notant après chaque instruction la valeur de chaque variable. Après les deux premières lignes, $a$ vaut $5$ et $b$ vaut $3$. La ligne `a = a + b` donne $a=8$, $b$ restant à $3$. La ligne `b = a - b` utilise le NOUVEAU $a$ : $b=8-3=5$, $a$ restant à $8$. La ligne `a = a - b` utilise le nouveau $b$ : $a=8-5=3$. Le programme affiche donc `3 5`.

b) Il ÉCHANGE le contenu des deux variables, sans utiliser de variable supplémentaire. On est parti de $a=5$ et $b=3$, on arrive à $a=3$ et $b=5$. Le mécanisme est général : la somme $a+b$ est stockée dans $a$ et sert de mémoire temporaire, dont on extrait successivement l'ancien $a$ puis l'ancien $b$.

c) Avec une variable auxiliaire, on écrit `c = a` puis `a = b` puis `b = c`. C'est la version que l'on écrit en pratique, pour deux raisons : elle se lit immédiatement, et elle fonctionne avec n'importe quel type de données, alors que la version de l'énoncé n'a de sens que pour des NOMBRES. On ne peut pas additionner deux chaînes de caractères et espérer les séparer ensuite.

d) Il affiche $7$. Au moment de l'affectation `y = x`, Python range dans $y$ la VALEUR que $x$ contient alors, c'est-à-dire $7$. Modifier $x$ ensuite ne modifie pas $y$ : une affectation copie une valeur à l'instant où elle s'exécute, elle ne crée aucun lien permanent entre les deux variables.

Les questions a) et d) portent sur le même point, et c'est le plus important du chapitre : le signe $=$ de Python n'est PAS l'égalité mathématique, c'est une AFFECTATION. En mathématiques, écrire $a=a+b$ serait absurde et forcerait $b$ à être nul ; en Python cela signifie calculer $a+b$ avec les valeurs actuelles, puis ranger le résultat dans $a$, en écrasant l'ancienne valeur. Une affectation se lit donc toujours de DROITE à GAUCHE, et le seul moyen fiable de suivre un programme est de tenir un tableau des valeurs successives, comme en a). C'est exactement ce que l'épreuve évalue, et c'est aussi ce qui permet de repérer une erreur sans machine.

c = a
a = b
b = c

a) `mention(14)` renvoie `'Bien'` : $14$ n'est pas supérieur ou égal à $16$, le premier test échoue, mais il l'est à $14$ et le second réussit. `mention(11.5)` renvoie `'Pas de mention'`, aucun test n'étant satisfait. `mention(16)` renvoie `'Tres bien'`, car le test utilise une inégalité LARGE et $16\geq 16$. `mention(20)` renvoie également `'Tres bien'`.

b) Tous les tests suivants deviendraient INACCESSIBLES pour les notes élevées : une note de $18$ vérifie déjà `note >= 12`, donc la fonction renverrait `'Assez bien'` et s'arrêterait là, sans jamais examiner les autres branches. Dans une cascade de `elif`, il faut ordonner les tests du plus RESTRICTIF au plus large, car le premier qui réussit met fin à la cascade.

c) Il suffit d'insérer un test supplémentaire avant le `else` final : on ajoute `elif note >= 10:` renvoyant `'Pas de mention'`, et le `else` renvoie alors `'Refuse'`. L'ordre décroissant est conservé, $10$ venant après $12$ dans la cascade.

d) La condition équivaut à `note >= 16` tout court : si une note est supérieure ou égale à $16$, elle est AUTOMATIQUEMENT supérieure ou égale à $14$, donc le second test n'apporte rien. L'élève voulait sans doute exprimer un INTERVALLE, ce qui s'écrit `note >= 14 and note < 16`, avec deux bornes différentes et surtout un test strict d'un côté.

Une cascade de `elif` fonctionne comme un filtre en escalier : chaque valeur descend jusqu'au premier test qu'elle satisfait, et s'y arrête. C'est ce qui rend l'ORDRE décisif, et c'est aussi ce qui permet d'écrire `elif note >= 14` sans préciser `and note < 16` : à ce stade, les notes supérieures à $16$ ont déjà été interceptées. Remplacer tous les `elif` par des `if` indépendants changerait complètement le comportement, chaque test étant alors évalué et la dernière affectation l'emportant. On retiendra enfin la différence entre le test large $\geq$ et le test strict $>$, qui décide du sort exact des valeurs frontières comme $16$ en a).

def mention(note):
    if note >= 16:
        return 'Tres bien'
    elif note >= 14:
        return 'Bien'
    elif note >= 12:
        return 'Assez bien'
    elif note >= 10:
        return 'Pas de mention'
    else:
        return 'Refuse'

a) Il calcule la SOMME des entiers de $1$ à $10$, puisque `range(1, 11)` parcourt $1$, $2$, jusqu'à $10$, la borne $11$ étant exclue. La valeur affichée est $55$, ce que confirme la formule $\frac{10\times 11}{2}=55$. Écrire `range(1, 10)` donnerait $45$ : oublier que la borne de droite est exclue est l'erreur la plus fréquente du chapitre.

b) Il suffit de remplacer la ligne du corps par `s = s + k*k`, la structure de la boucle restant identique. Le résultat est $1+4+9+16+25+36+49+64+81+100=385$.

c) La variable $k$ prend les valeurs $0$, $5$, $10$ et $15$. Le TROISIÈME argument est le pas ; la valeur $20$ est exclue, exactement comme dans `range(a, b)`. Il y a donc quatre valeurs et non cinq, et l'on notera que $15+5=20$ tombe précisément sur la borne exclue.

d) Il calcule le PRODUIT des entiers de $1$ à $5$, c'est-à-dire la factorielle de $5$. À la fin, $p$ vaut $1\times 2\times 3\times 4\times 5=120$. Le point important est l'INITIALISATION : il faut partir de $1$ et non de $0$, sinon tous les produits successifs seraient nuls et le résultat vaudrait $0$. L'élément neutre de la multiplication n'est pas celui de l'addition.

Le schéma commun aux deux programmes s'appelle un ACCUMULATEUR, et il structure une grande partie de l'algorithmique du lycée. On initialise une variable à la valeur neutre, $0$ pour une somme et $1$ pour un produit ; on parcourt les valeurs ; et à chaque tour on combine l'accumulateur avec la valeur courante. Deux erreurs le guettent, et elles reviennent à l'exercice 9 : une mauvaise initialisation, comme partir de $0$ pour un produit, et un écrasement au lieu d'une accumulation, en écrivant `s = k` au lieu de `s = s + k`. Un contrôle simple les détecte toutes deux : dérouler la boucle sur trois tours à la main et comparer au résultat attendu.

s = 0
for k in range(1, 11):
    s = s + k*k
print(s)

a) Elle représente le nombre d'HEURES au bout desquelles la population atteint ou dépasse $10\,000$ bactéries, c'est-à-dire le temps de doublement arrondi à l'heure supérieure. La variable `t` compte les tours de boucle, et chaque tour correspond à une heure.

b) Après $9$ heures, la population vaut $5\,000\times 1{,}9990\approx 9\,995$ bactéries : c'est encore strictement inférieur à $10\,000$, donc la condition `n < 10000` reste vraie et la boucle continue. Après $10$ heures, elle vaut $5\,000\times 2{,}1589\approx 10\,795$ bactéries, la condition devient fausse et la boucle s'arrête. Le programme affiche $10$. Le cas à neuf heures est à cinq bactéries près du seuil : conclure sans calculer aurait conduit à répondre $9$.

c) Parce que le nombre de tours n'est pas CONNU avant l'exécution. Une boucle `for` exige de fixer le nombre d'itérations à l'avance, alors qu'ici c'est justement ce nombre que l'on cherche. La boucle `while` est donc l'outil des problèmes de SEUIL, où l'on répète tant qu'une condition tient sans savoir combien de temps.

d) La valeur de `n` resterait bloquée à $5\,000$, la condition `n < 10000` resterait vraie indéfiniment et la boucle ne s'arrêterait JAMAIS : le programme tournerait sans fin. Une boucle `while` n'est sûre que si quelque chose progresse réellement vers la sortie à chaque tour, et c'est au programmeur de le garantir.

La question d) énonce la règle de sécurité de toute boucle conditionnelle, et l'exercice 9 en donnera une variante : avant d'écrire un `while`, il faut identifier ce qui PROGRESSE vers la condition de sortie, et vérifier que cette progression est effective. Ici c'est la multiplication par un facteur strictement supérieur à $1$ qui garantit la terminaison ; avec un facteur égal à $1$ elle disparaît, avec un facteur inférieur à $1$ la population diminuerait et la boucle serait encore infinie. En pratique, on protège souvent le programme en ajoutant un compteur maximal, ce qui transforme une boucle infinie en une erreur signalée.

a) La fonction se réduit à une ligne : `return L * l`. On obtient `aire_rectangle(7, 3)` $=21$. Le mot-clé `return` est indispensable, comme la question c) va le montrer.

b) On teste le reste de la division par $2$ : `return n % 2 == 0`. L'expression `n % 2 == 0` vaut DÉJÀ `True` ou `False`, il est donc inutile d'écrire une structure `if` renvoyant l'un ou l'autre, même si c'est correct. Un test est une expression comme une autre, on peut le renvoyer directement.

c) `y` vaut `None`. La fonction affiche bien $10$ à l'écran, mais elle ne RENVOIE rien : en l'absence de `return`, Python renvoie automatiquement `None`. C'est la distinction essentielle entre AFFICHER et RENVOYER, et elle explique la plupart des programmes qui semblent fonctionner mais dont on ne peut pas réutiliser le résultat.

d) $f(0)=2\times 0+3=3$ et $f(5)=10+3=13$. Pour résoudre $f(x)=17$, on résout $2x+3=17$, soit $2x=14$ et $x=7$. On vérifie : $f(7)=14+3=17$ ✓. Une fonction Python et une fonction mathématique se manipulent donc de la même façon, la première n'étant qu'une écriture de la seconde.

La question c) mérite d'être retenue comme la distinction la plus utile du chapitre. `print` COMMUNIQUE avec l'utilisateur, en écrivant sur l'écran, et ce qui est écrit est définitivement perdu pour le programme. `return` COMMUNIQUE avec le reste du code, en fournissant une valeur qu'on peut stocker, réutiliser, additionner ou passer à une autre fonction. Une fonction sans `return` est donc inutilisable dans un calcul, quelle que soit la qualité de ce qu'elle affiche. La règle pratique est simple : une fonction qui CALCULE quelque chose doit toujours le renvoyer, et l'affichage se fait ensuite à l'extérieur, avec `print(f(5))`.

def aire_rectangle(L, l):
    return L * l

def est_pair(n):
    return n % 2 == 0

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

a) `len(notes)` vaut $6$, `notes[0]` vaut $12$, `notes[2]` vaut $15$ et `notes[len(notes) - 1]` vaut $11$. Les indices commencent à ZÉRO, donc le dernier indice est $5$ et non $6$ : écrire `notes[6]` provoquerait une erreur d'indice. L'écriture `notes[len(notes) - 1]` est la façon standard de désigner le dernier élément sans connaître la taille.

b) On écrit `moyenne = sum(notes) / len(notes)`. La somme vaut $12+8+15+9+18+11=73$, donc la moyenne vaut $\frac{73}{6}\approx 12{,}17$. Utiliser `len(notes)` plutôt que $6$ rend l'instruction valable pour n'importe quelle liste, ce qui est toujours préférable.

c) On initialise un COMPTEUR à $0$, puis on parcourt la liste en l'incrémentant à chaque note qui vérifie la condition. Les notes concernées sont $12$, $15$ et $18$, donc le compteur vaut $3$ à la fin. On notera que $12$ compte, l'inégalité étant large.

d) On initialise avec `notes[0]`, puis on compare chaque élément suivant au maximum courant en le remplaçant s'il est plus grand. Le résultat est $18$. Initialiser à $0$ serait DANGEREUX : si toutes les valeurs étaient négatives, par exemple des températures hivernales à Montréal comme $-12$, $-8$, $-15$ et $-3$, l'algorithme renverrait $0$, valeur qui n'appartient même pas à la liste. Partir du premier élément garantit que le résultat est toujours une valeur réellement présente.

La question d) illustre un principe qui dépasse largement la recherche d'un maximum : une initialisation doit être NEUTRE pour l'opération considérée, ou tirée des données elles-mêmes. Pour une somme, $0$ convient car il est neutre pour l'addition. Pour un produit, c'est $1$, comme à l'exercice 3. Pour un maximum, aucune valeur numérique n'est neutre, puisqu'il n'existe pas de plus petit nombre : la seule solution correcte est donc de partir du premier élément. Le même raisonnement vaut pour un minimum, et l'erreur symétrique consisterait à l'initialiser à $0$ sur une liste de valeurs toutes positives.

compteur = 0
for note in notes:
    if note >= 12:
        compteur = compteur + 1

maxi = notes[0]
for note in notes:
    if note > maxi:
        maxi = note

a) La condition de poursuite est `capital < 3000` et la ligne de calcul est `capital = capital * 1.03`. Augmenter de $3\ \%$ revient à MULTIPLIER par $1+\frac{3}{100}=1{,}03$, et non à ajouter $3$ : la confusion entre hausse relative et hausse absolue est l'erreur classique de ce type d'énoncé.

b) Après $13$ ans, le capital vaut $2\,000\times 1{,}4685\approx 2\,937{,}07$ dollars, encore inférieur à $3\,000$ : la boucle continue. Après $14$ ans, il vaut $2\,000\times 1{,}5126\approx 3\,025{,}18$ dollars, la condition devient fausse et la boucle s'arrête. Le programme affiche $14$.

c) Le capital atteint est d'environ $3\,025{,}18$ dollars. Il DÉPASSE le seuil de $25{,}18$ dollars, ce qui est normal : la croissance étant discontinue, année par année, on n'atterrit jamais exactement sur le seuil. Une boucle de seuil renvoie donc toujours le premier instant où la condition est franchie, jamais l'instant exact du franchissement.

d) L'affichage se trouvant DANS le corps de la boucle, il s'exécute une fois par tour. Comme la boucle effectue $14$ tours, $14$ lignes s'affichent. Si l'affichage était placé APRÈS la boucle, au même niveau d'indentation que le `print` final, il n'y en aurait qu'une : en Python, c'est l'INDENTATION seule qui décide de ce qui est répété, là où d'autres langages utilisent des accolades.

La question d) touche à ce qui distingue Python de la plupart des langages, et à une source d'erreur permanente pour les débutants : l'indentation n'est pas une convention de présentation, c'est de la SYNTAXE. Décaler une ligne de quatre espaces la fait entrer dans la boucle ou en sortir, et change donc le programme. Deux vérifications s'imposent devant tout code à trous : d'abord ce qui est répété et ce qui ne l'est pas, ensuite ce qui doit être initialisé AVANT la boucle, ici `capital` et `annee`, car une initialisation placée à l'intérieur remettrait le compteur à zéro à chaque tour et produirait une boucle infinie.

capital = 2000
annee = 0
while capital < 3000:
    capital = capital * 1.03
    annee = annee + 1
    print(annee, capital)
print(annee)

a) Elle représente la FRÉQUENCE d'apparition du $6$ sur mille lancers simulés, c'est-à-dire le nombre de $6$ obtenus divisé par le nombre de lancers. C'est une fréquence OBSERVÉE, résultat d'une expérience, et non une probabilité, qui est une valeur théorique.

b) Le dé étant équilibré, la probabilité d'obtenir un $6$ vaut $\frac{1}{6}\approx 0{,}167$. La fréquence observée doit donc se situer AUTOUR de cette valeur, sans nécessairement l'atteindre.

c) Non, c'est parfaitement normal : c'est la FLUCTUATION D'ÉCHANTILLONNAGE. Deux échantillons de même taille tirés de la même expérience donnent en général des fréquences différentes, et c'est le propre du hasard. Un programme qui renverrait exactement $0{,}1666$ à chaque exécution serait au contraire suspect, et signalerait probablement un générateur défectueux.

d) Pour $n=100$, l'intervalle vaut $\left[\frac{1}{6}-0{,}1\,;\,\frac{1}{6}+0{,}1\right]$, soit environ $[0{,}067\,;\,0{,}267]$, de largeur $0{,}2$. Les deux résultats observés, $0{,}14$ et $0{,}19$, y figurent bien ✓. Pour $n=10\,000$, l'intervalle vaut $\left[\frac{1}{6}-0{,}01\,;\,\frac{1}{6}+0{,}01\right]$, soit environ $[0{,}157\,;\,0{,}177]$, de largeur $0{,}02$.

Le rapport entre les deux largeurs est le résultat le plus important de l'exercice, et il est contre-intuitif : multiplier la taille de l'échantillon par CENT ne divise la largeur que par DIX, puisque c'est $\sqrt{n}$ qui intervient et non $n$. Gagner une décimale de précision coûte donc cent fois plus de lancers, ce qui explique le prix des sondages et pourquoi ceux-ci se contentent presque tous d'un millier de personnes, avec une marge d'environ trois points. Sur le fond, cet exercice fait le lien entre la simulation informatique et les probabilités : le programme ne démontre rien, mais il permet d'OBSERVER une loi théorique et surtout de constater que l'écart entre théorie et observation est prévisible, ce qui est le point de départ de toute la statistique inférentielle.

a) `m` vaut `None`. La fonction affiche bien $5$ à l'écran, mais elle ne renvoie AUCUNE valeur, et Python renvoie alors `None` par défaut. La correction consiste à remplacer `print` par `return` : `return (a + b)/2`. On peut toujours afficher le résultat ensuite, depuis l'extérieur, avec `print(moyenne(4, 6))`. C'est exactement le piège de l'exercice 5 c).

b) À la fin, `s` vaut $10$ : à chaque tour on ÉCRASE la valeur précédente au lieu de l'accumuler, si bien que seul le dernier passage laisse une trace. On voulait la somme des entiers de $1$ à $10$, soit $55$. La correction est `s = s + k`, qui ajoute au lieu de remplacer. La différence entre $10$ et $55$ montre à quel point un seul caractère manquant change tout.

c) La variable `n` n'est jamais modifiée dans la boucle, donc la condition `n > 0` reste vraie indéfiniment : la boucle est INFINIE et le programme affiche $10$ sans jamais s'arrêter. Il faut ajouter `n = n - 1` dans le corps, ce qui affichera alors $10$, $9$, $8$, jusqu'à $1$, soit dix lignes. C'est la même faute qu'à l'exercice 4 d), sous une autre forme.

d) C'est une erreur de SYNTAXE. Le simple `=` est l'affectation, qui range une valeur dans une variable ; le test d'égalité s'écrit avec un double `==`. La ligne correcte est `if x == 5:`. Python refuse d'exécuter le programme, ce qui est ici une chance : l'erreur est signalée immédiatement plutôt que de produire silencieusement un mauvais résultat, comme le font les trois précédentes.

Ces quatre erreurs se classent en deux familles, et la distinction est instructive. L'erreur d) est SYNTAXIQUE : le programme ne démarre même pas, l'ordinateur la signale et elle se corrige en dix secondes. Les erreurs a), b) et c) sont LOGIQUES : le programme s'exécute sans se plaindre et produit un résultat faux, ou ne s'arrête pas. Ce sont de loin les plus dangereuses, précisément parce que rien ne les signale, et le seul moyen de les détecter est de tester le programme sur un cas dont on connaît la réponse. C'est aussi pourquoi savoir dérouler une exécution à la main, comme à l'exercice 1, reste indispensable même quand on dispose d'une machine.

def moyenne(a, b):
    return (a + b)/2

s = 0
for k in range(1, 11):
    s = s + k

n = 10
while n > 0:
    print(n)
    n = n - 1

a) La boucle continue TANT QUE le carré reste strictement inférieur à $7$, et s'arrête dès qu'il l'atteint. On a $2{,}6^{2}=6{,}76<7$, donc la boucle continue, et $2{,}7^{2}=7{,}29\geq 7$, donc elle s'arrête. Le programme affiche environ $2{,}7$ et fournit l'encadrement $2{,}6<\sqrt{7}<2{,}7$. La valeur affichée est la borne SUPÉRIEURE, la borne inférieure étant la valeur précédente.

b) Il suffit de remplacer le pas par $0{,}01$, c'est-à-dire d'écrire `x = x + 0.01`. On a $2{,}64^{2}=6{,}9696<7$ et $2{,}65^{2}=7{,}0225\geq 7$, d'où l'encadrement $2{,}64<\sqrt{7}<2{,}65$. La calculatrice confirme $\sqrt{7}\approx 2{,}6458$ ✓.

c) Le nombre $0{,}1$ n'a pas d'écriture BINAIRE exacte, pas plus que $\frac{1}{3}$ n'en a en décimal : en l'ajoutant des centaines de fois, les petites erreurs s'accumulent et la variable finit par valoir un nombre légèrement différent de celui attendu. On contourne le problème en comptant avec un ENTIER et en ne divisant qu'au moment du test : on initialise `n` à $0$, la condition devient `while (n/100)*(n/100) < 7:`, le corps devient `n = n + 1`, et l'on affiche `n/100` à la fin. Les entiers, eux, sont représentés exactement.

d) La boucle s'arrête pour $n=265$, puisque $\left(\frac{265}{100}\right)^{2}=7{,}0225\geq 7$ alors que la valeur précédente est inférieure : elle effectue donc $265$ tours. Pour gagner une décimale, il faudrait un pas dix fois plus petit, donc environ dix fois plus de tours, soit $2\,650$. Le coût croît LINÉAIREMENT avec la précision demandée.

C'est précisément ce coût linéaire qui fait préférer une autre méthode, la DICHOTOMIE. Partant de l'intervalle $[2\,;\,3]$, dont on sait qu'il contient $\sqrt{7}$ puisque $4<7<9$, on coupe en deux à chaque étape et l'on garde la moitié qui contient la solution. L'amplitude est alors divisée par deux à chaque tour, donc atteindre $0{,}01$ ne demande que sept étapes, car $\frac{1}{2^{7}}\approx 0{,}0078<0{,}01$ alors que $\frac{1}{2^{6}}\approx 0{,}0156$ est encore trop grand. Sept étapes contre deux cent soixante-cinq, et l'écart s'accroît encore avec la précision : gagner une décimale supplémentaire ne coûte que trois ou quatre étapes de plus, contre dix fois plus de tours pour le balayage. C'est l'illustration la plus simple de ce qu'un meilleur algorithme vaut mieux qu'une machine plus rapide.

n = 0
while (n/100)*(n/100) < 7:
    n = n + 1
print(n/100)

a) La boucle teste $d=1$, $2$, ..., $12$ et compte ceux pour lesquels le reste est nul : $1$, $2$, $3$, $4$, $6$, $12$. La fonction renvoie $6$. Le `range(1, n + 1)` est nécessaire pour que $n$ lui-même soit testé, la borne de droite étant exclue.

b) $13$ n'a que deux diviseurs, $1$ et $13$ : la fonction renvoie $2$. La boucle a tourné $13$ fois, autant que la valeur de $n$ : pour un grand nombre, cette méthode est lente.

c) Un nombre premier a EXACTEMENT deux diviseurs : `return nb_diviseurs(n) == 2`. Pour $n=1$, `nb_diviseurs(1)` vaut $1$, donc la fonction renvoie `False` : $1$ n'est pas premier, et la définition par « exactement deux diviseurs » règle ce cas sans exception à écrire.

d) Les nombres premiers inférieurs à $30$ sont $2$, $3$, $5$, $7$, $11$, $13$, $17$, $19$, $23$, $29$ : il y en a $10$. Une boucle `for n in range(1, 31)` qui incrémente un compteur quand `est_premier(n)` est vrai donne ce résultat.

e) Si $n$ a un diviseur autre que $1$ et lui-même, il en a un qui vérifie $d\times d\leq n$. Pour $n=97$, on teste $d=2$, $3$, ..., $9$, car $9\times 9=81\leq 97$ mais $10\times 10=100>97$ : $8$ tours au lieu de $97$. Aucun ne divise $97$, qui est donc premier.

Le fil : un test de divisibilité s'écrit avec `%`, un comptage avec un compteur initialisé à $0$, et une remarque mathématique (s'arrêter à $\sqrt{n}$) vaut mieux qu'une machine plus rapide.

def est_premier(n):
    return nb_diviseurs(n) == 2

compteur = 0
for n in range(1, 31):
    if est_premier(n):
        compteur = compteur + 1
print(compteur)

a) `//` est la division ENTIÈRE : $17=3\times 5+2$, donc `17 // 5` vaut $3$ et `17 % 5`, le reste, vaut $2$. La division `/` donne le quotient décimal : $3{,}4$.

b) `**` est la puissance : `2 ** 10` vaut $1\,024$ (et non `2 * 10`). `-7 // 2` vaut $-4$ et non $-3$ : la division entière arrondit vers le BAS, et $-3{,}5$ arrondi vers le bas donne $-4$. C'est le piège classique des nombres négatifs.

c) La division `/` renvoie toujours un flottant, même quand le résultat tombe juste : `10 / 2` vaut `5.0`, de type `float`. Pour obtenir l'entier $5$, il faut `10 // 2`.

d) Multiplier une chaîne par un entier la RÉPÈTE : `'ha' * 3` vaut `'hahaha'`. Additionner deux chaînes les COLLE : `'3' + '4'` vaut `'34'`, et non $7$. Les guillemets font toute la différence entre le nombre $3$ et le caractère `'3'`.

e) `5 > 3` vaut `True` et `2 == 3` vaut `False` ; `and` exige les deux, donc le résultat est `False`. `4 < 2` vaut `False`, et `not` le transforme en `True`.

À retenir : le même symbole ne fait pas la même chose selon le type des valeurs. `+` additionne des nombres mais colle des chaînes, et `/` renvoie toujours un flottant.

a) Départ $a=84$, $b=36$. Tour 1 : $r=84\ \%\ 36=12$, puis $a=36$, $b=12$. Tour 2 : $r=36\ \%\ 12=0$, puis $a=12$, $b=0$. La condition `b != 0` est fausse : la boucle s'arrête après $2$ tours et la fonction renvoie $12$. Contrôle : $84=12\times 7$ et $36=12\times 3$ ✓.

b) $1071=2\times 462+147$ ; $462=3\times 147+21$ ; $147=7\times 21+0$. Trois tours, et la fonction renvoie $21$. Chercher tous les diviseurs de $1071$ aurait été bien plus long.

c) $17\ \%\ 5=2$, puis $5\ \%\ 2=1$, puis $2\ \%\ 1=0$ : la fonction renvoie $1$ après $3$ tours. Le seul diviseur commun est $1$ : les nombres $17$ et $5$ sont PREMIERS ENTRE EUX.

d) Tour 1 : $r=36\ \%\ 84=36$, puis $a=84$, $b=36$. Le premier tour a simplement ÉCHANGÉ les deux nombres. On retrouve ensuite la question a) : $3$ tours au total, résultat $12$. L'algorithme n'a donc pas besoin qu'on range les nombres dans l'ordre.

e) On divise numérateur et dénominateur par le PGCD $21$ : $\frac{1071}{462}=\frac{51}{22}$. Comme on a divisé par le plus grand diviseur commun, la fraction obtenue est irréductible.

Le point de méthode : une boucle `while` convient ici parce qu'on ne sait pas d'avance combien de divisions seront nécessaires, et la terminaison est garantie car le reste diminue strictement à chaque tour.

a) `tarif(1)` : $1\leq 2$, première branche, $4$ euros. `tarif(10)` : deuxième branche, $4+1{,}5\times 8=16$ euros. `tarif(30)` : troisième branche, $4+1{,}5\times 18+1{,}2\times 10=4+27+12=43$ euros. On retire bien les $2$ km inclus, puis les $18$ km facturés à $1{,}50$.

b) Deuxième branche : $4+1{,}5\times 18=31$. Troisième branche : $4+27+1{,}2\times 0=31$. Les deux coïncident : pas de saut à $20$ km, le tarif est continu. Un tarif mal écrit, par exemple $4+1{,}2\times(d-2)$ après $20$ km, ferait brutalement baisser le prix de $5{,}40$ euros à $20{,}01$ km.

c) $13$ euros est entre $4$ et $31$ : deuxième branche. $4+1{,}5(d-2)=13$ donne $1{,}5(d-2)=9$, $d-2=6$ et $d=8$ km.

d) $50$ euros dépasse $31$ : troisième branche. $31+1{,}2(d-20)=50$ donne $d-20=\frac{19}{1{,}2}\approx 15{,}83$, donc $d\approx 35{,}83$ km.

e) Deuxième branche : $4+1{,}5(d-2)>25$ équivaut à $d-2>14$, soit $d>16$. Pour $d=16$, le prix vaut exactement $25$ ; pour $d=17$, il vaut $26{,}50$. Le plus petit entier est $17$ km. Une boucle `while tarif(d) <= 25: d = d + 1` partant de $d=0$ donne le même résultat.

Ce problème traduit une fonction définie par morceaux en instructions conditionnelles : chaque branche correspond à un intervalle, et l'ORDRE des tests garantit que chaque distance tombe dans la bonne.

a) $f(1)=1+1-5=-3$ et $f(2)=8+2-5=5$. La fonction est croissante et passe d'une valeur négative à une valeur positive : elle s'annule une fois entre $1$ et $2$.

b) $m=\frac{1+2}{2}=1{,}5$ et $f(1{,}5)=3{,}375+1{,}5-5=-0{,}125$. Comme $f(1)\times f(1{,}5)=(-3)\times(-0{,}125)>0$, les deux sont de même signe : la solution n'est pas dans $[1\ ;\ 1{,}5]$. On pose `a = m` et le nouvel intervalle est $[1{,}5\ ;\ 2]$.

c) Tour 2 : $m=1{,}75$, $f(1{,}75)\approx 2{,}109>0$, changement de signe avec $f(1{,}5)<0$ : on pose `b = m`, intervalle $[1{,}5\ ;\ 1{,}75]$. Tour 3 : $m=1{,}625$, $f(1{,}625)\approx 0{,}916>0$ : intervalle $[1{,}5\ ;\ 1{,}625]$.

d) L'amplitude vaut $1$ au départ et est divisée par $2$ à chaque tour. La boucle continue tant que l'amplitude dépasse $0{,}01$ : après $6$ tours elle vaut $\frac{1}{64}\approx 0{,}0156$, encore trop grande ; après $7$ tours, $\frac{1}{128}\approx 0{,}0078$. La boucle effectue $7$ tours.

e) Après $7$ tours, l'intervalle est $[1{,}515625\ ;\ 1{,}5234375]$. Tous ses nombres arrondis au centième donnent $1{,}52$ : la solution vaut environ $1{,}52$. Contrôle : $f(1{,}52)\approx 0{,}032$, proche de $0$ ✓.

La dichotomie est l'algorithme type du chapitre : à chaque tour elle gagne un bit de précision, là où un balayage au pas de $0{,}01$ aurait demandé jusqu'à cent tours.