NSI Arcade — Piles & Files

🌱 Avant les jeux : on commence petit

Tu hésites encore avec les listes ou les boucles ? Ce parcours fait partie du TP2. Commence par lire et modifier quelques lignes, puis construis une petite file d’attente. Pas de classes, pas de récursivité.

Étapes 1 à 6 : listes, parcours, fonctions et ajouts. Étapes 7 à 10 : piles, files et premier embarquement à PyLand. Avance à ton rythme, en une ou plusieurs séances.

Commencer les 10 petits exercices guidés →

Une consigne, un petit code, deux indices facultatifs et des essais ciblés à chaque étape. Les jeux ci-dessous sont des projets à choisir ensuite avec le professeur, pas une course à terminer tous les niveaux.

0 mission validéeProgression conservée sur ce navigateur uniquement.

NIVEAU 01 · ★☆☆🃏BATAILLE.PYLa première carte jouée… revient à la fin.FILE / FIFO NIVEAU 02 · ★★☆🎢PYLAND.PYDes visiteurs, une nacelle : mesure l’attente.FILE / FIFO · Simulation NIVEAU 03 · ★★☆🐍SNAKE.PYObserve le corps. À toi de trouver le modèle.FILE / FIFO NIVEAU 04 · ★★☆🗼HANOI.PYManipule des piles ; découvre ensuite la récursion.PILE / LIFO + découverte guidée BOSS FINAL · ★★★🧩ESCAPE_NSI.PYDeux façons d'explorer. Une sortie à trouver.PILE + FILE / DFS + BFS

🤔 Avant de coder

Observe la démo, fais une prédiction sur papier, puis écris ton algorithme avant d'ouvrir un indice. Les démonstrations sont des modèles à expliquer : ton programme Python reste à construire dans l’atelier en ligne ou dans ton IDE. Coche une mission seulement lorsque tu sais justifier et tester ton code.

📚 Le cours pour t’aider

Piles et assiettes · Files d’attente. Les petites ampoules ci-dessous donnent des explications à ouvrir seulement si nécessaire.

💡 Que fait raise ? Et NotImplementedError ?

raise déclenche une exception : Python interrompt l’exécution normale et cherche un bloc except capable de la traiter. Sans traitement, le programme s’arrête avec un message d’erreur. Ce n’est ni un affichage (print), ni une valeur renvoyée (return).

def retirer(file):
    if not file:
        raise ValueError("La file est vide")
    return file.pop(0)

try:
    retirer([])
except ValueError as erreur:
    print(erreur)  # affiche La file est vide

Dans les squelettes, raise NotImplementedError("Mission à compléter") est un repère volontaire. Remplace cette ligne par ton algorithme lorsque tu programmes la fonction. Le message ne signifie pas que Python est mal installé.

ValueError signale ici une opération refusée ; IndexError apparaît notamment avec un retrait invalide dans une liste. Respecte le contrat de chaque activité : dans PyLand, retirer d’une file vide renvoie None, tandis que la Bataille demande une exception.

01 / 🃏 BATAILLE.PY

FILE · FIFO · ★☆☆

Alice et Bob jouent la première carte de leur paquet. Le gagnant ajoute les cartes jouées à la fin du sien. Comment conserver cet ordre ?

Deux paquets, deux files

Début à gauche → fin à droite. Les 8 prochaines cartes sont visibles ; les compteurs portent sur les files entières.

Règle de bataille utilisée

Une égalité laisse les cartes au centre. Chaque joueur pose une carte cachée, puis compare la suivante au prochain tour. On répète si nécessaire. Pour poursuivre, il faut donc au moins deux cartes chacun. Si un joueur ne peut pas continuer, celui qui conserve le plus de cartes gagne l'enjeu et la partie ; à égalité d'effectif, le résultat est nul. Le gagnant reçoit l'enjeu dans l'ordre où les cartes ont été déposées : Alice puis Bob à chaque dépôt.

La démo s'arrête après 1 000 comparaisons si nécessaire : certaines parties peuvent être très longues ou cycliques.

Mission 1 — Créer le paquet

Représente une carte par (valeur, couleur), avec 2 à 14 pour la valeur, et quatre couleurs. Construis 52 cartes, mélange-les puis distribue deux files de 26 cartes. Vérifie qu'aucune carte n'est perdue ou dupliquée.

Je sais créer et distribuer le paquet.

Mission 2 — Programmer une file

Complète enfiler, defiler et est_vide. Le début de liste contient la prochaine carte à jouer. Teste une file vide, une file d'un élément et plusieurs ajouts/retraits successifs.

Mes trois fonctions préservent l'ordre FIFO.

Mission 3 — Jouer un tour

Retire une carte de chaque file, compare leurs valeurs et ajoute l'enjeu chez le gagnant. Affiche le numéro du tour, les deux cartes, le gagnant du pli et les tailles des files. Vérifie que len(alice) + len(bob) + len(enjeu) == 52.

Un tour sans égalité fonctionne.

Mission 4 — La bataille

Applique la règle de la démo. L'enjeu doit survivre d'un tour au suivant. Fabrique un petit paquet de test qui force deux égalités consécutives, puis un cas où il manque des cartes.

J'ai testé les égalités et les fins de partie.

Mission 5 — Partie automatique

Répète les tours jusqu'à ce qu'une file soit vide ou qu'un résultat terminal soit annoncé. Compte les tours et ajoute une limite de sécurité : une interruption n'est pas une victoire.

Ma boucle s'arrête correctement.

🧠 À retenir — après tes essais

Une file suit l'ordre FIFO : First In, First Out. Le premier arrivé est le premier sorti. Avec une liste Python, retirer à l'indice 0 décale les éléments : coût linéaire. L'interface abstraite d'une file n'impose pas cette implémentation ; collections.deque permet des opérations aux extrémités en temps constant.

🏆 Bonus

Lance 100 parties. Calcule la moyenne des tours des parties terminées, repère la plus longue et compte séparément les parties interrompues. Compare plusieurs mélanges.

