L'épreuve d'algorithmique de l'E3 (CCF)

L'algorithmique est évaluée au BTS SIO dans l'épreuve E3 « Mathématiques pour l'informatique » : en contrôle en cours de formation, c'est la situation A, une épreuve pratique et orale où tu écris un algorithme sur table, le programmes sur machine, puis le présentes à un professeur. Ce chapitre détaille son déroulement selon le référentiel, les critères d'évaluation, une méthode pour chaque phase, la façon de modifier ou compléter un algorithme fourni, et un aide-mémoire du pseudo-code et de Python.

Où l'algorithmique est évaluée

L'épreuve E3 (unité U3), « Mathématiques pour l'informatique », a un coefficient 3. Elle est commune aux options SISR et SLAM. Jusqu'à la session 2024, elle portait le numéro E2 (U2) : les documents plus anciens que tu trouveras en ligne parlent donc de l'« E2 » pour la même épreuve.

En CCF, l'algorithmique a donc sa propre situation d'évaluation. Elle a lieu quand ton professeur te juge prêt : la circulaire nationale recommande de l'organiser en fin de première année ou en début de deuxième année. Elle se déroule si possible dans ton établissement, sur le matériel que tu as utilisé en formation, et c'est le professeur qui t'a formé à l'algorithmique qui t'évalue.

Le déroulement de la situation A

Le référentiel décrit l'épreuve ainsi :

• Le sujet part d'une situation problème, avec des consignes écrites et, éventuellement, des composants logiciels fournis (des fonctions ou des fichiers déjà écrits, utilisables pour la résolution).
• La préparation dure une heure, en deux parties de 30 minutes. La première se fait sur table et donne une trace écrite, une production manuscrite que la commission peut examiner. La seconde se fait sur un équipement fourni par le centre d'examen ; tu peux y consulter librement l'aide syntaxique disponible dans l'environnement du langage. La circulaire nationale autorise aussi les ressources documentaires électroniques disponibles dans le centre d'examen, mais aucun service accessible sur internet ; tes connexions peuvent être contrôlées.
• L'oral dure 20 minutes : tu présentes ta solution algorithmique et son implémentation (10 minutes au maximum), puis tu participes à un entretien d'explicitation conduit par la commission (10 minutes au maximum).
• La commission est le professeur chargé de l'enseignement d'algorithmique appliquée.
• Aucun langage ni formalisme n'est imposé pour écrire les algorithmes. Python est recommandé par le référentiel, sans être obligatoire.
• Seule l'algorithmique est évaluée. Si le sujet s'appuie sur une notion d'un autre module (PGCD, matrice, graphe), la méthode est fournie dans le sujet (chapitre 11). Le sujet évite les difficultés théoriques et la technicité excessive.

L'objectif affiché : évaluer ta capacité à analyser un énoncé, formaliser une démarche, écrire, interpréter et éventuellement modifier ou compléter un ou plusieurs algorithmes.

Les critères d'évaluation

Le référentiel liste huit critères. Chacun correspond à une habitude que tu peux prendre dès maintenant.

Les 30 minutes sur table

Tu n'as pas de machine : c'est le moment de réfléchir, pas de taper.

1. Lire tout le sujet (5 minutes). Souligne les entrées, les sorties attendues et les contraintes (« sans utiliser de fonction de tri », « le tableau est trié »). Repère les composants fournis et lis leur interface : nom, paramètres, valeur renvoyée. Repère les questions qui dépendent les unes des autres.
2. Analyser. Pour chaque question, écris en une ligne : entrées → traitement → sortie (chapitre 1). Reconnais le motif : somme, maximum, comptage, recherche, tri, parcours de chaîne, double boucle.
3. Écrire l'algorithme (15 minutes). En pseudo-code ou directement en Python sur papier, au choix, mais proprement : indentation, en-tête, commentaires. Si le problème est gros, découpe-le en fonctions (méthode descendante).
4. Préparer les tests (5 minutes). Un tableau de jeu d'essai : un cas normal, deux ou trois cas limites, avec les résultats attendus calculés à la main. Fais une trace rapide sur le cas le plus simple.

Les 30 minutes sur machine

1. Taper l'algorithme par morceaux. Une fonction à la fois, et exécute après chacune. Une erreur trouvée sur 5 lignes se corrige en une minute ; sur 50 lignes, elle peut te coûter la demi-heure.
2. Tester avec ton jeu d'essai, au fur et à mesure. Garde les tests dans le fichier, sous forme d'assert ou d'affichages commentés, pour pouvoir les rejouer devant la commission.
3. Noter les erreurs trouvées : chaque bug corrigé est un excellent sujet pour l'oral (« mon premier essai renvoyait 0 pour une liste de températures négatives ; j'avais initialisé le maximum à 0 »).
4. Soigner la lisibilité dans les 5 dernières minutes : noms de variables, commentaires, docstrings.
5. Enregistrer souvent, dans le dossier indiqué par le centre.

Utilise l'aide syntaxique : help(str) dans la console liste les méthodes des chaînes, help(list.insert) explique insert. Le référentiel l'autorise explicitement ; il vaut mieux vérifier la syntaxe que deviner. Pas d'internet, en revanche : prépare-toi à travailler avec la seule documentation installée sur le poste.

Les 10 minutes de présentation

Tu présentes ta solution algorithmique et son implémentation. Un plan simple, qui tient dans le temps :

