Chapitre 12 – Algorithmique et programmation

Chapitre 12 | Première générale (spécialité) | Mathématiques

Dernière mise à jour : 21 octobre 2026

Objectifs du chapitre

Générer une liste : en extension, par ajouts successifs (append), ou en compréhension
Manipuler les éléments d'une liste (ajouter, supprimer, modifier) et travailler avec leurs indices
Parcourir une liste et itérer sur ses éléments (par indices ou directement)
Consolider les notions de variable, affectation, instruction conditionnelle, boucles et fonctions
Pratiquer la programmation modulaire : découper une tâche complexe en sous-tâches simples
Mettre en œuvre les algorithmes classiques du programme : seuil, factorielle, Newton, Euler, Monte-Carlo, Syracuse

La seule notion nouvelle de l'année est celle de liste, qui trouve sa place dans de nombreuses parties du programme (suites, tableaux de valeurs, séries statistiques). Tout le reste — variables, tests, boucles, fonctions — consolide les acquis de seconde. L'accent est mis sur la programmation modulaire. Les scripts sont écrits en Python.

I. Rappels : variables, affectation, structures de contrôle

Définition — Affectation

L'affectation donne une valeur à une variable. En langage naturel, on la note avec le symbole \(\leftarrow\) : ainsi \(x \leftarrow 3\) signifie « la variable \(x\) prend la valeur \(3\) ». En Python, on écrit x = 3.

Les trois structures de contrôle

Instruction conditionnelle : if condition: ... else: ...
Boucle bornée (nombre de tours connu) : for i in range(n): ...
Boucle non bornée (on répète tant qu'une condition est vraie) : while condition: ...

Attention — range(n)

L'appel range(n) parcourt les entiers \(0, 1, \dots, n-1\) (et non jusqu'à \(n\)). Il y a bien \(n\) valeurs, mais la dernière est \(n-1\).

II. La notion de liste

Définition — Liste

Une liste est une collection ordonnée d'éléments, repérés par leur indice (leur position). En Python, une liste s'écrit entre crochets :

\[\texttt{L = [4, 9, 16, 25]}\]

Attention — Les indices commencent à \(0\)

Le premier élément est L[0], le deuxième L[1], etc. Le dernier élément est L[-1] (ou L[len(L) - 1]). Attention : L[len(L)] provoque une erreur (hors bornes).

Exemple — Accéder aux éléments

L = [4, 9, 16, 25]
print(L[0])       # 4  (premier élément)
print(L[3])       # 25 (quatrième élément)
print(L[-1])      # 25 (dernier)
print(len(L))     # 4  (nombre d'éléments)

Exercice d'application 1. Soit L = [7, 2, 5, 9, 1]. Que valent L[0], L[2], L[-1] et len(L) ?

L[0] vaut \(7\) (premier), L[2] vaut \(5\) (troisième), L[-1] vaut \(1\) (dernier) et len(L) vaut \(5\) (la liste a \(5\) éléments).

III. Générer une liste

Trois façons de construire une liste

a) En extension — on écrit tous les éléments (comme un ensemble en extension) :

carres = [1, 4, 9, 16, 25]

b) Par ajouts successifs — on part d'une liste vide et on ajoute avec append :

carres = []
for k in range(1, 6):
    carres.append(k * k)
# carres vaut [1, 4, 9, 16, 25]

c) En compréhension — syntaxe compacte, en lien avec un ensemble en compréhension ; une condition permet de filtrer :

carres = [k*k for k in range(1, 6)]                 # [1, 4, 9, 16, 25]
pairs  = [n for n in range(20) if n % 2 == 0]       # les entiers pairs de 0 à 18

Exercice d'application 2. Écrire, par compréhension, la liste des cubes des entiers de \(1\) à \(6\).

[k**3 for k in range(1, 7)], ce qui donne [1, 8, 27, 64, 125, 216]. On pense à range(1, 7) pour aller de \(1\) à \(6\) inclus.

IV. Manipuler et parcourir une liste

1. Les opérations de base

Opération	Code Python	Effet
Ajouter en fin	`L.append(x)`	ajoute `x` à la fin
Supprimer par indice	`del L[i]`	retire l'élément d'indice `i`
Modifier	`L[i] = x`	remplace l'élément d'indice `i`
Longueur	`len(L)`	nombre d'éléments
Concaténer	`L1 + L2`	met les deux listes bout à bout
Tester l'appartenance	`x in L`	renvoie `True` ou `False`

2. Parcourir et itérer

Méthode — Deux façons de parcourir une liste

Parcours par indices (utile quand on a besoin de la position) :

for i in range(len(L)):
    print(i, L[i])

Itération directe sur les éléments (plus lisible quand la position importe peu) :

somme = 0
for x in L:
    somme = somme + x

Exercice d'application 3. Que renvoie ce code ?

L = [2, 4, 6, 8]
s = 0
for i in range(len(L)):
    if i % 2 == 0:
        s += L[i]
print(s)

On additionne les éléments d'indice pair (\(i = 0\) et \(i = 2\)) : L[0] + L[2] \(= 2 + 6 = 8\). Le code affiche 8.

V. Fonctions et programmation modulaire

Définition — Programmation modulaire