🐍 Coder en ligne · importer / exporter · tests

Ton atelier Python

Bibliothèque standard seulement. Les fonctions essentielles restent à compléter.

↓ Télécharger bataille.py

"""NSI Arcade — Bataille. Python 3, bibliothèque standard uniquement.
Lancer dans son IDE. Compléter les TODO mission par mission.
Convention : début de liste = prochain élément à sortir.
"""
from random import shuffle


def creer_paquet():
    # Mission 1. Carte = (valeur, couleur) ; valeurs de 2 à 14 (As).
    # TODO : à compléter — construire les 52 tuples.
    raise NotImplementedError("Mission 1 : créer le paquet")


def distribuer(paquet):
    # TODO : à compléter — mélanger puis renvoyer deux listes de 26 cartes.
    raise NotImplementedError("Mission 1 : distribuer")


def enfiler(file, element):
    # TODO : à compléter — ajouter sans changer l'ordre des autres cartes.
    raise NotImplementedError("Mission 2 : enfiler")


def defiler(file):
    # TODO : à compléter — retirer ET renvoyer la prochaine carte.
    # Lever ValueError si la file est vide.
    raise NotImplementedError("Mission 2 : défiler")


def est_vide(file):
    # TODO : à compléter
    raise NotImplementedError("Mission 2 : tester le vide")


def nom_carte(carte):
    valeur, couleur = carte
    noms = {11: "Valet", 12: "Dame", 13: "Roi", 14: "As"}
    return f"{noms.get(valeur, valeur)} {couleur}"


def jouer_tour(alice, bob, enjeu):
    """Modifie les trois listes. Renvoie 'Alice', 'Bob', 'nul' ou None.
    Un tour = une comparaison de deux cartes visibles.
    Enjeu conserve les cartes des égalités successives.
    """
    # Mission 3 : défiler une carte chacun, comparer les valeurs,
    # afficher les cartes, puis enfiler l'enjeu chez le gagnant.
    # Mission 4 : égalité -> une carte cachée chacun, puis prochain tour.
    # S'il manque des cartes pour continuer : le joueur qui en a le plus
    # gagne l'enjeu et la partie ; même nombre -> match nul.
    # TODO : à compléter
    raise NotImplementedError("Missions 3 et 4 : jouer un tour")


def partie(limite=10000):
    alice, bob = distribuer(creer_paquet())
    enjeu = []
    tours = 0
    # Mission 5 : répéter les tours tant que les deux files sont non vides,
    # qu'aucun résultat terminal n'est annoncé et que tours < limite.
    # Afficher le compteur et les tailles des files à chaque tour.
    # À la limite : annoncer 'partie interrompue', jamais un faux gagnant.
    # TODO : à compléter
    raise NotImplementedError("Mission 5 : boucle de partie")


if __name__ == "__main__":
    try:
        partie()
    except NotImplementedError as erreur:
        print(erreur)
        print("Complète cette mission puis relance le programme.")

"""NSI Arcade — Bataille. Python 3, bibliothèque standard uniquement.
Lancer dans son IDE. Compléter les TODO mission par mission.
Convention : début de liste = prochain élément à sortir.
"""
from random import shuffle

def creer_paquet():
    # Mission 1. Carte = (valeur, couleur) ; valeurs de 2 à 14 (As).
    # TODO : à compléter — construire les 52 tuples.
    raise NotImplementedError("Mission 1 : créer le paquet")

def distribuer(paquet):
    # TODO : à compléter — mélanger puis renvoyer deux listes de 26 cartes.
    raise NotImplementedError("Mission 1 : distribuer")

def enfiler(file, element):
    # TODO : à compléter — ajouter sans changer l'ordre des autres cartes.
    raise NotImplementedError("Mission 2 : enfiler")

def defiler(file):
    # TODO : à compléter — retirer ET renvoyer la prochaine carte.
    # Lever ValueError si la file est vide.
    raise NotImplementedError("Mission 2 : défiler")

def est_vide(file):
    # TODO : à compléter
    raise NotImplementedError("Mission 2 : tester le vide")

def nom_carte(carte):
    valeur, couleur = carte
    noms = {11: "Valet", 12: "Dame", 13: "Roi", 14: "As"}
    return f"{noms.get(valeur, valeur)} {couleur}"

def jouer_tour(alice, bob, enjeu):
    """Modifie les trois listes. Renvoie 'Alice', 'Bob', 'nul' ou None.
    Un tour = une comparaison de deux cartes visibles.
    Enjeu conserve les cartes des égalités successives.
    """
    # Mission 3 : défiler une carte chacun, comparer les valeurs,
    # afficher les cartes, puis enfiler l'enjeu chez le gagnant.
    # Mission 4 : égalité -> une carte cachée chacun, puis prochain tour.
    # S'il manque des cartes pour continuer : le joueur qui en a le plus
    # gagne l'enjeu et la partie ; même nombre -> match nul.
    # TODO : à compléter
    raise NotImplementedError("Missions 3 et 4 : jouer un tour")

def partie(limite=10000):
    alice, bob = distribuer(creer_paquet())
    enjeu = []
    tours = 0
    # Mission 5 : répéter les tours tant que les deux files sont non vides,
    # qu'aucun résultat terminal n'est annoncé et que tours < limite.
    # Afficher le compteur et les tailles des files à chaque tour.
    # À la limite : annoncer 'partie interrompue', jamais un faux gagnant.
    # TODO : à compléter
    raise NotImplementedError("Mission 5 : boucle de partie")

if __name__ == "__main__":
    try:
        partie()
    except NotImplementedError as erreur:
        print(erreur)
        print("Complète cette mission puis relance le programme.")

02 / 🎢 PYLAND.PY

FILE · FIFO · ★★☆

Bienvenue à PyLand Adventure Park ! La nacelle part toutes les deux minutes. À toi de gérer les visiteurs, puis de vérifier si une plus grande capacité réduit réellement leur attente.

