Réviser l'écrit en 10 jours
Objectif : sécuriser le 10/20
// adapté à ton cas : ~1-2h par jour, départ proche de zéro

Le strict essentiel pour décrocher le 10 en NSI

Cet outil ne couvre pas tout le programme — il couvre ce qui tombe le plus souvent à l'écrit, dans l'ordre de rentabilité. La logique : maximiser les points faciles (SQL, POO) avant de gratter le reste.

Chaque module = un mini-cours + un QCM corrigé + des exercices guidés (réponses à révéler) + une fiche « à retenir ». Les pourcentages indiquent la fréquence d'apparition estimée dans les annales 2021-2025.

! Comment utiliser ce site

⚡ Méthode anti-blocage

Tu bloques vite ? Normal. La règle : ne lis jamais une correction sans avoir essayé d'abord. Sur chaque QCM, clique ta réponse avant de voir l'explication. Sur chaque exercice, écris ta réponse sur papier, PUIS déplie la solution. C'est en te trompant maintenant que tu retiens pour le jour J.

🎯 La stratégie du 10/20

Les 3 exercices de l'écrit sont tous obligatoires (plus de choix depuis 2023). Mais tu peux viser ~80% des points sur SQL et POO (les plus faciles et les plus répétitifs), et ~30-40% sur le reste. Ça te place mécaniquement autour de 10.

# Les 6 modules, par priorité

⚠️ À lire avant de faire des impasses

