Bac NSI 2026 Polynésie jour 2

Elle identifie chaque ligne d’une relation de manière unique. Elle peut comporter plusieurs attributs : c’est alors la combinaison de leurs valeurs qui doit être unique, et ses composantes ne peuvent être NULL. Sans cette identité, deux mesures pourtant différentes pourraient être confondues.

StationId, DateDebut, DateFin et Polluant. Une station peut mesurer plusieurs polluants sur le même intervalle et un même polluant à des heures différentes. Ni la station ni la valeur mesurée ne suffisent seules à identifier une observation.

Une clé étrangère relie une ligne à une ligne référencée d’une autre relation, ou éventuellement de la même relation. La valeur doit correspondre à une clé existante dans la table cible, sauf NULL si le schéma l’autorise. Cette contrainte évite les références orphelines.

Station.AASQAId référence AASQA.Id. Autre exemple : Mesure.StationId référence Station.Id. Mentionner la colonne et sa cible rend la relation non ambiguë.

INSERT INTO Mesure
(StationId, DateDebut, DateFin, Polluant, TypeInfluence, Valeur)
VALUES ('FR33203', '2022-06-20 10:00:00', '2022-06-20 11:00:00',
        'PM10', 'Trafic', 34);

La table des stations donne l’identifiant FR33203. Les dates sont écrites au format ISO usuel pour DATETIME, même si le tableau pédagogique les affiche au format jour/mois/année. La mesure vaut 34 µg/m³ ; la valeur numérique ne nécessite pas de guillemets.

La clé composée explique pourquoi on peut conserver deux valeurs identiques de3,3 aux deux premières lignes de l’extrait : leurs heures diffèrent, donc ce sont deux observations distinctes. Inversement, réinsérer exactement la même station, le même intervalle et le même polluant violerait la clé primaire même si la valeur mesurée était différente. Une correction de mesure relèverait alors d’une mise à jour, pas d’un ajout concurrent.

La valeur FR41017 ne correspond pas à un identifiant de station présent dans la table Station au moment de l’insertion. La référence de Mesure.StationId serait orpheline ; le SGBD refuse donc l’écriture. Il faut vérifier l’identifiant ou créer préalablement la station avec une association AASQA valide. Le seul extrait des données ne suffirait pas à conclure à son absence ; c’est l’erreur d’intégrité explicitement fournie qui la révèle ici.

SELECT Nom, Siteweb
FROM AASQA;

Aucun filtre n’est demandé : toutes les associations sont concernées. La projection contient seulement les deux attributs utiles.

SELECT COUNT(*)
FROM Station;

COUNT(*) compte toutes les lignes de la table, pas seulement celles montrées dans l’extrait. On ne peut donc pas annoncer 5 comme total de la base : l’énoncé ne donne que quelques occurrences.

Elle renvoie le nom et le type d’implantation de toutes les stations gérées par ATMO AUVERGNE-RHONE-ALPES. La jointure associe une station à son AASQA, puis WHERE ne retient que l’association nommée. Dans l’extrait, cela donne Annecy Rocade / Urbaine et Pays du Mezenc / Rurale régionale.

SELECT m.DateDebut, m.DateFin, m.Valeur
FROM Mesure AS m
JOIN Station AS s ON m.StationId = s.Id
WHERE s.Nom = 'Mazagran' AND m.Polluant = 'PM10';

Le nom de station appartient à Station alors que le polluant et les valeurs appartiennent à Mesure. La jointure est donc nécessaire, sauf à connaître et utiliser l’identifiant exact, qui n’est pas fourni.

SELECT DISTINCT m.Polluant
FROM Mesure AS m
JOIN Station AS s ON m.StationId = s.Id
WHERE s.Nom = 'Mazagran';

Un polluant peut être mesuré de nombreuses fois. DISTINCT retire ses répétitions dans la projection afin d’obtenir la liste des polluants observés, pas une ligne par heure de mesure.

L’emplacement de DISTINCT est lié à la projection. SELECT DISTINCT Polluant donne un polluant par ligne ; SELECT DISTINCT Polluant,DateDebut conserverait plusieurs lignes du même polluant à des heures différentes. Le SGBD déduplique les lignes complètes du résultat, pas chaque colonne indépendamment.

SELECT s.Nom, m.Valeur, m.DateDebut, m.DateFin
FROM AASQA AS a
JOIN Station AS s ON s.AASQAId = a.Id
JOIN Mesure AS m ON m.StationId = s.Id
WHERE a.Nom = 'Air Pays de la Loire'
  AND m.Polluant = 'NO2';

Les deux jointures parcourent la chaîne association → station → mesure. Les stations sans mesure NO2 ne produisent aucune ligne avec cette jointure interne, ce qui correspond aux mesures demandées. Les alias évitent l’ambiguïté entre les différentes colonnes Nom.

Par exemple [0, 2, 1, 3]. Cette position n’apparaît pas parmi les douze sommets du cycle des positions accessibles. Elle échange seulement les tuiles 1 et 2 de la solution. La question peut se résoudre par comparaison exhaustive avec la figure, sans invoquer une formule de parité non donnée.