TP2 · Chapitre S01 · Sans POO

Après les files de cartes de la Bataille, une file de dictionnaires. Prérequis : listes, dictionnaires, fonctions, boucles. Aucun besoin d’écrire une classe. Revoir les files dans le cours.

Observe avant de programmer

Choisis les réglages, prédis le prochain groupe, puis avance d’un tour. Pour comparer, recommence avec une autre capacité : les arrivées restent identiques.

Places par nacelleBonus mascotte

🚶 Sortie à gauche → entrée à droite

🎢 Dernière nacelle revenue

Les réglages sont figés après le premier tour. Limite pédagogique : 30 tours. Le navigateur simule en JavaScript ; ton programme Python est à construire dans l’atelier en ligne ou dans ton IDE.

Le contrat de simulation : un ordre précis à respecter

À t minutes, départ : retirer les plus anciens, au maximum la capacité. Une nacelle part même incomplète. File vide : aucun embarquement.
Juste après le départ, arrivées à t : ajouter 3, 1, 5, 2, 4 visiteurs selon le tour, puis répéter cette séquence. Un nouvel arrivant ne prend donc pas la nacelle qui vient de partir.
De t à t + 2 : tous ceux qui sont dans la file, nouveaux compris, perdent 5 points. Les passagers gagnent 10 points. La satisfaction reste entre 0 et 100.
À t + 2, retour : enregistrer les passagers parmi les visiteurs sortis et avancer l’horloge. Si elle est activée, la mascotte donne ensuite 10 points aux personnes encore dans la file tous les X tours.

Au début : V1 à V4 attendent depuis t = 0, avec une satisfaction de 75. Pour les suivants, 50 + (numero * 17) % 51 fournit une satisfaction initiale reproductible entre 50 et 100. Ces règles sont un modèle pédagogique choisi, pas une mesure réelle de satisfaction.

Attente = heure de départ − heure d’arrivée. Les deux minutes dans l’attraction ne sont pas de l’attente. Les moyennes portent sur les 20 premiers visiteurs sortis, pas ceux qui restent dans la file. Avant 20 sorties, elles sont provisoires.

🤔 Fais une prédiction

Capacité 2, sans mascotte : qui embarque au premier tour ? Au deuxième ? Combien de minutes V5 aura-t-il attendu à son départ ? Écris ta trace avant d’appuyer sur le bouton.

Mission 1 — Modéliser un visiteur

Complète creer_visiteur(nom, arrivee, satisfaction). Il renvoie un dictionnaire avec ces trois clés. Crée deux visiteurs indépendants : modifier l’un ne doit pas modifier l’autre.

Je représente et teste les visiteurs.

Mission 2 — Faire respecter FIFO

Implémente ajouter_visiteur et retirer_visiteur avec une liste. Ajout en fin ; retrait et retour du plus ancien. Notre contrat : retirer d’une file vide renvoie None. Teste A, B, C : ils doivent sortir dans cet ordre.

Ma file respecte FIFO, même aux limites.

Mission 3 — Remplir une nacelle

Complète embarquer(file, capacite, heure). Renvoie la liste des passagers et ajoute à chacun la clé attente. Vérifie les cas 0, 1, 2 et 3 visiteurs pour une capacité de 2. Ne saute pas de visiteur et ne retire personne deux fois.

Je gère une nacelle vide, incomplète ou pleine.

Mission 4 — Faire évoluer la satisfaction

Complète mettre_a_jour(file, passagers) : −5 pour la file, +10 pour les passagers. Teste les frontières : 3 devient 0 après l’attente et 95 devient 100 après l’attraction. Le déroulement des tours est déjà fourni dans simuler.

Mes mises à jour respectent les bornes et le bon groupe.

Mission 5 — Mesurer, puis comparer

Complète statistiques(sortis) : renvoyer (effectif, attente_moyenne, satisfaction_moyenne) sur les 20 premiers sortis. Sans sortie : (0, None, None). Compare ensuite 2 et 4 places sur 15 tours identiques, sans mascotte.

Je calcule les moyennes sur le bon échantillon et les interprète.

🐍 Coder en ligne · importer / exporter · tests

Ton atelier Python

Les fonctions essentielles restent à compléter. L’orchestration est fournie. Télécharge les deux fichiers dans le même dossier ; lance test_pyland.py après chaque mission. Un test échoue normalement tant que sa fonction est incomplète.

↓ Télécharger pyland.py

↓ Télécharger les tests sans classes

"""TP2 — NSI Arcade / PyLand. Python 3, sans classes ni bibliothèque externe.
Compléter les cinq missions. Les tests sont fournis dans test_pyland.py.
Une liste représente la file : sortie à gauche, entrée à droite.
"""


def creer_visiteur(nom, arrivee, satisfaction=75):
    # Mission 1 : renvoyer un dictionnaire indépendant pour chaque visiteur.
    # Clés : nom, arrivee (minutes), satisfaction (entre 0 et 100).
    raise NotImplementedError("Mission 1 : dictionnaire visiteur")


def ajouter_visiteur(file, visiteur):
    # Mission 2 : ajouter à la fin, sans renvoyer de valeur.
    raise NotImplementedError("Mission 2 : enfiler")


def retirer_visiteur(file):
    # Mission 2 : retirer ET renvoyer le plus ancien ; None si file vide.
    raise NotImplementedError("Mission 2 : défiler")


def embarquer(file, capacite, heure):
    # Mission 3 : retirer au plus capacite visiteurs dans l'ordre FIFO.
    # Capacite est un entier >= 1 ; heure >= toutes les heures d'arrivée.
    # Pour chacun, ajouter attente = heure - arrivee.
    # Renvoyer la liste des visiteurs embarqués (même vide).
    raise NotImplementedError("Mission 3 : embarquer")


