Épreuve pratique NSI 2026 — Sujet 21 : cartes mémoire et boîtes de Leitner

Épreuve pratique de NSI, session 2026 — sujet n°21 de la banque nationale. Durée : 1 heure, sur ordinateur. Le candidat dispose de l'énoncé et de fichiers de code et de données ; il agit en autonomie et, aux « appels professeur » indiqués, présente son travail à l'examinateur ou le sollicite en cas de difficulté.

Cartes mémoire et boîtes de Leitner

Les cartes mémoire (ou flashcards) sont des supports de révision comportant au recto une question et au verso la réponse. Elles permettent des révisions actives très efficaces.

On souhaite développer une application utilisant le système des boîtes de Leitner, qui permet de gérer ces cartes en se basant sur un principe de répétition espacée. Dans cette méthode, chaque carte possède un niveau d'avancement (de 0 à 4). Plus le niveau est élevé, plus le délai avant la prochaine révision est grand. Les délais sont donnés par le tableau suivant :

En pratique, la méthode fonctionne ainsi : lorsque l'utilisateur révise une carte, s'il répond correctement, la carte passe au niveau supérieur (sans dépasser le niveau 4 maximum). S'il se trompe, la carte retombe immédiatement au niveau 0, quel que soit son niveau précédent. La prochaine date de révision est ensuite calculée en ajoutant le délai du nouveau niveau à la date du jour.

On modélise ce fonctionnement à l'aide de la programmation orientée objet. Dans le fichier cartes.py, la classe Carte a été commencée.

Question 1. Écrire la méthode traiter_reponse(self, succes) qui prend en paramètre un booléen succes (True si l'utilisateur a bien répondu, False sinon). Cette méthode doit mettre à jour l'attribut self.niveau de la carte selon les règles de Leitner énoncées, puis calculer et mettre à jour l'attribut self.date_prochaine en utilisant la liste globale DELAIS.

Indication : pour ajouter des jours à la date d'aujourd'hui, on utilisera la fonction fournie date_future(nb_jours) qui renvoie la date située nb_jours après aujourd'hui.

Appel professeur — Appeler le professeur pour lui présenter votre réponse ou en cas de difficulté.

On considère que la base de révision, le paquet de cartes, est une liste d'instances de la classe Carte.

Question 2. Écrire une fonction extraire_cartes_du_jour(paquet, date_jour) qui prend en paramètres une liste de cartes paquet et une date de référence date_jour et qui renvoie une nouvelle liste contenant uniquement les cartes dont la date_prochaine est inférieure ou égale à date_jour. On admet qu'on peut comparer des dates avec les opérateurs usuels <, <=, ==, >= et >.

Appel professeur — Appeler le professeur pour lui présenter votre réponse ou en cas de difficulté.

Afin d'aider l'étudiant à cibler ses lacunes, on souhaite extraire du paquet les cartes qui lui posent le plus de problèmes, c'est-à-dire celles dont le niveau est le plus bas parmi toutes les cartes du paquet. La fonction extraire_cartes_a_renforcer(paquet) a été rédigée dans ce but. Cependant, elle contient une faille logique.

Question 3. Exécuter la fonction test_renforcement() fournie. Observer le résultat affiché dans la console et constater l'incohérence. Analyser le code de la fonction extraire_cartes_a_renforcer(paquet), identifier la source de cette erreur logique, puis corriger le code afin qu'il ne renvoie que les cartes possédant rigoureusement le niveau minimum.

Appel professeur — Appeler le professeur pour lui présenter votre réponse ou en cas de difficulté.

Fichier fourni : cartes.py

import datetime
 
 
def date_future(nb_jours):
    """Renvoie la date située nb_jours après aujourd'hui"""
    return datetime.date.today() + datetime.timedelta(days=nb_jours)
 
 
# Variable contenant les délais en jours pour chaque niveau (index 0 à 4)
DELAIS = [1, 3, 7, 15, 30]
 
 
class Carte:
 
    def __init__(self, question, reponse):
        self.question = question
        self.reponse = reponse
        self.niveau = 0
        # À la création, la carte est à réviser le jour même
        self.date_prochaine = datetime.date.today()
 
    def __repr__(self):
        return f"<Carte: {self.question} (Niveau {self.niveau})>"
 
    #############################################################################
    # Écrire la méthode traiter_reponse(self, succes) de la question 1          #
    #############################################################################
 
 
# Des cartes et un paquet de cartes pour réaliser des tests
c1 = Carte("Capitale de l'Italie ?", "Rome")
c1.niveau = 2
c1.date_prochaine = date_future(4)
c2 = Carte("7 x 8 ?", "56")
c2.date_prochaine = date_future(1)
c3 = Carte("Symbole du Fer ?", "Fe")
c3.date_prochaine = date_future(7)
 
paquet = [c1, c2, c3]
 
 
#############################################################################
# Écrire la fonction extraire_cartes_du_jour de la question 2               #
#############################################################################
 
 
#############################################################################
# Fonction défaillante à analyser et corriger pour la question 3            #
#############################################################################
 
def extraire_cartes_a_renforcer(paquet):
    """
    Parcourt le paquet et renvoie la liste des cartes ayant le 
    niveau d'avancement le plus faible.
    """
    if len(paquet) == 0:
        return []
 
    niveau_min = paquet[0].niveau
    a_renforcer = []
 
    for carte in paquet:
        if carte.niveau < niveau_min:
            niveau_min = carte.niveau
            a_renforcer.append(carte)
        elif carte.niveau == niveau_min:
            a_renforcer.append(carte)
 
    return a_renforcer
 
 
def test_renforcement():
    # Création d'un paquet de test
    c1 = Carte("Capitale de l'Italie ?", "Rome")
    c1.niveau = 2
 
    c2 = Carte("7 x 8 ?", "56")
    c2.niveau = 1
 
    c3 = Carte("Symbole du Fer ?", "Fe")
    c3.niveau = 2
 
    mon_paquet = [c1, c2, c3]
 
    # Appel de la fonction défaillante
    resultat = extraire_cartes_a_renforcer(mon_paquet)
 
    print("Cartes à renforcer (celles ayant le niveau le plus bas) :")
    print(resultat)