Un graphe non orienté : un sommet représente une configuration et une arête représente un glissement autorisé. Chaque coup est réversible, ce qui donne les deux sens. Des cycles existent ; une structure d’arbre ne représenterait pas directement tous ces retours.

assert len(pos) == 9

Cette vérification porte uniquement sur la longueur. Elle ne prouve pas à elle seule que tous les nombres de 0 à 8 sont présents exactement une fois.

def est_finale(pos):
    for i in range(len(pos)):
        if pos[i] != i:
            return False
    return True

Dans la grille finale, chaque case contient exactement son indice. Une seule différence suffit à conclure False. True est renvoyé seulement après toutes les vérifications ; le placer dans la boucle validerait à tort des listes dont seul le premier élément est correct. On suppose la longueur validée auparavant.

def case_vide(pos):
    res = -1
    for i in range(9):
        if pos[i] == 0:
            if res != -1:
                return -1
            res = i
    return res

res = -1 signifie qu’aucun zéro n’a encore été trouvé. Au premier zéro, on conserve son indice. Au second, on peut immédiatement refuser la position. Ne pas renvoyer l’indice dès le premier zéro : cela empêcherait de détecter un doublon plus loin.

Trois familles de tests sont nécessaires : un zéro unique, aucun zéro et deux zéros. Une fonction qui renvoie au premier zéro réussit le premier test mais échoue à détecter le troisième. Le stockage temporaire de l’indice permet précisément de continuer à vérifier l’unicité tout en conservant la réponse à renvoyer.

i - 1, i + 1, i - 3, i + 3. Les écarts de 1 correspondent aux colonnes adjacentes, ceux de 3 aux lignes adjacentes. Le sujet demande les candidats seulement ; en code réel, il faudrait rejeter les dépassements et les faux voisins entre la fin d’une ligne et le début de la suivante.

Chaque appel recrée sa propre liste vide visites. Le souvenir des positions déjà rencontrées n’est donc pas partagé : un coup peut revenir vers la position précédente puis recommencer indéfiniment. Il faut un ensemble ou une liste de positions visitées commun à tout le parcours, passé en paramètre, et y marquer la position courante avant d’explorer ses voisins. Il faut aussi renvoyer False lorsque toutes les branches échouent. Une version itérative avec pile ou file évite de surcroît la limite de récursion sur ce grand graphe.

Pour un état A ayant pour voisin B, B possède aussi A comme voisin, puisque le déplacement inverse est légal. Avec une nouvelle liste vide à chaque appel, l’appel sur B n’a aucun souvenir de A et repart immédiatement vers lui. Une collection partagée ne suffit pas si l’on oublie d’y placer le sommet courant avant d’explorer : le moment du marquage fait partie de la preuve de terminaison.

Boyer-Moore. Il compare le motif depuis la droite et utilise les informations d’une discordance pour justifier des décalages parfois supérieurs à un caractère. Son intérêt ne se réduit pas à décaler systématiquement de la longueur du motif, ce qui peut manquer une occurrence.

2. À i = 0, le a final correspond puis n diffère de b, donc échec. Le code décale de m = 2. À i = 2, les caractères texte[3] = a puis texte[2] = n correspondent : la fonction renvoie 2. L’autre occurrence à l’indice 4 n’est pas examinée.

Avec motif = "ab" et texte = "xaby", la réponse correcte est 1 mais la fonction renvoie -1. Elle teste i = 0 puis i = 2 et ne teste jamais l’alignement i = 1. Décaler de toute la longueur du motif après n’importe quel échec est donc injustifié. Remplacer le décalage par 1 rétablit une recherche correcte pour un motif non vide, mais perd les optimisations de Boyer-Moore. Le code nécessite aussi un traitement séparé du motif vide.

126 : il reste 32 - 25 = 7 bits machine, donc 2⁷ = 128 adresses, moins réseau et diffusion. La figure distingue à juste titre les 128 adresses du bloc de ses 126 adresses hôtes.

Le routeur privilégie la route la plus spécifique, c’est-à-dire le préfixe le plus long. Pour .100, la table autorise deux sorties ; on ne peut en choisir une seule à partir de ces informations.

R1 donne accès à Internet, donc correspond à la route par défaut. R2 dessert les hôtes .10, .20 et .30 du switch S2 (ainsi que la route hôte .40 de la table). R3 et R4 atteignent le réseau derrière S1 ; les noms out3/out4 permettent l’association représentée dans le schéma.

Ces deux liens s’ajoutent à l’architecture initiale ; la liaison de R5 vers 192.168.0.0/24 est conservée. Les adresses désignent deux interfaces différentes du même routeur.

Le chemin passe par machine → S2 → R2 → R5 → réseau 192.168.0.0/24. Il traverse deux routeurs, R2 et R5, donc son coût vaut 2 selon la convention explicitement donnée ici (nombre de routeurs traversés). La portion entre R2 et R5 contient un seul lien inter-routeurs. Les commutateurs ne se comptent pas comme routeurs.