def mettre_a_jour(file, passagers):
    # Mission 4 : file perd 5 points ; passagers gagnent 10 points.
    # Borner chaque satisfaction entre 0 et 100. Modifier les dictionnaires.
    raise NotImplementedError("Mission 4 : satisfaction")


def statistiques(sortis):
    # Mission 5 : travailler seulement sur les 20 premiers sortis.
    # Renvoyer (effectif, attente_moyenne, satisfaction_moyenne).
    # Si personne n'est sorti : renvoyer (0, None, None).
    raise NotImplementedError("Mission 5 : moyennes")


def simuler(capacite=2, tours=15):
    """Orchestration fournie : compare 2 et 4 avec les mêmes arrivées.
    Chaque tour : départ -> arrivées -> attente/attraction -> retour.
    L'attente exclut les 2 minutes dans l'attraction.
    """
    file = [creer_visiteur(f"V{i}", 0) for i in range(1, 5)]
    sortis = []
    heure = 0
    prochain = 5
    for tour in range(tours):
        passagers = embarquer(file, capacite, heure)
        for _ in range([3, 1, 5, 2, 4][tour % 5]):
            visiteur = creer_visiteur(
                f"V{prochain}", heure, 50 + (prochain * 17) % 51
            )
            ajouter_visiteur(file, visiteur)
            prochain += 1
        mettre_a_jour(file, passagers)
        heure += 2
        sortis.extend(passagers)
        print(f"t={heure} min ; file={len(file)} ; sortis={len(sortis)}")
        print(statistiques(sortis))
    return file, sortis


if __name__ == "__main__":
    try:
        simuler()
    except NotImplementedError as erreur:
        print(erreur)
        print("Complète cette mission puis relance. Lance aussi test_pyland.py.")

"""TP2 — NSI Arcade / PyLand. Python 3, sans classes ni bibliothèque externe.
Compléter les cinq missions. Les tests sont fournis dans test_pyland.py.
Une liste représente la file : sortie à gauche, entrée à droite.
"""

def creer_visiteur(nom, arrivee, satisfaction=75):
    # Mission 1 : renvoyer un dictionnaire indépendant pour chaque visiteur.
    # Clés : nom, arrivee (minutes), satisfaction (entre 0 et 100).
    raise NotImplementedError("Mission 1 : dictionnaire visiteur")

def ajouter_visiteur(file, visiteur):
    # Mission 2 : ajouter à la fin, sans renvoyer de valeur.
    raise NotImplementedError("Mission 2 : enfiler")

def retirer_visiteur(file):
    # Mission 2 : retirer ET renvoyer le plus ancien ; None si file vide.
    raise NotImplementedError("Mission 2 : défiler")

def embarquer(file, capacite, heure):
    # Mission 3 : retirer au plus capacite visiteurs dans l'ordre FIFO.
    # Capacite est un entier >= 1 ; heure >= toutes les heures d'arrivée.
    # Pour chacun, ajouter attente = heure - arrivee.
    # Renvoyer la liste des visiteurs embarqués (même vide).
    raise NotImplementedError("Mission 3 : embarquer")

def mettre_a_jour(file, passagers):
    # Mission 4 : file perd 5 points ; passagers gagnent 10 points.
    # Borner chaque satisfaction entre 0 et 100. Modifier les dictionnaires.
    raise NotImplementedError("Mission 4 : satisfaction")

def statistiques(sortis):
    # Mission 5 : travailler seulement sur les 20 premiers sortis.
    # Renvoyer (effectif, attente_moyenne, satisfaction_moyenne).
    # Si personne n'est sorti : renvoyer (0, None, None).
    raise NotImplementedError("Mission 5 : moyennes")

def simuler(capacite=2, tours=15):
    """Orchestration fournie : compare 2 et 4 avec les mêmes arrivées.
    Chaque tour : départ -> arrivées -> attente/attraction -> retour.
    L'attente exclut les 2 minutes dans l'attraction.
    """
    file = [creer_visiteur(f"V{i}", 0) for i in range(1, 5)]
    sortis = []
    heure = 0
    prochain = 5
    for tour in range(tours):
        passagers = embarquer(file, capacite, heure)
        for _ in range([3, 1, 5, 2, 4][tour % 5]):
            visiteur = creer_visiteur(
                f"V{prochain}", heure, 50 + (prochain * 17) % 51
            )
            ajouter_visiteur(file, visiteur)
            prochain += 1
        mettre_a_jour(file, passagers)
        heure += 2
        sortis.extend(passagers)
        print(f"t={heure} min ; file={len(file)} ; sortis={len(sortis)}")
        print(statistiques(sortis))
    return file, sortis

if __name__ == "__main__":
    try:
        simuler()
    except NotImplementedError as erreur:
        print(erreur)
        print("Complète cette mission puis relance. Lance aussi test_pyland.py.")

🧪 Tests et trace attendue

Au premier départ : V1 et V2, attente 0 minute. Au deuxième : V3 et V4, attente 2 minutes. V5 embarque à t = 4 : son attente vaut 4 minutes. Après le premier retour, V3 a 70 points et V1 en a 85. Reproduis ces résultats dans ton programme.

Ton compte rendu de simulation

Capacité	Sorties totales	Taille finale de la file	Attente des 20 premiers	Satisfaction des 20 premiers
2 places	À mesurer	À mesurer	À mesurer	À mesurer
4 places	À mesurer	À mesurer	À mesurer	À mesurer

Sur ce scénario, 15 personnes arrivent tous les 5 tours. Combien de places offre une capacité de 2 pendant ce temps ? Pourquoi la file risque-t-elle de s’allonger ? Une moyenne calculée seulement sur les sortants représente-t-elle tous les visiteurs ?

🏆 Bonus — améliorer le modèle, sans classes