La programmation modulaire consiste à découper un problème complexe en fonctions simples, réutilisables, chacune réalisant une sous-tâche. Cela rend le code plus clair, plus court et plus facile à corriger.

Exemple — Combiner des modules

def carre(x):
    return x * x

def liste_carres(n):
    """Utilise la fonction carre : programmation modulaire."""
    return [carre(k) for k in range(1, n + 1)]

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

# On combine les modules :
print(somme_liste(liste_carres(5)))   # 1+4+9+16+25 = 55

Exercice d'application 4. Écrire une fonction compte_pairs(L) renvoyant le nombre d'éléments pairs d'une liste d'entiers.

def compte_pairs(L):
    c = 0
    for x in L:
        if x % 2 == 0:
            c += 1
    return c

On parcourt la liste, et on incrémente un compteur c chaque fois qu'un élément est pair.

VI. Méthodes-types avec les listes

Méthode 1 — Construire les premiers termes d'une suite

Liste des \(10\) premiers termes de \(u_0 = 1\), \(u_{n+1} = 2u_n + 3\) : on ajoute chaque terme à partir du dernier (L[-1]).

def premiers_termes(n):
    L = [1]                       # u_0
    for _ in range(n - 1):
        L.append(2 * L[-1] + 3)   # u_{n+1} à partir du dernier
    return L

print(premiers_termes(10))

Méthode 2 — Rechercher un seuil

Premier rang où une suite géométrique dépasse un seuil \(S\) : on répète tant que \(u \lt S\) (boucle while).

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

Méthode 3 — Calculer un indicateur à partir d'une liste

Moyenne d'une liste de données (module réutilisable) :

def moyenne(L):
    return sum(L) / len(L)

Exercice d'application 5. Écrire une fonction maximum(L) renvoyant le plus grand élément d'une liste non vide, sans utiliser max.

def maximum(L):
    m = L[0]
    for x in L:
        if x > m:
            m = x
    return m

On initialise m au premier élément, puis on le remplace dès qu'on rencontre un élément plus grand.

VII. Les grands classiques du programme

Factorielle

Suite définie par récurrence : \(n! = 1 \times 2 \times \dots \times n\).

def factorielle(n):
    f = 1
    for k in range(1, n + 1):
        f *= k
    return f

Méthode de Newton

Approximation d'une racine de \(f\) (cf. chapitre Applications de la dérivation) :

def newton(f, df, x0, n):
    x = x0
    for _ in range(n):
        x = x - f(x) / df(x)
    return x

Méthode d'Euler

Construction de l'exponentielle par \(y' = y\) (cf. chapitre Fonction exponentielle) :

def euler_exp(x, n):
    h = x / n
    y = 1.0
    for _ in range(n):
        y = y + h * y      # y' = y
    return y

Méthode de Monte-Carlo

Estimation de \(\pi\) par tirages aléatoires (cf. chapitre Probabilités conditionnelles) : on tire des points dans le carré \([0\,;1]^2\) et on compte ceux qui tombent dans le quart de disque.

from random import random

def estim_pi(N):
    dedans = 0
    for _ in range(N):
        x, y = random(), random()
        if x*x + y*y <= 1:
            dedans += 1
    return 4 * dedans / N

Suite de Syracuse

On construit la liste des termes jusqu'à atteindre \(1\) : si le terme est pair on le divise par \(2\), sinon on calcule \(3u+1\).

def syracuse(u0):
    L = [u0]
    while u0 != 1:
        u0 = u0 // 2 if u0 % 2 == 0 else 3 * u0 + 1
        L.append(u0)
    return L

Exercice d'application 6. Écrire une fonction qui renvoie la liste des \(n\) premiers termes de la suite de Fibonacci (\(1, 1, 2, 3, 5, \dots\)).

def fibonacci(n):
    L = [1, 1]
    while len(L) < n:
        L.append(L[-1] + L[-2])
    return L[:n]

Chaque terme est la somme des deux précédents (L[-1] + L[-2]). On renvoie les \(n\) premiers termes.

Erreurs fréquentes / points de vigilance

Les pièges du chapitre

❌ Croire que L[len(L)] est le dernier élément.

✅ Les indices vont de \(0\) à len(L) - 1 ; le dernier élément est L[-1].

❌ Confondre = et ==.

✅ = affecte une valeur ; == teste l'égalité.

❌ Écrire L = L.append(x).

✅ append ne renvoie rien : il modifie la liste « en place ». On écrit simplement L.append(x).

❌ Écrire une boucle while sans progression.

✅ Si la condition ne peut jamais devenir fausse, la boucle est infinie : vérifier que la variable testée évolue.

❌ Modifier une liste pendant qu'on la parcourt.

✅ Source d'erreurs : préférer construire une nouvelle liste.

L'essentiel à retenir

À retenir :

Liste = collection ordonnée d'éléments, indices à partir de \(0\) ; dernier élément L[-1].
Trois façons de générer : extension, ajouts successifs (append), compréhension.
Manipuler : append, del, L[i] = ..., len, in.
Parcourir : for i in range(len(L)) (indices) ou for x in L (éléments).
Programmation modulaire : découper en fonctions simples et réutilisables.
Algorithmes phares : seuil, factorielle, Newton, Euler (exp), Monte-Carlo, Syracuse, Fibonacci.