Bac NSI 2025 Métropole jour 1

Le numéro n’est unique qu’à l’intérieur d’une marque. Dans l’extrait, 81757532 apparaît pour la Gibson d’identifiant 4 et la Fender d’identifiant 8. Une clé primaire doit identifier une ligne de manière unique dans toute la relation, pas seulement dans un sous-ensemble.

On sélectionne les lignes d’année 1956, puis on conserve uniquement les deux colonnes demandées. Aucun ordre de lignes n’est garanti en l’absence de ORDER BY.

SELECT annee
FROM inventaire
WHERE modele = 'Les Paul Standard';

La projection porte sur l’année et le filtre sur le modèle. Si l’on veut éliminer les années répétées dans un inventaire plus grand, on peut ajouter DISTINCT ; l’extrait renvoie ici 1959 et 1987.

SELECT modele
FROM inventaire
WHERE marque = 'Gibson'
ORDER BY annee ASC;

On trie les guitares par année, puis on affiche leur modèle. Un même modèle peut apparaître plusieurs fois, puisqu’il existe plusieurs guitares de ce modèle. Ajouter DISTINCT sans préciser quelle année représenterait un modèle rendrait le sens du tri ambigu.

UPDATE inventaire
SET annee = 1957
WHERE id = 1;

Le filtre par clé primaire isole la guitare voulue. Sans WHERE, toutes les guitares recevraient l’année 1957.

marque, puis modele, puis guitare. modele.id_marque référence la clé de marque, et guitare.id_modele celle de modele. Créer les tables référencées d’abord permet de déclarer ensuite les contraintes sans dépendance manquante. Le même ordre est nécessaire pour insérer des données respectant immédiatement ces références.

SELECT guitare.num_ser, guitare.annee
FROM guitare JOIN modele ON guitare.id_modele = modele.id
WHERE modele.nom = 'Les Paul Standard';

Le nom du modèle et les caractéristiques d’une guitare sont dans deux tables différentes. La jointure les rapproche grâce à la référence, sans supposer que le modèle gardera toujours l’identifiant 2.

DELETE FROM guitare WHERE id = 3;

On retire uniquement l’instrument. Son modèle et sa marque peuvent encore décrire d’autres guitares et doivent rester présents.

INSERT INTO marque (id, nom) VALUES (3, 'BC Rich');
INSERT INTO modele (id, nom, id_marque) VALUES (5, 'Mockingbird', 3);
INSERT INTO guitare (id, id_modele, annee, num_ser, prix)
VALUES (9, 5, 1992, '92R', 5000);

On ajoute la marque avant son modèle, puis le modèle avant la guitare. 92R est une chaîne, alors que les identifiants, l’année et le prix sont numériques.

SELECT SUM(guitare.prix)
FROM guitare JOIN modele ON guitare.id_modele = modele.id
WHERE modele.nom = 'Stratocaster';

SUM additionne les prix après jointure et filtrage. Dans l’extrait, on obtient 200000 + 15000 = 215000 euros. COUNT compterait seulement les deux instruments.

tache1 = Tache(1, 'Répondre aux e-mails', 45)
tache2 = Tache(2, 'Ranger ma chambre', 60)

Le constructeur initialise lui-même la durée restante. On ne passe pas self explicitement : Python fournit l’objet en construction.

def avancer(self, n):
    self.duree_restante = self.duree_restante - n

On modifie la durée restante, jamais la durée initiale. Le sujet autorise une valeur négative : elle signifie que le bloc de temps a dépassé le travail nécessaire.

def est_terminee(self):
    return self.duree_restante <= 0

Tester seulement l’égalité à zéro serait faux : une tâche de 20 minutes avancée de 25 minutes a une durée restante de -5 et est terminée.

Après t6 : [début] (t3,4) (t1,3) (t2,3) (t6,2) (t4,1) (t5,1) [fin]
Après t7 : [début] (t3,4) (t7,4) (t1,3) (t2,3) (t6,2) (t4,1) (t5,1) [fin]