Une autre implémentation : remplace la liste par deque et pop(0) par popleft(). Garde les mêmes contrats. Explique pourquoi retirer en tête d’une liste est en O(n), contrairement à deque.
Mascotte : implémente le bonus +10 tous les X tours. À capacité 2, compare X = 1, 2, 4 sur les mêmes 15 tours. Parmi ces valeurs testées, trouve le plus grand intervalle donnant au moins 80 de satisfaction moyenne aux 20 premiers sortis, ou conclus qu’aucune ne convient. La mascotte peut améliorer la satisfaction modélisée, mais ne crée pas de places.
Aléatoire reproductible : utilise random.Random(42), des arrivées entre 1 et 5 et des satisfactions entre 50 et 100. Génère le scénario avant les deux essais pour conserver exactement les mêmes entrées. Ce sera un autre scénario que celui de la démo.
Panne : interdis un départ tous les X tours. Les arrivées et l’attente continuent. Compare avec le scénario sans panne.
Fast Pass : deux files FIFO et une politique explicite, par exemple au plus un prioritaire par départ si les deux files sont non vides. Le système n’est plus FIFO globalement. Vérifie qu’aucune file ne reste indéfiniment sans service.

À rendre : ton programme sans classes, les résultats des tests, la trace des trois premiers tours, le tableau des deux essais et une conclusion distinguant attente, satisfaction et personnes encore dans la file.

03 / 🐍 SNAKE.PY

OBSERVER → MODÉLISER · ★★☆

Observe ce qui arrive aux différentes cases du serpent lorsqu'il avance. Quelle structure de données étudiée pourrait modéliser ce comportement ? Justifie ta réponse avant de coder.

Une tête arrive. Que devient la queue ?

T = nouvelle tête× = queue retirée🍎 = pomme

Coordonnées (ligne, colonne), de 0 à 9. La liste est affichée dans l'ordre queue → tête.

Le scénario pomme repart de la même position et place une pomme juste devant la tête : prédis la liste, puis avance d'un pas. La démo va vers la droite jusqu'au mur ; le squelette Python permet de tourner.

Mission 1 — Trouver la représentation

Pars de [(5, 3), (5, 4), (5, 5), (5, 6)]. Écris la liste attendue après deux déplacements à droite, puis après un déplacement avec une pomme. Identifie l'élément le plus ancien.

J'explique le lien entre la liste et le corps.

Mission 2 — Calculer la nouvelle tête

Écris nouvelle_tete(serpent, direction). La direction est un tuple : haut (-1, 0), droite (0, 1), bas (1, 0), gauche (0, -1). Teste les quatre directions sans modifier le serpent.

Le calcul des coordonnées fonctionne.

Mission 3 — Avancer et grandir

Complète deplacer(serpent, tete, grandit). Sans pomme, la longueur doit rester constante. Avec une pomme, elle augmente de un. Distingue bien calculer une tête et modifier le corps.

Déplacement et croissance passent mes tests.

Mission 4 — Placer une pomme

Construis les coordonnées libres, puis choisis-en une au hasard. Une pomme ne doit jamais apparaître sur le serpent. Que renvoyer si toutes les cases sont occupées ? Le contrat prévoit None.

Mes pommes apparaissent sur des cases libres.

Mission 5 — Détecter les collisions

Écris collision(serpent, tete, grandit). Teste les quatre murs, un contact avec le corps et le déplacement vers la case de la queue lorsque celle-ci va disparaître. Ensuite seulement, lance le jeu complet.

Mes collisions couvrent les cas limites.

⚠️ Attention

Teste la collision avant de modifier le corps. Sans croissance, la queue libère sa case : elle ne constitue donc plus un obstacle au prochain état.

🧠 À retenir — quelle structure as-tu reconnue ?

Les cases du corps suivent l'ordre FIFO : une nouvelle position entre côté tête, la plus ancienne sort côté queue. Le corps se modélise donc par une file. Manger suspend un retrait, ce qui augmente sa longueur. Les tests de collision demandent aussi de consulter les positions du corps.

🏆 Bonus

Ajoute un score, une vitesse progressive, des obstacles ou la téléportation sur les bords. Puis un meilleur score local, ou un mode deux joueurs. Définis les règles avant de modifier le programme.

🐍 Coder en ligne · importer / exporter · tests

Le graphisme est déjà prêt

Télécharge le fichier complet et ouvre-le dans ton IDE Python. L'interface utilise tkinter, généralement fourni avec Python sur les postes du lycée. Pas de paquet à installer via pip. Si Tkinter manque sur un poste, les fonctions restent testables dans un fichier séparé.

L'interface s'ouvre avant que les TODO soient complétés ; elle indique la prochaine fonction à écrire au démarrage. L'aperçu ci-dessous montre uniquement l'algorithmique.

↓ Télécharger snake.py

"""NSI Arcade — Snake. Python 3 + tkinter (habituellement fourni avec Python).
Exécuter localement : python snake.py. Aucune installation pip nécessaire.
Les coordonnées sont (ligne, colonne). Queue au début, tête à la fin.
L'interface est fournie ; les fonctions algorithmiques restent à compléter.
"""
import random
import tkinter as tk

TAILLE = 12
CASE = 30
DELAI = 180


def nouvelle_tete(serpent, direction):
    # direction est un tuple (delta_ligne, delta_colonne).
    # TODO : à compléter — renvoyer un tuple, sans modifier serpent.
    raise NotImplementedError("Mission 2 : calculer la nouvelle tête")


def deplacer(serpent, tete, grandit):
    # TODO : à compléter — modifier serpent, conserver la queue si grandit.
    raise NotImplementedError("Mission 3 : déplacement et croissance")


def placer_pomme(serpent):
    # TODO : à compléter — choisir une case libre avec random.choice.
    # Renvoyer None si la grille est entièrement occupée.
    raise NotImplementedError("Mission 4 : placer une pomme")


def collision(serpent, tete, grandit):
    # TODO : à compléter — booléen : mur ou corps du serpent ?
    # Si le serpent ne grandit pas, sa queue va libérer sa case.
    raise NotImplementedError("Mission 5 : détecter les collisions")