« Moins probable » ne veut pas dire « impossible ». Un thème rare peut constituer un exercice entier (= ~33% de la note d'écrit). Ces 6 modules couvrent l'essentiel, mais si tu as le temps, jette quand même un œil aux tris et aux systèmes d'exploitation. Et garde en tête : ces % sont des estimations issues des annales, pas une garantie.

01 Bases de données & SQL ≈ 85% des sujets

C'est le module le plus rentable de toute l'épreuve. Les questions reviennent presque à l'identique chaque année. Une fois les 6 mots-clés en tête, tu réponds quasi mécaniquement.

Une base relationnelle, c'est quoi ?

Une base de données = un ensemble de tables (aussi appelées relations). Pense à un classeur tableur :

📐 Définition · clé primaire

La colonne qui identifie de façon unique chaque ligne. Deux élèves peuvent s'appeler « Martin », mais leur id diffère.

🧠 Mnémo

PRImaire = PRIvée : elle n'appartient qu'à UNE seule ligne.

📐 Définition · clé étrangère

Une colonne qui pointe vers la clé primaire d'une autre table. C'est le « fil » qui relie deux tables entre elles.

🧠 Mnémo

étrangère = elle vient d'ailleurs : elle voyage vers une autre table.

Les 6 mots-clés, dans l'ordre obligatoire

🧠 La phrase qui contient tout

« SELECT — FROM — WHERE — GROUP BY — HAVING — ORDER BY »

Astuce pour l'ordre : « Sache Filtrer Where, Groupe Habilement, Ordonne ». Et retiens surtout : SELECT … FROM … WHERE = le trio de base, qui suffit pour 90% des questions.

Mot-cléRôleTraduction mentale
SELECTquelles colonnes afficher« je veux voir… »
FROMdans quelle table« …dans le tableau… »
WHEREcondition de filtrage« …mais seulement si… »
ORDER BYtrier le résultat« …et range-moi ça »
GROUP BYregrouper pour compter« …par paquets »
JOIN … ONrelier deux tables« …en croisant 2 tables »

Fiche réflexe : reconnaître la question → recracher le motif

Tu vois dans l'énoncé…Tu écris…
« afficher / quels sont »SELECT … FROM …
« dont / qui ont / tel que »WHERE
« toutes les infos »SELECT *
« trier / classer / ordonner »ORDER BY (+ ASC ↑ / DESC ↓)
« combien / nombre de »COUNT(*)
« pour chaque »GROUP BY
condition sur un comptageHAVING (pas WHERE !)
infos dans 2 tablesJOIN … ON cléÉtr = cléPrim
« ajouter »INSERT INTO … VALUES …
« modifier »UPDATE … SET … WHERE …
« supprimer »DELETE FROM … WHERE …
🧠 Mnémos express

ASC = ASCenseur qui monte ↑ (croissant) · DESC = DEScente ↓ (décroissant)

Texte → réflexe : « combien » → COUNT · « pour chaque » → GROUP BY

⚠️ Le piège qui coûte des points

Un UPDATE ou un DELETE SANS WHERE modifie/supprime TOUTE la table. Les correcteurs vérifient systématiquement la présence du WHERE.

Le JOIN — la recette en 3 temps

C'est la seule partie un peu technique, mais elle tombe très souvent. Le motif est toujours identique :

SELECT Eleve.nom, Classe.nom
FROM Eleve
JOIN Classe ON Eleve.id_classe = Classe.id;
🧠 Recette JOIN (à recopier mécaniquement)

1️⃣ FROM table1 → 2️⃣ JOIN table2 → 3️⃣ ON cléÉtrangère = cléPrimaire

« ON relie les deux bouts du fil. » Le ON, c'est toujours cléÉtrangère = cléPrimaire.

? QCM — teste tes réflexes

Base utilisée : Livre(id, titre, annee, prix). Clique une réponse pour voir la correction.

✎ Exercices guidés

Base : Livre(id, titre, annee, id_auteur, prix) · Auteur(id_auteur, nom, nationalite) · Emprunt(id_emprunt, id_livre, date)

📌 À retenir — SQL

  • Ordre obligatoire : SELECT → FROM → WHERE → GROUP BY → HAVING → ORDER BY
  • SELECT * = toutes les colonnes · COUNT(*) = compter les lignes
  • Texte entre guillemets simples ('française'), nombres sans guillemets (> 2000)
  • WHERE filtre AVANT le regroupement · HAVING filtre APRÈS (condition sur un COUNT)
  • JOIN = relier 2 tables sur cléÉtrangère = cléPrimaire
  • Toujours un WHERE dans UPDATE et DELETE, sinon toute la table y passe
  • ASC = croissant ↑ · DESC = décroissant ↓

02 Programmation orientée objet ≈ 75% des sujets

Depuis 2023, la POO est presque partout. Bonne nouvelle : on te demande surtout de compléter du code fourni, pas d'inventer. Une fois le « squelette » d'une classe compris, tu le reconnais dans tous les sujets.

L'idée : ranger des données ET leurs actions ensemble

Une classe est un moule. Un objet (ou instance) est ce qu'on fabrique avec le moule. Exemple : la classe Chien est le concept ; Rex et Médor sont deux objets fabriqués à partir de ce moule.

🧠 Mnémo

Classe = moule à gâteaux. Objet = le gâteau. Un seul moule, autant de gâteaux qu'on veut, chacun avec ses propres caractéristiques.

Le squelette à connaître par cœur

class Chien:
    def __init__(self, nom, age):   # le constructeur
        self.nom = nom            # attribut
        self.age = age            # attribut

    def aboyer(self):              # méthode
        return "Wouf !"

rex = Chien("Rex", 3)        # instanciation
print(rex.nom)                 # accès attribut → Rex
print(rex.aboyer())            # appel méthode → Wouf !
📐 Le vocabulaire qui tombe (à savoir nommer !)

Constructeur : la méthode __init__, appelée automatiquement à la création de l'objet.
Attribut : une variable attachée à l'objet (self.nom).
Méthode : une fonction définie dans la classe (elle prend toujours self en 1er paramètre).
Instance / instancier : un objet créé / l'action de le créer (Chien("Rex", 3)).

🧠 Les 3 réflexes qui ne trompent pas

1. Toute méthode commence par def et prend self en premier.
2. Tout attribut s'écrit self.qqch à l'intérieur de la classe.
3. Le constructeur s'appelle toujours __init__ (deux underscores de chaque côté).

⚠️ Erreurs classiques sanctionnées

Oublier self en paramètre d'une méthode · écrire nom au lieu de self.nom dans la classe · oublier les parenthèses à l'appel d'une méthode (rex.aboyer au lieu de rex.aboyer()).

L'encapsulation (souvent une question de cours)

Idée : regrouper les données (attributs) et les fonctions qui agissent dessus (méthodes) dans un même objet, et y accéder via des méthodes plutôt que directement. On parle de getter (lire un attribut) et setter (le modifier).

class CompteBancaire:
    def __init__(self, solde):
        self.solde = solde

    def get_solde(self):        # getter : lire
        return self.solde

    def deposer(self, montant):  # setter : modifier
        self.solde = self.solde + montant

? QCM — POO

✎ Exercices guidés

📌 À retenir — POO

  • Classe = moule, objet = ce qu'on fabrique avec
  • Le constructeur s'appelle toujours __init__(self, …)
  • Attribut = self.nom · Méthode = fonction avec self en 1er paramètre
  • Instancier = créer un objet : rex = Chien("Rex", 3)
  • Accès : objet.attribut et objet.methode() (parenthèses !)
  • Encapsulation : getter (lire) + setter (modifier) les attributs

03 Récursivité & structures linéaires ≈ 70% des sujets

La récursivité fait peur mais repose sur un schéma toujours identique. Et les piles/files sont des structures simples avec un vocabulaire à connaître. Ensemble, ils apparaissent dans 2 sujets sur 3.

Récursivité : une fonction qui s'appelle elle-même

Toute fonction récursive a exactement deux parties :

🧠 Mnémo des poupées russes

Chaque poupée en contient une plus petite, jusqu'à la plus petite qu'on ne peut plus ouvrir (= cas de base). Sans cette dernière poupée, on ouvrirait à l'infini.

def factorielle(n):
    if n == 0:            # cas de base
        return 1
    else:                  # cas récursif
        return n * factorielle(n - 1)
💡 Le squelette universel

Devant N'IMPORTE quel exercice de récursivité, écris d'abord ce gabarit, puis remplis les trous :

def f(n):
    if # condition d'arrêt :
        return # valeur simple
    else:
        return # … f(plus petit) …

Les piles (LIFO) et les files (FIFO)

📐 Définitions

Pile (stack) : dernier entré, premier sorti — comme une pile d'assiettes. On ajoute/retire par le haut.
File (queue) : premier entré, premier sorti — comme une file d'attente. On ajoute d'un côté, on retire de l'autre.

🧠 Mnémos

Pile = LIFO = Last In First Out → pile d'assiettes (tu prends celle du dessus).
File = FIFO = First In First Out → file à la boulangerie (premier arrivé, premier servi).

StructureAjouterRetirerImage
Pile (LIFO)empiler / pushdépiler / pop🍽️ assiettes
File (FIFO)enfiler / enqueuedéfiler / dequeue🥖 file d'attente

? QCM — Récursivité & piles/files

✎ Exercices guidés

📌 À retenir — Récursivité & structures

  • Récursivité = cas de base (arrêt) + cas récursif (appel sur plus petit)
  • Sans cas de base → boucle infinie → erreur
  • Pile = LIFO (dernier entré, premier sorti) : empiler / dépiler
  • File = FIFO (premier entré, premier sorti) : enfiler / défiler
  • Réflexe : écris d'abord le squelette if base … else … f(plus petit)

04 Arbres binaires ≈ 65% des sujets

Très fréquent depuis 2023, souvent couplé avec POO et récursivité. Le cœur : le vocabulaire, les 3 parcours et la recherche dans un ABR.

Le vocabulaire (questions de cours faciles)

📐 Définitions

Nœud : un élément de l'arbre · Racine : le nœud tout en haut · Feuille : un nœud sans enfant · Arbre binaire : chaque nœud a au plus 2 enfants (gauche / droit).
Taille : nombre total de nœuds · Hauteur : nombre de niveaux (longueur du plus long chemin racine→feuille).

🧠 Mnémo

Un arbre en info est à l'envers : la racine est en haut, les feuilles en bas. Binaire = 2 branches max par nœud.

Les 3 parcours en profondeur (ça tombe presque à chaque fois)

📐 Où place-t-on la racine ?

Préfixe : racine AVANT (Racine → Gauche → Droite)
Infixe : racine AU MILIEU (Gauche → Racine → Droite)
Postfixe : racine APRÈS (Gauche → Droite → Racine)

🧠 Mnémo imparable

PRÉfixe = racine en PREmier · INfixe = racine IN (dedans, au milieu) · POSTfixe = racine en POST (après, à la fin).

Bonus : un parcours infixe d'un ABR donne les valeurs dans l'ordre croissant. ⭐

L'arbre binaire de recherche (ABR)

📐 La règle d'or de l'ABR

Pour chaque nœud : tout ce qui est à GAUCHE est plus petit, tout ce qui est à DROITE est plus grand. C'est ce qui rend la recherche rapide (on élimine la moitié à chaque étape).

class Noeud:
    def __init__(self, valeur):
        self.valeur = valeur
        self.gauche = None
        self.droite = None

? QCM — Arbres

✎ Exercices guidés

📌 À retenir — Arbres binaires

  • Racine en haut, feuilles en bas · binaire = 2 enfants max
  • Hauteur = nb de niveaux · Taille = nb de nœuds
  • Préfixe (R-G-D) · Infixe (G-R-D) · Postfixe (G-D-R)
  • Parcours infixe d'un ABR = valeurs triées croissantes
  • ABR : gauche < nœud < droite
  • Les parcours s'écrivent presque toujours de façon récursive

05 Réseaux & routage ≈ 55% des sujets

Beaucoup de questions de cours = des points à prendre sans écrire une ligne de code. Le cœur attendu : adressage IP et les deux protocoles de routage RIP et OSPF.

Adresse IP & masque

📐 Définitions

Adresse IP : identifiant d'une machine sur le réseau (ex : 192.168.1.10).
Masque de sous-réseau : sépare la partie « réseau » de la partie « machine ». Avec /24, les 24 premiers bits identifient le réseau.

Les 2 protocoles de routage à connaître

RIPOSPF
Critère choisinombre de sauts (routeurs traversés)coût des liens (lié au débit)
Typevecteur de distanceétat de liens
Choisit…le chemin le plus court (moins de sauts)le chemin le plus rapide (meilleur débit)
Limitemax 15 sautsplus complexe, plus efficace
🧠 Mnémo

RIP compte les sauts (R-I-P → « Routes : I count Pas » = je compte les pas). Il prend la route avec le moins d'étapes, même si elle est lente.
OSPF regarde le débit (« Open Shortest Path First ») → il prend la plus rapide, même avec plus d'étapes.

⚠️ Le piège classique RIP vs OSPF

RIP peut choisir une route lente si elle a moins de sauts. OSPF, lui, peut préférer une route avec plus de routeurs si le débit total est meilleur. L'exercice oppose presque toujours ces deux choix sur un même schéma.

? QCM — Réseaux

✎ Exercices guidés

📌 À retenir — Réseaux

  • IP = identifiant machine · masque /24 = 24 bits pour le réseau
  • RIP = nombre de sauts (le plus court), max 15 sauts
  • OSPF = coût/débit des liens (le plus rapide)
  • Piège : RIP ≠ OSPF peuvent choisir des routes différentes sur le même réseau
  • Table de routage : pour chaque destination, le prochain routeur (next hop)

06 Graphes ≈ 35% · en hausse

Quasi absents en 2021-2022, ils sont devenus fréquents depuis 2024. Le cœur : les deux représentations (matrice / liste d'adjacence) et les deux parcours (BFS / DFS).

Vocabulaire

📐 Définitions

Sommet (ou nœud) : un point du graphe · Arête : un lien entre deux sommets · Graphe orienté : les liens ont un sens (flèches) · Non orienté : les liens vont dans les deux sens.

Les 2 représentations

📐 Matrice vs liste d'adjacence

Matrice d'adjacence : un tableau 2D où M[i][j] = 1 s'il y a une arête de i vers j, sinon 0.
Liste d'adjacence : un dictionnaire où chaque sommet pointe vers la liste de ses voisins. Ex : {'A':['B','C'], 'B':['A']}.

🧠 Mnémo

Matrice = tableau de cases (0/1), pratique pour vérifier vite si 2 sommets sont reliés.
Liste = carnet d'adresses : chaque sommet a la liste de ses voisins.

Les 2 parcours

📐 BFS vs DFS

BFS (parcours en largeur) : on explore niveau par niveau, autour du sommet de départ. Utilise une FILE.
DFS (parcours en profondeur) : on s'enfonce le plus loin possible avant de revenir. Utilise une PILE (ou la récursivité).

🧠 Mnémo (le lien avec le module 03 !)

BFS = Breadth (largeur) = File (FIFO) · DFS = Depth (profondeur) = Pile (LIFO).
Astuce : BFS et Boulangerie (file) ↔ DFS et Dessous de la pile.

? QCM — Graphes

✎ Exercices guidés

📌 À retenir — Graphes

  • Sommet + arête · orienté (flèches) vs non orienté
  • Matrice d'adjacence : M[i][j]=1 si arête · Liste : dico de voisins
  • BFS = largeur = FILE (FIFO) · DFS = profondeur = PILE (LIFO)
  • Le choix de la structure (file/pile) détermine le type de parcours

📅 Ton planning sur 10 jours

Calibré pour ~1-2h par jour. La logique : on bétonne d'abord les modules les plus rentables (SQL, POO), puis on grignote le reste, et on garde les 2 derniers jours pour des sujets complets en conditions réelles.

⚡ Règle d'or

Mieux vaut maîtriser 4 modules à fond que survoler les 6. Si tu prends du retard, sacrifie Graphes et Réseaux avant SQL et POO. Jamais l'inverse.

Jour1
SQL — le cours + les réflexes

Lis le module SQL en entier, apprends les 6 mots-clés et la fiche réflexe. Fais le QCM.

module 01~1h30
Jour2
SQL — les exercices + le JOIN

Refais les exercices guidés sans regarder. Insiste sur GROUP BY/HAVING et le JOIN.

module 01JOIN
Jour3
POO — le squelette

Apprends le squelette d'une classe par cœur. Recopie-le 3 fois de mémoire. QCM + 2 exercices.

module 02__init__
Jour4
POO — compléter du code + révision SQL

Exercices POO restants. Puis 20 min de révision flash SQL (les réflexes).

module 02+ révision 01
Jour5
Récursivité & piles/files

Le squelette récursif + LIFO/FIFO. C'est le jour le plus technique : prends ton temps.

module 03
Jour6
Arbres binaires

Vocabulaire + les 3 parcours (mnémo PRÉ/IN/POST) + ABR. QCM + exercices.

module 04
Jour7
Réseaux (par-cœur) + révision POO

RIP vs OSPF, adressage. Beaucoup de cours = points faciles. Puis révision flash POO.

module 05+ révision 02
Jour8
Graphes + révision récursivité

Représentations + BFS/DFS (réutilise file/pile du module 03). Révision flash récursivité.

module 06+ révision 03
Jour9
SUJET BLANC en conditions réelles

Un sujet d'annale complet, 3h30 chrono (ou découpé en 2 fois). Métropole 2024 ou 2025.

annalechrono
Jour10
Correction + révision des « À retenir »

Corrige ton sujet blanc, repère tes erreurs. Relis les 6 fiches « À retenir ». Au lit tôt !

bilanfiches
📍 Le jour J — stratégie

Lis les 3 exercices dans les 5 premières minutes. Commence par celui qui te rassure le plus (effet de confiance). Sur chaque question SQL/POO, applique tes réflexes sans réfléchir. Garde ~1h pour l'exercice le plus dur. Et ne laisse jamais une question de cours vide : il y a souvent des points à gratter juste en récitant une définition.