Révision U22 — Algorithmique appliquée

Réponse : float. Tout littéral comportant un point décimal est un nombre à virgule flottante, même si la partie décimale est .00. Un entier comme 19 serait un int ; entre guillemets, "19.99" serait un str.

Réponse : compteur = 10. L'affectation utilise un seul =, avec le nom à gauche et la valeur à droite. == sert à comparer (il ne range rien). 10 = compteur est invalide (on ne peut pas affecter à un littéral).

Sortie attendue :

x = 10
y = 3

La variable temp mémorise l'ancienne valeur de x (3). Ensuite x prend la valeur de y (10), puis y reprend la valeur mise de côté dans temp (3). Les deux valeurs ont bien été échangées.

À la ligne L1, seule a existe (valeur 4) ; b et c n'existent pas encore. L3 copie a dans c : c vaut 4. L4 écrase a avec la valeur de b : a vaut 9. L5 met dans b la valeur mémorisée par c : b vaut 4. C'est un échange de a et b à l'aide de la variable temporaire c.

On utilise une variable temporaire pour ne perdre aucune valeur pendant l'échange :

# Nom : echanger
# Rôle : échange les valeurs de deux variables puis les affiche
# Entrées : aucune (valeurs fixées dans le code)
# Sortie : affichage des deux valeurs échangées
# Variables locales : gauche (entier), droite (entier), temp (entier)

gauche = 12
droite = 30
temp = gauche
gauche = droite
droite = temp
print("gauche =", gauche)
print("droite =", droite)

gauche = 30
droite = 12

Sans la variable temp, écrire directement gauche = droite puis droite = gauche perdrait la valeur de gauche : les deux dépôts finiraient à 30.

Réponse : str. input() renvoie toujours une chaîne, quel que soit ce qui est saisi. Même en tapant 7, on obtient la chaîne "7". Pour calculer avec, il faut convertir : int(reponse).

Réponse : 45. a et b sont des chaînes (guillemets) : + les concatène. Pour obtenir 9, il aurait fallu convertir : int(a) + int(b).

Sortie attendue :

Fabien_Aubert
Total 7

Le premier print colle prenom et nom avec un tiret bas (sep="_"). Le second additionne d'abord 3 + 4 (nombres, donc 7) et l'affiche après le mot Total, séparé par l'espace par défaut.

Réponse : int. Sans conversion, input() renvoie une chaîne et valeur * 2 répéterait le texte (par exemple "5" * 2 donnerait "55"). int(...) transforme la saisie en entier, ce qui permet la multiplication arithmétique.

Réponse : envelopper chaque input() dans int(...). Comme input() renvoie des chaînes, "5" + "7" concatène en "57". Avec int(input(...)), on manipule les entiers 5 et 7, donc 5 + 7 vaut bien 12. On aurait pu utiliser float si les nombres pouvaient être à virgule.

Le prix pouvant être à virgule, on convertit la saisie avec float :

# Nom : calcul_ttc
# Rôle : lit un prix HT au clavier et affiche le prix TTC (TVA 20 %)
# Entrées : prix_ht saisi au clavier (chaîne convertie en réel)
# Sortie : affichage du prix TTC
# Variables locales : prix_ht (réel), prix_ttc (réel)

prix_ht = float(input("Prix HT en euros : "))
prix_ttc = prix_ht * 1.2
print("Prix TTC :", prix_ttc, "€")

Prix HT en euros : Prix TTC : 120.0 €

Ici la saisie était 100. On utilise float (et non int) car un prix comme 19.99 comporte des décimales. Attention : sur certaines valeurs, l'affichage flottant peut faire apparaître de nombreuses décimales (par exemple 19.99 * 1.2 affiche 23.987999999999996) — c'est le comportement normal des réels en machine.

Réponse : if code == 1234:. L'égalité se teste avec le double ==. Un seul = est une affectation (interdite dans un if). =! et >< n'existent pas ; l'inégalité s'écrit !=.

