Exercices corrigés — Algorithmique Et Programmation (2nde)

Cette page propose des exercices corrigés de mathématiques en 2nde sur Algorithmique Et Programmation. Tu vas t’entraîner sur variables, conditions, boucles, raisonnement algorithmique avec des questions progressives et des corrections pour vérifier chaque étape.
Cours Fiches Exercices Quiz 2nde Chapitres 👁️ Prévisualiser (PDF) ⬇️ Télécharger

✏️ Exercices - Algorithmique & programmation (Python)

2nde

Thèmes : variables • affectations • conditions • boucles for/while • fonctions • calcul numérique • géométrie algorithmique • simulation et probabilités.
Objectif : interpréter, compléter, corriger et écrire des algorithmes Python solides, puis relier le calcul numérique aux notions mathématiques de 2nde.

Exercice 1 - Variables, types, conversions - pièges de input()
Ex. 1/30

On exécute ce script :

age = input("Âge ? ")
x = input("Nombre réel ? ")
print(age + 1)
print(x * 2)
  1. Expliquer précisément l’erreur provoquée par print(age + 1).
  2. Si l’utilisateur saisit 3.5 pour x, indiquer exactement ce qu’affiche print(x * 2).
  3. Corriger le script pour afficher l’âge augmenté de 1 et le double de \(x\) comme des nombres.
  4. Donner une entrée pour laquelle int(...) échoue et expliquer pourquoi.
Exercice 2 - Affectation, priorités, // et % - lecture de trace
Ex. 2/30

On pose a = 17 et b = 5.

  1. Calculer a + b * 2 puis (a + b) * 2.
  2. Calculer a / b, a // b et a % b, puis relier les deux derniers résultats à la division euclidienne.
  3. Faire la trace de a = a + b; b = a - b; a = a - b et donner les valeurs finales.
  4. Expliquer ce que réalise a, b = b, a et pourquoi cette écriture est préférable en Python.
Exercice 3 - Tests - intervalles et logique booléenne
Ex. 3/30