"""NSI Arcade — Snake. Python 3 + tkinter (habituellement fourni avec Python).
Exécuter localement : python snake.py. Aucune installation pip nécessaire.
Les coordonnées sont (ligne, colonne). Queue au début, tête à la fin.
L'interface est fournie ; les fonctions algorithmiques restent à compléter.
"""
import random
import tkinter as tk

TAILLE = 12
CASE = 30
DELAI = 180

def nouvelle_tete(serpent, direction):
    # direction est un tuple (delta_ligne, delta_colonne).
    # TODO : à compléter — renvoyer un tuple, sans modifier serpent.
    raise NotImplementedError("Mission 2 : calculer la nouvelle tête")

def deplacer(serpent, tete, grandit):
    # TODO : à compléter — modifier serpent, conserver la queue si grandit.
    raise NotImplementedError("Mission 3 : déplacement et croissance")

def placer_pomme(serpent):
    # TODO : à compléter — choisir une case libre avec random.choice.
    # Renvoyer None si la grille est entièrement occupée.
    raise NotImplementedError("Mission 4 : placer une pomme")

def collision(serpent, tete, grandit):
    # TODO : à compléter — booléen : mur ou corps du serpent ?
    # Si le serpent ne grandit pas, sa queue va libérer sa case.
    raise NotImplementedError("Mission 5 : détecter les collisions")

# ---------- Interface fournie : aucune modification nécessaire ----------
class Jeu:
    def __init__(self, fenetre):
        self.fenetre = fenetre
        fenetre.title("NSI Arcade — Snake")
        self.canvas = tk.Canvas(fenetre, width=TAILLE * CASE,
                                height=TAILLE * CASE, bg="#edf3fa")
        self.canvas.pack(padx=12, pady=12)
        self.message = tk.StringVar()
        tk.Label(fenetre, textvariable=self.message, wraplength=360).pack()
        tk.Button(fenetre, text="Démarrer / reprendre", command=self.demarrer).pack()
        tk.Button(fenetre, text="Pause", command=self.pause).pack()
        tk.Button(fenetre, text="Recommencer", command=self.reinitialiser).pack()
        for touche, direction in {"Up": (-1, 0), "Right": (0, 1),
                                  "Down": (1, 0), "Left": (0, -1)}.items():
            fenetre.bind(f"<{touche}>", lambda e, d=direction: self.orienter(d))
        self.tache = None
        self.reinitialiser()

def pause(self):
        if self.tache is not None:
            self.fenetre.after_cancel(self.tache)
            self.tache = None

def reinitialiser(self):
        self.pause()
        self.serpent = [(5, 3), (5, 4), (5, 5), (5, 6)]
        self.direction = (0, 1)
        self.prochaine_direction = self.direction
        self.pomme = (5, 8)  # Première pomme fournie pour tester le mouvement.
        self.termine = False
        self.message.set("Flèches : direction. Complète les TODO puis démarre.")
        self.dessiner()

def orienter(self, direction):
        if direction != (-self.direction[0], -self.direction[1]):
            self.prochaine_direction = direction

def demarrer(self):
        if self.tache is None and not self.termine:
            self.tick()

def tick(self):
        self.tache = None
        try:
            self.direction = self.prochaine_direction
            tete = nouvelle_tete(self.serpent, self.direction)
            grandit = tete == self.pomme
            if collision(self.serpent, tete, grandit):
                self.termine = True
                self.message.set("Collision ! Recommence pour tester un autre cas.")
                return
            deplacer(self.serpent, tete, grandit)
            if grandit:
                self.pomme = placer_pomme(self.serpent)
            self.dessiner()
            if self.pomme is None:
                self.termine = True
                self.message.set("Grille remplie !")
                return
            self.message.set(f"Longueur : {len(self.serpent)} — flèches pour tourner")
        except NotImplementedError as erreur:
            self.message.set(str(erreur))
            return
        except Exception as erreur:
            self.message.set(f"À déboguer : {type(erreur).__name__} : {erreur}")
            return
        self.tache = self.fenetre.after(DELAI, self.tick)

def dessiner(self):
        self.canvas.delete("all")
        for i in range(TAILLE + 1):
            self.canvas.create_line(i * CASE, 0, i * CASE, TAILLE * CASE, fill="#cdd8e5")
            self.canvas.create_line(0, i * CASE, TAILLE * CASE, i * CASE, fill="#cdd8e5")
        for index, (ligne, colonne) in enumerate(self.serpent):
            couleur = "#155e50" if index == len(self.serpent) - 1 else "#80bea5"
            self.canvas.create_rectangle(colonne * CASE + 2, ligne * CASE + 2,
                                         (colonne + 1) * CASE - 2, (ligne + 1) * CASE - 2,
                                         fill=couleur, outline="")
        if self.pomme is not None:
            ligne, colonne = self.pomme
            self.canvas.create_oval(colonne * CASE + 5, ligne * CASE + 5,
                                    (colonne + 1) * CASE - 5, (ligne + 1) * CASE - 5,
                                    fill="#cf4444", outline="")

if __name__ == "__main__":
    racine = tk.Tk()
    Jeu(racine)
    racine.mainloop()

04 / 🗼 HANOI.PY

PILE · LIFO + RÉCURSIVITÉ · ★★☆

💡 Découvrir la récursion — pas encore étudiée

Une fonction est récursive lorsqu’elle s’appelle elle-même pour traiter un problème plus petit. Il faut un cas d’arrêt et s’en rapprocher à chaque appel.

def compte_a_rebours(n):
    # Précondition : n est un entier positif ou nul.
    if n == 0:
        print("Départ !")
        return
    print(n)
    compte_a_rebours(n - 1)

compte_a_rebours(3)  # affiche 3, 2, 1, puis Départ !

Trace : appel avec 3 → 2 → 1 → 0 ; puis les appels se terminent dans l’ordre inverse. Les appels en attente forment une pile. Sans arrêt, ou sans diminution de n, les appels finissent par provoquer une erreur RecursionError.

