Algorithmique et programmation.
Décrire une méthode, l’automatiser

Fiche 01 / 06

Avant de commencer : diagnostic et rappels

Durée : 12 minutes, sans exécuter les programmes. Pour chaque question, écrire les étapes sur papier avant de chercher une commande.

1. On exécute successivement $x\leftarrow3$, puis $x\leftarrow x+2$. Quelle est la valeur finale de $x$ ?

2. Que teste la condition $\texttt{x >= 5}$ ?

3. Quelles valeurs produit $\texttt{range(4)}$ en Python ?

4. Que renvoie une fonction qui contient $\texttt{return 7}$ ?

5. Dans la liste $[12,\,8,\,5]$, quel est l’indice du premier élément en Python ?

6. Pourquoi une boucle qui ne modifie jamais sa condition d’arrêt peut-elle ne pas se terminer ?

Corrections du diagnostic →

Rappels ciblés

Une variable possède un nom et une valeur. Une affectation remplace la valeur précédente : $x\leftarrow x+1$ signifie « calculer l’ancienne valeur de $x$ plus $1$, puis la ranger dans $x$ ». Ce n’est pas une égalité algébrique à résoudre.

Une condition est une proposition vraie ou fausse. Une boucle répète un bloc selon une règle ; une fonction reçoit éventuellement des paramètres et renvoie un résultat avec return.

En Python, les indices d’une liste commencent à $0$. Ainsi, dans [12, 8, 5], l’indice $0$ désigne $12$, l’indice $1$ désigne $8$, et l’indice $2$ désigne $5$. La fonction range(n) produit $0,1,\ldots,n-1$.

À retenirAvant d’exécuter un programme, écrire : les valeurs initiales, la condition testée, le nombre de répétitions et la valeur renvoyée. La programmation est une traduction précise d’une méthode ; elle ne dispense pas d’expliquer ce que le résultat signifie.

Fiche 02 / 06

1. Construire un algorithme

Entrées, traitement, sortie

Un algorithme décrit une suite finie d’actions. Pour le lire, repérer :

1. les entrées fournies au départ ;

2. les variables intermédiaires ;

3. les conditions qui choisissent un chemin ;

4. les boucles qui répètent une action ;

5. la sortie affichée ou renvoyée.

Affectation, condition et boucle

En langage naturel, on utilise souvent la flèche $$\texttt{somme} \leftarrow \texttt{somme}+\texttt{valeur}.$$ En Python, cette affectation s’écrit avec le signe égal. Une condition if choisit un bloc, et une boucle for répète sur une collection ou une suite d’indices.

Exemple entièrement détaillé

On veut calculer $1+2+\cdots+n$, pour un entier $n\geq1$.

Méthode en langage naturel :

Entrée : un entier n
somme <- 0
Pour k allant de 1 à n
    somme <- somme + k
Renvoyer somme

Traduction Python :

def somme_entiers(n):
    somme = 0
    for k in range(1, n+1):
        somme = somme + k
    return somme

Pour $n=4$, on suit les quatre passages : $$\begin{array}{c|c|c} k&\text{ancienne somme}&\text{nouvelle somme}\\ \hline 1&0&1\\ 2&1&3\\ 3&3&6\\ 4&6&10 \end{array}$$ Le programme renvoie donc $10$, ce qui correspond à $1+2+3+4=10$. Le test sur $n=1$, qui renvoie $1$, vérifie également la première valeur.

Un invariant simple

Après le passage d’indice $k$ dans l’exemple, la variable somme contient exactement $1+2+\cdots+k$. Cette phrase, vraie avant et après chaque passage, explique pourquoi le résultat final est correct. Elle joue le rôle d’un contrôle du raisonnement.

Fiche 03 / 06

2. Fonctions et listes

Découper une tâche

Une fonction informatique rassemble une tâche sous un nom réutilisable. Elle peut avoir zéro, un ou plusieurs paramètres. Les variables créées à l’intérieur sont locales à la fonction, et return transmet le résultat au programme appelant.

def carre(x):
    return x * x

resultat = carre(3)

Après l’appel, resultat vaut $9$. Une fonction ne doit pas seulement calculer : son nom, ses paramètres et son résultat doivent correspondre à la question.

Générer et parcourir une liste

Une liste est une collection ordonnée, dans laquelle une valeur peut apparaître plusieurs fois. On peut la créer en extension, par ajouts successifs ou en compréhension.

valeurs = [2, 5, 8]

carres = []
for valeur in valeurs:
    carres.append(valeur * valeur)

carres_bis = [valeur * valeur for valeur in valeurs]

