À propos de cette page
Ce cours de mathématiques en seconde sur « Algorithmique et programmation » suit le programme officiel de mathématiques de seconde. Il présente les définitions, les propriétés et les méthodes essentielles, accompagnées d'exemples résolus pour bien comprendre. Au programme : Qu'est-ce qu'un algorithme ?, Variables et affectation, Instructions d'entrée / sortie, Instructions conditionnelles. Chaque notion est expliquée pas à pas, puis mise en pratique grâce à des exercices interactifs, un QCM et une évaluation corrigée. Idéal pour réviser à son rythme, combler ses lacunes et progresser, en autonomie ou avec un professeur. Cours rédigé par un professeur particulier à Marseille pour aider les élèves de seconde à réussir en mathématiques.
Au programme
1 · Qu'est-ce qu'un algorithme ?
2 · Variables et affectation
3 · Instructions d'entrée / sortie
4 · Instructions conditionnelles
5 · Boucles bornées (for)
6 · Boucles non bornées (while)
7 · Fonctions en Python
8 · Mise en œuvre : exemples résolus
1Qu'est-ce qu'un algorithme ?
Un algorithme est une suite finie et ordonnée d'instructions permettant de résoudre un problème ou d'effectuer un calcul. Les algorithmes existent bien avant l'informatique (recettes, modes d'emploi…).
Définition. Un algorithme est une procédure systématique composée d'un nombre fini d'étapes clairement définies, garantissant d'aboutir à un résultat en un temps fini.
Un algorithme possède :
- des données en entrée (valeurs fournies par l'utilisateur ou le contexte) ;
- des instructions (calculs, tests, boucles…) ;
- des données en sortie (résultats produits).
Astuce. En classe de 2nde, on utilisera principalement le langage Python pour coder les algorithmes. Un algorithme peut aussi s'écrire en pseudo-code ou sous forme d'organigramme.
Exemple. Algorithme de calcul de la somme des 100 premiers entiers : on initialise une variable somme à 0, puis on additionne successivement 1, 2, 3, …, 100, et on affiche le résultat.
2Variables et affectation
Une variable est un espace mémoire repéré par un nom, contenant une valeur susceptible de changer au cours de l'exécution.
Définition. L'affectation est l'opération qui attribue une valeur à une variable. En Python, on écrit $x = 5$ (le signe $=$ est l'opérateur d'affectation, pas d'égalité mathématique).
Types de données courants en Python :
| Type | Notation Python | Exemple |
|---|
| Entier | $int$ | $n = 7$ |
| Décimal (flottant) | $float$ | $x = 3.14$ |
| Chaîne de caractères | $str$ | $s = "bonjour"$ |
| Booléen | $bool$ | $b = True$ |
Attention ! L'affectation $x = x + 1$ est parfaitement licite en algorithmique : on lit la valeur actuelle de x, on lui ajoute 1, et on range le résultat dans x. Ce n'est pas une équation mathématique.
Exemple. $a = 3$ puis $a = a * 2$ : après la deuxième instruction, $a$ vaut 6.
3Instructions d'entrée / sortie
Pour interagir avec l'utilisateur, on utilise des instructions de lecture (entrée) et d'affichage (sortie).
| Action | Python | Rôle |
|---|
| Entrée | $x = int(input("Entrer x : "))$ | Lit une valeur saisie au clavier |
| Sortie | $print(x)$ | Affiche une valeur à l'écran |
La fonction $input()$ renvoie toujours une chaîne de caractères. Il faut donc la convertir si l'on attend un nombre : $int(…)$ pour un entier, $float(…)$ pour un décimal.
Astuce. On peut afficher plusieurs éléments avec $print("La somme est :", s)$ ou utiliser les f-strings : $print(f"La somme est {s}")$.
Exemple.
$n = int(input("Entrez un entier : "))$
$print("Son carré est", n**2)$
Si l'utilisateur saisit 5, l'affichage sera : Son carré est 25.
4Instructions conditionnelles
Une instruction conditionnelle permet d'exécuter un bloc d'instructions seulement si une condition est vraie.
Syntaxe Python.
$if condition :$
$bloc si vrai$
$elif autre_condition :$
$bloc sinon-si$
$else :$
$bloc sinon$
L'indentation (4 espaces ou 1 tabulation) est obligatoire en Python.
Opérateurs de comparaison : $==$ (égal), $!=$ (différent), $<$, $>$, $<=$, $>=$.
Opérateurs logiques : $and$, $or$, $not$.
Attention ! Ne pas confondre $=$ (affectation) et $==$ (test d'égalité). Écrire $if x = 5 :$ provoque une erreur de syntaxe.
Exemple. Signe d'un nombre :
$x = float(input("Entrez x : "))$
$if x > 0 :$
$print("Positif")$
$elif x < 0 :$
$print("Négatif")$
$else :$
$print("Nul")$
5Boucles bornées (for)
Une boucle bornée répète un bloc d'instructions un nombre de fois déterminé à l'avance.
Syntaxe Python.
$for i in range(n) :$
$instruction(s)$
$range(n)$ génère les entiers de 0 à n−1 (soit n valeurs). $range(a, b)$ génère les entiers de a à b−1. $range(a, b, p)$ avance par pas de p.
On peut aussi parcourir une liste : $for x in [1, 4, 9, 16] :$
Astuce. Si la variable de boucle est inutilisée dans le corps, on peut écrire $for _ in range(n) :$.
Exemple 1. Afficher les entiers de 1 à 10 :
$for i in range(1, 11) :$
$print(i)$
Exemple 2. Calculer la somme 1 + 2 + … + n :
$n = int(input())$
$s = 0$
$for i in range(1, n+1) :$
$s = s + i$
$print(s)$
Pour n = 5, on obtient s = 15.
6Boucles non bornées (while)
Une boucle non bornée répète un bloc d'instructions tant qu'une condition reste vraie, sans connaître à l'avance le nombre d'itérations.
Syntaxe Python.
$while condition :$
$instruction(s)$
La condition est testée avant chaque itération. Si elle est fausse dès le départ, le bloc n'est jamais exécuté.
Attention ! Si la condition ne devient jamais fausse, la boucle tourne indéfiniment (boucle infinie). Il faut toujours s'assurer que la condition finit par devenir fausse (en modifiant une variable dans le corps de la boucle).
Exemple. Premier entier n tel que 2n > 1000 :
$n = 0$
$while 2**n <= 1000 :$
$n = n + 1$
$print(n)$
On obtient n = 10 car 210 = 1024 > 1000.
Astuce. On utilise $for$ quand le nombre d'itérations est connu, et $while$ quand on répète jusqu'à ce qu'une condition soit satisfaite.
7Fonctions en Python
Une fonction est un bloc d'instructions réutilisable, identifié par un nom, qui peut recevoir des paramètres et renvoyer un résultat.
Syntaxe de définition.
$def nom_fonction(param1, param2, ...) :$
$instructions$
$return valeur$
L'instruction $return$ met fin à la fonction et renvoie la valeur indiquée. Si elle est absente, la fonction renvoie $None$.
On appelle la fonction en écrivant $nom_fonction(argument1, argument2)$.
Exemple. Fonction renvoyant le maximum de deux nombres :
$def maximum(a, b) :$
$if a >= b :$
$return a$
$else :$
$return b$
$print(maximum(3, 7))$ → affiche 7
Astuce. Décomposer un programme en fonctions le rend plus lisible, plus facile à tester et réutilisable. C'est la base de la modularité.
8Mise en œuvre : exemples résolus
Voici deux algorithmes complets illustrant les notions vues.
Exemple 1 — Test de parité.
Écrire une fonction qui indique si un entier est pair ou impair.
$def parite(n) :$
$if n % 2 == 0 :$
$return "pair"$
$else :$
$return "impair"$
$print(parite(14))$ → pair
$print(parite(9))$ → impair
L'opérateur $%$ (modulo) renvoie le reste de la division euclidienne.
Exemple 2 — Suite de Collatz.
Partant d'un entier n > 0 : si n est pair, diviser par 2 ; sinon, remplacer par 3n + 1. Répéter jusqu'à obtenir 1.
$def collatz(n) :$
$nb_etapes = 0$
$while n != 1 :$
$if n % 2 == 0 :$
$n = n // 2$
$else :$
$n = 3*n + 1$
$nb_etapes += 1$
$return nb_etapes$
$print(collatz(6))$ → 8 étapes (6→3→10→5→16→8→4→2→1)
Méthode. Face à un algorithme inconnu, on peut en simuler l'exécution sur un exemple simple en complétant un tableau de valeurs des variables à chaque étape (trace d'exécution).
★À retenir
En bref :
• Un algorithme est une suite finie d'instructions pour résoudre un problème.
• Une variable stocke une valeur ; l'affectation ($=$) lui attribue une valeur.
• $if / elif / else$ : exécution conditionnelle selon un test.
• $for i in range(n)$ : boucle répétée n fois (bornée).
• $while condition$ : boucle répétée tant que la condition est vraie (non bornée).
• $def f(x) : … return …$ : définit une fonction réutilisable.
• Ne pas confondre $=$ (affectation) et $==$ (test d'égalité).