Bac NSI 2026 Métropole jour 2

172.16.0.0. Le /16 fixe les deux premiers octets ; les seize bits restants deviennent 0 pour l’adresse réseau. Il ne faut pas conserver le 2 du troisième octet : il appartient ici à la partie machine.

172.16.255.255. Les deux octets de la partie machine sont remplis de bits à 1, soit 255 pour chacun.

2¹⁶ - 2 = 65 534 adresses hôtes utilisables. On enlève le réseau et la diffusion. Le nombre demandé est une capacité totale, pas une capacité restante après décompte des machines dessinées.

Pour chaque destination, la colonne « Passe par » contient le premier routeur après R1, pas la route entière. Les voisins directs ont un coût de 1.

PC A01 → switch A → R1 → R3 → R2 → switch B → PC B01. La portion de routage utilise deux sauts : R1-R3 et R3-R2. Les commutateurs locaux ne s’ajoutent pas à la métrique RIP définie ici.

R1 → R4 → R5 → R2, soit trois sauts. Une panne de routeur supprime toutes ses liaisons, et pas seulement une arête.

On applique exactement la formule donnée, y compris le coût fractionnaire de la fibre. Aucune règle d’arrondi d’un équipement réel n’est à ajouter au modèle du sujet.

R1 → R3 → R4 coûte 0,1 + 1 = 1,1, contre 10 pour la liaison directe R1-R4. Le détour par R3-R2-R5-R4 coûterait 0,1 + 10 + 1 + 1 = 12,1. Le protocole choisit donc deux liens rapides plutôt qu’un seul lien lent.

MAX_ROUTES reçoit 5, mais cette constante n’intervient jamais dans la fonction. Chaque appel à append ajoute une route, y compris la sixième et les suivantes. Donner un nom à une limite n’impose pas automatiquement la contrainte : il faut la tester avant la modification.

class Routage:
    def __init__(self, capacite=5):
        self.capacite = capacite
        self.routes = []

    def ajouter(self, route):
        if len(self.routes) < self.capacite:
            self.routes.append(route)
        else:
            print("Capacité maximale atteinte")

La capacité fournie au constructeur est conservée dans l’instance. L’inégalité doit être stricte : si la liste contient déjà cinq routes pour une capacité de cinq, aucun nouvel ajout ne doit avoir lieu. Chaque instance possède sa propre liste.

On peut vérifier la borne avec une instance de capacité1 : le premier ajout laisse une route dans la liste ; le second doit conserver cette même longueur et produire le message de refus. Avec deux instances, un ajout dans l’une ne doit pas modifier les routes de l’autre. Ces tests contrôlent la contrainte et l’indépendance de l’état, pas seulement l’affichage.

def afficher(self):
    for route in self.routes:
        for routeur in route:
            print(routeur)
        print("---")

La boucle externe choisit une route ; la boucle interne affiche ses routeurs. Le séparateur est dans la boucle externe mais en dehors de la boucle interne, donc il apparaît une seule fois par route.

10 : l’indice 2 désigne la troisième ligne [2, 10, 9, 4] et l’indice 1 son deuxième élément. Les indices Python commencent à zéro.

valeurs = [k for k in range(1, 17)]

La borne de départ 1 est incluse, la borne de fin 17 est exclue. La version initiale produisait 0 à 15 : elle contenait seize valeurs, mais pas les bonnes valeurs.

shuffle(valeurs)

shuffle modifie la liste en place et renvoie None. Il faut appeler la fonction sans affecter son résultat à valeurs. La liste mélangée reste accessible par la variable initiale.

assert len(valeurs) == n * n

Une grille n × n requiert exactement n² cases. Ce test ne vérifie pas à lui seul que les valeurs sont distinctes ou qu’elles vont de 1 à n² : la question porte seulement sur la taille.

grille[i][j] = valeurs[i * n + j]

Avant la ligne i, il y a i lignes complètes de n éléments. On ajoute le décalage j dans cette ligne. L’ancienne expression inversait le rôle de la ligne et de la colonne, et produisait une transposition.

La ligne suivante commence immédiatement après les n valeurs de la précédente. Pour vérifier la formule sur une taille quelconque, la dernière case (n-1,n-1) doit lire (n-1)×n+(n-1)=n²-1, dernier indice valide.

Non. Dans la liste aplatie, les seules inversions sont (16, 15), (16, 14) et (15, 14), soit 3. La case vide 16 est à la ligne d’indice 3 et colonne d’indice 1 : sa distance au coin (3, 3) vaut 2. La somme 3 + 2 = 5 est impaire. On compte bien ici les inversions impliquant 16, puisque c’est la convention de l’énoncé.

assert compte_inversions([2, 3, 1, 4]) == 2

Les inversions sont (indice 0, indice 2), car 2 > 1, et (indice 1, indice 2), car 3 > 1. Aucun autre couple i < j ne convient. Utiliser les valeurs 1 à 4 permet en plus de rester dans le cadre d’un taquin 2 × 2.