Réponse : False. 3 > 2 est True, mais 5 < 1 est False. Avec and, il faut que les deux soient vraies ; comme l'une est fausse, le résultat est False. Avec or, le résultat aurait été True.

Réponse : positif puis grand. Ce sont deux if indépendants, testés chacun de leur côté. Comme 5 > 0 et 5 > 3 sont tous deux vrais, les deux messages s'affichent. Avec un elif à la place du second if, seul positif serait affiché (la première branche vraie arrête la chaîne).

Pour stock = 0 : la condition stock == 0 est vraie → branche if, etat = "Rupture". Pour stock = 3 : == 0 est faux, mais < 5 est vrai → branche elif, etat = "Bas". Pour stock = 12 : les deux conditions sont fausses → branche else, etat = "OK". Une seule branche est retenue à chaque fois.

Réponse : <= des deux côtés, soit if 0 <= note <= 20:. On utilise <= (et non <) car les bornes 0 et 20 sont incluses. Cet encadrement remplace avantageusement note >= 0 and note <= 20.

On enchaîne if / elif / else du seuil le plus haut au plus bas, pour que chaque plage soit correctement séparée :

# Nom : etat_capteur
# Rôle : affiche un message d'alerte selon la valeur d'un capteur de température
# Entrées : temperature saisie au clavier (chaîne convertie en entier)
# Sortie : affichage du niveau d'alerte
# Variables locales : temperature (entier)

temperature = int(input("Température mesurée (°C) : "))
if temperature >= 80:
    print("ALERTE : surchauffe critique")
elif temperature >= 60:
    print("Attention : température élevée")
else:
    print("Température normale")

Température mesurée (°C) : ALERTE : surchauffe critique

Ici la saisie était 85, donc la première branche s'active. L'ordre est essentiel : si l'on testait >= 60 avant >= 80, une valeur de 90 déclencherait à tort le message « élevée » au lieu de « critique ».

15. range(1, 6) donne les valeurs 1, 2, 3, 4, 5 (la borne 6 est exclue). L'accumulateur somme part de 0, puis vaut successivement 1, 3, 6, 10 et enfin 15. Le print est hors de la boucle : il n'affiche qu'une fois, à la fin.

5 fois. Avec un pas de 2 en partant de 3 et en s'arrêtant avant 12, on obtient les valeurs 3, 5, 7, 9, 11, soit 5 tours. Le distracteur « 9 fois » vient d'un oubli du pas (12 − 3) ; « 4 fois » et « 6 fois » sont des erreurs de off-by-one sur la borne exclue.

On part de produit = 1. À chaque tour on multiplie par i :

• Tour 1 : 1 × 1 = 1
• Tour 2 : 1 × 2 = 2
• Tour 3 : 2 × 3 = 6
• Tour 4 : 6 × 4 = 24