Le débit doit être converti en bit/s. La constante de référence vaut ici 10⁹, pas 10⁸ comme dans d’autres sujets.

Le chemin favorise la fibre : machine → S2 → R2 → R0 → R4 → S1 → R5 → réseau destination. La partie variable de R2 à R5 utilise quatre liaisons fibre, donc coûte 0,4, contre 1 pour le lien Ethernet direct R2-R5. En additionnant toutes les liaisons physiques dessinées, machine-S2, S2-R2 et R5-réseau destination apportent trois liaisons Ethernet communes, soit un coût total 3,4 contre 4 pour le chemin direct. L’essentiel du choix est la comparaison 0,4 < 1 ; préciser les extrémités évite de confondre coût de transit inter-routeurs et coût physique de bout en bout. Dans un réseau OSPF réel, un segment Ethernet partagé est modélisé au niveau des interfaces de routage, pas comme un routeur supplémentaire S1 : on applique ici le modèle de liaisons du dessin.

racine
├─ 168 → 16 → 0
│              ├─ 100 : saut 10.0.0.3
│              ├─ 200 : saut 10.0.0.4
│              └─ 10  : saut 10.0.0.7
├─ 203 → 18
│        ├─ 17 → 10 : saut 10.0.0.5
│        └─ 15
│           ├─ 30 : saut 10.0.0.8
│           ├─ 20 : saut 10.0.0.9
│           └─ 10 : saut 10.0.0.10
└─ 0 → 0 → 0 → 0 : saut 10.0.0.6

On partage les préfixes d’octets identiques. Les adresses commencent bien par 168 dans cette partie, et non par 172 comme dans la partie A. Le prochain saut est stocké au nœud terminal ; ce n’est pas une étiquette de branche.

Dans cet arbre, une branche 168-16-0 est partagée par les trois destinations terminées par100,200 et10. Les caractères "1" et "0" ne sont pas des niveaux distincts : l’étiquette "100" est un seul octet stocké comme chaîne. Cela distingue un arbre de préfixes par octets d’un arbre binaire par bits et explique pourquoi les adresses IPv4 complètes utilisent quatre niveaux.

return None
# Après le if :
return self.dict_adjacence[octet]

Si la clé octet est absente, on renvoie None. Sinon on lit le nœud associé à cette clé. Le test évite une exception KeyError sur un enfant inexistant.

noeud = self.racine
for octet in ip_dest.split("."):
    noeud = noeud.rechercher_enfant(octet)
    if noeud is None:
        return None
if noeud.saut == "":
    return None
return noeud

On descend d’un niveau pour chaque octet. Dès qu’une branche manque, l’adresse est absente. Le contrôle final de saut évite de considérer un simple préfixe non terminal comme une destination. Dans le cadre des IPv4 complètes de quatre octets fournies, tous les terminaux insérés sont bien marqués.

Rechercher 203.18.15.20 visite successivement les enfants "203", "18", "15", "20", puis renvoie le nœud dont saut vaut10.0.0.9. Rechercher 203.18.15.99 partage trois niveaux puis échoue sur "99". Les clés de dict_adjacence sont des chaînes issues de split ; utiliser l’entier203 comme clé ne retrouverait pas la branche "203".

Son intention est d’insérer une destination et son prochain saut : parcourir les octets, créer les branches manquantes, puis affecter saut au terminal. Mais la condition imprimée est inversée : if noeud_suivant is not None remplace les branches existantes et laisse None quand une branche manque, ce qui provoque une erreur. Il faut la corriger en if noeud_suivant is None:. Avec cette correction, les préfixes existants sont conservés ; réinsérer une même destination met à jour son prochain saut.

Effectuer un parcours en profondeur en mémorisant la liste des octets du chemin. Lorsqu’un nœud a un saut non vide, reconstituer la destination avec ".".join(prefixe), puis l’ajouter au dictionnaire inverse sous la clé saut. Continuer récursivement pour chaque enfant en ajoutant son octet au chemin. Comme plusieurs destinations peuvent partager un même prochain saut, utiliser une liste de destinations par saut afin de ne rien perdre ; dans la table du sujet, les huit sauts sont distincts.

def inverser(arbre):
    inverse = {}
    def visiter(noeud, prefixe):
        if noeud.saut != "":
            destination = ".".join(prefixe)
            if noeud.saut not in inverse:
                inverse[noeud.saut] = []
            inverse[noeud.saut].append(destination)
        for octet, enfant in noeud.dict_adjacence.items():
            visiter(enfant, prefixe + [octet])
    visiter(arbre.racine, [])
    return inverse

L’algorithme visite chaque nœud une fois. Il ne suffit pas d’échanger aveuglément une clé et une valeur dans un dictionnaire si les valeurs peuvent se répéter.

Pour la table fournie, l’entrée inverse 10.0.0.9 contient la destination203.18.15.20. Si un second réseau utilisait le même prochain saut, sa destination serait ajoutée à cette liste plutôt que d’écraser la première. Le préfixe transmis à chaque appel est construit avec prefixe+[octet], une nouvelle liste : les branches sœurs n’altèrent donc pas réciproquement leurs chemins.