# -*- coding: utf-8 -*-
"""Génère les deux notebooks PERRIAND-7 (élève + corrigé)."""
import json, os, uuid

CELLS = []


def md(src):
    CELLS.append(("markdown", src, src))


def code(eleve, corrige=None):
    CELLS.append(("code", eleve, corrige if corrige is not None else eleve))


# ---------------------------------------------------------------- INTRO
md("""# PERRIAND-7 : protocole de réveil

> **Journal de bord, jour 68.**
> Il y a soixante-huit jours, l'équipage de la station orbitale **PERRIAND-7** est entré
> en cryosommeil pour traverser la ceinture de radiations de Van Allen étendue.
> Vous venez d'ouvrir les yeux.
>
> La station, elle, s'est moins bien réveillée que vous. Les radiations ont provoqué des
> corruptions mémoire dans l'ordinateur de bord : plusieurs programmes affichent des
> valeurs absurdes, d'autres refusent tout simplement de s'exécuter.
>
> Vous êtes l'**ingénieur système** de bord. Cinq modules à réveiller, puis la sortie
> d'orbite. Dans l'ordre.

---

## Comment travailler

Chaque module contient quatre types d'exercices :

| Type | Ce qu'on attend de vous |
|---|---|
| **DIAGNOSTIC** | Lire le code et **prédire** ce qu'il affiche **avant** de l'exécuter. Écrivez votre prédiction dans le commentaire prévu, puis exécutez pour vérifier. |
| **RÉPARATION** | Le code est cassé. Trouvez l'erreur et corrigez-la. |
| **PRODUCTION** | Écrivez le code demandé. |
| **BONUS** | Facultatif. À faire si vous avez terminé le module. |

**La difficulté monte.** Dans chaque module, les derniers exercices sont volontairement
plus exigeants, et le module 6 l'est encore davantage. C'est le principe d'un sujet de
bac : les dernières questions servent à voir jusqu'où vont les meilleurs. Ne pas les
terminer n'est pas un échec ; les faire, c'est du bonus.

**Auto-correction.** Chaque exercice de production est suivi d'une cellule de tests.
Exécutez-la : si `OK` s'affiche, c'est gagné. Si vous obtenez une `AssertionError`,
c'est que le code ne fait pas encore ce qui est demandé.

**Bloqué ?** Chaque module commence par une cellule **SECOURS** qui remet en place
toutes les données dont il a besoin. Les modules sont **indépendants** : vous pouvez
passer au suivant sans avoir fini le précédent.

---

*Objectif de la séance : redémarrer le moteur après deux mois d'arrêt. Rien de ce qui suit
n'est nouveau : tout a été vu en Première. Mais chaque notion révisée ici sert directement
un chapitre de Terminale.*
""")

# ---------------------------------------------------------------- MODULE 1
md("""---

# Module 1 : LE RÉACTEUR

### *Variables, affectation, mutabilité*

> Le réacteur tourne. C'est déjà ça. Mais les jauges du poste de pilotage affichent
> n'importe quoi : 4 % d'oxygène ici, 340 % là. Avant de réparer un seul programme,
> il faut comprendre **comment l'ordinateur de bord range ses valeurs en mémoire**.

*Ce module prépare : POO (les attributs d'un objet sont des variables), et les listes
chaînées (où deux variables peuvent pointer vers le même maillon).*
""")

md("### SECOURS : exécutez cette cellule pour démarrer le module 1")
code("""# Relevés des capteurs au réveil
TAUX_O2_NOMINAL = 21        # en pourcentage
PRESSION_NOMINALE = 101     # en kilopascals
""")

md("""## Diagnostic 1.1 : l'ordre des affectations

L'ordinateur a exécuté ces quatre lignes. **Avant d'exécuter la cellule**, écrivez ce que
vous pensez qu'elle va afficher.

*Rappel : une affectation `a = b` calcule d'abord la valeur de droite, puis la range dans
la variable de gauche. Ce qui est calculé est calculé, ça ne se recalcule pas tout seul.*
""")
code("""oxygene = 21
oxygene = oxygene - 4
pression = oxygene * 2
oxygene = 21

print(oxygene, pression)

# Ma prédiction :
""",
"""oxygene = 21
oxygene = oxygene - 4
pression = oxygene * 2
oxygene = 21

print(oxygene, pression)

# Ma prédiction : 21 34
# La ligne 3 a utilisé la valeur d'oxygene à cet instant (17), pas sa valeur finale.
# pression vaut donc 34 et ne « suit » pas les changements ultérieurs d'oxygene.
""")