def compte_inversions(valeurs):
    total = 0
    for i in range(len(valeurs)):
        for j in range(i + 1, len(valeurs)):
            if valeurs[i] > valeurs[j]:
                total += 1
    return total

La seconde boucle impose désormais j > i. L’ancienne version comparait toutes les paires dans les deux sens ; pour quatre valeurs distinctes, elle comptait toujours six comparaisons vraies, même sur une liste triée. La complexité de la version corrigée reste quadratique.

Sur [2,3,1,4], i=0 compare2 aux valeurs placées après lui et trouve2>1 ; i=1 trouve3>1 ; les autres comparaisons n’ajoutent rien. Chaque paire d’indices est visitée une seule fois avec i

if grille[i][j] == num_tuile_vide:
    return (n - 1 - i) + (n - 1 - j)

Le coin inférieur droit possède les indices (n - 1, n - 1). Tous les indices de la grille sont inférieurs ou égaux à ces deux coordonnées, donc les écarts sont déjà positifs. On cherche n², numéro conventionnel du vide, et non 0.

def est_resoluble(valeurs, n):
    grille = en_grille(valeurs, n)
    inv = compte_inversions(valeurs)
    dis = distance_tuile_vide(grille, n)
    return (inv + dis) % 2 == 0

Le modulo 2 teste la parité de la somme. Les fonctions reçoivent la bonne représentation : la liste aplatie pour les inversions, la grille pour la distance. La formule admise concerne le taquin 4 × 4 de cette partie, et convient plus généralement aux dimensions paires avec le vide inclus ; il ne faut pas la présenter comme un critère général valide pour toute dimension impaire.

Une grille peut sembler presque rangée et être pourtant irrésoluble : la propriété de parité porte sur la permutation entière, pas sur une distance visuelle intuitive à la solution. Le test ne fournit pas les mouvements à jouer ; il décide seulement de l’existence d’une solution dans le modèle étudié. Calculer effectivement un chemin est une autre tâche, que l’on peut aborder comme une recherche dans le graphe des configurations.

[5, 8, 10, 13]

L’indice 9 est à la ligne 2, colonne 1. Ses voisins haut, gauche, droite et bas portent les indices 5, 8, 10, 13. L’ordre de la liste ne compte pas. Un décalage de 1 n’est valide horizontalement que si l’on reste sur la même ligne.

for k in range(nb_dep):
    prochaine = choice(graphe[actuelle])
    valeurs[actuelle] = valeurs[prochaine]
    valeurs[prochaine] = num_tuile_vide

La tuile voisine remplit l’ancien vide ; son ancienne case devient vide, puis actuelle = prochaine actualise la position. Chaque mouvement est réversible : refaire tous les mouvements en sens inverse ramène à la grille rangée.

Coquille à corriger en plus dans le programme fourni : la ligne 4 produit 0 à n² - 1 alors que la convention est 1 à n². Il faut écrire valeurs = [i for i in range(1, n*n + 1)]. Compléter uniquement les quatre lignes demandées sans rectifier cette initialisation ne donne pas un taquin valide.

Le programme construit volontairement une marche dans le graphe des positions du vide. Même si les choix sont aléatoires, inverser la suite des échanges est toujours un chemin légal vers la solution, car un glissement est réversible. Cela garantit la résolubilité mais pas que la grille soit très mélangée : des mouvements peuvent s’annuler ou ramener tôt à la solution. La fonction doit conserver exactement une occurrence de chaque nombre de1 à n².

Deux salariés peuvent avoir le même nom et le même prénom. Leur combinaison ne garantit donc pas l’unicité d’une ligne. Un identifiant propre à chaque utilisateur reste distinct même en cas d’homonymie ou de changement de nom.

inscription.trajet et inscription.passager sont des clés étrangères vers des identifiants entiers. Ils doivent appartenir aux mêmes domaines de valeurs que les attributs référencés afin de représenter ces références et de permettre leur contrôle.

SELECT COUNT(*)
FROM inscription
WHERE trajet = 1291;

Le résultat est 3 pour l’extrait fourni. On compte les inscriptions et non les places proposées : nb_places décrit la capacité, qui n’est pas toujours égale au nombre de passagers inscrits.

SELECT *
FROM trajet
WHERE arrivee = 'Nancy'
  AND heure >= '2026-06-19 00:00:00'
  AND heure < '2026-06-20 00:00:00'
ORDER BY heure ASC;

La borne basse inclusive contient tout le 19 juin, y compris un éventuel départ à minuit. La borne haute exclusive exclut le 20 juin. Avec les données fournies : 1292 à 07:45, puis 1293 à 08:00. Le champ heure décrit l’heure de départ ; aucune heure d’arrivée n’est fournie.

INSERT INTO trajet
(id_trajet, depart, arrivee, heure, nb_places, conducteur)
VALUES (1295, 'Nancy', 'Allain', '2026-06-19 17:45:00', 3, 25);

