Bac général Spé NSI 2026 Sujet 1 [Corrigé]

• Sujet disponible ici

Exercice 1 - Les réseaux, les protocoles de routage et la sécurisation des communications

Partie A - Configuration IP du site 3

Question 1. Convertir les adresses suivantes en binaire sur 32 bits.

Adresse IP :

Octet décimal	172	16	32	15
Octet binaire	10101100	00010000	00100000	00001111

Adresse IP : 10101100.00010000.00100000.00001111

Masque de sous-réseau :

Octet décimal	255	255	240	0
Octet binaire	11111111	11111111	11110000	00000000

Masque de sous-réseau : 11111111.11111111.11110000.00000000

Question 2. Indiquer le nombre d’hôtes que le réseau peut accueillir, ainsi que la première et la dernière adresse IP utilisables par ces hôtes.

L’adresse comporte 32 bits. Le masque de sous-réseaux en utilise 20. Il reste donc 32 - 20 = 12 bits pour la partie machine.

Le nombre d'adresses possibles est donc 2^12 = 4096. Or, l'adresse réseau et l'adresse de diffusion ne sont pas utilisables. Le nombre d'hôtes utilisables est donc 4096 - 2 = 4094 hôtes.

La première adresse IP utilisable est 172.16.32.1 et la dernière 172.16.47.254.

Question 3. Identifier dans la configuration de cet hôte le paramètre mal configuré et proposer une correction.

Le paramètre mal configuré est la passerelle. Dans cette configuration, elle vaut 172.16.48.254 : elle n'appartient pas au réseau du site 3. Elle devrait être remplacée par 172.16.47.254.

Question 4. Proposer deux adresses IP à attribuer aux interfaces des routeurs R2 et R4 pour établir ce lien.

On a :

-       Adresse réseau : 192.168.0.8

-       Deux adresses utilisables : 192.168.0.9 et 192.168.0.10

-       Adresse de diffusion : 192.168.0.11

On peut donc attribuer, par exemple, 192.168.0.9 à R2 et 192.168.0.10 à R4.

Partie B - Routage dynamique

Question 5. Donner le chemin suivi par l’information et son coût pour aller de R2 à R5.

D'après le traceroute, le chemin suivi est : R2 -> R3 -> R4 -> R5

Le coût correspond au nombre de liens empruntés, soit 3 (R2-R3, R3-R4 et R4-R5).

Question 6. Expliquer en quoi le réseau présente un dysfonctionnement et formuler une cause possible de ce problème.

Le réseau présente un dysfonctionnement de routage. Le chemin choisi devrait être le plus court en nombre de sauts. Or, il existe un chemin que celui emprunter pour aller de R2 vers R5 (R2 -> R4 -> R5).

Une cause possible pourrait être une mauvaise configuration ou une panne de la liaison R2-R4.

Question 7. Sur un réseau informatique, pour chacun des deux termes ‘débit’ et ‘coût’ d’une liaison, préciser si l’on souhaite le minimiser ou le maximiser.

Sur un réseau informatique, on souhaite maximiser le débit (pour transmettre plus de données par seconde) et minimiser le coût d'une liaison.

Question 8. Donner, en précisant son coût, le chemin emprunté par un paquet de données depuis le site 4 jusqu’à Internet.

Le site 4 est relié au routeur R2. Le chemin le plus court serait R2-R4-R5, mais la liaison R2-R4 est en Ethernet avec un très faible débit, donc un coût élevé :

Type de liaison	Débit	Coût
Ethernet	10 Mbit/s = 10^7 bit/s	10
Fast Ethernet	100 Mbit/s = 10^8 bit/s	1
Fibre optique	4 Gbit/s = 4 x 10^9 bit/s	0,025

Le chemin avec le coût minimal favorise les liaisons en fibre optique : R2 -> R1 -> R3 -> R4 -> R5