Pour Hanoï, résoudre avec n disques se ramène à déplacer n−1 disques, déplacer le plus grand, puis déplacer à nouveau les n−1 petits. Commence par les déplacements manuels : la résolution récursive est un prolongement guidé, pas un prérequis.

Transfère tous les disques de A vers C. Un seul disque à la fois, et jamais un grand disque sur un plus petit.

À toi de jouer

Clique sur une tour de départ, puis sur une tour d'arrivée. Au clavier : Tab pour choisir, Entrée ou Espace pour sélectionner.

Disques0 déplacement

Mission 1 — Trois tours, trois piles

Représente les tours par A = [5, 4, 3, 2, 1], B = [], C = []. La fin de liste est le sommet. Quel disque est accessible ? Quel invariant doit vérifier chaque liste ?

Je repère le sommet et l'ordre des disques.

Mission 2 — Sécuriser un déplacement

Complète deplacer(depart, arrivee). Renvoie un booléen et refuse les déplacements interdits sans modifier les piles. Teste un départ vide, une arrivée vide, un grand disque sur un petit et la même tour choisie deux fois.

Ma fonction respecte toutes les règles.

Mission 3 — Résoudre à la main

Résous le puzzle à trois disques et note tes déplacements. Combien en as-tu effectués ? Rejoue si nécessaire : peux-tu faire mieux ? Reproduis ta séquence avec des appels à deplacer en Python.

J'ai résolu et retracé le cas à trois disques.

Mission 4 — Penser récursivement

Pour déplacer le plus grand disque, où doivent se trouver les autres ? Décompose le problème en déplacements de n-1 disques, puis complète hanoi(n, depart, intermediaire, arrivee). Quel est le cas de base ?

J'explique les appels récursifs et leur arrêt.

🧠 À retenir — après la manipulation

Une pile est LIFO : Last In, First Out. Seul son sommet est directement accessible. Les tours sont des piles de disques ; l'exécution récursive utilise aussi une pile d'appels, qui mémorise les appels suspendus avant d'y revenir.

🏆 Bonus

Relève le minimum pour 1, 2, 3, 4 disques. Explique la relation M(n) = 2*M(n-1) + 1 avec M(0) = 0, puis conjecture une formule.

Vérifier ma conjecture

Le minimum est 2**n - 1. Peux-tu justifier cette formule par récurrence ?

🐍 Coder en ligne · importer / exporter · tests

Ton atelier Python

Commence avec trois disques. N'écris la récursion qu'après avoir sécurisé un déplacement.

↓ Télécharger hanoi.py

"""NSI Arcade — Hanoï. Fin de liste = sommet. Python 3."""
A = [5, 4, 3, 2, 1]
B = []
C = []


def deplacer(depart, arrivee):
    """Déplace un seul disque. Renvoie True si réussi, False sinon.
    Ne jamais modifier les piles lors d'un déplacement interdit.
    """
    # TODO : à compléter — départ vide ? même tour ? ordre des disques ?
    raise NotImplementedError("Mission 2 : déplacer un disque")


def hanoi(n, depart, intermediaire, arrivee):
    # TODO : à compléter — cas de base puis trois étapes récursives.
    # Utiliser deplacer et observer les piles après chaque déplacement.
    raise NotImplementedError("Mission 4 : stratégie récursive")


if __name__ == "__main__":
    # Commencer par trois disques avant le défi à cinq.
    A = [3, 2, 1]
    print("État initial :", A, B, C)
    print("Mission 3 : appelle deplacer(A, C), etc. dans la console.")
    # Décommenter après avoir complété la mission 4 :
    # hanoi(3, A, B, C)
    # print("État final :", A, B, C)

04 / 🧩 ESCAPE_NSI.PY

BOSS FINAL · ★★★

Une matrice, une entrée, une sortie. Explore sans tourner en rond, puis compare deux stratégies avec exactement les mêmes voisins.

Le laboratoire d'exploration

Structure

@ courante· visitée? à explorerE sortie◆ chemin trouvé

# mur · . passage · S départ · E sortie. Coordonnées : (ligne, colonne).

Voisins ajoutés dans l'ordre haut, gauche, bas, droite. Pour la pile, le sommet est à droite ; pour la file, le prochain retrait est à gauche.

Termine une exploration avec chaque structure pour comparer les résultats.

Voir la matrice Python

###########
#S..#.....#
#.#.#.###.#
#.#...#...#
#.#####.#E#
#.........#
###########

Voir l'ordre des cases explorées

Étape 1 — Comprendre les voisins

Écris voisins(case, labyrinthe) : quatre directions, dans les bornes et sans mur. Départ et sortie sont accessibles. Teste un couloir, une intersection, une impasse et une case au bord.

Mes voisins sont accessibles et dans la matrice.

Étape 2 — Explorer avec une pile

Place le départ dans la pile. Retire une case, visite-la, puis ajoute ses voisins encore inconnus. Marque une case dès son ajout pour éviter de l'ajouter plusieurs fois. Prédis trois étapes avant de lancer la démo.

🧠 Mettre un nom sur l'exploration avec une pile

C'est un parcours en profondeur, ou DFS (Depth-First Search). Le dernier voisin ajouté est exploré en premier ; on s'enfonce dans une branche avant de revenir aux autres cases en attente.

Mon exploration par pile trouve la sortie.

Étape 3 — Explorer avec une file

Reprends le même algorithme, les mêmes voisins et le même marquage. Change uniquement la façon de retirer la prochaine case. Compare l'ordre obtenu avec celui de la pile.

🧠 Mettre un nom sur l'exploration avec une file

C'est un parcours en largeur, ou BFS (Breadth-First Search). On explore les cases par distance croissante depuis le départ, déplacement par déplacement.

Mon exploration par file fonctionne.

Étape 4 — Comparer et argumenter