md("""## Diagnostic 1.2 : deux noms, une seule liste

Celui-ci piège tout le monde. Prédisez, puis exécutez.
""")
code("""reserve_principale = [120, 80, 50]
reserve_secours = reserve_principale
reserve_secours.append(0)

print("principale :", reserve_principale)
print("secours    :", reserve_secours)

# Ma prédiction :
""",
"""reserve_principale = [120, 80, 50]
reserve_secours = reserve_principale
reserve_secours.append(0)

print("principale :", reserve_principale)
print("secours    :", reserve_secours)

# Ma prédiction : les deux affichent [120, 80, 50, 0]
# `reserve_secours = reserve_principale` ne copie PAS la liste : elle donne un
# deuxième nom à la même liste en mémoire. Modifier l'une modifie l'autre.
# Pour obtenir une vraie copie : reserve_secours = list(reserve_principale)
""")

md("""> **À retenir.** Une liste est **mutable** : on peut la modifier sur place.
> Un entier ou une chaîne ne le sont pas. C'est pour ça que le piège ci-dessus
> n'existe pas avec des entiers.
""")

md("""## Réparation 1.3 : l'échange raté

Le programme de bord doit **échanger** les valeurs de deux capteurs mal branchés.
Le technicien précédent a écrit ceci. Ça ne marche pas.

**Corrigez** la cellule pour que l'échange fonctionne réellement.
""")
code("""temp_interne = 18
temp_externe = -270

# --- échange (cassé) ---
temp_interne = temp_externe
temp_externe = temp_interne
# -----------------------

print(temp_interne, temp_externe)
""",
"""temp_interne = 18
temp_externe = -270

# --- échange (corrigé) ---
temp_interne, temp_externe = temp_externe, temp_interne
# Variante sans affectation multiple, avec une variable tampon :
# tampon = temp_interne
# temp_interne = temp_externe
# temp_externe = tampon
# -------------------------

print(temp_interne, temp_externe)
""")
code("""assert temp_interne == -270 and temp_externe == 18
print("OK. Échange réussi")
""")

md("""## Production 1.4 : calcul de l'autonomie

Il reste `litres_oxygene` litres d'oxygène dans les réserves. Chaque membre d'équipage
consomme `consommation_par_heure` litres par heure.

Calculez dans une variable **`autonomie_h`** le nombre **entier** d'heures complètes
que l'équipage peut encore tenir.

*Indice : `//` est la division entière, celle qui ne garde que le nombre de tours complets.*
""")
code("""litres_oxygene = 480
consommation_par_heure = 3
nb_membres = 4

autonomie_h = ...   # à compléter

print("Autonomie :", autonomie_h, "heures")
""",
"""litres_oxygene = 480
consommation_par_heure = 3
nb_membres = 4

autonomie_h = litres_oxygene // (consommation_par_heure * nb_membres)

print("Autonomie :", autonomie_h, "heures")
""")
code("""assert autonomie_h == 40, "Attendu 40, obtenu " + str(autonomie_h)
print("OK. Autonomie correcte : 40 h")
""")

md("""## Bonus 1.5 : copie indépendante

Créez `sauvegarde` : une copie de `releves` qui **ne bouge pas** quand on modifie `releves`.
""")
code("""releves = [21, 101, 18]

sauvegarde = ...   # à compléter

releves.append(999)
print("releves   :", releves)
print("sauvegarde:", sauvegarde)
""",
"""releves = [21, 101, 18]

sauvegarde = list(releves)     # ou releves[:] , ou releves.copy()

releves.append(999)
print("releves   :", releves)
print("sauvegarde:", sauvegarde)
""")
code("""assert sauvegarde == [21, 101, 18]
assert releves == [21, 101, 18, 999]
print("OK. La sauvegarde est bien indépendante")
""")

# ---------------------------------------------------------------- MODULE 2
md("""---

# Module 2 : LES PROTOCOLES

### *Fonctions : paramètres, `return`, portée*

> Les protocoles de sécurité de la station sont des **fonctions**. On les appelle, elles
> répondent. Sauf que depuis les radiations, plusieurs d'entre elles ne répondent plus
> rien du tout : elles se contentent de parler dans le vide.

*Ce module prépare : la **récursivité** (une fonction qui s'appelle elle-même n'a de
sens que si elle **renvoie** quelque chose) et la Modularité.*
""")

md("### SECOURS : exécutez cette cellule pour démarrer le module 2")
code("""SEUIL_CRITIQUE = 80
SEUIL_ALERTE = 95
""")

md("""## Diagnostic 2.1 : `print` n'est pas `return`

Prédisez les **deux** lignes affichées.
""")
code("""def niveau_pression(pression):
    if pression < 80:
        print("CRITIQUE")
    else:
        print("NOMINAL")

resultat = niveau_pression(45)
print("resultat vaut :", resultat)

# Ma prédiction :
""",
"""def niveau_pression(pression):
    if pression < 80:
        print("CRITIQUE")
    else:
        print("NOMINAL")

resultat = niveau_pression(45)
print("resultat vaut :", resultat)

# Ma prédiction : CRITIQUE  puis  resultat vaut : None
# La fonction AFFICHE mais ne RENVOIE rien. Une fonction sans return renvoie None.
# On ne peut donc rien faire du résultat : ni le tester, ni le stocker, ni le réutiliser.
""")

