Aller au contenu

Algorithmique et Python Seconde : 12 exercices corrigés

Niveau
Seconde
Type
Exercices corrigés
Exercices
12

Avant d'écrire un programme, il faut savoir prévoir ce qu'il affiche. Les 12 exercices corrigés de Python pour la Seconde partent de là : affectations, tests, boucles for et while, recherche de seuil. Ils passent ensuite aux fonctions à plusieurs arguments, aux simulations d'expériences aléatoires et à la lecture d'une fonction qui calcule une moyenne ou un écart type, après 5 questions flash. Chaque affichage donné dans les corrigés est celui que produit réellement Python 3, avec une graine fixée pour les simulations.

Les exercices 10 à 12 simulent des lancers de pièce ou de dés ; la loi des grands nombres explique pourquoi les fréquences se stabilisent quand le nombre de lancers augmente.

Sommaire6 parties

Questions flash : lire du Python

Python ne figure pas dans la liste officielle des automatismes, mais ces lectures rapides s'entraînent de la même façon : sans ordinateur, une seule bonne réponse par question.

Question 1 : Quotient et reste

Automatisme
L'instruction print(17 // 5, 17 % 5) affiche :
  1. 3 2
  2. 3.4 2
  3. 3 3.4
  4. 2 3
Voir le corrigé
Réponse A : 17=5×3+217=5\times3+2. // donne le quotient entier 3, % le reste 2. Le nombre 3.4 serait 17 / 5.

Question 2 : Valeurs parcourues par range

Automatisme
Dans for k in range(2, 6):, la variable k prend les valeurs :
  1. 2, 3, 4, 5, 6
  2. 2, 3, 4, 5
  3. 3, 4, 5
  4. 2 et 6
Voir le corrigé
Réponse B : la première borne est incluse, la seconde exclue. La boucle fait 6−2=46-2=4 tours.

Question 3 : Type d’un quotient

Automatisme
La valeur de 10 / 2 est de type :
  1. int
  2. float
  3. bool
  4. str
Voir le corrigé
Réponse B : l'opérateur / renvoie toujours un flottant, ici 5.0, même quand la division tombe juste.

Question 4 : Suite d’affectations

Automatisme
Après x = 5, puis x = x * 2, puis x = x - 3, la variable x vaut :
  1. 77
  2. 55
  3. 1010
  4. 22
Voir le corrigé
Réponse A : xx devient 5×2=105\times2=10, puis 10−3=710-3=7. Chaque affectation utilise la valeur courante de x.

Question 5 : Valeurs de randint

Automatisme
randint(1, 4) peut renvoyer :
  1. 1, 2 ou 3
  2. 0, 1, 2, 3 ou 4
  3. 1, 2, 3 ou 4
  4. n'importe quel réel entre 1 et 4
Voir le corrigé
Réponse C : randint renvoie un entier, et ses deux bornes sont incluses, contrairement à range.

Niveau 1 : variables, types et affectations

Exercice 1 : Suivre des affectations

Facile
x = 4
y = x * 3
x = y - x
y = y // x
print(x, y)
  1. Dresser le tableau de suivi des variables et donner l'affichage.
  2. Que devient l'affichage si la première ligne est x = 4.0 ?
Voir le corrigé
  1. Instructionxy
    x = 44
    y = x * 3412
    x = y - x812
    y = y // x81
    Au dernier calcul, x vaut déjà 8 : 1212 divisé par 88 donne le quotient entier 1. Affichage :
    8 1
  2. Les calculs sont les mêmes, mais un flottant contamine tous les résultats qui en dépendent :
    x = 4.0
    y = x * 3
    x = y - x
    y = y // x
    print(x, y)
    8.0 1.0

Exercice 2 : Une puissance mal écrite

Facile
Pour calculer f(x)=3x2−2x+1f(x)=3x^2-2x+1, un élève écrit :
def f(x):
    return 3*x^2 - 2*x + 1

print(f(2))
Le programme affiche -7.
  1. Calculer f(2)f(2) à la main. Le résultat affiché est-il plausible ?
  2. Corriger la fonction, puis donner les affichages de f(2) et f(-1).
  3. Pourquoi Python n'a-t-il signalé aucune erreur ?