Les valeurs suivent l’ordre des colonnes explicitement citées. Le conducteur 25 doit exister dans utilisateur. Il ne faut pas ajouter ici les inscriptions des passagers : elles sont dans une autre table.

UPDATE trajet
SET heure = '2026-06-19 18:40:00'
WHERE id_trajet = 1294;

On conserve la date du 19 juin et on cible le trajet par sa clé primaire. Sans WHERE, tous les trajets auraient été modifiés.

La ligne (1296, 18) d’inscription référence le trajet 1296. La suppression de ce trajet laisserait cette clé étrangère sans cible. Le SGBD refuse donc l’opération pour préserver l’intégrité référentielle. Il faut supprimer les inscriptions correspondantes avant le trajet, sauf si une règle de cascade a été prévue. Ce n’est ni une erreur de syntaxe de DELETE ni une confusion avec le conducteur.

SELECT DISTINCT u.nom, u.prenom
FROM utilisateur AS u
JOIN inscription AS i ON i.passager = u.id_utilisateur
JOIN trajet AS t ON t.id_trajet = i.trajet
WHERE t.conducteur = 25;

On part des passagers, rejoint leurs inscriptions puis les trajets concernés. DISTINCT élimine les doublons de projection, car un passager peut voyager plusieurs fois avec la conductrice. Dans l’extrait, on retrouve Yasmine Mizab, Maxime Rey et Clément Fabre. La requête ne limite pas les trajets à une journée, car la question dit « au moins une fois » sans restriction de date.

La jointure sur inscription.passager choisit bien les passagers : relier utilisateur directement à trajet.conducteur retournerait la conductrice au lieu des personnes transportées. La deuxième jointure associe chaque inscription à son trajet. Le filtre conducteur=25 garde alors les voyages pertinents, même si le passager y figure plusieurs fois.

graphe = {
    "C": [
        "P1",
        "P2"
    ],
    "P1": [
        "C",
        "A"
    ],
    "A": [
        "P1",
        "P2",
        "P3"
    ],
    "P2": [
        "C",
        "A",
        "M"
    ],
    "P3": [
        "A",
        "M"
    ],
    "M": [
        "P2",
        "P3",
        "V"
    ],
    "V": [
        "M"
    ]
}

Le graphe n’est pas orienté : chaque arête doit être présente dans les deux listes correspondantes. Les positions sur le dessin ne créent pas de liaison implicite. Par exemple V ne possède que M pour voisin ; P2 et P3 ne sont pas directement reliés.

Une file suit la règle premier entré, premier sorti, ou FIFO. Une insertion se fait à une extrémité et une extraction à l’autre. Ainsi, un sommet découvert avant un autre est exploré avant lui. Une pile suivrait au contraire la règle dernier entré, premier sorti.

Avec l’ordre des voisins du dictionnaire proposé : P1, C, A, P2, P3, M, V. P1 découvre C et A ; C découvre P2 ; A découvre P3 (P2 est déjà marqué) ; P2 découvre M ; M découvre V. Chaque sommet est inscrit dans dico dès son insertion, ce qui évite de l’insérer plusieurs fois. D’autres ordres sont possibles si l’ordre des voisins change.

Un parcours en largeur. La file fait explorer les sommets par distance croissante ; chaque voisin inédit reçoit la distance de son prédécesseur plus un. Sur ce graphe non pondéré, c’est sa distance minimale au départ.

def excentricite(graphe, sommet):
    dico = dico_distance(graphe, sommet)
    plus_grande = 0
    for s in dico:
        if dico[s] > plus_grande:
            plus_grande = dico[s]
    return plus_grande

L’excentricité est la plus grande distance du sommet aux autres sommets. Le dictionnaire contient des distances non négatives ; initialiser à zéro convient, y compris pour un graphe réduit à un sommet. Le graphe du sujet est connexe. Sur un graphe non connexe, ce programme donnerait seulement le maximum dans la composante atteignable, ce qu’il faudrait distinguer d’une excentricité globale infinie ou non définie selon la convention.

L’invariant de la boucle est : plus_grande est la plus grande distance parmi les entrées déjà traitées. Initialiser à0 est correct puisque les distances ne sont jamais négatives et que le sommet de départ se trouve dans dico à distance0. En fin de parcours, toutes les distances atteignables ont été comparées. Il ne faut pas comparer les noms des sommets s entre eux : ce sont les valeurs dico[s] qui mesurent l’éloignement.

P2 minimise le plus grand trajet : personne ne parcourt plus de deux arêtes. Ses distances à P1 et P3 valent aussi 2, donc son excentricité globale est 2, contre 4 pour P1 et 3 pour P3. P2 minimise également la somme des distances des quatre domiciles (5), mais ce second indicateur est distinct : il est ici cohérent avec la minimisation du trajet le plus défavorisé.