md("""> **À retenir.** `print` **montre** à l'humain. `return` **rend** une valeur au
> programme. Une fonction qui ne fait que `print` est un cul-de-sac : on ne peut pas
> construire quoi que ce soit par-dessus.
""")

md("""## Réparation 2.2 : rendre le protocole utilisable

Réécrivez `niveau_pression` pour qu'elle **renvoie** la chaîne au lieu de l'afficher.

- pression strictement inférieure à 80 : renvoie `"CRITIQUE"`
- pression entre 80 (inclus) et 95 (exclu) : renvoie `"ALERTE"`
- pression supérieure ou égale à 95 : renvoie `"NOMINAL"`
""")
code("""def niveau_pression(pression):
    ...   # à compléter
""",
"""def niveau_pression(pression):
    if pression < 80:
        return "CRITIQUE"
    elif pression < 95:
        return "ALERTE"
    else:
        return "NOMINAL"
""")
code("""assert niveau_pression(45) == "CRITIQUE"
assert niveau_pression(79) == "CRITIQUE"
assert niveau_pression(80) == "ALERTE"
assert niveau_pression(94) == "ALERTE"
assert niveau_pression(95) == "NOMINAL"
assert niveau_pression(120) == "NOMINAL"
print("OK. Protocole de pression opérationnel")
""")

md("""## Diagnostic 2.3 : la variable qui n'existe pas

Ce code **plante**. Avant de l'exécuter, essayez de dire **pourquoi**.
""")
code("""compteur_alertes = 0

def signaler_alerte():
    compteur_alertes = compteur_alertes + 1
    return compteur_alertes

print(signaler_alerte())

# Ma prédiction (quelle erreur, et pourquoi ?) :
""",
"""compteur_alertes = 0

def signaler_alerte():
    compteur_alertes = compteur_alertes + 1
    return compteur_alertes

print(signaler_alerte())

# Ma prédiction : UnboundLocalError.
# Comme `compteur_alertes` reçoit une affectation DANS la fonction, Python la considère
# comme une variable LOCALE. Au moment du calcul `compteur_alertes + 1`, cette variable
# locale n'a encore aucune valeur : erreur.
# La bonne solution n'est PAS `global` : c'est de passer la valeur en PARAMÈTRE
# et de renvoyer la nouvelle (voir cellule suivante).
""")

md("""**Corrigez** en transformant `signaler_alerte` en une fonction qui prend le compteur
actuel en paramètre et renvoie le compteur augmenté de 1.
""")
code("""def signaler_alerte(compteur):
    ...   # à compléter

compteur_alertes = 0
compteur_alertes = signaler_alerte(compteur_alertes)
compteur_alertes = signaler_alerte(compteur_alertes)
print(compteur_alertes)
""",
"""def signaler_alerte(compteur):
    return compteur + 1

compteur_alertes = 0
compteur_alertes = signaler_alerte(compteur_alertes)
compteur_alertes = signaler_alerte(compteur_alertes)
print(compteur_alertes)
""")
code("""assert signaler_alerte(0) == 1
assert signaler_alerte(41) == 42
assert compteur_alertes == 2
print("OK. Compteur d'alertes réparé")
""")

md("""## Production 2.4 : une fonction qui en appelle une autre

Écrivez `diagnostic(pression, temperature)` qui renvoie une chaîne de la forme :

```
"Pression NOMINAL / Temperature 18"
```

Votre fonction **doit appeler** `niveau_pression` : ne recopiez pas les tests de seuil.

*Indice : pour coller des morceaux de texte, `+` fonctionne, mais il faut convertir les
nombres avec `str(...)`.*
""")
code("""def diagnostic(pression, temperature):
    ...   # à compléter
""",
"""def diagnostic(pression, temperature):
    return "Pression " + niveau_pression(pression) + " / Temperature " + str(temperature)
""")
code("""assert diagnostic(101, 18) == "Pression NOMINAL / Temperature 18"
assert diagnostic(45, -3) == "Pression CRITIQUE / Temperature -3"
assert diagnostic(88, 0) == "Pression ALERTE / Temperature 0"
print("OK. Diagnostic complet opérationnel")
""")

md("""## Bonus 2.5 : paramètre par défaut

Écrivez `verrouiller(module, code_acces="0000")` qui renvoie :
- `"MODULE VERROUILLE"` si le code fourni est `"0000"`
- `"CODE REFUSE"` sinon
""")
code("""def verrouiller(module, code_acces="0000"):
    ...   # à compléter
""",
"""def verrouiller(module, code_acces="0000"):
    if code_acces == "0000":
        return "MODULE VERROUILLE"
    else:
        return "CODE REFUSE"
""")
code("""assert verrouiller("Sas") == "MODULE VERROUILLE"
assert verrouiller("Sas", "0000") == "MODULE VERROUILLE"
assert verrouiller("Sas", "1234") == "CODE REFUSE"
print("OK. Verrouillage opérationnel")
""")

