Situation A : méthode et sujet corrigé

La situation A est l'épreuve pratique d'algorithmique de l'E3 en CCF : une heure de préparation, 30 minutes sur table puis 30 minutes sur machine, suivie de 20 minutes d'oral avec le professeur qui t'a formé, pour un coefficient 1 sur 3. Ce chapitre résume la méthode en une page, puis la met en œuvre sur un sujet complet et corrigé, construit comme ceux de l'épreuve. Le cours d'algorithmique détaille chaque phase et chaque critère et propose trois autres sujets.

Le déroulement en bref

Les huit critères en une liste de contrôle

Le référentiel évalue la situation A sur huit critères. Avant de rendre ta trace écrite et avant de présenter, coche chaque ligne.

1. Connaissances du module : les bonnes structures (boucle, condition, fonction, tableau) au bon endroit.
2. Efficacité et pertinence de la solution : elle répond à la question posée, sans détour.
3. Formalisme cohérent : mêmes conventions du début à la fin (affectation, indices, mots-clés).
4. Lisibilité : indentation, noms parlants, commentaires, en-tête de chaque fonction.
5. Efficacité de l'implémentation : pas de calcul répété inutilement, pas de boucle de trop.
6. Composants fournis : tu les utilises au lieu de les réécrire, en respectant leurs paramètres.
7. Tests de validation : un jeu d'essai avec des cas normaux et des cas limites, résultats attendus calculés à la main.
8. Éléments de correction : tu sais expliquer et corriger une erreur, la tienne ou celle d'un algorithme fourni.

La méthode express

• Minutes 0 à 5. Lis tout le sujet. Souligne entrées, sorties et contraintes. Lis l'interface des composants fournis (nom, paramètres, valeur renvoyée).
• Minutes 5 à 25. Pour chaque question : une ligne « entrées → traitement → sortie », puis l'algorithme, proprement. Reconnais le motif : parcours, comptage, recherche, accumulation, conversion.
• Minutes 25 à 30. Le jeu d'essai, avec les résultats attendus calculés à la main.
• Minutes 30 à 55. Sur machine, une fonction à la fois : tu tapes, tu exécutes, tu testes. Garde tes tests dans le fichier.
• Minutes 55 à 60. Relis : noms, commentaires, en-têtes. Note les erreurs trouvées : ce sont d'excellents sujets pour l'oral.

Sujet type : à quel VLAN appartient cette adresse ?

Sujet d'entraînement construit sur le modèle de la situation A ; ce n'est pas un sujet officiel.