La tâche 6 s’insère entre les priorités 3 et 1. La tâche 7 a la priorité maximale, mais se place après t3, déjà présente avec la même priorité : l’ordre d’arrivée départage les égalités.

tache3

[début] (t1,3) (t2,3) (t4,1) (t5,1) [fin]

defiler retire et renvoie le premier tuple ; l’indice 0 en extrait l’objet tâche, représenté par <t3>. On ne renvoie pas la priorité 4.

La valeur est 4. examiner() ne retire rien et l’indice 1 désigne la priorité.

[début] (t3,4) (t1,3) (t2,3) (t4,1) (t5,1) [fin]

def ajouter_file_prio(f, t, p):
    f_aux = File()
    while not f.est_vide() and f.examiner()[1] >= p:
        f_aux.enfiler(f.defiler())
    f_aux.enfiler((t, p))
    while not f.est_vide():
        f_aux.enfiler(f.defiler())
    while not f_aux.est_vide():
        f.enfiler(f_aux.defiler())

La première boucle déplace les tâches de priorité supérieure ou égale avant la nouvelle. Le >= préserve donc l’ordre d’arrivée. Le test de vacuité passe avant examiner pour ne jamais consulter une file vide. On transfère ensuite le reste de f, puis on remet tous les éléments dans l’objet f d’origine.

Le coût est linéaire, O(m), en supposant les opérations primitives de file de coût constant. Les m anciens éléments sont tous transférés vers la file auxiliaire, puis les m + 1 éléments sont remis dans f. Les deux premières boucles se partagent les m éléments ; leurs coûts s’additionnent au lieu de se multiplier.

Avec une implémentation naïve de defiler qui décale une liste entière, ce coût pourrait augmenter. La réponse porte sur l’interface abstraite de file du sujet.

Les priorités 4 passent avant toutes les autres : t3, puis t7, puis les trois blocs restants de t3. Aux priorités 3 et 1, les tâches alternent tant qu’elles restent toutes deux inachevées. Une tâche terminée au milieu d’un bloc ne permet pas de démarrer la suivante plus tôt : Alice se repose jusqu’à sa fin.

On obtient 17 blocs, soit 425 minutes planifiées pour 335 minutes de travail estimé ; les 90 minutes restantes sont les fins de blocs inutilisées.

def planning(f):
    resultat = []
    while not f.est_vide():
        tache, priorite = f.defiler()
        resultat.append(tache)
        tache.avancer(25)
        if not tache.est_terminee():
            ajouter_file_prio(f, tache, priorite)
    return resultat

Chaque entrée du résultat correspond à un bloc, donc une même tâche peut apparaître plusieurs fois. La fonction consomme la file et modifie les durées restantes des objets : pour refaire une simulation, il faut recréer des tâches fraîches.

Les choix a et b sont valides : ils appartiennent au réseau 192.168.20.0/24, sont disponibles et ne sont ni le réseau ni le broadcast. L’octet 261 de c dépasse 255. L’adresse d appartient au réseau 192.168.24.0/24, différent de celui du café.

192.168.20.255. Avec le masque /24, les huit bits de la partie machine sont tous mis à 1 : 11111111 vaut 255.

Le /24 contient 256 adresses, dont 2 réservées (réseau et diffusion), soit 254 adresses d’hôtes. Trois bornes et l’interface du routeur en occupent 4. Il reste donc 254 - 4 = 250 adresses pour de nouvelles machines. Le switch n’en consomme aucune selon l’énoncé.

Il faut conserver au moins 3 bits pour la partie hôte, car 2³ = 8. La longueur maximale est donc 32 - 3 = 29 bits, soit /29 et le masque 255.255.255.248. Un /30 ne fournirait que 4 adresses.

Il s’agit d’un dimensionnement. Pour l’appliquer réellement, il faudrait aussi choisir un bloc /29 et renuméroter les machines si nécessaire : les anciennes adresses .1, .10 et .11 ne sont pas toutes dans le même bloc /29.

