← Retour au sommaire

Exercices – Chapitre 12

Algorithmique et programmation | Première générale (spécialité) | Mathématiques

Dernière mise à jour : 21 octobre 2026

Rappels utiles :

Exercice 1 — Indices et accès aux éléments

On considère la liste L = [3, 8, 1, 6, 4].

1. Que valent L[0], L[2] et L[-1] ?

2. Que vaut len(L) ?

3. Quelle instruction remplace le deuxième élément par \(20\) ?

1. L[0] \(= 3\) (premier), L[2] \(= 1\) (troisième), L[-1] \(= 4\) (dernier).

2. len(L) \(= 5\).

3. Le deuxième élément a pour indice \(1\) : on écrit L[1] = 20.

Exercice 2 — Générer une liste de trois façons

On veut obtenir la liste des multiples de \(3\) de \(3\) à \(18\), c'est-à-dire [3, 6, 9, 12, 15, 18].

1. L'écrire en extension.

2. L'obtenir par ajouts successifs avec append.

3. L'obtenir par compréhension.

1. M = [3, 6, 9, 12, 15, 18].

2. Par ajouts successifs :

M = []
for k in range(1, 7):
    M.append(3 * k)

3. Par compréhension : M = [3 * k for k in range(1, 7)].

Exercice 3 — Lire un script

Que renvoie ce code ?

L = [5, 2, 7, 3, 9]
s = 0
for x in L:
    if x > 4:
        s += x
print(s)

On additionne les éléments strictement supérieurs à \(4\) : ce sont \(5\), \(7\) et \(9\). La somme vaut \(5 + 7 + 9 = 21\). Le code affiche 21.

Exercice 4 — Écrire une fonction avec une liste

1. Écrire une fonction somme_liste(L) qui renvoie la somme des éléments de L (sans utiliser sum).

2. Écrire une fonction minimum(L) qui renvoie le plus petit élément d'une liste non vide (sans utiliser min).

1. On accumule dans une variable :

def somme_liste(L):
    s = 0
    for x in L:
        s += x
    return s

2. On part du premier élément et on garde le plus petit rencontré :

def minimum(L):
    m = L[0]
    for x in L:
        if x < m:
            m = x
    return m

Exercice 5 — Boucle while et seuil

On considère la suite géométrique \(u_0 = 100\), \(u_{n+1} = 1{,}5\,u_n\).

1. Écrire une fonction rang_seuil(S) renvoyant le premier rang \(n\) tel que \(u_n \geqslant S\).

2. Que renvoie rang_seuil(500) ? (On donne \(u_0=100,\ u_1=150,\ u_2=225,\ u_3=337{,}5,\ u_4=506{,}25\).)

1. On répète tant que \(u \lt S\) :

def rang_seuil(S):
    u, n = 100, 0
    while u < S:
        u = 1.5 * u
        n += 1
    return n

2. Le premier terme \(\geqslant 500\) est \(u_4 = 506{,}25\), donc rang_seuil(500) renvoie \(4\).

Exercice 6 — Premiers termes d'une suite

Soit la suite \(u_0 = 2\), \(u_{n+1} = 3u_n - 1\).

1. Écrire une fonction termes(n) renvoyant la liste des \(n\) premiers termes.

2. Que contient la liste renvoyée par termes(4) ?

1. On ajoute chaque terme à partir du dernier (L[-1]) :

def termes(n):
    L = [2]                       # u_0
    for _ in range(n - 1):
        L.append(3 * L[-1] - 1)
    return L

2. \(u_0 = 2\), \(u_1 = 3\times 2 - 1 = 5\), \(u_2 = 3\times 5 - 1 = 14\), \(u_3 = 3\times 14 - 1 = 41\). La liste est [2, 5, 14, 41].

Exercice 7 — Statistiques et compréhension

Une liste de notes est donnée : notes = [12, 8, 15, 6, 18, 10].

1. Écrire une fonction moyenne(L) renvoyant la moyenne de L.

2. Par compréhension, construire la liste des notes \(\geqslant 10\).

3. Écrire une fonction nb_admis(L) renvoyant le nombre de notes \(\geqslant 10\).

1. def moyenne(L): return sum(L) / len(L). Ici la moyenne vaut \((12+8+15+6+18+10)/6 = 69/6 = 11{,}5\).

2. [x for x in notes if x >= 10], ce qui donne [12, 15, 18, 10].

3. On compte les éléments \(\geqslant 10\) :

def nb_admis(L):
    c = 0
    for x in L:
        if x >= 10:
            c += 1
    return c

(On peut aussi écrire return len([x for x in L if x >= 10]).)

Exercice 8 — Problème type : écrire un script complet

On veut, par programmation modulaire, calculer la moyenne des carrés des entiers de \(1\) à \(n\).

1. Écrire une fonction carre(x) qui renvoie \(x^2\).

2. Écrire une fonction liste_carres(n) qui, en utilisant carre, renvoie la liste des carrés de \(1\) à \(n\).

3. Écrire une fonction moyenne_carres(n) qui, en s'appuyant sur les deux fonctions précédentes, renvoie la moyenne de ces carrés.

4. Calculer à la main la valeur renvoyée par moyenne_carres(3).

1 à 3. Chaque fonction s'appuie sur la précédente :

def carre(x):
    return x * x

def liste_carres(n):
    return [carre(k) for k in range(1, n + 1)]

def moyenne_carres(n):
    L = liste_carres(n)
    return sum(L) / len(L)

4. liste_carres(3) vaut [1, 4, 9]. La moyenne est \((1+4+9)/3 = 14/3 \approx 4{,}67\).