Bac NSI pratique 2026 sujet 10 : Consommation d’eau, fuite nocturne et moyenne glissante

def total_conso(donnees, jour):
    total = 0
    trouve = False
    for mesure in donnees:
        if mesure['jour'] == jour:
            trouve = True
            total += mesure['chaude'] + mesure['froide']
    return total if trouve else None

assert total_conso(donnees,'2025-02-04') == 33
assert total_conso(donnees,'2025-12-25') is None
assert total_conso([{'jour':'x','heure':'00:00','chaude':0,'froide':0}], 'x') == 0

Le booléen trouve distingue absence et zéro. Tester seulement total==0 confondrait ces deux situations. La somme du 04 février vaut 5+3+0+0+1+0+10+14=33 litres.

def fuite_possible(donnees, jour):
    suite = 0
    for mesure in donnees:
        if mesure['jour'] == jour and '00:00' <= mesure['heure'] <= '05:00':
            if mesure['chaude'] + mesure['froide'] > 0:
                suite += 1
                if suite >= 3:
                    return True
            else:
                suite = 0
    return False

suite mesure la longueur de la série positive en cours. Un zéro interrompt cette série et remet le compteur à zéro. Trois mesures positives dispersées ne suffisent pas. Comme les heures sont au format fixe HH: MM, leur comparaison lexicographique respecte l’ordre chronologique. Le sujet parle de mesures consécutives dans une série horaire triée ; si des relevés horaires peuvent manquer, il faudrait en plus contrôler l’écart d’une heure entre relevés, ce qui est une extension du contrat.

assert not fuite_possible(donnees,'2025-02-04')
assert fuite_possible(donnees,'2025-02-05')
assert not fuite_possible([], '2025-02-05')

Sur la suite 5, 3, 0, 3, 0, 0, le compteur prend successivement les valeurs 1, 2, 0, 1, 0, 0 : aucune série n’atteint 3. Sur 2, 1, 1, 0, 0, 0, il atteint 3 au troisième relevé et permet un retour immédiat. Cette trace montre pourquoi compter simplement le nombre de relevés positifs serait insuffisant : la première série contient aussi trois valeurs positives, mais séparées par des zéros. Le test doit donc inclure ces deux formes, pas seulement une suite entièrement positive.

La branche des éléments intermédiaires additionne trois valeurs puis divise par 2. Elle produit 30,45,60 au lieu de 20,30,40. Les extrémités sont correctes. La sortie attendue est [15.0,20.0,30.0,40.0,45.0]. Voici la version corrigée, incluant le cas limite de la question 4 :

def lissage_conso(valeurs):
    if len(valeurs) <= 1:
        return valeurs.copy()
    lisse = []
    for i in range(len(valeurs)):
        if i == 0:
            m = (valeurs[0] + valeurs[1]) / 2
        elif i == len(valeurs) - 1:
            m = (valeurs[i-1] + valeurs[i]) / 2
        else:
            m = (valeurs[i-1] + valeurs[i] + valeurs[i+1]) / 3
        lisse.append(m)
    return lisse

On lit toujours la liste originale et on écrit dans une nouvelle liste. Modifier les valeurs source au fil du calcul ferait dépendre les moyennes suivantes des résultats déjà lissés.

Le dénominateur exprime combien de mesures ont participé à la moyenne. À une extrémité, on n’a que deux valeurs ; à l’intérieur, on en a trois. Pour une série constante, chaque résultat doit rester cette constante : par exemple [12, 12, 12] doit rester [12, 12, 12]. Ce test est très efficace contre le mauvais diviseur, car la version fournie produit 18 au centre. Il complète le test croissant de l’énoncé et illustre une propriété générale du lissage.

Avec une seule valeur, la première branche accède à valeurs[1] : cet indice n’existe pas. La convention naturelle est de conserver la valeur unique. La liste vide était déjà rendue vide par la boucle ; la garde de la correction traite ces deux tailles explicitement et renvoie une copie.

def test_lissage():
    assert lissage_conso([]) == []
    assert lissage_conso([8]) == [8]
    assert lissage_conso([10,20]) == [15.0,15.0]
    assert lissage_conso([10,20,30,40,50]) == [15,20,30,40,45]
    origine = [10,20,30]
    resultat = lissage_conso(origine)
    assert origine == [10,20,30] and resultat is not origine