Écrire des conditions Python correspondant exactement aux ensembles indiqués.

  1. Tester si \(x\in[-2\,;\,5[\).
  2. Tester si \(x\notin[0\,;\,1]\).
  3. Tester si \(x\in]-\infty\,;\,-3]\cup[2\,;\,+\infty[\).
  4. Tester si \(x\in[1\,;\,4]\) et \(x\ne3\).
Exercice 4 - Logique - lois de De Morgan
Ex. 4/30

On considère la condition :

not((x >= 0 and x <= 1) or (x == 3))
  1. Réécrire la condition sans not, uniquement avec and, or, comparaisons et !=.
  2. Décrire l’ensemble des réels qui valident cette condition.
  3. Tester mentalement la condition pour \(x=0{,}5\), \(x=2\), \(x=3\) et \(x=-1\).
  4. Écrire une version lisible utilisant deux variables booléennes intermédiaires.
Exercice 5 - Boucle while - seuil et arrêt garanti
Ex. 5/30

On définit \(u_0=1\) et \(u_{n+1}=1{,}15u_n+2\).

  1. Écrire un programme qui calcule le plus petit entier \(n\) tel que \(u_n\ge100\).
  2. Calculer \(u_0,u_1,u_2,u_3\).
  3. Justifier rigoureusement, à un niveau de 2nde, que la boucle finit.
  4. Donner le couple \((n,u_n)\) obtenu à l’arrêt, avec \(u_n\) arrondi au millième.
Exercice 6 - Boucle for - somme de carrés et vérification
Ex. 6/30

On veut calculer \(S=1^2+2^2+\cdots+n^2\).

  1. Écrire un programme utilisant for qui calcule \(S\) pour un entier naturel \(n\).
  2. Calculer \(S\) à la main pour \(n=5\).
  3. Vérifier pour \(n=5\) la formule \(S=\dfrac{n(n+1)(2n+1)}{6}\).
  4. Écrire un programme qui vérifie automatiquement cette formule pour tous les entiers de 1 à 50.
Exercice 7 - Division euclidienne - convertir une durée
Ex. 7/30

On dispose d’une durée entière t = 9876 secondes. On veut l’écrire sous la forme heures, minutes, secondes.

  1. Calculer le nombre entier d’heures complètes.
  2. Calculer le nombre de minutes complètes restant après retrait des heures.
  3. Calculer le nombre de secondes restantes et donner la décomposition de 9876 s.
  4. Écrire une fonction decompose(t) qui renvoie les trois valeurs, en refusant une durée négative.
Exercice 8 - Fonction par morceaux - tarif progressif
Ex. 8/30

Un service facture une consommation \(x\ge0\) selon le tarif suivant : \(2\) € par unité jusqu’à 10 unités ; puis \(1{,}5\) € par unité supplémentaire jusqu’à 25 ; puis \(1{,}2\) € par unité supplémentaire au-delà.

  1. Écrire une fonction Python prix(x) qui renvoie None si \(x<0\).
  2. Calculer prix(8) et prix(18).
  3. Calculer prix(30) en justifiant la continuité des paliers.
  4. Expliquer pourquoi, dans un bloc if/elif/else, il suffit de tester x <= 10, puis x <= 25.
Exercice 9 - Fonction à plusieurs arguments - distance dans le plan
Ex. 9/30

On rappelle que la distance entre \(A(x_A,y_A)\) et \(B(x_B,y_B)\) vaut \(AB=\sqrt{(x_B-x_A)^2+(y_B-y_A)^2}\).

  1. Écrire une fonction distance(xA, yA, xB, yB) utilisant math.sqrt.
  2. Calculer exactement la distance entre \(A(-2;3)\) et \(B(4;-5)\).
  3. Vérifier que la fonction renvoie 10 pour ces coordonnées.
  4. Expliquer pourquoi la distance ne change pas si l’on échange A et B.
Exercice 10 - Algorithme d’Euclide - PGCD et invariant
Ex. 10/30

On veut calculer le PGCD de deux entiers positifs avec l’algorithme d’Euclide.

def pgcd(a, b):
    while b != 0:
        r = a % b
        a = b
        b = r
    return a
  1. Faire la trace pour a=9999 et b=3663.
  2. Donner le PGCD obtenu.
  3. Expliquer pourquoi remplacer \((a,b)\) par \((b,a\%b)\) conserve les diviseurs communs.
  4. Adapter la fonction pour accepter des entrées négatives.
Exercice 11 - Simulation - pièce équilibrée puis biaisée
Ex. 11/30

On simule des lancers indépendants d’une pièce et on estime la fréquence de Pile.

  1. Écrire une fonction freq_pile(N) pour une pièce équilibrée.
  2. Expliquer pourquoi le résultat n’est généralement pas exactement \(0{,}5\).
  3. Modifier la fonction pour une pièce donnant Pile avec probabilité \(p=0{,}62\).
  4. Ajouter une protection pour N <= 0 et expliquer l’effet d’un grand N.
Exercice 12 - Simulation - au moins un 6 en quatre lancers
Ex. 12/30

On lance un dé équilibré quatre fois et on s’intéresse à l’événement « obtenir au moins un 6 ».

  1. Écrire une simulation de N expériences qui estime cette probabilité.
  2. Calculer la probabilité théorique exacte avec l’événement contraire.
  3. Donner une valeur décimale approchée au dix-millième.
  4. Expliquer ce que l’on doit observer pour un grand nombre d’expériences, par exemple N=50000.
Exercice 13 - Boucles imbriquées - compter exactement les passages
Ex. 13/30

On considère le programme :

c = 0
for i in range(n):
    for j in range(i, n):
        c += 1
  1. Pour \(n=4\), lister les couples \((i,j)\) parcourus.
  2. Exprimer le nombre final c en fonction de \(n\).
  3. Calculer c pour \(n=10\).
  4. Comparer approximativement le nombre de passages quand on remplace \(n\) par \(2n\).
Exercice 14 - Calcul itératif - terme d’une suite et somme partielle
Ex. 14/30

On définit \(u_0=2\) et \(u_{n+1}=2u_n+1\).

  1. Écrire une fonction terme(n) qui calcule \(u_n\).
  2. Calculer \(u_1,u_2,u_3\).
  3. Écrire une fonction qui calcule \(S_n=u_0+u_1+\cdots+u_n\), puis donner \(S_3\).
  4. Conjecturer une expression de \(u_n\) et la vérifier en la remplaçant dans la relation de récurrence.
Exercice 15 - Boucle while - premier entier dépassant un seuil
Ex. 15/30

On cherche le plus petit entier \(n\) tel que \(1+2+\cdots+n\ge1000\).

  1. Écrire un programme while qui calcule ce plus petit n.
  2. Expliquer pourquoi la boucle s’arrête.
  3. Utiliser \(1+2+\cdots+n=\dfrac{n(n+1)}2\) pour prévoir la valeur de n.
  4. Vérifier la minimalité en comparant les sommes aux rangs \(n-1\) et \(n\).
Exercice 16 - Débogage - erreur de borne dans range
Ex. 16/30

Le but de la fonction suivante est de calculer \(1+2+\cdots+n\), mais elle est fausse :

def somme(n):
    S = 0
    for k in range(n):
        S = S + k
    return S
  1. Tester mentalement la fonction pour \(n=1,2,3\).
  2. Identifier précisément l’erreur.
  3. Donner deux corrections différentes de la boucle.
  4. Ajouter une validation qui renvoie 0 si \(n<1\).
Exercice 17 - Multiples et diviseurs - fonctions booléennes
Ex. 17/30

On travaille avec des entiers. L’opérateur % permet de tester une divisibilité.

  1. Écrire est_multiple(a, b) qui indique si a est un multiple de b, en refusant b=0.
  2. Utiliser la fonction pour décider si 357 est un multiple de 7.
  3. Écrire une fonction qui renvoie le plus grand multiple positif de a inférieur ou égal à b, avec \(a>0\) et \(b\ge0\).
  4. Déterminer le plus grand multiple de 7 inférieur ou égal à 100 et expliquer le calcul.
Exercice 18 - Nombres premiers - test par divisions successives
Ex. 18/30

Un entier \(n\ge2\) est premier s’il n’a pas de diviseur autre que 1 et lui-même.

  1. Écrire une fonction est_premier(n) utilisant une boucle while.
  2. Expliquer pourquoi il suffit de tester jusqu’à ce que \(d^2>n\).
  3. Tester mentalement 1, 2, 9, 17 et 221.
  4. Optimiser le programme en traitant 2 séparément puis en ne testant que les diviseurs impairs.
Exercice 19 - Statistiques - lire une fonction à cinq valeurs
Ex. 19/30

On considère cinq valeurs réelles \(x_1,\ldots,x_5\). On veut calculer leur moyenne, leur variance de population et leur écart-type sans utiliser de liste.

from math import sqrt

def stats5(a, b, c, d, e):
    m = (a+b+c+d+e)/5
    V = ((a-m)**2 + (b-m)**2 + (c-m)**2
         + (d-m)**2 + (e-m)**2)/5
    return m, V, sqrt(V)
  1. Expliquer ce que représentent les trois valeurs renvoyées.
  2. Calculer la moyenne pour \((2,4,4,4,6)\).
  3. Calculer exactement la variance pour ces cinq valeurs.
  4. Donner l’écart-type approché au millième et interpréter son rôle.
Exercice 20 - Flottants - comparaison à une précision donnée
Ex. 20/30

On exécute :

S = 0.0
for k in range(10):
    S += 0.1
print(S)
  1. Donner le résultat attendu en mathématiques exactes.
  2. Expliquer pourquoi Python peut afficher une valeur comme 0.9999999999999999.
  3. Écrire un test robuste pour vérifier que S est égal à 1 à \(10^{-9}\) près.
  4. Proposer une méthode évitant l’accumulation d’erreurs pour ce calcul particulier.
Exercice 21 - Balayage - encadrer $\sqrt{2}$ au millième
Ex. 21/30

On veut encadrer \(\sqrt2\) au millième sans utiliser sqrt. On cherche un entier n tel que \((n/1000)^2\le2<((n+1)/1000)^2\).

  1. Écrire une boucle while qui détermine n avec uniquement des calculs entiers.
  2. Donner la valeur de n obtenue.
  3. En déduire un encadrement de \(\sqrt2\) au millième.
  4. Expliquer pourquoi tester n*n <= 2000000 évite les flottants pendant la recherche.
Exercice 22 - Boucle while - méthode de Babylone pour $\sqrt a$
Ex. 22/30

Pour \(a>0\), on définit \(x_0=a\) et \(x_{n+1}=\dfrac12\left(x_n+\dfrac{a}{x_n}\right)\).

  1. Écrire une fonction qui s’arrête quand deux approximations successives diffèrent de moins de \(10^{-6}\).
  2. Calculer \(x_1\) et \(x_2\) pour \(a=2\) à quatre décimales.
  3. Expliquer le rôle du seuil eps.
  4. Ajouter les validations nécessaires pour a <= 0 ou eps <= 0.
Exercice 23 - Dichotomie - approximer $\sqrt2$
Ex. 23/30

On sait que \(1<\sqrt2<2\). On coupe répétitivement l’intervalle en deux et on conserve la moitié contenant \(\sqrt2\).

  1. Écrire une fonction racine2_dicho(eps) qui renvoie le milieu d’un intervalle de largeur inférieure à eps.
  2. Donner les trois premiers intervalles obtenus à partir de [1,2].
  3. Expliquer pourquoi le test m*m < 2 permet de choisir la bonne moitié.
  4. Indiquer la valeur approchée obtenue pour eps=1e-6.
Exercice 24 - Premier rang - puissance dépassant 2
Ex. 24/30

Un capital est multiplié chaque année par \(1{,}07\). On cherche le plus petit entier n tel que \(1{,}07^n>2\).

  1. Écrire une boucle while qui calcule ce plus petit n sans utiliser de logarithme.
  2. Donner la valeur de n.
  3. Vérifier numériquement la minimalité avec les puissances aux rangs n-1 et n.
  4. Adapter le programme en une fonction premier_rang(q, seuil) avec validations.
Exercice 25 - Simulation - somme de deux dés au moins égale à 10
Ex. 25/30

On lance deux dés équilibrés et indépendants. On note S la somme des deux résultats.

  1. Écrire une simulation de N expériences estimant \(P(S\ge10)\).
  2. Déterminer exactement les couples donnant une somme au moins égale à 10.
  3. Calculer la probabilité théorique exacte.
  4. Expliquer comment utiliser la théorie pour contrôler la cohérence d’une simulation.
Exercice 26 - Géométrie algorithmique - tester l’alignement de trois points
Ex. 26/30

Pour \(A(x_A,y_A)\), \(B(x_B,y_B)\) et \(C(x_C,y_C)\), on peut tester l’alignement avec le déterminant \(D=(x_B-x_A)(y_C-y_A)-(y_B-y_A)(x_C-x_A)\).

  1. Écrire une fonction alignes(xA,yA,xB,yB,xC,yC) qui renvoie un booléen.
  2. Tester \(A(1;2)\), \(B(4;5)\) et \(C(7;8)\).
  3. Tester les mêmes A et B avec \(D(7;9)\).
  4. Expliquer pourquoi cette méthode est préférable au calcul et à la comparaison de deux pentes.
Exercice 27 - Équations de droites - coefficient directeur et intersection
Ex. 27/30

On considère la droite \((d)\) passant par \(A(-2;1)\) et \(B(4;7)\), ainsi que la droite \((d')\) d’équation \(y=-2x+6\).

  1. Calculer le coefficient directeur de \((d)\) puis déterminer une équation de \((d)\).
  2. Écrire une fonction qui, pour deux points d’abscisses différentes, renvoie les coefficients m et p de \(y=mx+p\).
  3. Calculer exactement les coordonnées du point d’intersection I de \((d)\) et \((d')\).
  4. Vérifier par substitution que I appartient aux deux droites et identifier ce point sur la figure.
Exercice 28 - Balayage numérique - rechercher un maximum
Ex. 28/30

On étudie \(f(x)=-x^2+6x+1\) sur \([0;6]\). On veut approcher le maximum par balayage avec un pas h.

  1. Écrire une fonction maximum_balayage(h) qui teste les points \(0,h,2h,\ldots,6\).
  2. Avec \(h=0{,}5\), déterminer le point où le maximum est trouvé.
  3. Vérifier algébriquement la valeur exacte du maximum en écrivant \(f(x)=10-(x-3)^2\).
  4. Expliquer l’effet d’un pas plus petit sur la précision et le nombre de calculs.
Exercice 29 - Approximation géométrique - longueur d’une courbe
Ex. 29/30

On approxime la longueur de la courbe \(y=x^2\) entre \(x=0\) et \(x=2\) par une ligne brisée reliant n points régulièrement espacés.

  1. Écrire une fonction longueur(n) qui additionne les distances entre points consécutifs.
  2. Pour \(n=4\) sous-intervalles, donner les cinq abscisses utilisées.
  3. Calculer la longueur approchée pour \(n=4\) à \(10^{-4}\) près.
  4. Expliquer pourquoi augmenter n améliore en général l’approximation.
Exercice 30 - Simulation conditionnelle - arbre à deux étapes
Ex. 30/30

Une population contient 40 % d’individus du groupe A et 60 % du groupe B. Un test est positif avec probabilité 0,7 dans A et 0,3 dans B.

  1. Écrire une simulation qui génère d’abord le groupe puis le résultat du test et estime \(P(A\mid T)\), où T signifie « test positif ».
  2. Calculer exactement \(P(T)\).
  3. Calculer exactement \(P(A\mid T)\).
  4. Expliquer pourquoi, dans la simulation, il faut diviser le nombre de cas « A et T » par le nombre total de cas T, et non par N.
Suivez votre progression
Connectez-vous pour enregistrer votre progression et vos tentatives de quiz.
Login Register
↗ Cours ↗ Fiche de révision ↗ Exercices corrigés ↗ Quiz ↗ Tous les chapitres de mathématiques 2nde