1. Le problème en une phrase et ce qui t'a été demandé (30 secondes).
2. Ta démarche : le découpage en sous-problèmes, le motif reconnu, le choix des structures (pourquoi un TantQue plutôt qu'un Pour, pourquoi une liste de dictionnaires) (2 minutes).
3. Le cœur de l'algorithme, expliqué ligne par ligne sur la partie la plus intéressante, pas sur tout (3 minutes).
4. La démonstration : exécute ton jeu d'essai, en annonçant le résultat attendu avant d'appuyer sur Entrée, et insiste sur les cas limites (3 minutes).
5. Les limites et les améliorations : ce qui ne marche pas encore, ce que tu ferais avec plus de temps (1 minute).

Les 10 minutes d'entretien

L'entretien d'explicitation vérifie que tu comprends ce que tu as écrit. Les questions types, et l'esprit des réponses :

Comprendre, modifier et compléter un algorithme existant

Le sujet peut te fournir un algorithme à interpréter (« que fait-il ? »), à modifier (« adaptez-le pour… ») ou à compléter (des lignes manquantes). Le programme d'algorithmique appliquée en fait des compétences à part entière : comprendre un algorithme et expliquer ce qu'il fait, modifier un algorithme existant pour obtenir un résultat différent. La méthode :

1. Lire l'en-tête : rôle, entrées, sorties, préconditions. S'il n'y en a pas, c'est à toi de les retrouver.
2. Identifier le rôle de chaque variable : compteur, accumulateur, indice, booléen d'arrêt, résultat.
3. Faire la trace sur un exemple minuscule (deux ou trois éléments), puis formuler le rôle en une phrase.
4. Modifier le minimum : souvent une condition, une initialisation ou une borne. Ne réécris pas tout.
5. Retester avec l'ancien jeu d'essai et de nouveaux cas.

Exemple. Le sujet fournit cette fonction :

def moyenne_classe(notes):
    somme = 0
    for n in notes:
        somme = somme + n
    return somme / len(notes)

On demande : « Les absences sont codées −1 dans la liste. Modifiez la fonction pour qu'elle ignore les absences et renvoie aussi le nombre d'absents. »

Trace de l'existant sur [12, -1, 16] : somme vaut 27, la fonction renvoie 27 / 3 = 9. C'est faux à deux titres : −1 est ajouté comme une note, et l'absent compte dans le diviseur. La modification touche trois points : un test dans la boucle, un compteur de présents (le diviseur), un compteur d'absents (la nouvelle sortie).

def moyenne_classe(notes):
    """Moyenne des notes présentes (les absences valent -1) et nombre d'absents."""
    somme = 0
    nb_presents = 0
    nb_absents = 0
    for n in notes:
        if n == -1:
            nb_absents = nb_absents + 1
        else:
            somme = somme + n
            nb_presents = nb_presents + 1
    if nb_presents == 0:
        return None, nb_absents     # aucune note : pas de moyenne
    return somme / nb_presents, nb_absents


print(moyenne_classe([12, -1, 16]))
print(moyenne_classe([-1, -1]))

(14.0, 1)
(None, 2)

La structure d'origine (un parcours avec accumulateur) est conservée ; tout ce qui a changé se justifie en une phrase. C'est ce qu'on attend d'une modification.

L'E3 en forme ponctuelle

Si tu passes l'E3 en forme ponctuelle, l'exercice d'algorithmique est écrit, sans machine. On te demande typiquement de compléter, d'interpréter ou d'écrire un algorithme, et d'en faire la trace. Les conseils de la partie « sur table » s'appliquent, avec une exigence de plus : personne ne vérifiera ton code en l'exécutant, donc fais la trace toi-même sur l'exemple de l'énoncé, et écris les résultats intermédiaires. Annonce tes conventions (indices à partir de 0 ou de 1) en tête de copie.

Aide-mémoire pseudo-code et Python

Les erreurs qui coûtent des points

• Se lancer sur la machine sans algorithme écrit : la demi-heure sur table sert justement à éviter de chercher en tapant.
• Présenter un programme sans jeu d'essai, ou avec des tests dont on n'a pas calculé le résultat attendu.
• Réécrire une fonction fournie dans le sujet au lieu de l'appeler.
• Mélanger les conventions : = pour l'affectation à une ligne, ← à la suivante ; indices à partir de 1 dans la boucle, à partir de 0 dans l'accès.
• Afficher au lieu de renvoyer dans une fonction de calcul (chapitre 6).
• Oublier les cas limites : liste vide, un seul élément, valeur absente, égalités.
• Lire le code à l'écran pendant la présentation, au lieu d'expliquer la démarche.
• Dépasser les 10 minutes de présentation : prépare un plan minuté.

Exercices

def contient_chiffre(mdp):
    for c in mdp:
        if c.isdigit():
            return True
    return False


def nb_conformes(liste):
    nb = ...
    for mdp in liste:
        if ...:
            ...
    return nb

def contient_chiffre(mdp):
    for c in mdp:
        if c.isdigit():
            return True
    return False


def nb_conformes(liste):
    nb = 0
    for mdp in liste:
        if len(mdp) >= 12 and contient_chiffre(mdp):
            nb = nb + 1
    return nb


print(nb_conformes(["Soleil2026!!", "court1", "pasdechiffreici", "Rentree-SIO-2026"]))

temperatures = [12.5, 14.0, 17.5, 16.0, 17.5, 11.0, 9.5]
maxi = temperatures[0]
for t in temperatures:
    if t > maxi:
        maxi = t
print(maxi)

jours = ["lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi", "dimanche"]
temperatures = [12.5, 14.0, 17.5, 16.0, 17.5, 11.0, 9.5]
i_max = 0
for i in range(1, len(temperatures)):
    if temperatures[i] >= temperatures[i_max]:
        i_max = i
print(temperatures[i_max], jours[i_max])

def f(s):
    if s == "":
        return ""
    r = ""
    c = s[0]
    n = 1
    for i in range(1, len(s)):
        if s[i] == c:
            n = n + 1
        else:
            r = r + c + str(n)
            c = s[i]
            n = 1
    return r + c + str(n)