Le café 2 est directement relié à R3 : depuis R2, on envoie sur l’interface du lien R2-R3, vers l’adresse de R3 sur ce lien. Le réseau 172.16.1.0 est relié à R1, donc on l’atteint en un saut R2-R1. Les interfaces de sortie sont des adresses de R2, les prochains routeurs des adresses du voisin.

Le siège, raccordé à R4, est à deux sauts de R2 par R1 comme par R3 : R2-R1-R4 et R2-R3-R4. RIP ne départage pas ces chemins par leur débit. La ligne initiale passait par R1 ; celle proposée passe par R3.

Internet est relié à R1. R2 transmet donc à son voisin R1 par le réseau 172.16.3.0. Il n’utilise pas directement 203.0.113.1 comme prochain saut : cette interface de R1 n’appartient pas à leur lien commun.

Le calcul est 10⁹ / débit. Un débit dix fois plus élevé donne un coût dix fois plus faible. On additionne ces coûts sur un trajet.

Le meilleur chemin est R1-R2-R3-R4, de coût 21. Il comporte davantage de sauts que la liaison directe, mais utilise des connexions plus rapides. Avec des coûts strictement positifs, ajouter un cycle ne peut pas améliorer un chemin.

'11000000.10101000.00010100.00001100'

192 = 128 + 64 ; 168 = 128 + 32 + 8 ; 20 = 16 + 4 ; 12 = 8 + 4. Chaque octet occupe huit bits : les zéros en tête sont conservés. On obtient 32 bits et 3 points, soit 35 caractères.

Quand les deux chaînes sont identiques. Aucune comparaison n’a rencontré un caractère différent, donc la boucle a examiné les 35 positions sans retourner. Deux adresses égales ne se précèdent pas strictement.

def precede(ip_1, ip_2):
    for i in range(35):
        if ip_1[i] < ip_2[i]:
            return True
        elif ip_1[i] > ip_2[i]:
            return False
    return False

Un premier caractère plus petit impose True, un plus grand impose False, et l’égalité complète donne False. Les points sont aux mêmes positions dans les deux chaînes : ils ne créent aucune différence parasite.

adresse_ip est un attribut qui contient une donnée de l’objet. est_vide est une méthode, c’est-à-dire une fonction associée à la classe. interface, passerelle ou cout conviennent aussi comme attributs.

def est_vide(self):
    return self.adresse_ip == ''

Le test suit la représentation choisie. Un ABR vide n’est pas None, et ne possède pas nécessairement d’attributs gauche et droite.

À chaque comparaison, on choisit un seul sous-arbre : on ne parcourt pas toutes les destinations. La recherche coûte O(h), où h est la hauteur. Si l’arbre est équilibré, cela donne O(log n) pour n entrées, contre O(n) pour une recherche séquentielle.

Un arbre très déséquilibré peut avoir une hauteur linéaire : le gain n’est donc pas automatique. Le modèle du sujet effectue une recherche exacte sur des destinations ; le routage réel peut aussi demander une recherche de préfixe le plus long, qui est une opération différente.

def modifie(self, adresse_ip, interface, passerelle, cout):
    if self.est_vide():
        self.gauche = Abr('', '', '', 0)
        self.droite = Abr('', '', '', 0)
    self.adresse_ip = adresse_ip
    self.interface = interface
    self.passerelle = passerelle
    self.cout = cout

On crée les deux sous-arbres uniquement si le nœud était vide, puis on effectue les quatre affectations communes. Tester la vacuité avant de remplacer l’adresse est essentiel : une fois l’adresse mise à jour, le nœud ne paraît plus vide et on risquerait d’oublier ses enfants.

elif precede(ip_bin(adresse_ip), ip_bin(self.adresse_ip)):

On descend à gauche si l’adresse recherchée précède l’adresse du nœud courant. Les deux chaînes décimales doivent être converties avant la comparaison. Inverser les arguments ferait choisir la mauvaise branche.

Le premier test de rechercher renvoie soit le nœud trouvé, soit le premier arbre vide à la bonne position. Ainsi inserer met à jour une entrée existante ou remplit cet emplacement sans casser l’ordre de l’ABR.