# ---------------------------------------------------------------- MODULE 3
md("""---

# Module 3 : LE BALAYAGE

### *Boucles : `for`, `while`, accumulateur*

> Il faut maintenant **balayer** les 5 000 relevés de capteurs accumulés pendant
> l'hibernation, pour repérer les anomalies. Personne ne fera ça à la main.

*Ce module prépare : le parcours des arbres et des graphes, où l'on visite un à un
tous les éléments d'une structure sans savoir à l'avance combien il y en a.*
""")

md("### SECOURS : exécutez cette cellule pour démarrer le module 3")
code("""mesures = [12, 45, 7, 88, 23, 91, 4]
""")

md("""## Diagnostic 3.1 : combien de tours ?

Prédisez ce qui s'affiche, **et combien de lignes**.
""")
code("""i = 0
while i < 5:
    print(i)
    i = i + 2

print("fin, i vaut", i)

# Ma prédiction :
""",
"""i = 0
while i < 5:
    print(i)
    i = i + 2

print("fin, i vaut", i)

# Ma prédiction : 0, 2, 4 (trois lignes), puis « fin, i vaut 6 ».
# Le test est réévalué AVANT chaque tour. Après le tour où i valait 4, i passe à 6 :
# 6 < 5 est faux, la boucle s'arrête. i vaut donc 6 à la sortie, pas 5.
""")

md("""## Diagnostic 3.2 : NE PAS EXÉCUTER

Cette cellule est en mode texte : **ne l'exécutez pas**, elle ne s'arrêterait jamais.

```python
carburant = 100
while carburant > 0:
    print("Purge en cours...")
    carburant = 100
```

**Question (répondez dans la cellule ci-dessous) :** pourquoi cette boucle ne se
termine-t-elle jamais, et quelle est la plus petite modification qui la ferait terminer ?
""")
code("""# Ma réponse :
""",
"""# Ma réponse :
# La condition `carburant > 0` reste vraie éternellement parce que le corps de la boucle
# remet carburant à 100 au lieu de le faire décroître. Rien ne rapproche le programme de
# la condition d'arrêt.
# Plus petite correction : remplacer `carburant = 100` par une décrémentation,
# par exemple `carburant = carburant - 10`.
#
# Règle : dans un while, une variable au moins doit évoluer VERS la condition d'arrêt.
""")

md("""## Réparation 3.3 : le capteur oublié

Ce code doit afficher **toutes** les mesures. Il en rate une. Trouvez laquelle, et corrigez.
""")
code("""for i in range(1, len(mesures)):
    print("capteur", i, ":", mesures[i])
""",
"""for i in range(len(mesures)):      # range(len(...)) commence à 0, pas à 1
    print("capteur", i, ":", mesures[i])

# La version initiale commençait à l'indice 1 et sautait donc mesures[0] (la valeur 12).
# En Python le premier indice d'une liste est 0.
""")

md("""## Production 3.4 : le maximum, à la main

Écrivez `maximum(valeurs)` qui renvoie la plus grande valeur d'une liste **non vide**,
**sans utiliser `max()`**.

*Méthode de l'accumulateur : on retient un « meilleur pour l'instant », et on le met à
jour à chaque tour.*
""")
code("""def maximum(valeurs):
    ...   # à compléter
""",
"""def maximum(valeurs):
    plus_grand = valeurs[0]            # on part du premier élément, pas de 0 !
    for v in valeurs:
        if v > plus_grand:
            plus_grand = v
    return plus_grand
""")
code("""assert maximum([12, 45, 7, 88, 23, 91, 4]) == 91
assert maximum([5]) == 5
assert maximum([3, 3, 3]) == 3
assert maximum([-10, -3, -50]) == -3, "attention aux valeurs négatives : ne partez pas de 0"
print("OK. Détection du maximum opérationnelle")
""")

md("""## Production 3.5 : le premier capteur défaillant

Écrivez `premier_defaillant(valeurs, seuil)` qui renvoie **l'indice** de la première
mesure strictement inférieure à `seuil`, et `-1` si aucune ne l'est.

*Indice : ici on a besoin de l'indice, donc de `range(len(valeurs))`. Et on peut sortir
de la fonction dès qu'on a trouvé.*
""")
code("""def premier_defaillant(valeurs, seuil):
    ...   # à compléter
""",
"""def premier_defaillant(valeurs, seuil):
    for i in range(len(valeurs)):
        if valeurs[i] < seuil:
            return i               # return sort immédiatement de la fonction
    return -1                      # atteint seulement si la boucle s'est terminée
""")
code("""assert premier_defaillant([12, 45, 7, 88], 20) == 0
assert premier_defaillant([45, 88, 7, 4], 10) == 2
assert premier_defaillant([45, 88, 91], 10) == -1
assert premier_defaillant([], 10) == -1
print("OK. Détection de défaillance opérationnelle")
""")

