Bac NSI pratique 2026 sujet 4 : Croissance des plantes et suppression dans une liste

def croissance_moyenne(plantes):
    if not plantes:
        return None
    total = 0
    for plante in plantes:
        total += plante.croissance
    return total / len(plantes)

On additionne l’attribut croissance de chaque instance. Pour les cinq plantes fournies, (60+80+80+85+90)/5=79 jours. Le contrôle initial empêche la division par zéro.

assert croissance_moyenne([]) is None
assert croissance_moyenne([Plante('A','x',10,20,'ombre'),
                          Plante('B','x',30,40,'ombre')]) == 20.0
assert croissance_moyenne(plantes) == 79.0

def dictionnaire_mesure(plantes, mesures):
    resultat = {plante.nom: [] for plante in plantes}
    for mesure in mesures:
        nom = mesure['plante']
        if nom in resultat:
            resultat[nom].append(mesure)
    return resultat

On crée d’abord toutes les clés, avec une liste distincte pour chacune. Ensuite on distribue les mesures. La garde nom in resultat ignore un éventuel nom inconnu, puisque les clés attendues viennent de plantes. Ne pas utiliser dict.fromkeys(noms, []) : toutes les clés partageraient la même liste.

a=Plante('A','x',10,20,'ombre'); b=Plante('B','x',30,40,'ombre')
m1={'plante':'A','jour':1}; m2={'plante':'A','jour':2}
assert dictionnaire_mesure([a,b],[m1,m2]) == {'A':[m1,m2],'B':[]}
assert dictionnaire_mesure([a,b],[]) == {'A':[],'B':[]}
assert dictionnaire_mesure([],[]) == {}

Imaginons deux plantes A et B, puis deux relevés pour A. Au départ, le dictionnaire est {'A': [], 'B': []}. Après le premier relevé, seule la liste associée à A contient une mesure ; après le second, elle en contient deux, tandis que B reste présente avec une liste vide. Le point essentiel est l’indépendance des listes. Un test utile consiste à ajouter une mesure au groupe A puis à vérifier que B n’a pas changé. Cela détecte un partage involontaire de la même liste entre toutes les clés.

La boucle for avance son indice interne pendant que remove décale les éléments. Avec 18,19,22,28,29, supprimer 18 fait passer 19 à l’indice 0 ; la boucle visite ensuite l’indice 1, donc 22. Elle supprime 28 et saute de la même manière 29. Le résultat fautif est 19,22,29 au lieu de 22. Une suppression peut donc faire sauter l’élément suivant.

def purger_mesures_extremes(liste_mesures):
    for i in range(len(liste_mesures) - 1, -1, -1):
        if not 20 <= liste_mesures[i]['temperature'] <= 25:
            liste_mesures.pop(i)

Le parcours part de la fin. Supprimer une case ne change alors que les indices déjà visités ; les positions restant à examiner sont intactes. La fonction modifie bien la liste fournie, comme le code initial et son appel le prévoient. Une autre solution correcte est une affectation de tranche liste_mesures[:] = [m for m in liste_mesures if 20<=m["temperature"]<=25] ; une simple réaffectation locale n’aurait pas cet effet sur la liste appelante.

for valeurs, attendu in [([],[]),([18,19,22,28,29],[22]),
                         ([20,25],[20,25]),([18,19],[])]:
    mesures_test=[{'temperature': t} for t in valeurs]
    alias=mesures_test
    purger_mesures_extremes(mesures_test)
    assert alias is mesures_test
    assert [m['temperature'] for m in alias] == attendu

Pourquoi le parcours inverse est-il sûr ? À l’indice i, les cases à droite ont déjà été traitées. Supprimer i décale ces cases déjà traitées, mais ne change pas les indices strictement inférieurs à i. L’itération suivante peut donc examiner i−1 sans perdre de mesure. À l’inverse, dans un parcours croissant, l’élément i+1 devient i après la suppression ; avancer ensuite à i+1 le saute. Cette explication reste vraie pour deux, trois ou dix températures extrêmes consécutives, au-delà du seul exemple testé.