Épreuve pratique NSI 2026 — Sujet 01 (sujet zéro 3) : codage RLE d'images

Épreuve pratique d'une heure sur ordinateur. Le candidat dispose de l'énoncé et de fichiers de code et de données. Il agit en autonomie ; aux « appels professeur » indiqués dans le sujet, il présente son travail à l'examinateur ou le sollicite en cas de difficulté.

Ce sujet zéro est devenu le sujet n°01 de la banque nationale 2026 de l'épreuve pratique. Le texte est le même, à la présentation près.

Codage RLE d'images

On considère des images en niveaux de gris : chaque pixel est décrit par une valeur entre 0 (noir) et 255 (blanc), qui représente l'intensité du gris. Une image est vue comme la liste des valeurs de ses pixels, ligne par ligne. Par exemple, une petite image en niveaux de gris peut, une fois « aplatie », devenir la liste [0, 128, 128, 255, 64, 255, 128, 128, 255, 255, 128, 128, 0, 0, 64, 255, 0, 0, 0, 0], à partir de laquelle on retrouve l'image si l'on connaît sa largeur.

Les images manipulées sont des dessins ou des schémas présentant de grandes zones d'un même gris. On veut les représenter efficacement en tirant parti de cette particularité : les aplats font apparaître des valeurs qui se répètent. On remplace donc chaque suite de valeurs identiques par un couple (compte, valeur), qui indique le nombre de répétitions et la valeur répétée. La liste de couples est elle-même aplatie en une liste de longueur paire [compte1, valeur1, compte2, valeur2, ...]. Cette nouvelle liste est le codage RLE de l'image (de l'anglais run-length encoding : une suite de valeurs identiques s'appelle un run).

Exemple. La liste [4, 4, 4, 0, 5, 5] présente trois fois de suite la valeur 4, soit le couple (3, 4), une fois la valeur 0, soit (1, 0), et deux fois la valeur 5, soit (2, 5). Son codage RLE est [3, 4, 1, 0, 2, 5]. Ici, les deux listes ont la même longueur ; mais la liste [0, 0, 0, 0, 0] aurait pour codage [5, 0], plus court.

1. La liste obtenue par codage RLE est-elle forcément de longueur inférieure ou égale à celle de la liste de départ ?

Appel 1 — Appeler le professeur en cas de difficulté de compréhension du codage.

2. En étudiant la fonction codage_rle, qui réalise le codage, écrire le corps de la fonction decodage_rle, qui réalise le décodage d'une liste. Des tests sont fournis dans la fonction test_codage ; on pourra les compléter.

Appel 2 — Appeler le professeur pour lui présenter votre fonction et son fonctionnement, ou en cas de difficultés.

3. Pour tester le codage sur une image, on peut utiliser la fonction fournie encoder_decoder_image, qui code puis décode une image et enregistre le résultat dans un nouveau fichier. Utiliser cette fonction sur les images bac_nsi_32.png et bac_nsi_256.png, et observer la différence de comportement.

4. Le problème précédent vient de ce que, sur de grandes images, plus de 255 pixels consécutifs peuvent avoir la même couleur. Proposer une démarche de résolution de ce problème, qui modifie les fonctions de codage et de décodage, puis l'implémenter.

Appel 3 — Appeler le professeur pour lui présenter votre démarche, ou en cas de difficultés.

Fichier fourni : rle.py

Le dossier contient aussi les images bac_nsi_32.png (32 × 32 pixels) et bac_nsi_256.png (256 × 256 pixels). Le code nécessite la bibliothèque pillow.

from PIL import Image
 
def codage_rle(liste_octets):
    '''Renvoie une liste d'octets obtenue par compression RLE'''
    liste_rle = []
    i = 0
    while i < len(liste_octets):
        c = liste_octets[i]
        k = 1
        while i+k < len(liste_octets) and liste_octets[i+k] == c:
            k += 1
        liste_rle.append(k)
        liste_rle.append(c)
        i += k
    return liste_rle
 
def decodage_rle(liste_rle):
    '''Renvoie la liste d'octets obtenue à partir de la liste liste_rle obtenue
    par compression RLE'''
    # A VOUS D'ÉCRIRE LE CODE LA FONCTION
 
def test_codage():
    assert codage_rle([255, 255, 0, 255, 255, 255]) == [2, 255, 1, 0, 3, 255]
    assert decodage_rle([2, 255, 1, 0, 3, 255]) == [255, 255, 0, 255, 255, 255]
 
#############################################################################
# Il n'est pas nécessaire de comprendre le code de ces 4 fonctions, mais il #
# sera nécessaire de les utiliser dans la suite à partir de l'exemple.      #
#############################################################################
 
def enregistrer_octets(nom_fichier, liste_octets):
    '''Enregistre une liste de valeurs numériques entre 0 et 255 dans un
    le fichier nom_fichier. Si une valeur est plus grande que 255 on considère
    que c'est 255. De même pour les valeur plus petite que 0.'''
    with open(nom_fichier, 'wb') as fichier:
        fichier.write(bytes([ max(0, min(255, b)) for b in liste_octets]))
 
def charger_octets(nom_fichier):
    '''Renvoie la liste des octets présents dans le fichier nom_fichier'''
    with open(nom_fichier, 'rb') as fichier:
        liste_octets = list(fichier.read())
        return liste_octets
 
def enregistrer_image(nom_image, largeur, liste_niveaux):
    '''Enregistre un fichier image nom_image de la largeur donnée et dont les
    valeurs de niveaux de gris des pixels sont celles de la liste
    liste_niveaux'''
    hauteur = len(liste_niveaux) // largeur
    im = Image.frombytes('L', (largeur, hauteur), bytes(liste_niveaux))
    im.save(nom_image)
 
def charger_image(nom_image):
    '''Étant donné une image nom_image, renvoie un couple (largeur, liste_niveaux) où
    largeur est la largeur de l'image et liste_niveaux est la liste des valeurs de niveaux
    de gris de l'image ligne par ligne'''
 
    image = Image.open(nom_image).convert('L')
    return (image.width, list(image.tobytes()))
 
#############################################################################
# Fonction nécessaire pour les tests de la question 3                       #
#############################################################################
 
def encoder_decoder_image(nom_image):
    '''Fonction de test permettant d'encoder puis décoder une image avec un
    codage RLE. Le fichier rle est nommé nom_image.rle et le fichier decodé
    est nom_image.dec.png'''
    w, l = charger_image(nom_image)
    enregistrer_octets(nom_image+'.rle', codage_rle(l))
    l = charger_octets(nom_image+'.rle')
    enregistrer_image(nom_image+'.dec.png', w, decodage_rle(l))