Son coût vaut : R2-R1 + R1-R3 + R3-R4 + R4-R5 = 1 + 0,025 + 0,025 + 0,025 = 1,075

Partie C - Sécurisation des échanges de données

Question 9. Entre le chiffrement symétrique ou asymétrique, donner en justifiant lequel des deux Alice et Bob doivent préférer utiliser pour éviter que le pirate ne puisse connaître le contenu de leurs échanges.

Alice et Bob doivent préférer utiliser un chiffrement asymétrique. Ce dernier possède en effet deux clés : une clé publique, à laquelle a accès le pirate, et une clé privée, secrète, que le pirate ne peut pas déduire de la clé publique. La communication est donc sécurisée, contrairement à un chiffrement symétrique.

Question 10. Expliquer en quoi le protocole HTTPS est plus sécurisé que le protocole http pour les échanges entre Alice et Bob.

Le protocole HTTP transmet juste des informations : elles sont donc visibles par le pirate déjà placé sur le réseau. Le protocole HTTPS est plus sécurisé, car les données sont protégées par une couche de chiffrement (SSL/TLS). Il implique également une authentification qui permet de vérifier l'identité du serveur grâce à un certificat numérique.

• Qu'est-ce que les réseaux informatiques et comment les comprendre réellement ?

• L'administration réseaux : le protocole de routage

Exercice 2 – Le binaire, les graphes et la récursivité

Partie A - Représentation binaire des configurations

Question 1. Justifier que le nombre total de configurations possibles est 2^9.

Le plateau contient 9 jetons et chacune peut être soit Recto, soit Verso (donc 2 possibilités). Les choix étant indépendants, le nombre total de configurations possibles est : 2 x 2 x 2 x 2 x 2 x 2 x 2 x 2 x 2 = 2^9,

Question 2. Indiquer en justifiant si la séquence de coups suivante, jouée depuis la configuration donnée en figure 1, permet de mener à la victoire : ligne 1, ligne 2, colonne 2.

Sur la figure 1, la configuration initiale est :

bbn

bbb

bnn

On applique alors les coups demandés :

Coup ligne 1

nnb

bbb

bnn

Coup ligne 2

nnb

nnn

bnn

Coup colonne 2

nbb

nbn

bbn

La configuration finale n'est pas composée uniquement de jetons noirs, donc cette séquence ne mène pas à la victoire.

Question 3. Donner l’entier représentant la configuration illustrée en figure 1.

La configuration de la figure 1 est [0, 0, 1, 0, 0, 1, 1, 1, 0], ce qui correspond à l'écriture binaire 001001110.

On calcule 0 x 2^8 + 0 x 2^7 + 1 x 2^6 + 0 x 2^5 + 0 x 2^4 + 1 x 2^3 + 1 x 2^2 + 1 x 2^1 + 0 x 2^0 = 64 + 8 + 4 + 2 = 78.

L'entier représentant la configuration illustrée en figure 1 est donc 78.

Question 4. Implémenter une fonction représentant prenant en paramètre une liste de 0 et de 1 et renvoyant l’entier correspondant.

En parcourant la liste de bits de gauche à droite, à chaque nouveau bit, on multiplie le résultat courant par 2, puis on ajoute le bit lu.

def representant(liste_position):

    entier = 0

    puissance = 0

    for i in range(len(liste_position)-1, -1, -1):

        entier += liste_position[i] * 2**puissance

        puissance += 1

    return entier

Question 5. Implémenter une fonction xor_etendu qui prend en paramètre deux listes de bits de même longueur l_x et l_y et renvoie la liste l_x⊕l_y.

def xor_etendu(l_x, l_y):

    resultat = []

    for i in range(len(l_x)):

        bit_combine = xor(l_x[i], l_y[i])

        resultat.append(bit_combine)

    return resultat

Question 6. Recopier et compléter la fonction configurations_suivantes.

Pour chaque coup possible, on applique le xor_étendu :

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