md("""## Bonus 3.6 : la sentinelle

Le capteur d'altitude envoie ses relevés en continu et termine sa transmission par la
valeur `-1`. Écrivez `somme_jusqu_a_sentinelle(flux)` qui additionne les valeurs
**jusqu'au premier `-1` exclu**. Les valeurs après le `-1` sont du bruit : on les ignore.

*Indice : un `while` avec deux conditions est plus naturel qu'un `for` ici.*
""")
code("""def somme_jusqu_a_sentinelle(flux):
    ...   # à compléter
""",
"""def somme_jusqu_a_sentinelle(flux):
    total = 0
    i = 0
    while i < len(flux) and flux[i] != -1:
        total = total + flux[i]
        i = i + 1
    return total
""")
code("""assert somme_jusqu_a_sentinelle([10, 20, 30, -1, 999, 999]) == 60
assert somme_jusqu_a_sentinelle([-1, 5, 5]) == 0
assert somme_jusqu_a_sentinelle([1, 2, 3]) == 6
assert somme_jusqu_a_sentinelle([]) == 0
print("OK. Lecture du flux opérationnelle")
""")

# ---------------------------------------------------------------- MODULE 4
md("""---

# Module 4 : LA SOUTE

### *Listes : indices, tranches, listes de listes*

> La soute est organisée en rayonnages. L'inventaire numérique a survécu, mais les
> programmes qui l'exploitent, non.

*Ce module prépare : les structures linéaires (pile, file, listes chaînées) et le
tri fusion du chapitre « diviser pour régner ».*
""")

md("### SECOURS : exécutez cette cellule pour démarrer le module 4")
code("""soute = ["eau", "vivres", "outils", "piles", "filtres"]

# Chaque sous-liste est un rayonnage : [rayon_0, rayon_1, rayon_2]
# Chaque ligne = un étage de la soute.
stock = [[12, 5, 0],
         [3, 8, 7],
         [0, 0, 4],
         [9, 1, 2]]
""")

md("""## Diagnostic 4.1 : indices et tranches

Prédisez les quatre affichages.
""")
code("""print(soute[0])
print(soute[-1])
print(soute[1:3])
print(len(soute[1:3]))

# Ma prédiction :
""",
"""print(soute[0])
print(soute[-1])
print(soute[1:3])
print(len(soute[1:3]))

# Ma prédiction :
#   eau
#   filtres
#   ['vivres', 'outils']
#   2
# Une tranche [a:b] va de l'indice a INCLUS à l'indice b EXCLU : elle contient b - a
# éléments. L'indice -1 désigne le dernier élément.
""")

md("""## Réparation 4.2 : le bug du technicien

Ce code doit retirer de `soute` tout ce qui commence par la lettre `"p"`.
Il en oublie. **Exécutez-le d'abord** pour constater le problème, puis corrigez-le.

*Indice : modifier une liste pendant qu'on la parcourt décale les indices sous les pieds
de la boucle. La solution habituelle est de **construire une nouvelle liste** plutôt que
de retirer dans l'ancienne.*
""")
code("""soute_test = ["piles", "pinces", "eau", "outils"]

for objet in soute_test:
    if objet[0] == "p":
        soute_test.remove(objet)

print(soute_test)   # devrait afficher ['eau', 'outils']
""",
"""soute_test = ["piles", "pinces", "eau", "outils"]

# Version corrigée : on construit une nouvelle liste au lieu de modifier celle qu'on parcourt
soute_gardee = []
for objet in soute_test:
    if objet[0] != "p":
        soute_gardee.append(objet)
soute_test = soute_gardee

print(soute_test)   # ['eau', 'outils']

# Pourquoi la version initiale échouait : après avoir retiré "piles" (indice 0), tous les
# éléments se décalent d'un cran. La boucle passe alors à l'indice 1, qui contient
# désormais "eau" : "pinces" a été SAUTÉ.
""")
code("""assert soute_test == ["eau", "outils"]
print("OK. Purge de la soute correcte")
""")

md("""## Production 4.3 : total d'un rayonnage

`stock` est une **liste de listes** : `stock[i][j]` est la quantité stockée à l'étage `i`,
rayon `j`.

Écrivez `total_rayon(grille, r)` qui renvoie la somme des quantités du rayon `r`,
**tous étages confondus**.

*Attention : le rayon `r` est une **colonne**, pas une ligne. Il faut parcourir les étages.*
""")
code("""def total_rayon(grille, r):
    ...   # à compléter
""",
"""def total_rayon(grille, r):
    total = 0
    for etage in grille:        # etage est une liste : [rayon_0, rayon_1, rayon_2]
        total = total + etage[r]
    return total
""")
code("""assert total_rayon(stock, 0) == 24
assert total_rayon(stock, 1) == 14
assert total_rayon(stock, 2) == 13
print("OK. Inventaire par rayon opérationnel")
""")

