Annales bac NSI 2024 : sujets corriges
Pourquoi les annales bac NSI 2024 sont indispensables avant le jour J
En Terminale, NSI pèse lourd : c’est une spécialité à coefficient 16 au baccalauréat 2024, ce qui veut dire qu’une note catastrophique fait saigner ta moyenne générale et, par ricochet, ton dossier Parcoursup pour les BTS SIO, les prépas MPSI ou les licences info. Sans compter le Grand Oral, qui peut porter sur un projet NSI si tu l’as choisi comme axe. Autant dire que maîtriser les annales bac NSI 2024, c’est pas optionnel.
Cet article décortique trois exercices types tels qu’ils apparaissent dans les sujets 2024 (épreuves de mai et de juin, centres France métropolitaine et centres étrangers), avec le barème indicatif, le corrigé complet en Python et les pièges à ne pas tomber dedans.
Exercice 1 : structures de données — les listes et les piles
Énoncé résumé
Dans un sujet type 2024, on demande d’implémenter une pile (stack) à partir d’une liste Python, puis d’écrire une fonction qui vérifie si une expression mathématique contient des parenthèses correctement équilibrées. On manipule les opérations empiler, dépiler et est_vide. Le contexte change (éditeur de texte, calculatrice, compilateur) mais la logique reste identique.
Barème indicatif
- Définition de la classe ou des fonctions de base : 3 points
- Algorithme de vérification des parenthèses : 4 points
- Jeux de tests commentés : 3 points
Corrigé Python commenté
# Implémentation d'une pile avec une liste Python
def creer_pile():
return []
def est_vide(pile):
return len(pile) == 0
def empiler(pile, element):
pile.append(element) # append ajoute en fin de liste = sommet
def depiler(pile):
if est_vide(pile):
raise IndexError("Pile vide")
return pile.pop() # pop retire le dernier élément
def parentheses_equilibrees(expression):
pile = creer_pile()
ouvrantes = "([{"
fermantes = ")]}"
correspondance = {')': '(', ']': '[', '}': '{'}
for caractere in expression:
if caractere in ouvrantes:
empiler(pile, caractere)
elif caractere in fermantes:
if est_vide(pile):
return False
if depiler(pile) != correspondance[caractere]:
return False
return est_vide(pile) # True si toutes les ouvrantes ont été fermées
# Tests
print(parentheses_equilibrees("(a+b)*[c-{d}]")) # True
print(parentheses_equilibrees("(a+b]")) # False
Piège récurrent : beaucoup d’élèves oublient le return est_vide(pile) à la fin et renvoient True directement. Or si l’expression se termine par une parenthèse ouvrante non fermée, la pile n’est pas vide et la réponse est False. Ce détail vaut souvent 2 points.
Exercice 2 : algorithmes — tri et complexité
Énoncé résumé
Un sujet type 2024 propose d’implémenter le tri par insertion sur une liste d’entiers, puis d’analyser sa complexité dans le meilleur et le pire cas. On demande souvent de comparer avec le tri par sélection ou de justifier le choix d’un algorithme selon la taille des données.
Barème indicatif
- Implémentation correcte du tri : 4 points
- Trace d’exécution sur un exemple : 2 points
- Analyse de complexité justifiée : 4 points
Corrigé Python commenté
def tri_insertion(liste):
"""
Tri par insertion en place.
Complexité : O(n) meilleur cas (liste déjà triée),
O(n²) pire cas (liste triée à l'envers).
"""
for i in range(1, len(liste)):
cle = liste[i] # élément à insérer
j = i - 1
while j >= 0 and liste[j] > cle:
liste[j + 1] = liste[j] # décale vers la droite
j -= 1
liste[j + 1] = cle # insère à la bonne position
return liste
# Trace sur [5, 3, 8, 1]
# i=1 : cle=3, [3,5,8,1]
# i=2 : cle=8, [3,5,8,1]
# i=3 : cle=1, [1,3,5,8]
print(tri_insertion([5, 3, 8, 1])) # [1, 3, 5, 8]
Piège récurrent : confondre complexité temporelle et complexité spatiale. Le correcteur attend que tu précises que le tri par insertion est en place (O(1) en mémoire) et stable. Si tu n’écris que “c’est O(n²)”, tu perds les points de justification.
Exercice 3 : bases de données — requêtes SQL
Énoncé résumé
Un sujet type 2024 présente un schéma relationnel avec deux ou trois tables (par exemple Eleves, Cours, Inscriptions) et demande d’écrire des requêtes SQL : sélection avec condition, jointure, agrégation avec GROUP BY, et parfois une sous-requête. On peut aussi demander de corriger une requête contenant une erreur.
Barème indicatif
- Requêtes simples SELECT / WHERE : 3 points
- Jointure (INNER JOIN ou JOIN) : 3 points
- Agrégation GROUP BY / HAVING : 4 points
Corrigé SQL avec explications
-- Schéma supposé :
-- Eleves(id_eleve, nom, classe)
-- Inscriptions(id_eleve, id_cours, note)
-- Cours(id_cours, intitule, coefficient)
-- 1. Noms des élèves de Terminale avec une note > 15
SELECT e.nom
FROM Eleves e
JOIN Inscriptions i ON e.id_eleve = i.id_eleve
WHERE e.classe = 'Terminale' AND i.note > 15;
-- 2. Moyenne par cours, seulement si > 12
SELECT c.intitule, AVG(i.note) AS moyenne
FROM Cours c
JOIN Inscriptions i ON c.id_cours = i.id_cours
GROUP BY c.intitule
HAVING AVG(i.note) > 12;
Piège récurrent : écrire WHERE AVG(note) > 12 au lieu de HAVING. La clause WHERE s’applique avant le regroupement, HAVING après. Ce piège revient dans quasiment chaque sujet NSI depuis 2022.
Code source complet — fichier Python prêt à tester
On regroupe ici les trois fonctions dans un seul script fonctionnel, utilisable directement dans Thonny, VS Code ou un notebook Jupyter :
# ── STRUCTURES DE DONNÉES ──────────────────────────────
def creer_pile(): return []
def est_vide(p): return len(p) == 0
def empiler(p, e): p.append(e)
def depiler(p): return p.pop() if not est_vide(p) else None
def parentheses_equilibrees(expr):
p, corr = creer_pile(), {')':'(', ']':'[', '}':'{'}
for c in expr:
if c in "([{": empiler(p, c)
elif c in ")]}":
if est_vide(p) or depiler(p) != corr[c]: return False
return est_vide(p)
# ── ALGORITHMES ───────────────────────────────────────
def tri_insertion(lst):
for i in range(1, len(lst)):
cle, j = lst[i], i - 1
while j >= 0 and lst[j] > cle:
lst[j+1] = lst[j]; j -= 1
lst[j+1] = cle
return lst
# ── TESTS RAPIDES ─────────────────────────────────────
assert parentheses_equilibrees("(a+[b])") == True
assert parentheses_equilibrees("(a+[b)") == False
assert tri_insertion([4,2,7,1]) == [1,2,4,7]
print("Tous les tests sont passés.")
FAQ — annales bac NSI 2024
Les sujets 2024 sont-ils vraiment différents des années précédentes ?
Globalement, la structure reste stable depuis 2022 : trois exercices indépendants sur environ 3 heures, couvrant structures de données, algorithmes, bases de données et réseaux. En 2024, les sujets ont davantage intégré le paradigme objet et les graphes dans l’exercice sur les algorithmes.
Quel langage utiliser à l’écrit : Python ou pseudocode ?
Python est fortement recommandé car le programme officiel le cite explicitement. Si le sujet dit “en Python”, tout pseudocode perd des points. En revanche, pour l’explication d’un algorithme, un commentaire clair dans le code remplace avantageusement un pseudocode séparé.
Combien de points perd-on pour un code qui ne s’exécute pas ?
Le barème valorise la démarche. Une erreur de syntaxe mineure (parenthèse manquante) ne coûte généralement qu’1 point si la logique est correcte. En revanche, un algorithme logiquement faux sur le fond est rarement sauvé par un code qui tourne.
Les bases de données, ça compte vraiment ?
Oui. L’exercice SQL représente en moyenne 8 à 10 points sur 20 dans les sujets 2024. C’est souvent l’exercice où les élèves récupèrent des points facilement car les requêtes de base (SELECT, WHERE, JOIN) sont très répétitives d’une annale à l’autre.
Comment préparer le Grand Oral si mon projet porte sur NSI ?
Le Grand Oral vaut coefficient 10. Si tu présentes un projet NSI (application web, IA, base de données), prépare-toi à expliquer tes choix algorithmiques sans ordinateur, en lien avec une question de société (protection des données, accessibilité numérique). Le jury teste ta compréhension, pas ta mémoire du code.
Pour approfondir avec un tutorat IA par spécialité et simuler le Grand Oral, rendez-vous sur bacia.fr.