Partie B - Graphe des configurations

Question 7. Montrer que s’il existe une arête 𝑥 → 𝑦 dans le graphe, alors il existe également une arête 𝑦 → 𝑥.

S'il existe une arête x -> y, cela signifie qu'il existe un coup permettant de passer de la configuration x à la configuration y. Or, un coup consiste à retourner une ligne ou une colonne entière de jetons. Donc, si on fait deux fois le même coup d’affilé, on revient à l’état initial. Le coup permettant de passer de x à y permet aussi de passer de y à x. Il existe donc aussi une arête y -> x.

Question 8. Justifier le choix du dictionnaire en comparant pour les deux structures le nombre d’entiers nécessaires pour stocker en mémoire le graphe des configurations.

Le graphe possède 2^9 sommets, car il y a 2^9 configurations possibles.

Avec une matrice d'adjacence, il faudrait une case pour chaque couple de sommets. Il faudrait donc stocker 2^9 x 2^9 = 2^18 valeurs.

Avec un dictionnaire d'adjacence, chaque configuration possède exactement 8 voisines, car il y a 8 coups possibles : 3 lignes, 3 colonnes et 2 diagonales. Il faut donc stocker environ 8 x 2^9 = 2^3 x 2^9 = 2^12 entiers pour les listes de voisins. Le dictionnaire est donc plus adapté, car plus optimisé.

Question 9. Recopier et compléter la fonction parcours_profondeur.

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

Question 10. En utilisant la fonction parcours_profondeur, écrire en Python une suite d’instructions permettant de vérifier que la configuration représentée par l’entier 4 est bien perdante.

La configuration gagnante finale correspond à la liste [1, 1, 1, 1, 1, 1, 1, 1, 1]. L'entier correspondant est 511. On parcourt toutes les configurations accessibles depuis 4 afin de vérifier que 511 n’en fait pas partie :

vus = []
parcours_profondeur(graphe, 4, vus)
if 511 in vus:
    print("La configuration 4 est gagnante.")
else:
    print("La configuration 4 est perdante.")

Question 11. Indiquer et justifier quel parcours de graphe (en largeur ou en profondeur) est le plus approprié pour trouver un chemin partant d’une configuration gagnante et menant à la victoire en un minimum de coups.

Pour trouver un chemin menant à la victoire avec un minimum de coups, le parcours le plus approprié est le parcours en largeur.

Ce dernier explore d'abord toutes les configurations accessibles en 1 coup, puis en 2 coups, en 3 coups, etc. Le premier résultat trouvé correspond donc forcément au minimum de coup(s). En revanche, un parcours en profondeur peut trouver une solution sans qu’elle ne corresponde au chemin le plus court, puisqu’il suit une branche jusqu’au bout avant de revenir sur le début d’une autre branche.

• Cours de programmation : récursivité, fractales et labyrinthe en Java

• Langage Python - Exercice d'entrainement

Exercice 3 – Les arbres, les algorithmes sur les arbres et les bases de données

Partie A - Structure arborescente des arguments

Question 1. Indiquer le nom donné au nœud “point de départ du débat” dans le vocabulaire des arbres.

Dans le vocabulaire des arbres, le nœud qui correspond au point de départ du débat s'appelle la racine de l’arbre.

Question 2. Indiquer en justifiant si un arbre de débat est un arbre binaire ou non.

Dans un arbre binaire, chaque nœud possède deux enfants. Or, ici, une affirmation peut recevoir plusieurs réponses (sur la figure, on voit que certaines affirmations ont trois ou quatre réponses rattachées). Donc, un arbre de débat n'est pas un arbre binaire.

Question 3. Donner le nom et le type de chaque attribut de la classe Affirmation.

Attribut	Type
contenu	str
sorte	str
arguments	list
nb_likes	int
nb_dislikes	int

Question 4. Recopier et compléter les lignes 10 à 12 de la méthode soutenir, en respectant sa documentation.

