Corrigé NSI Métropole 2026 – Jour 1

1. Conversion en binaire de l’adresse IP et du masque

On convertit chaque octet séparément sur 8 bits.

2. Nombre d’hôtes et adresses utilisables du site3

Le site3 est dans le réseau 172.16.32.0/20. Un préfixe /20 laisse 12 bits pour la partie machine, car 32 – 20 = 12.

Nombre total d’adresses : 2¹² = 4096. On retire l’adresse réseau et l’adresse de diffusion : 4094 hôtes utilisables.

3. Paramètre mal configuré

L’hôte peut communiquer avec le site3, mais pas avec Internet. Le test vers 172.16.47.254 réussit : cette adresse correspond à la bonne passerelle du réseau site3, puisqu’elle est la dernière adresse utilisable du sous-réseau.

Dans le fichier, la passerelle indiquée est pourtant 172.16.48.254, qui appartient au sous-réseau suivant, celui du site4.

4. Adresses du lien R2-R4 en 192.168.0.8/30

Un réseau /30 laisse 2 bits pour les machines, donc 4 adresses au total : adresse réseau, deux adresses utilisables et adresse de diffusion.

Pour 192.168.0.8/30 : adresse réseau = 192.168.0.8, diffusion = 192.168.0.11.

5. Chemin observé avec traceroute et coût RIP

La commande indique les routeurs traversés depuis le site3 : R2, puis R3, puis R4, puis R5, avant la sortie vers Internet.

6. Dysfonctionnement du réseau

Le réseau contient un lien direct entre R2 et R4. Un chemin plus court existe donc : R2 → R4 → R5, de coût RIP 2. Or le chemin observé a un coût 3.

7. Débit et coût d’une liaison

Le débit mesure la quantité de données transmises par seconde. On cherche donc à le maximiser. Le coût, dans OSPF, représente une pénalité de passage par une liaison : on cherche donc à le minimiser.

8. Chemin OSPF depuis le site4 vers Internet

Les coûts sont calculés avec la formule coût = 10⁸ / débit.

Depuis le site4, le routeur d’entrée est R2. Le meilleur chemin vers R5 est :

R2 → R1 → R3 → R4 → R5

Coût total : 1 + 0,025 + 0,025 + 0,025 = 1,075.

9. Chiffrement symétrique ou asymétrique ?

Alice et Bob doivent préférer le chiffrement asymétrique pour initialiser un échange sécurisé. En effet, avec un chiffrement symétrique, les deux interlocuteurs doivent partager une même clé secrète. Si cette clé est échangée sur un réseau déjà compromis, le pirate peut l’intercepter.

10. Pourquoi HTTPS est plus sécurisé que HTTP

HTTP transmet les données en clair. Un pirate placé sur le réseau peut donc lire ou modifier les informations échangées. HTTPS ajoute une couche de sécurité grâce au protocole TLS : les échanges sont chiffrés, l’intégrité est vérifiée et le serveur peut être authentifié par certificat.

1. Nombre total de configurations

Il y a 9 jetons. Chaque jeton possède 2 états possibles : Recto ou Verso. Les choix sont indépendants.

2. Séquence ligne 1, ligne 2, colonne 2

La figure 1 se lit, ligne par ligne : [0, 0, 1, 0, 0, 1, 1, 1, 0]. Après les trois coups :

• ligne 1 : [1, 1, 0, 0, 0, 1, 1, 1, 0] ;
• ligne 2 : [1, 1, 0, 1, 1, 0, 1, 1, 0] ;
• colonne 2 : [1, 0, 0, 1, 0, 0, 1, 0, 0].

3. Entier représentant la configuration de la figure 1

La configuration de la figure 1 est 001001110 en binaire.

Calcul : 0×2⁸ + 0×2⁷ + 1×2⁶ + 0×2⁵ + 0×2⁴ + 1×2³ + 1×2² + 1×2¹ + 0×2⁰.

Donc : 64 + 8 + 4 + 2 = 78.

4. Fonction representant

On lit les bits de gauche à droite. À chaque nouveau bit, on décale l’entier déjà construit d’un rang binaire, puis on ajoute le bit.

def representant(bits):
    total = 0
    for bit in bits:
        total = 2 * total + bit
    return total

5. Fonction xor_etendu

On applique le XOR élément par élément sur deux listes de même longueur.

def xor_etendu(l_x, l_y):
    resultat = []
    for i in range(len(l_x)):
        resultat.append(xor(l_x[i], l_y[i]))
    return resultat

6. Fonction configurations_suivantes

On convertit la configuration entière en liste de bits, puis on applique chaque masque de coup possible. Chaque configuration obtenue est reconvertie en entier.

def configurations_suivantes(config):
    config_bin = binaire(config)
    voisins = []
    for coup in coups_possibles:
        masque = coups_possibles[coup]
        config_suivante = xor_etendu(config_bin, masque)
        voisins.append(representant(config_suivante))
    return voisins

7. Pourquoi l’arête réciproque existe

Si l’on passe de x à y en appliquant un coup, cela signifie que y = x ⊕ masque. Or appliquer deux fois le même XOR revient à annuler l’opération : un jeton retourné deux fois revient dans son état initial.

8. Dictionnaire ou matrice d’adjacence ?