Les deux méthodes trouvent-elles la sortie ? Explorent-elles dans le même ordre ? Trouvent-elles nécessairement le même chemin ? Laquelle garantit un nombre minimal de déplacements dans ce labyrinthe non pondéré ? Appuie ta réponse sur la démo, puis sur une propriété de la structure.

Je sais expliquer la différence entre DFS et BFS.

Étape 5 — Reconstruire le chemin · avancé

Mémorise le prédécesseur de chaque case au moment de sa découverte. Depuis la sortie, remonte ces liens jusqu'au départ et inverse le résultat. Teste aussi une sortie inaccessible.

Je distingue chemin trouvé et ordre de visite.

⚠️ Attention

La liste des cases visitées n'est pas forcément un chemin : deux visites consécutives peuvent être éloignées. Un chemin suit des cases voisines. Dans un graphe pondéré, BFS ne garantit pas un coût total minimal.

🧠 Vers les graphes

Chaque case accessible est un sommet. Deux cases voisines sont reliées par une arête. Un déplacement coûte toujours une unité ici. Si la sortie est accessible, les deux explorations la trouvent ; l'ordre des voisins influence leurs traces et peut départager plusieurs chemins de même longueur.

🏆 Bonus

Modifie la matrice, ajoute une impasse, rends la sortie inaccessible, puis compare les cases explorées. Programme une course DFS/BFS ou un générateur de labyrinthes.

🐍 Coder en ligne · importer / exporter · tests

Ton atelier Python

L'affichage en console est fourni. Travaille d'abord sur les voisins, puis sur l'exploration ; ajoute les prédécesseurs en dernier.

↓ Télécharger escape_nsi.py

"""NSI Arcade — Escape. Python 3. Coordonnées = (ligne, colonne)."""
LABYRINTHE = [
    "###########",
    "#S..#.....#",
    "#.#.#.###.#",
    "#.#...#...#",
    "#.#####.#E#",
    "#.........#",
    "###########",
]
DEPART = (1, 1)
SORTIE = (4, 9)


def voisins(case, labyrinthe):
    # TODO : à compléter — haut, gauche, bas, droite (dans cet ordre).
    # Vérifier les bornes AVANT de lire la matrice. Exclure les murs.
    raise NotImplementedError("Étape 1 : voisins accessibles")


def explorer(labyrinthe, depart, sortie, mode):
    """mode = 'pile' ou 'file'. Renvoie (ordre_exploration, predecesseurs).
    Le dictionnaire des prédécesseurs est utile à l'étape 5 seulement.
    """
    a_explorer = [depart]
    decouvertes = {depart}
    ordre = []
    predecesseurs = {depart: None}
    # TODO : à compléter — tant qu'il reste une case à explorer :
    # - choisir et retirer une case selon mode ;
    # - la noter dans ordre, arrêter si c'est la sortie ;
    # - ajouter les voisins encore inconnus, les marquer dès l'ajout.
    # Étape 5 : mémoriser qui a permis de découvrir chaque voisin.
    raise NotImplementedError("Étapes 2 et 3 : explorer")


def reconstruire(predecesseurs, sortie):
    # TODO : à compléter — remonter vers le départ puis inverser.
    # Si la sortie n'a pas été découverte, renvoyer une liste vide.
    raise NotImplementedError("Étape 5 : reconstruire le chemin")


def afficher(labyrinthe, cases=()):
    for ligne, texte in enumerate(labyrinthe):
        print("".join("*" if (ligne, colonne) in cases and caractere == "."
                      else caractere for colonne, caractere in enumerate(texte)))


if __name__ == "__main__":
    afficher(LABYRINTHE)
    try:
        ordre, parents = explorer(LABYRINTHE, DEPART, SORTIE, "pile")
        print("Ordre :", ordre)
        afficher(LABYRINTHE, ordre)
    except NotImplementedError as erreur:
        print(erreur)

"""NSI Arcade — Escape. Python 3. Coordonnées = (ligne, colonne)."""
LABYRINTHE = [
    "###########",
    "#S..#.....#",
    "#.#.#.###.#",
    "#.#...#...#",
    "#.#####.#E#",
    "#.........#",
    "###########",
]
DEPART = (1, 1)
SORTIE = (4, 9)

def voisins(case, labyrinthe):
    # TODO : à compléter — haut, gauche, bas, droite (dans cet ordre).
    # Vérifier les bornes AVANT de lire la matrice. Exclure les murs.
    raise NotImplementedError("Étape 1 : voisins accessibles")

def explorer(labyrinthe, depart, sortie, mode):
    """mode = 'pile' ou 'file'. Renvoie (ordre_exploration, predecesseurs).
    Le dictionnaire des prédécesseurs est utile à l'étape 5 seulement.
    """
    a_explorer = [depart]
    decouvertes = {depart}
    ordre = []
    predecesseurs = {depart: None}
    # TODO : à compléter — tant qu'il reste une case à explorer :
    # - choisir et retirer une case selon mode ;
    # - la noter dans ordre, arrêter si c'est la sortie ;
    # - ajouter les voisins encore inconnus, les marquer dès l'ajout.
    # Étape 5 : mémoriser qui a permis de découvrir chaque voisin.
    raise NotImplementedError("Étapes 2 et 3 : explorer")

def reconstruire(predecesseurs, sortie):
    # TODO : à compléter — remonter vers le départ puis inverser.
    # Si la sortie n'a pas été découverte, renvoyer une liste vide.
    raise NotImplementedError("Étape 5 : reconstruire le chemin")

def afficher(labyrinthe, cases=()):
    for ligne, texte in enumerate(labyrinthe):
        print("".join("*" if (ligne, colonne) in cases and caractere == "."
                      else caractere for colonne, caractere in enumerate(texte)))

if __name__ == "__main__":
    afficher(LABYRINTHE)
    try:
        ordre, parents = explorer(LABYRINTHE, DEPART, SORTIE, "pile")
        print("Ordre :", ordre)
        afficher(LABYRINTHE, ordre)
    except NotImplementedError as erreur:
        print(erreur)