Ligne 10 : assert argument.sorte == ""
Ligne 11 : self.arguments.append(argument)
Ligne 12 : argument.sorte = "pour"

Question 5. Écrire la méthode nb_contre qui permet d’obtenir le nombre d’arguments contre directement rattachés à cette Affirmation.

On parcourt la liste des arguments directement rattachés à l'affirmation et on compte seulement ceux dont l'attribut sorte vaut "contre" :

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

Question 6. Expliquer par une phrase ce que renvoie la méthode mystere.

La méthode mystère calcule le nombre d'arguments « contre » directement rattachés à l'affirmation courante, puis à ses arguments et garde la plus grande valeur trouvée : elle renvoie donc le nombre maximal d'arguments « contre » directement rattachés à une même affirmation dans tout le sous-arbre ayant self pour racine.

Question 7. Écrire, en utilisant uniquement des lignes de code choisies parmi les lignes suivantes, une méthode evaluation qui renvoie le résultat du calcul décrit dans la formule ci-dessus.

Après avoir pris en complet les likes et dislikes de l'affirmation, pour chaque argument, s'il s'agit d'un argument « pour », on ajoute son évaluation, mais s'il s'agit d'un argument « contre », on la soustrait :

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

Partie B - Base de données des utilisateurs et de leurs contributions

Question 8. Parmi les propositions suivantes, indiquer celles qui font partie des rôles d’un SGBD :

a) oui

b) non, cela relève du matériel et de l'infrastructure

c) oui

d) oui

e) non, HTTPS concerne plutôt le serveur web et la sécurisation des communications réseau

Question 9. Indiquer en justifiant quel autre attribut de la table utilisateur aurait aussi pu servir de clé primaire.

Dans la table utilisateur, l'attribut utilisé doit être unique pour chaque utilisateur. L’adresse e-mail, par exemple, aurait donc pu servir de clé primaire.

Question 10. Écrire une requête SQL permettant d’obtenir le nombre d’affirmations qui ont 50 likes ou plus.

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

Question 11. Écrire une requête qui permet d’obtenir les contenus des sujets et leur nombre de likes, créés par les utilisateurs dont les prénom et nom sont respectivement 'Pierre' et 'Durand'.

Il faut joindre la table affirmation avec la table utilisateur :

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

Question 12. Donner une interprétation en français de ce que permet d’obtenir la requête ci-dessus.

Cette requête permet d'obtenir, pour chaque affirmation, le contenu d'un argument contre qui lui répond et qui a reçu au moins deux fois plus de likes que l’affirmation initiale. Elle met donc en évidence des contre-arguments particulièrement approuvés par rapport à l'affirmation qu'ils attaquent.

Question 13. Recopier et compléter les deux requêtes SQL suivantes, permettant de mettre à jour les informations de la base de données suite à cette action.

Il faut insérer la réaction dans la table réaction, puis augmenter le compteur nb_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;

Question 14. Expliquer pourquoi il est nécessaire de supprimer les réactions de l’utilisateur avant de supprimer l’utilisateur.

On ne peut pas supprimer d'abord l'utilisateur, car il resterait dans réaction des lignes faisant référence à un utilisateur qui n'existe plus : c’est la contrainte de clé étrangère.

Question 15. Écrire les trois requêtes qui permettent la suppression des données du compte de 'i<3rgpd' en suivant la procédure décrite ci-dessus.

1/ Anonymiser les affirmations

UPDATE affirmation
SET auteur = NULL
WHERE auteur = 'i<3rgpd';
2/ Supprimer les réactions
DELETE FROM reaction
WHERE utilisateur = 'i<3rgpd';
3/ Supprimer le compte utilisateur
DELETE FROM utilisateur
WHERE pseudo = 'i<3rgpd';

• Les algorithmes : structure, organisation, arbres...

• Bases de Données Open Source - SQL : 7 exercices corrigés