Contexte. Le réseau du siège de Sorbier Logistique est découpé en VLAN. Chaque VLAN a une adresse de réseau et un masque (cours de réseaux, TP d'adressage IP). Le technicien veut un petit programme qui dit à quel VLAN appartient une adresse IPv4, pour contrôler les adresses relevées dans les journaux.

Une adresse appartient à un réseau quand le ET bit à bit entre l'adresse et le masque, octet par octet, redonne l'adresse du réseau.

Composants fournis.

def octets(adresse):
    """Renvoie la liste des quatre entiers d'une adresse IPv4 écrite '192.168.10.71'."""
    return [int(x) for x in adresse.split(".")]


VLANS = [
    (10, "POSTES", "192.168.10.64", "255.255.255.192"),
    (20, "SERVEURS", "192.168.10.176", "255.255.255.240"),
    (21, "APPLIS", "192.168.21.0", "255.255.255.0"),
    (30, "ENTREPOT", "192.168.10.128", "255.255.255.224"),
    (40, "VISITEURS", "192.168.10.0", "255.255.255.192"),
    (50, "TELEPHONIE", "192.168.10.160", "255.255.255.240"),
    (60, "DMZ", "192.168.10.224", "255.255.255.240"),
    (99, "ADMIN", "192.168.10.208", "255.255.255.240"),
]

Chaque élément de VLANS est un tuple (numéro, nom, adresse du réseau, masque). L'opérateur & de Python calcule le ET bit à bit de deux entiers : 71 & 192 vaut 64.

Sur table (30 minutes).

1. Écris une fonction binaire8(n) qui renvoie l'écriture binaire sur 8 bits d'un entier n compris entre 0 et 255, sous forme de chaîne, par divisions successives par 2 (sans utiliser bin ni format).
2. Écris une fonction reseau(adresse, masque) qui renvoie l'adresse du réseau, sous forme de chaîne, en faisant le ET bit à bit octet par octet.
3. Écris une fonction vlan_de(adresse) qui renvoie le numéro du VLAN qui contient l'adresse, ou 0 si aucun VLAN ne la contient.
4. Prépare un jeu d'essai pour vlan_de : au moins six adresses, dont des cas limites, avec le résultat attendu.

Sur machine (30 minutes).

5. Programme et teste les trois fonctions.
6. Écris une fonction hors_plan(adresses) qui reçoit une liste d'adresses et renvoie la liste de celles qui n'appartiennent à aucun VLAN du siège.
7. Pour aller plus loin. Écris une fonction prefixe(masque) qui renvoie la longueur du préfixe d'un masque (26 pour 255.255.255.192), en réutilisant binaire8.

Corrigé

Question 1. On divise par 2 huit fois ; chaque reste est un bit, que l'on place devant les bits déjà obtenus, puisque le premier reste est le bit de poids faible.

Fonction binaire8(n : entier) : chaîne
    // n entre 0 et 255 ; renvoie ses 8 bits, poids fort à gauche
    bits ← ""
    Pour i allant de 1 à 8 faire
        bits ← chaîne(n mod 2) + bits
        n ← n div 2
    Fin Pour
    Renvoyer bits
Fin Fonction

La boucle « Pour » tourne exactement 8 fois : c'est ce qui garantit les zéros de tête (5 donne 00000101, pas 101).

Questions 2 et 3.

Fonction reseau(adresse : chaîne, masque : chaîne) : chaîne
    a ← octets(adresse)
    m ← octets(masque)
    resultat ← ""
    Pour i allant de 0 à 3 faire
        resultat ← resultat + chaîne(a[i] ET m[i])
        Si i < 3 alors
            resultat ← resultat + "."
        Fin Si
    Fin Pour
    Renvoyer resultat
Fin Fonction

Fonction vlan_de(adresse : chaîne) : entier
    Pour chaque (numero, nom, adresse_reseau, masque) de VLANS faire
        Si reseau(adresse, masque) = adresse_reseau alors
            Renvoyer numero
        Fin Si
    Fin Pour
    Renvoyer 0
Fin Fonction

Le parcours s'arrête dès qu'un VLAN correspond : c'est une recherche, pas un comptage. Le Renvoyer 0 est après la boucle : le placer dans un « Sinon » à l'intérieur arrêterait la recherche au premier VLAN qui ne correspond pas.

Question 4. Le jeu d'essai, avec le calcul qui justifie chaque résultat attendu :

Questions 5, 6 et 7 : le programme complet.

# Composants fournis par le sujet
def octets(adresse):
    """Renvoie la liste des quatre entiers d'une adresse IPv4 écrite '192.168.10.71'."""
    return [int(x) for x in adresse.split(".")]


VLANS = [
    (10, "POSTES", "192.168.10.64", "255.255.255.192"),
    (20, "SERVEURS", "192.168.10.176", "255.255.255.240"),
    (21, "APPLIS", "192.168.21.0", "255.255.255.0"),
    (30, "ENTREPOT", "192.168.10.128", "255.255.255.224"),
    (40, "VISITEURS", "192.168.10.0", "255.255.255.192"),
    (50, "TELEPHONIE", "192.168.10.160", "255.255.255.240"),
    (60, "DMZ", "192.168.10.224", "255.255.255.240"),
    (99, "ADMIN", "192.168.10.208", "255.255.255.240"),
]


def binaire8(n):
    """Écriture binaire de n (0 <= n <= 255) sur 8 bits, par divisions successives."""
    bits = ""
    for _ in range(8):
        bits = str(n % 2) + bits
        n = n // 2
    return bits


def reseau(adresse, masque):
    """Adresse du réseau de adresse avec ce masque : ET bit à bit, octet par octet."""
    a = octets(adresse)
    m = octets(masque)
    resultat = []
    for i in range(4):
        resultat.append(str(a[i] & m[i]))
    return ".".join(resultat)


def vlan_de(adresse):
    """Numéro du VLAN du siège qui contient adresse, ou 0 si aucun."""
    for numero, nom, adresse_reseau, masque in VLANS:
        if reseau(adresse, masque) == adresse_reseau:
            return numero
    return 0


def hors_plan(adresses):
    """Liste des adresses qui n'appartiennent à aucun VLAN du siège."""
    resultat = []
    for adresse in adresses:
        if vlan_de(adresse) == 0:
            resultat.append(adresse)
    return resultat


def prefixe(masque):
    """Longueur du préfixe d'un masque : nombre de bits à 1."""
    total = 0
    for octet in octets(masque):
        total = total + binaire8(octet).count("1")
    return total


# Jeu d'essai
assert binaire8(0) == "00000000"
assert binaire8(5) == "00000101"
assert binaire8(255) == "11111111"
assert reseau("192.168.10.71", "255.255.255.192") == "192.168.10.64"
essais = {
    "192.168.10.71": 10, "192.168.10.180": 20, "192.168.21.37": 21,
    "192.168.10.140": 30, "192.168.10.64": 10, "192.168.10.63": 40,
    "192.168.10.200": 0, "192.168.20.10": 0,
}
for adresse, attendu in essais.items():
    assert vlan_de(adresse) == attendu, adresse
assert hors_plan(["192.168.10.71", "192.168.10.200", "192.168.20.10"]) == ["192.168.10.200", "192.168.20.10"]
assert prefixe("255.255.255.192") == 26
assert prefixe("255.255.255.240") == 28
print("Tous les tests passent.")

Les assert gardent les tests dans le fichier : devant la commission, tu relances le programme et tout le jeu d'essai s'exécute en une seconde. Si un test échoue, Python affiche l'adresse en cause.

Les questions de l'entretien

Exercices

def vlan_de(adresse):
    for numero, nom, adresse_reseau, masque in VLANS:
        if reseau(adresse, masque) == adresse_reseau:
            return numero
        else:
            return 0

def compter(adresses, numero):
    """Nombre d'adresses de la liste qui appartiennent au VLAN numero."""
    total = 0
    for adresse in adresses:
        if vlan_de(adresse) == numero:
            total = total + 1
    return total


liste = ["192.168.10.71", "192.168.10.100", "192.168.10.180", "192.168.20.10"]
assert compter(liste, 10) == 2      # .71 et .100 sont dans 192.168.10.64/26
assert compter(liste, 99) == 0      # aucune adresse d'administration
assert compter([], 10) == 0         # liste vide