Voir le corrigé
  1. f(2)=3×4−4+1=9f(2)=3\times4-4+1=9. Le programme affiche −7-7 : il est faux.
  2. La puissance s'écrit ** :
    def f(x):
        return 3*x**2 - 2*x + 1
    
    print(f(2), f(-1))
    9 6
    Contrôle : f(−1)=3+2+1=6f(-1)=3+2+1=6.
  3. ^ est un opérateur qui existe en Python (le « ou exclusif » sur les écritures binaires), et il est moins prioritaire que + et -. La ligne a été lue comme (3*x) ^ (2 - 2*x + 1), soit 6 ^ (-1), qui vaut -7. Le programme est syntaxiquement correct, mais il ne calcule pas ce qu'on veut : seul un calcul de contrôle à la main révèle l'erreur.

Exercice 3 : Opérations, booléens et divisibilité

Facile
On pose a = 23 et b = 4. Prévoir la valeur et le type de chaque expression : a // b, a % b, a / b, a > 3*b, a % 2 == 0, a == b*(a//b) + a%b.
Voir le corrigé
a = 23
b = 4
print(a // b, a % b, a / b, a > 3*b, a % 2 == 0, a == b*(a//b) + a%b)
5 3 5.75 True False True
  • a // b vaut 5 et a % b vaut 3 (entiers), car 23=4×5+323=4\times5+3.
  • a / b vaut 5.75 (flottant).
  • a > 3*b compare 23 et 12 : True (booléen).
  • a % 2 == 0 teste si 23 est pair : False.
  • La dernière expression traduit la division euclidienne a=bq+ra=bq+r : elle vaut True pour tous entiers aa et b>0b\gt0.

Niveau 2 : conditions et boucles

Exercice 4 : Frais de livraison

Moyen
Un site facture la livraison 4,90 €, mais elle est gratuite dès 50 € d'achat. L'option express ajoute 2 € dans tous les cas.
  1. Écrire une fonction livraison(montant, express), où express est un booléen, qui renvoie les frais.
  2. Donner les valeurs renvoyées pour (35, False), (60, True), (50, False) et (49.99, True).
  3. Que changerait l'écriture if montant > 50: ? Quel cas de la question 2 permet de le voir ?
Voir le corrigé
  1. Deux tests successifs et indépendants : le seuil, puis l'option.
    def livraison(montant, express):
        if montant >= 50:
            frais = 0
        else:
            frais = 4.9
        if express:
            frais = frais + 2
        return frais
    
    print(livraison(35, False), livraison(60, True), livraison(50, False), livraison(49.99, True))
  2. 4.9 2 0 6.9
    Un booléen peut servir directement de condition : if express: équivaut à if express == True:.
  3. Avec >, un achat d'exactement 50 € paierait 4,90 € alors que l'énoncé dit « dès 50 € ». Le cas livraison(50, False) renverrait 4.9 au lieu de 0. Il faut toujours tester la valeur frontière.

Exercice 5 : Somme des nombres impairs

Facile
On admet que range(a, b, p) parcourt les entiers de a à b exclu, avec un pas p : par exemple range(1, 10, 2) donne 1, 3, 5, 7, 9.
  1. Écrire un programme qui calcule S=1+3+5+⋯+99S=1+3+5+\dots+99 et donner le résultat.
  2. Combien de termes comporte cette somme ? Comparer SS avec le carré de ce nombre.
  3. Modifier le programme pour calculer 2+4+⋯+1002+4+\dots+100.
Voir le corrigé
  1. Un accumulateur initialisé à 0 :
    s = 0
    for k in range(1, 100, 2):
        s = s + k
    print(s)
    2500
    La borne 100 est exclue, mais 99 est bien atteint ; range(1, 101, 2) donnerait le même résultat.
  2. Les impairs de 1 à 99 sont les 2k−12k-1 pour kk de 1 à 50 : il y a 50 termes, et 502=2500=S50^2=2500=S. On peut le vérifier sur de petits cas : 1+3=4=221+3=4=2^2, 1+3+5=9=321+3+5=9=3^2.
  3. On change seulement la boucle :
    s = 0
    for k in range(2, 101, 2):
        s = s + k
    print(s)
    2550
    Ici la borne doit être 101 pour inclure 100. Contrôle : chaque pair dépasse l'impair qui le précède de 1, donc la somme vaut 2500+50=25502500+50=2550.

Exercice 6 : Chercher un seuil avec while

Moyen
Une colonie compte 120 abeilles. Chaque semaine, son effectif augmente de 8 % et 5 abeilles s'y ajoutent : on remplace uu par 1,08u+51{,}08u+5. On cherche après combien de semaines l'effectif dépasse 250.
  1. Compléter le programme en remplaçant les pointillés, puis donner son affichage.
    u = 120
    n = 0
    while ...:
        u = ...
        n = n + 1
    print(n, round(u, 2))
  2. Vérifier le résultat avec les valeurs successives de uu, arrondies au centième.
  3. Un élève écrit while u > 250:. Qu'affiche son programme, et pourquoi ?
Voir le corrigé
  1. La condition est celle qui permet de continuer : tant que l'effectif ne dépasse pas 250.
    u = 120
    n = 0
    while u <= 250:
        u = 1.08 * u + 5
        n = n + 1
    print(n, round(u, 2))
    7 250.27
  2. Valeurs successives : 120 ; 134,6 ; 150,37 ; 167,4 ; 185,79 ; 205,65 ; 227,1 ; 250,27. La septième valeur est la première au-dessus de 250 : l'effectif dépasse 250 au bout de 7 semaines.
  3. Au départ, u=120u=120, donc u > 250 est faux : la boucle ne s'exécute pas du tout et le programme affiche 0 120. L'élève a écrit la condition d'arrêt au lieu de la condition pour continuer.

Exercice 7 : Une boucle qui ne s’arrête pas

Moyen
On cherche le plus petit entier nn tel que 2n>10002^n\gt1000. Le programme suivant ne s'arrête jamais.
n = 0
p = 1
while p <= 1000:
    n = n + 1
print(n)
  1. Expliquer pourquoi la boucle est infinie.
  2. Corriger le programme et donner son affichage.
  3. Remplacer <= par < change-t-il le résultat ici ?
  4. On cherche maintenant le plus petit nn tel que 2n>10242^n\gt1024. Comparer les résultats avec <= et avec <, et dire lequel est correct.
Voir le corrigé
  1. La condition porte sur p, qui vaut toujours 1 : rien ne la modifie dans la boucle. La condition reste vraie indéfiniment.
  2. On double p à chaque tour, de sorte que p vaut 2n2^n :
    n = 0
    p = 1
    while p <= 1000:
        p = 2 * p
        n = n + 1
    print(n)
    10
    Contrôle : 29=512≤10002^9=512\le1000 et 210=1024>10002^{10}=1024\gt1000.
  3. Non : les deux conditions ne diffèrent que si p vaut exactement 1000, ce qui n'arrive jamais, 1000 n'étant pas une puissance de 2.
  4. Avec le seuil 1024, while p <= 1024: donne 11, et while p < 1024: donne 10. On veut 2n>10242^n\gt1024 : or 210=10242^{10}=1024 n'est pas strictement supérieur à 1024. La bonne réponse est 11, obtenue avec <=, qui est exactement la négation de la condition d'arrêt p>1024p\gt1024.

Niveau 3 : fonctions, simulations et statistiques

Exercice 8 : Approcher un minimum par balayage

Moyen
On considère f(x)=x2−3x+1f(x)=x^2-3x+1 sur [0 ;3][0\,;3] et le programme suivant.
def f(x):
    return x**2 - 3*x + 1

def minimum_approche(a, b, n):
    pas = (b - a) / n
    xmin = a
    for k in range(n + 1):
        x = a + k * pas
        if f(x) < f(xmin):
            xmin = x
    return xmin
  1. Quelles valeurs de xx sont testées par minimum_approche(0, 3, 30) ? Que contient xmin à la fin ?
  2. Donner l'affichage de print(round(minimum_approche(0, 3, 30), 2), round(f(minimum_approche(0, 3, 30)), 2)).
  3. Démontrer que le minimum de ff sur R\mathbb R vaut bien −1,25-1{,}25.
Voir le corrigé
  1. Le pas vaut 3−030=0,1\frac{3-0}{30}=0{,}1 ; les valeurs testées sont 00, 0,10{,}1, 0,20{,}2, …, 33 (31 valeurs, d'où range(n + 1)). À chaque tour, si f(x)f(x) est plus petit que la plus petite valeur trouvée jusque-là, xmin est remplacé par xx : à la fin, xmin est l'abscisse testée où ff est minimale.
  2. print(round(minimum_approche(0, 3, 30), 2), round(f(minimum_approche(0, 3, 30)), 2))
    1.5 -1.25
  3. On fait apparaître un carré : x2−3x+1=(x−32)2−94+1=(x−1,5)2−1,25x^2-3x+1=\left(x-\frac32\right)^2-\frac94+1=\left(x-1{,}5\right)^2-1{,}25. Un carré est positif ou nul, donc f(x)≥−1,25f(x)\ge-1{,}25, avec égalité seulement pour x=1,5x=1{,}5. Le balayage tombe ici sur la valeur exacte parce que 1,51{,}5 est un multiple du pas ; en général, il ne donne qu'une valeur approchée.

Exercice 9 : Le plus grand multiple inférieur à un nombre

Moyen
Soit aa un entier strictement positif et bb un entier positif. On cherche le plus grand multiple de aa inférieur ou égal à bb.
  1. Écrire une fonction plus_grand_multiple(a, b) qui part de 0 et ajoute aa tant que c'est possible.
  2. Donner les résultats pour (7, 100), (7, 5) et (6, 42).
  3. Justifier que b - b % a donne le même résultat, sans boucle.
Voir le corrigé
  1. On ajoute aa tant que le multiple suivant ne dépasse pas bb :
    def plus_grand_multiple(a, b):
        m = 0
        while m + a <= b:
            m = m + a
        return m
    
    print(plus_grand_multiple(7, 100), plus_grand_multiple(7, 5), plus_grand_multiple(6, 42))
  2. 98 0 42
    98=7×1498=7\times14 et 7×15=105>1007\times15=105\gt100. Pour (7,5)(7,5), aucun multiple non nul ne convient : la boucle ne tourne pas et 0 est renvoyé. Pour (6,42)(6,42), 42 est lui-même multiple de 6 : la condition large <= permet de l'atteindre.
  3. Par division euclidienne, b=aq+rb=aq+r avec 0≤r<a0\le r\lt a, et b % a vaut rr. Donc b - b % a vaut aqaq, un multiple de aa inférieur ou égal à bb, et le multiple suivant a(q+1)=b−r+aa(q+1)=b-r+a dépasse bb puisque a>ra\gt r. Pour (7,100)(7,100) : 100−2=98100-2=98.

Exercice 10 : Simuler des lancers de pièce

Moyen
from random import randint, seed

def lancer_piece():
    return randint(0, 1)

def nb_piles(n):
    nb = 0
    for i in range(n):
        nb = nb + lancer_piece()
    return nb

seed(7)
for n in [10, 1000, 100000]:
    p = nb_piles(n)
    print(n, p, p / n)
Affichage obtenu :
10 3 0.3
1000 489 0.489
100000 49864 0.49864
  1. Que renvoie lancer_piece() ? Expliquer pourquoi nb_piles(n) compte le nombre de piles, si l'on code pile par 1.
  2. Quelles valeurs nb_piles(10) peut-il renvoyer ?
  3. Interpréter la troisième colonne de l'affichage.
Voir le corrigé
  1. lancer_piece() renvoie 0 ou 1, chacun avec la probabilité 12\frac12. Ajouter le résultat à nb l'augmente de 1 pour un pile et ne le change pas pour un face : après nn tours, nb est le nombre de piles.
  2. Tout entier de 0 à 10. Les valeurs extrêmes sont possibles mais rares : 0 n'arrive qu'avec dix faces de suite.
  3. C'est la fréquence des piles. Sur 10 lancers, elle vaut 0,3, loin de 0,5 ; sur 100 000 lancers, elle vaut 0,498640{,}49864, très proche de 12\frac12. C'est la loi des grands nombres : plus on répète l'expérience, plus la fréquence a tendance à se rapprocher de la probabilité. Avec une autre graine, les valeurs changeraient, pas cette tendance.

Exercice 11 : Somme de deux dés, un modèle à ne pas raccourcir

Difficile
On lance deux dés équilibrés et on s'intéresse à l'événement « la somme vaut 7 ».
  1. Écrire une fonction somme_deux_des() qui renvoie la somme de deux dés, puis une fonction frequence_sept(n) qui renvoie la fréquence des sommes égales à 7 sur nn lancers.
  2. Calculer la probabilité d'obtenir 7 à l'aide d'un tableau des 36 issues équiprobables.
  3. Un élève remplace somme_deux_des() par randint(2, 12), « puisque la somme est entre 2 et 12 ». Avec la graine 3 et 10 000 lancers, sa fréquence vaut 0.0993, contre 0.1678 avec la bonne fonction. Expliquer l'erreur.
Indication
Combien d'issues donnent une somme de 2 ? Et une somme de 7 ?
Voir le corrigé
  1. Une fonction pour une expérience, une autre pour la répétition :
    from random import randint, seed
    
    def somme_deux_des():
        return randint(1, 6) + randint(1, 6)
    
    def frequence_sept(n):
        nb = 0
        for i in range(n):
            if somme_deux_des() == 7:
                nb = nb + 1
        return nb / n
    
    seed(3)
    print(frequence_sept(10000))
    0.1678
  2. Les 36 couples (dé 1, dé 2) sont équiprobables. La somme vaut 7 pour (1,6)(1,6), (2,5)(2,5), (3,4)(3,4), (4,3)(4,3), (5,2)(5,2), (6,1)(6,1) : 6 issues. Donc P(somme=7)=636=16≈0,167P(\text{somme}=7)=\frac{6}{36}=\frac16\approx0{,}167, proche de la fréquence simulée.
  3. randint(2, 12) rend les 11 sommes équiprobables, chacune de probabilité 111≈0,091\frac1{11}\approx0{,}091 : c'est ce que reflète la fréquence 0,09930{,}0993. Or les sommes ne sont pas équiprobables : 2 ne s'obtient que par (1,1)(1,1), soit 136\frac1{36}, alors que 7 s'obtient de six façons. Le programme simule une autre expérience que celle de l'énoncé. Pour simuler, on reproduit le mécanisme réel (deux dés), pas seulement l'ensemble des résultats possibles.

Exercice 12 : Lire une fonction qui renvoie une moyenne et un écart type

Difficile
On admet une seconde formule de l'écart type : c'est la racine carrée de la différence entre la moyenne des carrés des valeurs et le carré de la moyenne. On considère :
from random import randint, seed
from math import sqrt

def stats_des(n):
    s = 0
    s2 = 0
    for i in range(n):
        x = randint(1, 6)
        s = s + x
        s2 = s2 + x**2
    m = s / n
    return round(m, 3), round(sqrt(s2 / n - m**2), 3)

seed(10)
print(stats_des(100000))
Affichage obtenu :
(3.494, 1.704)
  1. Que contiennent s et s2 à la fin de la boucle ?
  2. Expliquer pourquoi la fonction renvoie la moyenne et l'écart type des nn résultats.
  3. On remplace x = randint(1, 6) par x = 4. Que renvoie stats_des(10) ? Est-ce cohérent ?
  4. Interpréter l'affichage obtenu.
Voir le corrigé
  1. s est la somme des nn résultats, s2 la somme de leurs carrés : à chaque tour, le résultat xx est ajouté à s et x2x^2 à s2.
  2. m = s / n est la moyenne des résultats. s2 / n est la moyenne des carrés, donc sqrt(s2 / n - m**2) est l'écart type, d'après la formule admise. Les résultats ne sont jamais stockés : deux accumulateurs suffisent.
  3. Tous les résultats valent 4 : s=40s=40, s2=160s_2=160, m=4m=4 et 16−16=0\sqrt{16-16}=0.
    from math import sqrt
    
    def stats_constante(n):
        s = 0
        s2 = 0
        for i in range(n):
            x = 4
            s = s + x
            s2 = s2 + x**2
        m = s / n
        return round(m, 3), round(sqrt(s2 / n - m**2), 3)
    
    print(stats_constante(10))
    (4.0, 0.0)
    C'est cohérent : une série constante a pour moyenne cette constante et ne présente aucune dispersion. Tester un programme sur un cas dont on connaît la réponse est un bon moyen de le valider.
  4. Sur 100 000 lancers, la moyenne est 3,4943{,}494, proche de 3,53{,}5, moyenne des six faces ; l'écart type 1,7041{,}704 mesure la dispersion des résultats autour de cette moyenne. Avec un très grand nombre de lancers, il se stabilise lui aussi, vers environ 1,711{,}71.

Problème de synthèse : un plan d’épargne

Problème : combien d’années pour atteindre 5 000 euros ?

Type bac
Inès place 2 000 € sur un livret rémunéré à 3 % par an. À la fin de chaque année, après le versement des intérêts, elle ajoute 100 €. On note CnC_n le capital au bout de nn années, avec C0=2000C_0=2000.
  1. Calculer C1C_1 et C2C_2. Justifier que l'on passe de CnC_n à Cn+1C_{n+1} en multipliant par 1,031{,}03 puis en ajoutant 100.
  2. Écrire une fonction capital(n), avec une boucle for, qui renvoie CnC_n arrondi au centième. Vérifier avec la question 1.
  3. Écrire une fonction annees(objectif, taux), avec une boucle while, qui renvoie le nombre d'années nécessaires pour que le capital atteigne au moins objectif, le taux étant donné en pourcentage.
  4. Que renvoient annees(5000, 3) et annees(5000, 4) ? Vérifier le premier résultat avec capital.
  5. Sans la boucle, expliquer pourquoi Cn≥2000×1,03nC_n\ge2000\times1{,}03^n pour tout nn.
Indication
Augmenter de tt % revient à multiplier par 1+t1001+\frac{t}{100}.
Voir le corrigé
  1. Les intérêts d'une année valent 3 % du capital : Cn+0,03 Cn=1,03 CnC_n+0{,}03\,C_n=1{,}03\,C_n, puis on ajoute 100. C1=1,03×2000+100=2160C_1=1{,}03\times2000+100=2160 et C2=1,03×2160+100=2224,8+100=2324,8C_2=1{,}03\times2160+100=2224{,}8+100=2324{,}8.
  2. def capital(n):
        c = 2000
        for k in range(n):
            c = 1.03 * c + 100
        return round(c, 2)
    
    print(capital(1), capital(2))
    2160.0 2324.8
  3. Le nombre d'années est inconnu d'avance, d'où la boucle while ; on continue tant que l'objectif n'est pas atteint.
    def annees(objectif, taux):
        c = 2000
        n = 0
        while c < objectif:
            c = c * (1 + taux / 100) + 100
            n = n + 1
        return n
    
    print(annees(5000, 3), annees(5000, 4))
  4. 16 14
    À 3 %, il faut 16 ans ; à 4 %, 14 ans. Vérification :
    print(capital(15), capital(16))
    4975.83 5225.1
    Le capital est encore sous 5 000 € après 15 ans et le dépasse après 16 ans : 16 est bien le premier rang qui convient.
  5. Sans les versements, le capital serait multiplié par 1,031{,}03 chaque année et vaudrait 2000×1,03n2000\times1{,}03^n. Les versements de 100 € ne font qu'ajouter des sommes positives, qui rapportent elles-mêmes des intérêts : le capital réel est donc au moins égal à 2000×1,03n2000\times1{,}03^n. On contrôle pour n=1n=1 : 2160≥20602160\ge2060.

Pages liées