md("""## Production 4.4 : filtrer en une ligne

Écrivez `au_dessus(valeurs, seuil)` qui renvoie la liste des valeurs strictement
supérieures à `seuil`, **en utilisant une compréhension de liste**.

*Rappel de la forme : `[expression for element in liste if condition]`*
""")
code("""def au_dessus(valeurs, seuil):
    ...   # à compléter (une seule ligne, avec une compréhension)
""",
"""def au_dessus(valeurs, seuil):
    return [v for v in valeurs if v > seuil]
""")
code("""assert au_dessus([12, 45, 7, 88, 23], 20) == [45, 88, 23]
assert au_dessus([1, 2, 3], 10) == []
assert au_dessus([], 0) == []
print("OK. Filtrage opérationnel")
""")

md("""## Bonus 4.5 : fusionner deux listes triées

Deux capteurs ont enregistré des relevés, chacun **déjà trié dans l'ordre croissant**.
Écrivez `fusion(a, b)` qui renvoie une seule liste triée contenant tous les éléments,
**sans utiliser `sorted()` ni `.sort()`**.

*Méthode : deux indices qui avancent, on prend à chaque tour le plus petit des deux
éléments courants.*

> Cet exercice est **exactement** la seconde moitié du tri fusion, que vous verrez
> dans le chapitre « diviser pour régner ».
""")
code("""def fusion(a, b):
    ...   # à compléter
""",
"""def fusion(a, b):
    resultat = []
    i = 0
    j = 0
    while i < len(a) and j < len(b):
        if a[i] <= b[j]:
            resultat.append(a[i])
            i = i + 1
        else:
            resultat.append(b[j])
            j = j + 1
    # une des deux listes est épuisée : on recopie ce qui reste de l'autre
    while i < len(a):
        resultat.append(a[i])
        i = i + 1
    while j < len(b):
        resultat.append(b[j])
        j = j + 1
    return resultat
""")
code("""assert fusion([1, 4, 9], [2, 3, 10]) == [1, 2, 3, 4, 9, 10]
assert fusion([], [2, 3]) == [2, 3]
assert fusion([5], []) == [5]
assert fusion([1, 1], [1]) == [1, 1, 1]
print("OK. Fusion opérationnelle, vous venez d'écrire la moitié d'un tri fusion")
""")

# ---------------------------------------------------------------- MODULE 5
md("""---

# Module 5 : L'ÉQUIPAGE

### *Dictionnaires : clés, valeurs, parcours*

> Reste le plus important : les **dossiers de l'équipage** et le **plan de la station**.
> Une liste ne suffit plus : on ne cherche pas « le 3ᵉ membre », on cherche « Kowalski ».

*Ce module prépare : les graphes (un graphe se représente par un dictionnaire de
listes) et la mémoïsation en programmation dynamique (un dictionnaire de résultats
déjà calculés).*
""")

md("### SECOURS : exécutez cette cellule pour démarrer le module 5")
code("""equipage = {
    "Kowalski": "pilote",
    "Ndiaye":   "medecin",
    "Reyes":    "ingenieur",
    "Sokolova": "pilote",
    "Tanaka":   "ingenieur",
}

# Plan de la station : à chaque module, la liste des modules directement accessibles
plan = {
    "Sas":        ["Couloir"],
    "Couloir":    ["Sas", "Cockpit", "Soute", "Labo"],
    "Cockpit":    ["Couloir"],
    "Soute":      ["Couloir", "Reacteur"],
    "Labo":       ["Couloir"],
    "Reacteur":   ["Soute"],
}
""")

md("""## Diagnostic 5.1 : accès et absence

Prédisez le résultat des trois premières lignes. La quatrième est volontairement
commentée : dites ce qui se passerait si on la décommentait.
""")
code("""print(equipage["Reyes"])
print(len(equipage))
print("Bowman" in equipage)
# print(equipage["Bowman"])

# Ma prédiction :
""",
"""print(equipage["Reyes"])
print(len(equipage))
print("Bowman" in equipage)
# print(equipage["Bowman"])

# Ma prédiction :
#   ingenieur
#   5              (len d'un dictionnaire = son nombre de clés)
#   False
#   La 4e ligne lèverait une KeyError : accéder à une clé absente est une ERREUR,
#   ce n'est pas None. Pour éviter ça : equipage.get("Bowman", "inconnu").
""")