Les deux dernières listes valent $[4,25,64]$. La méthode par compréhension est concise ; la boucle explicite est souvent plus facile à lire au début.

Pour parcourir une liste :

• for valeur in valeurs utilise directement les valeurs ;

• for i in range(len(valeurs)) utilise les indices et permet d’écrire valeurs[i].

La fonction append ajoute une valeur à la fin. La longueur est obtenue avec len.

Exemple entièrement détaillé

On veut calculer la moyenne d’une liste non vide valeurs.

def moyenne(valeurs):
    total = 0
    for valeur in valeurs:
        total = total + valeur
    return total / len(valeurs)

Pour $[10,12,14]$, la boucle construit successivement les totaux $10$, $22$, puis $36$. La fonction renvoie $$\frac{36}{3}=\boxed{12}.$$ La condition « liste non vide » est importante : diviser par len(valeurs) n’aurait pas de sens pour une liste de longueur nulle.

Fiche 04 / 06

3. Conditions, recherche et simulation

Filtrer avec une condition

Une condition peut être combinée avec and, or et not. Pour construire une liste des valeurs positives :

def positives(valeurs):
    resultat = []
    for valeur in valeurs:
        if valeur > 0:
            resultat.append(valeur)
    return resultat

La liste produite conserve l’ordre d’origine et ne contient que les valeurs qui vérifient la condition.

Rechercher un premier rang

Pour chercher le premier entier satisfaisant une condition, on initialise un rang, on teste, puis on l’augmente tant que la condition n’est pas vérifiée.

def premier_seuil(condition, limite):
    n = 0
    while n <= limite and not condition(n):
        n = n + 1
    if n <= limite:
        return n
    return None

Dans une copie, il faut préciser ce que signifie condition(n) et prévoir le cas où aucun rang ne convient dans la limite choisie. La borne limite protège contre une boucle infinie.

Simuler une expérience

Pour une expérience aléatoire, une simulation fournit une réalisation du modèle. Par exemple :

from random import random

def compter_succes(n, p):
    compteur = 0
    for i in range(n):
        if random() < p:
            compteur = compteur + 1
    return compteur

La comparaison random() < p crée un succès de probabilité $p$ dans le modèle usuel. Une simulation donne un résultat aléatoire ; elle ne remplace ni la formule ni la justification mathématique.

À retenirUne fonction doit avoir un objectif vérifiable. Une boucle doit faire évoluer une variable ou parcourir une liste. Pour une recherche, indiquer la condition d’arrêt et le cas où la valeur recherchée n’existe pas. Pour une simulation, distinguer une réalisation, une fréquence observée et une probabilité théorique.

Fiche 05 / 06

4. Exercices gradués

Les corrections détaillées sont dans le fascicule séparé.

liste = []
for k in range(1, 5):
    if k % 2 == 0:
        liste.append(k)

Fiche 06 / 06

Bilan et rappel différé

Erreurs fréquentes

• Confondre une affectation avec une équation à résoudre.

• Oublier que range(n) s’arrête à $n-1$.

• Mélanger une valeur de liste et son indice.

• Diviser par la longueur d’une liste vide.

• Oublier return, ou afficher une valeur alors que la fonction doit la renvoyer.

• Écrire une boucle qui n’avance pas vers sa condition d’arrêt.

• Conclure qu’une simulation donne exactement la probabilité théorique.

Auto-évaluation

Rappel différé

R1. Que vaut $\texttt{list(range(3))}$ en Python ?

R2. Quelle est la différence entre return et print dans une fonction ?

R3. Pourquoi une variable de somme est-elle souvent initialisée à zéro ?

R4. Citer un test simple permettant de vérifier une fonction de moyenne.

En cas de blocage. Écrire d’abord la méthode en français : « je reçois..., j’initialise..., je parcours..., je teste..., je renvoie... ». Puis traduire chaque verbe en instruction Python.

Cadre et références

Hypothèse de travail : terminale générale, spécialité mathématiques, session 2027 supposée ; l’échéance exacte reste à confirmer. Les exercices sont des créations pédagogiques ; ils ne sont pas présentés comme des sujets officiels.

Programme de référence : programme de spécialité de terminale, Bulletin officiel spécial n^o 8 du 25 juillet 2019.

Le programme publié au Bulletin officiel n^o 14 du 2 avril 2026 s’appliquera en terminale à partir de la rentrée 2027–2028 ; il est signalé ici sans être utilisé.

Les pages du Bulletin officiel ont renvoyé une erreur HTTP 403 lors de la vérification du 3 octobre 2026 ; le cadre repris est celui déjà présent dans les fascicules LaTeX du chapitre.