Il y a 2⁹ configurations, donc 512 sommets. Dans une matrice d’adjacence, il faudrait stocker 2⁹ × 2⁹ = 2¹⁸ valeurs.

Avec un dictionnaire de successeurs, chaque configuration possède seulement 8 voisins, car il y a 8 coups possibles. On stocke donc environ 8 × 2⁹ entiers pour les voisins, ou 9 × 2⁹ si l’on compte aussi les clés du dictionnaire.

9. Fonction parcours_profondeur

Un parcours en profondeur marque le sommet courant comme vu, puis explore récursivement ses voisins non encore visités.

def parcours_profondeur(graphe, configuration, vus):
    vus.append(configuration)
    for s in graphe[configuration]:
        if s not in vus:
            parcours_profondeur(graphe, s, vus)

10. Vérifier que la configuration 4 est perdante

La configuration gagnante est celle où tous les bits valent 1, soit 111111111 en binaire, c’est-à-dire 2⁹ – 1 = 511.

vus = []
parcours_profondeur(graphe, 4, vus)

if 511 not in vus:
    print("La configuration 4 est perdante")
else:
    print("La configuration 4 est gagnante")

11. Parcours le plus adapté pour obtenir un minimum de coups

Le graphe n’est pas pondéré : chaque arête correspond à un coup. Pour trouver un chemin avec un nombre minimal de coups, il faut explorer les sommets par distance croissante depuis le départ.

1. Nom du nœud de départ

Dans le vocabulaire des arbres, le nœud de départ, placé tout en haut de la structure, s’appelle la racine.

2. L’arbre de débat est-il binaire ?

Un arbre binaire est un arbre dans lequel chaque nœud possède au maximum deux enfants. Ici, une affirmation peut recevoir plusieurs arguments directs : plusieurs pour et plusieurs contre.

3. Attributs de la classe Affirmation

4. Méthode soutenir

L’argument ne doit pas déjà appartenir à un autre arbre ou à une autre position. On vérifie donc que sa sorte est encore vide.

def soutenir(self, argument):
    assert argument.sorte == ""
    self.arguments.append(argument)
    argument.sorte = "pour"

5. Méthode nb_contre

Il faut compter seulement les arguments directement rattachés à l’affirmation courante et dont la sorte vaut « contre ».

def nb_contre(self):
    compteur = 0
    for arg in self.arguments:
        if arg.sorte == "contre":
            compteur = compteur + 1
    return compteur

6. Interprétation de la méthode mystere

La méthode commence par calculer le nombre d’arguments contre directement rattachés à l’affirmation courante. Puis elle parcourt récursivement tous les arguments descendants et conserve la plus grande valeur trouvée.

7. Méthode evaluation

On part du score propre de l’affirmation : likes – dislikes. Puis on ajoute l’évaluation des arguments pour et on retire l’évaluation des arguments contre.

def evaluation(self):
    total = self.nb_likes - self.nb_dislikes
    for arg in self.arguments:
        if arg.sorte == "pour":
            total = total + arg.evaluation()
        if arg.sorte == "contre":
            total = total - arg.evaluation()
    return total

8. Rôles d’un SGBD

Un SGBD sert à gérer une base de données : il sécurise l’accès, conserve les données et permet l’accès simultané de plusieurs utilisateurs.

9. Autre clé primaire possible pour utilisateur

La table utilisateur utilise le pseudo comme clé primaire. L’attribut email pourrait aussi servir de clé primaire si l’on impose qu’une adresse e-mail ne puisse appartenir qu’à un seul utilisateur.

10. Nombre d’affirmations ayant au moins 50 likes

SELECT COUNT(*)
FROM affirmation
WHERE nb_likes >= 50;

11. Contenus des sujets créés par Pierre Durand

Il faut joindre affirmation et utilisateur, puis filtrer sur le prénom, le nom et le fait que l’affirmation soit un sujet.

SELECT affirmation.contenu, affirmation.nb_likes
FROM affirmation JOIN utilisateur
     ON affirmation.auteur = utilisateur.pseudo
WHERE utilisateur.prenom = 'Pierre'
  AND utilisateur.nom = 'Durand'
  AND affirmation.sorte = 'sujet';

12. Interprétation de la requête avec auto-jointure

La requête joint la table affirmation avec elle-même : une première fois pour l’affirmation attaquée, une seconde fois pour sa réponse.

13. Ajouter un like de l’utilisateur i<3descartes

Il faut insérer une réaction, puis incrémenter le compteur de likes de l’affirmation concernée.

INSERT INTO reaction
VALUES (108, 'i<3descartes', 'like');

UPDATE affirmation
SET nb_likes = nb_likes + 1
WHERE id_aff = 108;

14. Pourquoi supprimer les réactions avant l’utilisateur ?

La table reaction contient une clé étrangère vers la table utilisateur. Si l’on supprimait l’utilisateur avant ses réactions, il resterait des réactions faisant référence à un utilisateur qui n’existe plus.

15. Requêtes pour le droit à l’effacement de i<3rgpd

La procédure demandée impose trois étapes : anonymiser les affirmations, supprimer les réactions, puis supprimer le compte utilisateur.

UPDATE affirmation
SET auteur = NULL
WHERE auteur = 'i<3rgpd';

DELETE FROM reaction
WHERE utilisateur = 'i<3rgpd';

DELETE FROM utilisateur
WHERE pseudo = 'i<3rgpd';