md("""## Réparation 5.2 : le poste qui n'existe pas

Cette fonction plante dès qu'on lui donne un nom inconnu. Corrigez-la pour qu'elle
renvoie `"inconnu"` dans ce cas.
""")
code("""def poste_de(registre, nom):
    return registre[nom]

print(poste_de(equipage, "Tanaka"))
print(poste_de(equipage, "Bowman"))   # plante
""",
"""def poste_de(registre, nom):
    return registre.get(nom, "inconnu")

# Variante explicite, tout aussi correcte :
# def poste_de(registre, nom):
#     if nom in registre:
#         return registre[nom]
#     return "inconnu"

print(poste_de(equipage, "Tanaka"))
print(poste_de(equipage, "Bowman"))
""")
code("""assert poste_de(equipage, "Tanaka") == "ingenieur"
assert poste_de(equipage, "Bowman") == "inconnu"
print("OK. Registre sécurisé")
""")

md("""## Production 5.3 : compter les postes

Écrivez `compter_postes(registre)` qui renvoie un **dictionnaire** associant à chaque
poste le nombre de membres qui l'occupent.

Sur `equipage`, on doit obtenir : `{'pilote': 2, 'medecin': 1, 'ingenieur': 2}`

*Méthode classique : on part d'un dictionnaire vide, et pour chaque valeur rencontrée,
soit la clé existe déjà et on l'incrémente, soit elle n'existe pas et on la crée à 1.*
""")
code("""def compter_postes(registre):
    ...   # à compléter
""",
"""def compter_postes(registre):
    comptes = {}
    for poste in registre.values():
        if poste in comptes:
            comptes[poste] = comptes[poste] + 1
        else:
            comptes[poste] = 1
    return comptes
""")
code("""resultat = compter_postes(equipage)
assert resultat == {"pilote": 2, "medecin": 1, "ingenieur": 2}
assert compter_postes({}) == {}
assert compter_postes({"A": "pilote"}) == {"pilote": 1}
print("OK. Recensement de l'équipage opérationnel")
""")

md("""## Production 5.4 : lire le plan de la station

`plan` est un dictionnaire dont **les valeurs sont des listes**.

1. Écrivez `voisins(plan, module)` : la liste des modules directement accessibles depuis
   `module`, ou `[]` si le module n'existe pas.
2. Écrivez `nb_liaisons(plan)` : le nombre **total** de liaisons listées dans le plan
   (on compte simplement la longueur de toutes les listes).

> Cette structure a un nom : c'est une **liste d'adjacence**. C'est celle que vous
> utiliserez pour représenter un graphe.
""")
code("""def voisins(plan, module):
    ...   # à compléter


def nb_liaisons(plan):
    ...   # à compléter
""",
"""def voisins(plan, module):
    return plan.get(module, [])


def nb_liaisons(plan):
    total = 0
    for liste_voisins in plan.values():
        total = total + len(liste_voisins)
    return total
""")
code("""assert voisins(plan, "Cockpit") == ["Couloir"]
assert voisins(plan, "Couloir") == ["Sas", "Cockpit", "Soute", "Labo"]
assert voisins(plan, "Hangar") == []
assert nb_liaisons(plan) == 10
print("OK. Lecture du plan opérationnelle")
""")

md("""## Bonus 5.5 : regrouper par poste

Écrivez `par_poste(registre)` qui renvoie un dictionnaire associant à chaque poste la
**liste des noms** qui l'occupent :

```python
{'pilote': ['Kowalski', 'Sokolova'], 'medecin': ['Ndiaye'], 'ingenieur': ['Reyes', 'Tanaka']}
```
""")
code("""def par_poste(registre):
    ...   # à compléter
""",
"""def par_poste(registre):
    groupes = {}
    for nom, poste in registre.items():
        if poste not in groupes:
            groupes[poste] = []
        groupes[poste].append(nom)
    return groupes
""")
code("""attendu = {"pilote": ["Kowalski", "Sokolova"],
           "medecin": ["Ndiaye"],
           "ingenieur": ["Reyes", "Tanaka"]}
assert par_poste(equipage) == attendu
assert par_poste({}) == {}
print("OK. Regroupement opérationnel")
""")

# ---------------------------------------------------------------- MODULE 6
md("""---

# Module 6 : SORTIE D'ORBITE

### *Synthèse, et retour à la récursivité*

> Tous les systèmes répondent. Reste à vérifier qu'aucun module n'est resté isolé après
> les avaries : si un compartiment n'est plus relié au reste de la station, l'équipage
> qui s'y trouve est piégé.
""")

md("### SECOURS : exécutez cette cellule pour démarrer le module 6")
code("""plan = {
    "Sas":        ["Couloir"],
    "Couloir":    ["Sas", "Cockpit", "Soute", "Labo"],
    "Cockpit":    ["Couloir"],
    "Soute":      ["Couloir", "Reacteur"],
    "Labo":       ["Couloir"],
    "Reacteur":   ["Soute"],
    "Serre":      ["Cellule"],      # compartiment isolé du reste !
    "Cellule":    ["Serre"],
}
""")

