Bac NSI pratique 2026 sujet 5 : Empreinte carbone et parcours récursif de dictionnaires

def total_simple(empreinte):
    total = 0
    for valeur in empreinte.values():
        total += valeur
    return total

empreinte = chargement_json('empreinte_ada_agr.json')
print(total_simple(empreinte))
assert total_simple(empreinte) == 7252
assert total_simple({}) == 0

Le résultat est 7252 kg deCO₂ dans les données fournies. Le dictionnaire est parcouru par ses valeurs : additionner les clés ferait une opération sur des chaînes. Le total nul correspond naturellement à un dictionnaire vide.

def total_rec(empreinte):
    total = 0
    for valeur in empreinte.values():
        if est_dictionnaire(valeur):
            total += total_rec(valeur)
        else:
            total += valeur
    return total

Un sous-dictionnaire fournit son propre sous-total. Une valeur numérique est un cas terminal. Chaque appel traite un dictionnaire strictement plus profond et plus petit : le fichier est une structure finie sans cycle. Le total reste 7252, ce qui permet aussi de vérifier l’accord des deux exports.

test_total_rec()
assert total_rec({'Logement': {'Energie': {'Electricité': 206,
    'Cuisson': 105, 'Chauffage individuel': 1500},
    'Construction': 650, 'Location': 37, 'Ameublement': 162}}) == 2660
assert total_rec(chargement_json('empreinte_ada.json')) == 7252

On peut voir le dictionnaire comme un arbre : les catégories sont des nœuds, les nombres sont des feuilles. Le total d’un nœud est la somme des résultats de ses enfants. Pour Logement, le sous-total Énergie vaut 206 + 105 + 1500 = 1811 ; le niveau supérieur ajoute 650 + 37 + 162 et obtient 2660. Chaque feuille n’est visitée qu’une fois, et aucune catégorie n’est ajoutée en plus de ses feuilles : cela évite de compter deux fois la même émission.

Le return placé devant le premier appel récursif termine immédiatement le parcours, même lorsque ce premier sous-arbre ne contient aucune alerte. Dans le fichier réel, Alimentation vient avant Logement : le programme s’arrête dans la première branche, sans atteindre le chauffage. Une réponse True peut être propagée aussitôt ; une réponse False impose de continuer les autres branches.

def alerte_valeur_aberrante(empreinte, limite):
    for valeur in empreinte.values():
        if est_dictionnaire(valeur):
            if alerte_valeur_aberrante(valeur, limite):
                return True
        elif valeur > limite:
            return True
    return False

Le False final signifie que toutes les branches ont échoué à trouver une valeur strictement supérieure au seuil. Déplacer ce False dans la boucle reproduirait le même défaut sous une autre forme. La détection porte sur une feuille, pas sur le total du sous-dictionnaire.

La recherche d’une alerte correspond à un « ou » entre branches. Pour prouver l’existence d’une valeur trop grande, un seul témoin suffit ; pour prouver son absence, il faut avoir exploré toutes les branches. Cette asymétrie explique la place des retours. L’appel récursif qui trouve False ne permet pas de conclure globalement, tandis qu’un True remonte immédiatement jusqu’à la racine. Tester une première branche vide puis une seconde branche contenant 1500 cible précisément cette différence logique.

assert not alerte_valeur_aberrante({}, 1000)
assert not alerte_valeur_aberrante({'a': 1000}, 1000)
assert alerte_valeur_aberrante({'a': 1001}, 1000)
assert alerte_valeur_aberrante({'a': {'b': {'c': 1500}}}, 1000)
assert alerte_valeur_aberrante({'a': {'b': 10}, 'c': 1500}, 1000)
assert alerte_valeur_aberrante({'a': {}, 'b': {'c': 1500}}, 1000)
assert not alerte_valeur_aberrante({'a': {'b': 800}, 'c': 800}, 1000)

Les tests ciblent la structure et les frontières, pas seulement des nombres différents dans un même cas. Ajoutez l’appel sur le fichier réel, qui doit maintenant renvoyer True pour 1000 et False pour 1500, car la comparaison est stricte et la plus grande feuille vaut 1500.