Bac NSI pratique 2026 sujet 1 : Compression RLE des images en niveaux de gris

Non. La liste [0,255] devient [1,0,1,255] : deux valeurs deviennent quatre. Pour n pixels répartis en r suites maximales, le codage occupe 2 r valeurs. Il raccourcit la liste si 2 r < n, soit une longueur moyenne des suites supérieure à 2. Dans le pire cas, chaque pixel diffère du précédent et la taille double. Il faut donc examiner le contenu, pas seulement la taille de l’image.

def decodage_rle(liste_rle):
    resultat = []
    for i in range(0, len(liste_rle), 2):
        compte = liste_rle[i]
        valeur = liste_rle[i + 1]
        for _ in range(compte):
            resultat.append(valeur)
    return resultat

Les indices 0,2,4… désignent les comptes. La valeur associée se situe juste après. La boucle intérieure recopie cette valeur autant de fois qu’indiqué. La liste vide produit naturellement une liste vide. On suppose ici une liste RLE valide, de longueur paire, comme le prévoit le contrat. Appeler test_codage(), puis vérifier plusieurs cas :

assert decodage_rle([]) == []
assert decodage_rle([1, 0]) == [0]
assert decodage_rle([3, 255, 2, 0]) == [255, 255, 255, 0, 0]
for image in ([], [0], [4, 4, 4, 0, 5, 5], [0, 255] * 10):
    assert decodage_rle(codage_rle(image)) == image

Suivons le décodage de [3, 4, 1, 0, 2, 5]. Au départ, le résultat est vide. Le premier couple ajoute trois fois 4, le deuxième ajoute une fois 0, le troisième ajoute deux fois 5. Après chaque couple, le résultat contient exactement les pixels décrits par les couples déjà lus. C’est cette propriété qui permet d’expliquer pourquoi la concaténation finale restitue toute l’image.

Une assertion d’aller-retour doit porter sur la liste entière. Comparer seulement les longueurs laisserait passer une image dont les couleurs ont été changées ; comparer seulement la première valeur laisserait passer un décalage des lignes. L’égalité de listes contrôle longueur, ordre et valeurs. Elle n’explique toutefois pas seule pourquoi le programme convient à toute image : il faut aussi justifier la lecture par couples.

encoder_decoder_image("bac_nsi_32.png")
encoder_decoder_image("bac_nsi_256.png")

La petite image est restituée sans perte. La grande est corrompue : enregistrer_octets remplace toute valeur supérieure à 255 par 255, y compris les comptes RLE. Des répétitions sont donc perdues. Le tableau ci-dessus provient des fichiers fournis : ce défaut se produit lors de l’écriture des octets, alors que l’encodage et le décodage en mémoire peuvent réussir. enregistrer_image calcule ensuite la hauteur par division entière, qui ne répare pas la perte de pixels. L’affichage exact peut dépendre de Pillow ; la perte de données, elle, se démontre par ces longueurs.

Une solution simple conserve le format de couples mais découpe chaque suite en blocs d’au plus 255 pixels. Une suite de 600 zéros devient [255,0,255,0,90,0]. Le décodeur de la question 2 accepte déjà des couples consécutifs de même valeur : il reste compatible et n’a pas besoin d’une modification algorithmique. Il suffit donc de remplacer l’encodeur ; cette absence de changement du décodage doit être explicitement justifiée, même si l’énoncé invite à modifier les deux fonctions.

def codage_rle(liste_octets):
    resultat = []
    i = 0
    while i < len(liste_octets):
        valeur = liste_octets[i]
        compte = 1
        while (i + compte < len(liste_octets)
               and liste_octets[i + compte] == valeur
               and compte < 255):
            compte += 1
        resultat.extend([compte, valeur])
        i += compte
    return resultat

def decodage_rle(liste_rle):
    resultat = []
    for i in range(0, len(liste_rle), 2):
        compte = liste_rle[i]
        valeur = liste_rle[i + 1]
        for _ in range(compte):
            resultat.append(valeur)
    return resultat

La garde compte <255 impose la capacité d’un octet sans perdre de pixel. L’indice i avance du nombre réellement encodé, donc les pixels restants sont traités à l’itération suivante. Aucun compte nul n’est émis. Relancer les deux images et vérifier l’égalité pixel par pixel, pas seulement la ressemblance visuelle.

for n in [0, 1, 254, 255, 256, 510, 511, 600]:
    image = [42] * n
    rle = codage_rle(image)
    assert all(0 <= v <= 255 for v in rle)
    assert decodage_rle(list(bytes(rle))) == image
for nom in ["bac_nsi_32.png", "bac_nsi_256.png"]:
    encoder_decoder_image(nom)
    assert charger_image(nom) == charger_image(nom + ".dec.png")

Le cas frontière le plus instructif est une suite de 256 pixels. La première itération encode 255 pixels et place i sur le dernier pixel restant. La suivante émet un couple de compte 1. Le décodeur lit donc 255 + 1 pixels de même couleur, ce qui reconstitue exactement l’aplat. Pour 510 pixels, deux couples de compte 255 suffisent : aucun bloc final vide ne doit apparaître. Ces deux cas mettent à l’épreuve deux frontières différentes.