md("""## Synthèse 6.1 : quels modules sont atteignables ?

Écrivez `atteignables(plan, depart)` : la liste des modules que l'on peut rejoindre
depuis `depart`, en comptant `depart` lui-même.

L'algorithme vous est donné, il ne reste qu'à le traduire :

```
a_visiter  ←  liste contenant seulement depart
visites    ←  liste vide
tant que a_visiter n'est pas vide :
      module  ←  on retire le DERNIER élément de a_visiter
      si module n'est pas déjà dans visites :
            ajouter module à visites
            pour chaque v dans les voisins de module :
                  ajouter v à a_visiter
renvoyer visites
```

*Indice : « retirer le dernier élément » se dit `liste.pop()` en Python.*

> Ce que vous venez d'écrire est un **parcours en profondeur**. `a_visiter` est une
> **pile**. Vous retrouverez les deux, sous ces noms, dans les chapitres Pile/File et
> Graphes.
""")
code("""def atteignables(plan, depart):
    ...   # à compléter
""",
"""def atteignables(plan, depart):
    a_visiter = [depart]
    visites = []
    while len(a_visiter) > 0:
        module = a_visiter.pop()            # retire et renvoie le dernier élément
        if module not in visites:
            visites.append(module)
            for v in plan.get(module, []):
                a_visiter.append(v)
    return visites
""")
code("""r = atteignables(plan, "Sas")
assert sorted(r) == ["Cockpit", "Couloir", "Labo", "Reacteur", "Sas", "Soute"]
assert "Serre" not in r, "La serre ne doit PAS être atteignable depuis le sas"
assert sorted(atteignables(plan, "Serre")) == ["Cellule", "Serre"]
assert atteignables(plan, "Hangar") == ["Hangar"]
print("OK. Cartographie terminée, 2 compartiments isolés détectés : Serre et Cellule")
""")

md("""## Diagnostic 6.2 : le compte à rebours

Dernière étape avant le décollage. **Ne l'exécutez pas tout de suite** : écrivez d'abord,
sur votre feuille, l'ordre exact des affichages pour `compte_a_rebours(3)`.
""")
code("""def compte_a_rebours(n):
    if n == 0:
        print("DECOLLAGE")
    else:
        print(n)
        compte_a_rebours(n - 1)
        print("verif", n)

compte_a_rebours(3)

# Ma prédiction :
""",
"""def compte_a_rebours(n):
    if n == 0:
        print("DECOLLAGE")
    else:
        print(n)
        compte_a_rebours(n - 1)
        print("verif", n)

compte_a_rebours(3)

# Ma prédiction :
#   3
#   2
#   1
#   DECOLLAGE
#   verif 1
#   verif 2
#   verif 3
#
# Les « verif » sortent dans l'ORDRE INVERSE : chaque appel est mis en attente pendant
# que l'appel suivant se déroule, puis reprend là où il s'était arrêté. C'est exactement
# la PILE D'APPELS du chapitre en cours.
""")

md("""---

## Fin du protocole

**PERRIAND-7 est de nouveau opérationnelle.**

Ce que vous venez de réutiliser, et où ça resservira :

| Module | Notion | Chapitre de Terminale concerné |
|---|---|---|
| 1 · Réacteur | variables, mutabilité, aliasing | POO, listes chaînées |
| 2 · Protocoles | `return`, paramètres, portée | **Récursivité**, Modularité |
| 3 · Balayage | boucles, accumulateur | parcours d'arbres et de graphes |
| 4 · Soute | listes, listes de listes, compréhensions | structures linéaires, tri fusion |
| 5 · Équipage | dictionnaires, dict de listes | **graphes**, mémoïsation |
| 6 · Sortie d'orbite | pile, parcours, pile d'appels | Pile/File, **Récursivité** |

---
*Lycée Charlotte Perriand, NSI Terminale, Licence CC BY-SA 4.0*
""")


# ---------------------------------------------------------------- WRITE
def build(index):
    cells = []
    for kind, eleve, corrige in CELLS:
        src = (eleve, corrige)[index]
        lines = src.splitlines(keepends=True)
        cells.append({
            "cell_type": kind,
            "id": uuid.uuid4().hex[:8],
            "metadata": {},
            "source": lines,
            **({"execution_count": None, "outputs": []} if kind == "code" else {}),
        })
    return {
        "cells": cells,
        "metadata": {
            "kernelspec": {"display_name": "Python 3", "language": "python", "name": "python3"},
            "language_info": {"name": "python", "version": "3.11"},
        },
        "nbformat": 4,
        "nbformat_minor": 5,
    }


DEST = os.path.expanduser("~/Documents/Cours/NSI/Terminale/Revisions_Rentree")
os.makedirs(DEST, exist_ok=True)

for idx, name in ((0, "PERRIAND-7_Reveil_des_systemes.ipynb"),
                  (1, "PERRIAND-7_CORRIGE.ipynb")):
    with open(os.path.join(DEST, name), "w", encoding="utf-8") as f:
        json.dump(build(idx), f, ensure_ascii=False, indent=1)
    print("écrit :", name, len(CELLS), "cellules")