Le produit final vaut 24 (c'est 4! = 4 × 3 × 2 × 1). Noter l'initialisation à 1 et non à 0 : un produit qui démarre à 0 resterait toujours 0.

La division entière // arrondit vers le bas : 20//2 = 10, 10//2 = 5, 5//2 = 2, 2//2 = 1, 1//2 = 0. Quand n atteint 0, la condition n > 0 devient fausse et la boucle s'arrête. Elle a fait 5 tours.

La variable i vaut toujours 1 : rien ne la fait évoluer dans la boucle, donc i <= 3 reste éternellement vraie. Il manque une instruction pour incrémenter i. Correction : ajouter i = i + 1 à la fin du corps de la boucle. On obtient alors :

i = 1
while i <= 3:
    print(i)
    i = i + 1

1
2
3

Réponse : != "stop". La boucle continue tant que le mot est différent de la sentinelle. Si l'utilisateur tape stop dès la première saisie, la condition est fausse d'entrée et la boucle n'affiche rien (cas de non-entrée) — c'est le comportement voulu. Attention à lire la première saisie avant le while, sinon mot n'existerait pas encore.

On utilise un compteur nb initialisé à 0 et une boucle à sentinelle : première saisie avant la boucle, saisie suivante en fin de tour, condition d'arrêt sur "fin".

# Nom : compter_urgents
# Rôle : compte les tickets de priorité "urgent" saisis jusqu'à "fin"
# Entrées : saisies clavier (chaînes), sentinelle "fin"
# Sortie : affiche le nombre de tickets urgents
# Variables locales : nb (entier), saisie (chaîne)
nb = 0
saisie = input("Priorité du ticket (fin pour terminer) : ")
while saisie != "fin":
    if saisie == "urgent":
        nb = nb + 1
    saisie = input("Priorité du ticket (fin pour terminer) : ")
print("Tickets urgents :", nb)

Priorité du ticket (fin pour terminer) : Priorité du ticket (fin pour terminer) : Priorité du ticket (fin pour terminer) : Priorité du ticket (fin pour terminer) : Priorité du ticket (fin pour terminer) : Priorité du ticket (fin pour terminer) : Tickets urgents : 3

Le texte du input apparaît autant de fois qu'il y a de saisies (6 fois), y compris pour la sentinelle fin qui déclenche la sortie.

True puis False. La fonction renvoie directement le résultat de la comparaison age >= 18 : un booléen. Avec 20 on obtient True, avec 16 False. En Python, l'affichage d'un booléen utilise la majuscule : True / False.

tva(100) renvoie 20.0, stocké dans montant puis affiché : TVA récupérée : 20.0. afficher_tva(100) affiche 20.0 mais ne renvoie rien. Appelé une 2^e fois, il affiche encore 20.0. Comme il n'a pas de return, r reçoit None — d'où r = None. C'est le cœur du piège : print montre, return renvoie.

100. Le x = 5 écrit à l'intérieur de modifier crée une variable locale qui masque la globale le temps de l'appel, puis disparaît. La globale x vaut toujours 100 après l'appel. Le distracteur (a) est l'erreur classique : croire qu'affecter dans une fonction change la globale.

Il faut return a dans le if et return b ensuite. Dès qu'un return s'exécute, la fonction s'arrête : si a > b, on renvoie a et on ne va jamais jusqu'au return b. Sinon on tombe sur return b. Sortie : 8 puis 10. Attention à utiliser return et non print, sinon la fonction renverrait None.

Comme carre utilise print et non return, elle renvoie None. Donc resultat vaut None, et resultat + 1 déclenche une TypeError. Il faut renvoyer la valeur :

def carre(n):
    return n * n

resultat = carre(5)
print(resultat + 1)

26

On accumule le total et on compte le nombre de notes dans une boucle, puis on renvoie le quotient. La division / donne un résultat réel.

# Nom : moyenne_notes
# Rôle : calcule la moyenne d'une liste de notes
# Entrées : notes (liste de réels)
# Sortie : moyenne (réel)
# Variables locales : total (réel), n (entier)
def moyenne_notes(notes):
    total = 0
    n = 0
    for note in notes:
        total = total + note
        n = n + 1
    return total / n

print(moyenne_notes([12, 8, 16]))
print(moyenne_notes([10, 10, 10, 10]))

12.0
10.0

On obtient 12.0 ((12+8+16)/3) et 10.0. Le résultat porte un .0 car la division / renvoie toujours un réel. On utilise return (et non print) pour que la moyenne soit réutilisable ailleurs dans le programme.

Les indices commencent à 0 : t[0]=5, t[1]=9, t[2]=3, t[3]=8. L'indice 2 désigne donc le troisième élément, soit 3. Piège fréquent : confondre l'indice (2) et le rang (3e).

On part de r = t[0] puis on garde dans r tout élément plus grand que la valeur courante : c'est la recherche du maximum. Ici le maximum vaut 5. Pour le minimum, on remplacerait > par <.

capteurs[2] vaut 25 (3e case). len(capteurs) vaut 4 avant l'ajout. append(55) ajoute la valeur en fin, la liste devient [10, 25, 25, 40, 55].

25
4
[10, 25, 25, 40, 55]

Le compteur compte part de 0 et s'incrémente à chaque "ok". Il y en a trois (positions 0, 2 et 3), donc la sortie est 3. C'est le schéma de comptage par accumulateur : on initialise à 0, on ajoute 1 quand la condition est vraie.

somme vaut 0 avant la boucle. À chaque tour on lit valeur = t[i] et on l'ajoute :

• i=0 : valeur=5, somme = 0+5 = 5
• i=1 : valeur=2, somme = 5+2 = 7
• i=2 : valeur=8, somme = 7+8 = 15

Résultat final : 15.

Le code fautif utilisait range(len(t) + 1), soit range(4) : à l'itération i = 3, t[3] n'existe pas (indices valides 0 à 2) d'où l'IndexError. La bonne borne est range(len(t)) : elle produit les indices 0, 1, 2, exactement les cases existantes.

t = [3, 6, 9]
for i in range(len(t)):
    print(t[i])

3
6
9

On accumule le total dans une variable partant de 0, puis on divise par le nombre d'éléments (len). On parcourt par élément car seules les valeurs comptent.

# Nom : moyenne_temperatures
# Role : calcule la moyenne d'un releve de temperatures
# Entrees : releve (liste de reels)
# Sortie : moyenne (reel)
# Variables locales : total (reel), n (entier)

releve = [18, 21, 19, 23, 20]
total = 0
for t in releve:
    total = total + t
n = len(releve)
moyenne = total / n
print("Moyenne :", moyenne)

Moyenne : 20.2

On utilise un accumulateur booléen present initialisé à False. Dès qu'on rencontre la valeur cherchée, on le passe à True. On parcourt par élément.

# Nom : contient_valeur
# Role : indique si une valeur est presente dans un releve
# Entrees : releve (liste d'entiers), cible (entier)
# Sortie : present (booleen)
# Variables locales : present (booleen)

releve = [10, 25, 30, 25, 12]
cible = 30
present = False
for v in releve:
    if v == cible:
        present = True
print(present)

True

Astuce : en Python on peut aussi écrire directement cible in releve, mais l'épreuve attend souvent l'algorithme détaillé.

m[1] est la deuxième ligne [2, 9, 5]. Sa colonne d'indice 2 est 5. Piège : ne pas lire colonne d'abord — c'est bien ligne (1) puis colonne (2).

len(m) compte les éléments de la liste extérieure : les lignes, ici 2. len(m[0]) compte les éléments de la première ligne : les colonnes, ici 4. Cette matrice a donc 2 lignes et 4 colonnes.

Chaque pixel v devient 255 - v : 10→245, 20→235, 30→225, 40→215. La matrice modifiée sur place vaut [[245, 235], [225, 215]].

La borne des colonnes est len(img[0]) (nombre de colonnes de la première ligne). Le négatif d'un pixel est 255 - img[i][j]. On réaffecte la case pour modifier l'image sur place.

img = [[0, 255, 128],
       [64, 200, 32]]
for i in range(len(img)):
    for j in range(len(img[0])):
        img[i][j] = 255 - img[i][j]
print(img)

[[255, 0, 127], [191, 55, 223]]

Le test est img[i][j] < seuil : en dessous du seuil on met 0 (noir), sinon 255 (blanc). Attention, un pixel égal au seuil (128) n'est pas « inférieur » : il passe donc à 255.

img = [[100, 130, 50],
       [200, 30, 128]]
seuil = 128
for i in range(len(img)):
    for j in range(len(img[0])):
        if img[i][j] < seuil:
            img[i][j] = 0
        else:
            img[i][j] = 255
print(img)

[[0, 255, 0], [255, 0, 255]]

On accumule la somme de tous les pixels et on compte le nombre de pixels avec la double boucle, puis on divise. Le nombre de pixels vaut aussi len(img) * len(img[0]).

# Nom : moyenne_pixels
# Role : calcule la luminosite moyenne d'une image en niveaux de gris
# Entrees : img (matrice d'entiers 0..255)
# Sortie : moyenne (reel)
# Variables locales : total (entier), nb (entier)

img = [[100, 150, 200],
       [ 50,  80, 120],
       [  0, 255, 128]]
total = 0
nb = 0
for i in range(len(img)):
    for j in range(len(img[0])):
        total = total + img[i][j]
        nb = nb + 1
moyenne = total / nb
print("Luminosite moyenne :", moyenne)

Luminosite moyenne : 120.33333333333333

On construit une nouvelle matrice ligne par ligne. Pour chaque pixel, max(0, v - n) soustrait n tout en gardant un plancher de 0 (un pixel à 30 assombri de 60 donnerait -30, écrêté à 0).

# Nom : assombrir
# Role : assombrit une image en niveaux de gris (soustrait n, ecretage a 0)
# Entrees : img (matrice d'entiers 0..255), n (entier)
# Sortie : res (nouvelle matrice assombrie)
# Variables locales : res (matrice), ligne (liste)

img = [[50, 10, 200],
       [30, 90, 255]]
n = 60
res = []
for i in range(len(img)):
    ligne = []
    for j in range(len(img[0])):
        ligne.append(max(0, img[i][j] - n))
    res.append(ligne)
print(res)

[[0, 0, 140], [0, 30, 195]]

On numérote à partir de 0 : s[0]="r", s[1]="e", s[2]="s", s[3]="e", s[4]="a", s[5]="u". L'indice 3 vaut donc "e".

À chaque tour on ajoute le caractère deux fois à la fin de r : après 'a' → "aa", après 'b' → "aabb", après 'c' → "aabbcc". C'est une construction de chaîne par accumulation, chaque caractère étant dupliqué.

s[0] est le premier caractère S. s * 3 répète la chaîne : SIOSIOSIO. len(s) vaut 3, donc len(s) + 1 vaut 4.

S
SIOSIOSIO
4

On teste chaque caractère avec c in voyelles. Dans "Abc123", seule la lettre A figure dans la liste des voyelles (les lettres b, c et les chiffres n'y sont pas). La sortie est donc 1.

inverse part de "". À chaque tour on place le nouveau caractère devant :

• i=0 : c='a', inverse = "a" + "" = "a"
• i=1 : c='b', inverse = "b" + "a" = "ba"
• i=2 : c='c', inverse = "c" + "ba" = "cba"

Résultat final : "cba".

Le symétrique de l'indice i est n - 1 - i : pour i=0 c'est n-1 (dernier caractère), pour i=1 c'est n-2, etc. Dès qu'une paire diffère, on renvoie False ; si la boucle se termine sans écart, le mot est un palindrome.

def est_palindrome(mot):
    n = len(mot)
    for i in range(n):
        if mot[i] != mot[n - 1 - i]:
            return False
    return True

print(est_palindrome("radar"))
print(est_palindrome("python"))
print(est_palindrome("ressasser"))

True
False
True

On place toutes les voyelles acceptées dans une chaîne de référence, puis on parcourt le mot de passe caractère par caractère : chaque caractère présent dans cette référence incrémente le compteur.

# Nom : compter_voyelles
# Role : compte le nombre de voyelles dans un mot de passe
# Entrees : mdp (chaine)
# Sortie : nb (entier)
# Variables locales : voyelles (chaine), nb (entier)

mdp = "Motdepasse2024"
voyelles = "aeiouyAEIOUY"
nb = 0
for c in mdp:
    if c in voyelles:
        nb = nb + 1
print("Nombre de voyelles :", nb)

Nombre de voyelles : 4

Les voyelles de « Motdepasse2024 » sont o, e, a, e — soit 4.

Schéma de comptage classique : un accumulateur entier part de 0 et s'incrémente chaque fois que le caractère courant vaut la cible. On parcourt par élément.

# Nom : compter_caractere
# Role : compte les occurrences d'un caractere dans une chaine
# Entrees : texte (chaine), cible (chaine d'un caractere)
# Sortie : nb (entier)
# Variables locales : nb (entier)

texte = "banane"
cible = "a"
nb = 0
for c in texte:
    if c == cible:
        nb = nb + 1
print(nb)

2

La réponse est 2. L'opérateur % donne le reste de la division entière, pas le quotient. Ici 47 = 5 × 9 + 2, donc 47 // 5 vaut 9 (le quotient) et 47 % 5 vaut 2 (le reste). La réponse 9.4 correspondrait à la division réelle 47 / 5.

La réponse est 11. On additionne les poids des bits à 1, de droite à gauche : 1×2³ + 0×2² + 1×2¹ + 1×2⁰ = 8 + 0 + 2 + 1 = 11. On peut vérifier avec int("1011", 2) qui renvoie 11.

La réponse est False. En binaire, 0.1 et 0.2 n'ont pas de représentation exacte : leur somme donne 0.30000000000000004, légèrement différent de 0.3. C'est pour cela qu'on ne compare jamais deux flottants avec ==, mais via un écart : abs((0.1 + 0.2) - 0.3) < 0.0001.

À chaque tour on affiche n et son reste par 2, avant de diviser. Les quotients successifs sont 22, 11, 5, 2, 1 (puis 0 : la boucle s'arrête). Les restes lus de bas en haut donnent 10110, soit 22 en binaire (16 + 4 + 2).

n = 22 reste = 0
n = 11 reste = 1
n = 5 reste = 1
n = 2 reste = 0
n = 1 reste = 1
resultat : 10110

La condition « i est divisible par 3 » s'écrit i % 3 == 0 : le reste de la division de i par 3 doit être nul. On complète donc par % puis ==. Le programme affiche alors 3, 6, 9, 12, 15, 18.

On parcourt les chiffres de gauche à droite. À chaque chiffre, on multiplie l'accumulateur par 2 (décalage d'un rang) et on ajoute le nouveau chiffre : c'est la méthode de Horner, qui applique directement les poids des puissances de 2.

# Nom : octet_vers_decimal
# Role : convertit un octet binaire (8 bits) saisi au clavier en decimal
# Entrees : octet (chaine de 0 et 1)
# Sortie : affiche la valeur decimale
# Variables locales : valeur (entier), chiffre (chaine)
octet = input("Entrez un octet binaire : ")
valeur = 0
for chiffre in octet:
    valeur = valeur * 2 + int(chiffre)
print("Valeur decimale :", valeur)

Entrez un octet binaire : Valeur decimale : 154

Ici 10011010 vaut 128 + 16 + 8 + 2 = 154. Le prompt de input() apparaît, mais la valeur tapée n'est pas ré-affichée par le programme.

La version fautive se contente d'additionner les chiffres : elle renvoie 1+0+1+1+0 = 3 au lieu de 22. Elle ignore le poids de chaque position. Il faut multiplier l'accumulateur par 2 à chaque tour : valeur = valeur * 2 + int(chiffre). La version corrigée renvoie bien :

binaire = "10110"
valeur = 0
for chiffre in binaire:
    valeur = valeur * 2 + int(chiffre)
print(valeur)
print("verif :", int("10110", 2))

22
verif : 22

La réponse est géométrique de raison 2. L'écart entre les termes n'est pas constant (3, 6, 12, 24…), mais le rapport l'est : 6/3 = 12/6 = 24/12 = 2. On multiplie donc chaque terme par 2 : c'est une suite géométrique de raison q = 2.

La réponse est 34. On applique la formule du terme général u(n) = u(0) + n × r, donc u(6) = 4 + 6 × 5 = 4 + 30 = 34. Attention à ne pas confondre : u(6) est le septième terme (on part de u(0)), pas le sixième.

On affiche u avant de le mettre à jour. Départ : 3. Puis 2×3−1 = 5, 2×5−1 = 9, 2×9−1 = 17, 2×17−1 = 33. La boucle fait 5 tours, donc 5 lignes.

3
5
9
17
33

À chaque tour, le nouveau a prend l'ancien b, et le nouveau b prend l'ancienne somme a + b. Comme la partie droite est calculée d'abord, les deux valeurs de départ du tour servent ensemble. Le déroulé donne (a, b) : (1, 1), puis (1, 2), (2, 3), (3, 5), (5, 8). On retrouve bien la suite 0, 1, 1, 2, 3, 5, 8.

depart : a = 0 b = 1
tour 1 -> a = 1 b = 1
tour 2 -> a = 1 b = 2
tour 3 -> a = 2 b = 3
tour 4 -> a = 3 b = 5
tour 5 -> a = 5 b = 8

L'affectation multiple a, b = b, a + b fait avancer la suite : le nouveau a devient l'ancien b, le nouveau b devient la somme des deux. Après n tours, a contient le n-ième terme. Pour n = 10, la sortie est Fibonacci(10) = 55.

On ne connaît pas d'avance combien d'années seront nécessaires : c'est le cas typique du while. On répète « appliquer le taux, compter une année » tant que le capital courant reste inférieur à l'objectif (le double du capital de départ). Le compteur annee donne la réponse.

# Nom : annees_pour_doubler
# Role : nombre d'annees pour qu'un capital double avec un taux annuel fixe
# Entrees : capital (reel), taux (reel, en pourcentage)
# Sortie : affiche le nombre d'annees
# Variables locales : objectif (reel), courant (reel), annee (entier)
capital = float(input("Capital de depart : "))
taux = float(input("Taux annuel (%) : "))
objectif = 2 * capital
courant = capital
annee = 0
while courant < objectif:
    courant = courant * (1 + taux / 100)
    annee = annee + 1
print("Nombre d'annees :", annee)

Capital de depart : Taux annuel (%) : Nombre d'annees : 15

À 5 % par an, un capital met 15 ans à doubler (1,05¹⁵ ≈ 2,08). Les deux prompts de input() s'affichent l'un après l'autre ; les valeurs tapées, elles, n'apparaissent pas dans la sortie.

L'ordre est inversé : la version fautive calcule d'abord le terme suivant, puis l'ajoute. Elle additionne donc 7 + 12 + 17 + 22 = 58 et oublie le premier terme u(0) = 2. Il faut ajouter u à la somme avant de le faire avancer :

# Version CORRIGEE : somme des termes u(0)..u(3), suite arithmetique u0=2 r=5
u = 2
r = 5
somme = 0
for n in range(4):   # u(0) a u(3)
    somme = somme + u
    u = u + r
print("somme :", somme)

somme : 38

La bonne initialisation est mini = t[0] : une valeur qui appartient vraiment à la liste. Avec mini = 0, une liste de nombres négatifs (températures, soldes…) renverrait 0 à tort. Avec une grande constante comme 1000000, on risque de la dépasser un jour. Partir du premier élément est sûr dans tous les cas.

La réponse est 4. En reprenant la trace du cours, la boucle examine successivement t[5]=23, t[8]=56, t[6]=38, puis t[7]=45 : cible trouvée au 4ᵉ examen. La recherche séquentielle, elle, aurait comparé les 8 premiers éléments avant d'atteindre 45. La dichotomie divise l'intervalle par deux à chaque tour, d'où sa rapidité.

Tour 1 : 84 % 30 = 24, donc (a, b) devient (30, 24). Tour 2 : 30 % 24 = 6 → (24, 6). Tour 3 : 24 % 6 = 0 → (6, 0). b vaut 0 : la boucle s'arrête et a = 6 est le PGCD.

depart : a = 84 b = 30
tour 1 -> a = 30 b = 24
tour 2 -> a = 24 b = 6
tour 3 -> a = 6 b = 0
PGCD = 6

Tour 1 : debut = 0, fin = 8, milieu = (0+8)//2 = 4 → t[4] = 19 < 27, donc la cible est à droite : debut = 5. Tour 2 : debut = 5, fin = 8, milieu = (5+8)//2 = 6 → t[6] = 27 : trouvé, on s'arrête. Deux tours suffisent.

tour 1 : debut = 0 fin = 8 milieu = 4 t[milieu] = 19
tour 2 : debut = 5 fin = 8 milieu = 6 t[milieu] = 27
trouve a l'indice 6

La boucle tourne tant que i * i <= 37, soit pour i = 2, 3, 4, 5, 6 (car 6×6 = 36 ≤ 37, mais 7×7 = 49 > 37) : 5 tours. Aucun de ces i ne divise 37, donc aucune ligne « divisible » n'apparaît. 37 est bien premier.

nombre de tours : 5

On échange quand l'élément de gauche est plus grand que son voisin de droite (t[i] > t[i + 1]). L'échange en Python s'écrit d'une traite t[i], t[i + 1] = t[i + 1], t[i] : les deux valeurs sont permutées simultanément, sans variable temporaire. Le programme affiche [1, 2, 4, 7].

Quand t[milieu] < cible, la cible est à droite : on écarte la moitié gauche en posant debut = milieu + 1. Sinon (t[milieu] > cible), elle est à gauche : fin = milieu - 1. Le +1 et le -1 sont essentiels : ils excluent le milieu déjà testé et garantissent que l'intervalle rétrécit à chaque tour (sinon la boucle tournerait indéfiniment). Ici le programme affiche indice : 4.

On initialise maxi avec le premier élément du relevé (jamais 0 : ici toutes les valeurs sont négatives, 0 fausserait le résultat). On parcourt ensuite la liste et on remplace maxi dès qu'on trouve plus grand.

# Nom : temperature_max
# Role : trouve la plus haute temperature d'un releve
# Entrees : releve (liste de reels non vide)
# Sortie : retourne la temperature maximale
# Variables locales : maxi (reel), t (reel)
def temperature_max(releve):
    maxi = releve[0]        # initialisation au 1er element, jamais a 0
    for t in releve:
        if t > maxi:
            maxi = t
    return maxi

releve = [-3.0, -8.0, -1.0, -5.0]
print("Temperature max :", temperature_max(releve))

Temperature max : -1.0

La plus haute température est −1.0 °C. Si on avait initialisé maxi = 0, la fonction aurait renvoyé 0, une température qui n'a jamais été relevée.

On répète a, b = b, a % b tant que b n'est pas nul. À la sortie de la boucle, a contient le PGCD. L'affectation multiple évite d'avoir à sauvegarder l'ancien b dans une variable temporaire.

# Nom : pgcd
# Role : calcule le PGCD de deux entiers par l'algorithme d'Euclide
# Entrees : a (entier > 0), b (entier > 0)
# Sortie : retourne le PGCD
# Variables locales : (a et b sont modifies au fil des tours)
def pgcd(a, b):
    while b != 0:
        a, b = b, a % b
    return a

print("PGCD(60, 48) =", pgcd(60, 48))
print("PGCD(17, 5) =", pgcd(17, 5))

PGCD(60, 48) = 12
PGCD(17, 5) = 1

PGCD(60, 48) = 12 ; PGCD(17, 5) = 1 (17 et 5 sont premiers entre eux). La récursivité donnerait le même résultat mais n'est pas attendue à l'épreuve.

Sans le +1 ni le -1, quand l'intervalle se réduit à deux cases, milieu retombe toujours sur le même indice : debut (ou fin) ne bouge plus, la condition debut <= fin reste vraie et la boucle ne s'arrête jamais. Il faut exclure le milieu déjà testé : debut = milieu + 1 et fin = milieu - 1. La liste est déjà triée (réponse c inutile), et / 2 donnerait un flottant invalide comme indice (réponse d fausse).

# Version CORRIGEE : bornes qui excluent le milieu deja teste
t = [1, 4, 6, 9, 13, 20, 25]
cible = 20
debut = 0
fin = len(t) - 1
trouve = -1
while debut <= fin:
    milieu = (debut + fin) // 2
    if t[milieu] == cible:
        trouve = milieu
        break
    elif t[milieu] < cible:
        debut = milieu + 1
    else:
        fin = milieu - 1
print("indice :", trouve)

indice : 5