Corrigé NSI Antilles 2026 – Jour 2

1. Clés étrangères de la relation reservation

La relation reservation contient deux attributs qui renvoient vers d’autres tables :

• id_client référence la clé primaire client(id_client) ;
• id_salle référence la clé primaire salle(id_salle).

2. Résultat de la requête SELECT

La requête garde les salles dont le nombre de places est strictement supérieur à 5, puis trie les résultats par tarif croissant. Les salles concernées sont RB, RA et Ravel.

3. Liste sans doublon des salles réservées depuis janvier 2024

SELECT DISTINCT id_salle
FROM reservation
WHERE date > '2024-01-01';

Le mot-clé DISTINCT est indispensable : une même salle peut apparaître plusieurs fois dans la table des réservations.

4. Ajout du client EN et de sa réservation

INSERT INTO client (id_client, societe, num_tel)
VALUES (3, 'EN', '0144624055');

INSERT INTO reservation (id, id_client, id_salle, date, duree)
VALUES (5, 3, 4, '2024-06-12', 1);

On ajoute d’abord le client, car la réservation contient une clé étrangère id_client. Ensuite seulement, on ajoute la réservation liée à ce client.

5. Mise à jour de la capacité de la salle Ravel

UPDATE salle
SET nb_places = 95
WHERE id_salle = 2;

Utiliser l’identifiant de la salle est plus robuste que se fonder sur la casse du nom Ravel ou RAVEL.

6. Temps total de réservation de la salle 6

SELECT SUM(duree) AS temps_total
FROM reservation
WHERE id_salle = 6;

La fonction d’agrégation SUM additionne toutes les durées des réservations de la salle d’identifiant 6.

7. Sociétés ayant réservé une salle de réunion

SELECT DISTINCT client.societe
FROM client
JOIN reservation ON client.id_client = reservation.id_client
JOIN salle ON reservation.id_salle = salle.id_salle
WHERE salle.type = 'Réunion';

Deux jointures sont nécessaires : la table reservation relie les clients aux salles, puis la table salle permet de filtrer le type ‘Réunion’.

8. Exemple d’attribut et de méthode

Un attribut possible est self.intitule, self.nb_places, self.dispo ou self.occupant. Une méthode possible est reserver.

9. Méthode liberer

def liberer(self):
    self.dispo = True
    self.occupant = ""

La salle redevient disponible et l’occupant est remis à la chaîne vide, conformément à l’énoncé.

10. Fonction salles_dispos

def salles_dispos(liste_salles):
    res = []
    for salle in liste_salles:
        if salle.dispo:
            res.append(salle.intitule)
    return res

Dans le code fourni, S1 et S2 ont déjà été réservées. La fonction renverrait donc les intitulés des salles encore disponibles : [‘RA’, ‘B2’, ‘RB’].

11. Méthode ajouter_reservation

def ajouter_reservation(self, salle):
    if salle.dispo:
        self.liste_salles.append(salle)
        self.prix_total = self.prix_total + salle.reserver(self.client)
        return True
    return False

La méthode vérifie d’abord la disponibilité. Ensuite, elle ajoute la salle dans la liste du séminaire et augmente le prix total avec le tarif renvoyé par salle.reserver(self.client). Si la salle est déjà prise, rien ne change et la méthode renvoie False.

1. Pourquoi R2 ne peut pas avoir l’adresse 192.168.2.3 sur le lien avec R1

Le lien entre R1 et R2 appartient au sous-réseau 192.168.1.0/24. Avec un suffixe /24, les trois premiers octets identifient le réseau. Une adresse de ce sous-réseau doit donc commencer par 192.168.1.

2. Table de routage possible de R4 avec RIP

RIP minimise le nombre de routeurs à traverser. En cas d’égalité, plusieurs passerelles peuvent être acceptées. Voici une table cohérente.

3. Débit entre R1 et R2

Le coût est inversement proportionnel au débit. Le lien R3-R4 a un coût de 1 et un débit de 10 Gbit/s. Le lien R1-R2 a un coût de 20.

Donc son débit vaut : 10 / 20 = 0,5 Gbit/s.

4. Chemin de R1 vers R5 avec RIP

RIP minimise le nombre de routeurs traversés. Le plus court chemin en nombre de liaisons est :

Ce chemin traverse moins de routeurs que le chemin R1 → R2 → R3 → R4 → R5.

5. Chemin avec RIP si la liaison R2-R6 tombe en panne

Si la liaison R2-R6 n’existe plus, le chemin précédent est impossible. Le meilleur chemin RIP restant est :

6. Chemin avec OSPF et comparaison avec RIP

OSPF minimise la somme des coûts. Comparons les deux chemins principaux :

• R1 → R2 → R6 → R5 : coût 20 + 100 + 200 = 320 ;
• R1 → R2 → R3 → R4 → R5 : coût 20 + 50 + 1 + 20 = 91.

7. Graphe du réseau mis à jour

Deux routeurs sont reliés lorsqu’ils possèdent une adresse dans le même sous-réseau /24. Une représentation possible du graphe mis à jour est donc donnée par les arêtes suivantes :

8. Itinéraires GPS, RIP et OSPF

L’itinéraire A minimise le temps de parcours : il correspond à OSPF, car OSPF minimise une somme de coûts. L’itinéraire B minimise le nombre de villes traversées : il correspond à RIP, car RIP minimise le nombre de sauts.

9. Parcours en largeur depuis V3

En suivant l’ordre des listes d’adjacence donné dans le dictionnaire, le parcours en largeur depuis ‘V3’ visite les sommets couche par couche.

10. Évolution de la variable precedent

En suivant exactement le programme, l’évolution complète à la fin de chaque passage utile dans la boucle est :

Attention : le programme ne teste pas si un voisin est déjà présent dans precedent. La valeur associée à ‘V4’ peut donc être remplacée par ‘V6’.

11. Valeur renvoyée par itineraire_court(route, ‘V1’, ‘V5’)

On reconstruit le chemin à rebours : V5 vient de V6, V6 vient de V2, V2 vient de V1. Après inversion, on obtient :

1. Initialiser le dictionnaire effectif

effectif = {1: 3, 2: 4, 4: 1}

La clé est la longueur de la planche, et la valeur est l’effectif correspondant.

2. Valeur totale des planches de 10 m

Comme l’énoncé précise qu’il existe au moins une planche de 10 m, on peut utiliser directement la clé 10.

3. Tester la présence de planches de 5 m

Dans un dictionnaire Python, l’opérateur in teste la présence d’une clé.

4. Fonction valeur_stock

def valeur_stock(effectif):
    valeur_totale = 0
    for longueur in effectif:
        valeur_totale = valeur_totale + effectif[longueur] * prix[longueur]
    return valeur_totale

On parcourt les longueurs présentes dans le dictionnaire. Pour chaque longueur, on multiplie l’effectif par le prix unitaire de cette longueur.

5. Fonction mise_a_jour

def mise_a_jour(effectif, autre_effectif):
    for longueur in autre_effectif:
        if longueur in effectif:
            effectif[longueur] = effectif[longueur] + autre_effectif[longueur]
        else:
            effectif[longueur] = autre_effectif[longueur]

La fonction modifie directement le dictionnaire effectif. Si la longueur existe déjà, on ajoute l’effectif apporté par le camion. Sinon, on crée une nouvelle entrée.

6. Fonction vendre

def vendre(effectif, longueur):
    effectif[longueur] = effectif[longueur] - 1
    if effectif[longueur] == 0:
        del effectif[longueur]

Après la vente, l’effectif diminue de 1. Si l’effectif devient nul, il faut supprimer la clé, car l’énoncé précise qu’une longueur absente du stock ne doit pas apparaître dans le dictionnaire.

7. Valeur maximale d’une planche de 4 m

On compare toutes les possibilités pertinentes :

• vendre la planche entière : 9 € ;
• découper en 3 m + 1 m : 8 + 1 = 9 € ;
• découper en 2 m + 2 m : 5 + 5 = 10 € ;
• découper en quatre planches de 1 m : 4 €.

8. Cas d’arrêt de la formule récursive

Le cas d’arrêt est n ≤ 3. Pour les longueurs 1, 2 et 3, on connaît directement la meilleure valeur : prix[n]. La fonction n’a donc pas besoin de s’appeler elle-même.

9. Calculs de valmax(1), valmax(2), valmax(3), valmax(4)

• valmax(1) = prix[1] = 1 ;
• valmax(2) = prix[2] = 5 ;
• valmax(3) = prix[3] = 8 ;
• valmax(4) = max(prix[4], prix[3]+valmax(1), prix[2]+valmax(2), prix[1]+valmax(3)) = max(9, 9, 10, 9) = 10.

10. Justification de la formule pour n ≥ 4

Pour une planche de longueur n, deux stratégies existent. Soit on la vend entière pour prix[n], soit on fait une première découpe : une partie est vendue directement, et le reste est optimisé grâce à valmax. La formule teste toutes les premières découpes possibles et conserve le maximum.

11. Fonction valmax récursive

def valmax(n):
    if n <= 3:
        return prix[n]
    else:
        maximum = prix[n]
        for longueur in range(1, n):
            maximum = max(maximum, prix[n-longueur] + valmax(longueur))
        return maximum

La boucle teste toutes les premières découpes possibles. La partie de longueur n-longueur est vendue directement, tandis que la partie de longueur longueur est optimisée récursivement.

12. Pourquoi valmax(7) appelle deux fois valmax(5)

Lors de l’appel valmax(7), la boucle appelle directement valmax(5) pour l’une des découpes. Elle appelle aussi valmax(6), et le calcul de valmax(6) appelle à son tour valmax(5). Sans mémoïsation, le même calcul est donc répété.

13. Fonction valmax_dynamique

def valmax_dynamique(n):
    if memo[n] != -1:
        return memo[n]
    else:
        maximum = prix[n]
        for longueur in range(1, n):
            maximum = max(maximum, prix[n-longueur] + valmax_dynamique(longueur))
        memo[n] = maximum
    return maximum

Si memo[n] est différent de -1, la valeur a déjà été calculée. Sinon, on la calcule, puis on la mémorise dans memo[n].

14. Nombre d’appels récursifs pour valmax_dynamique(6) après valmax_dynamique(5)

Après l’exécution de valmax_dynamique(5), les valeurs utiles jusqu’à 5 sont déjà mémorisées. L’appel valmax_dynamique(6) effectue alors 5 appels récursifs directs : pour les longueurs 1, 2, 3, 4 et 5. Mais ces appels renvoient immédiatement leur valeur mémorisée.

15. Initialiser memo uniquement avec des -1

Les valeurs de base memo[1], memo[2] et memo[3] ne seraient plus disponibles immédiatement. Avec le code proposé, le programme pourrait tout de même les calculer lors des premiers appels, mais il perdrait l’intérêt de les avoir déjà mémorisées. Il ferait donc des calculs inutiles au début.

16. Fonction valeur_max_stock

def valeur_max_stock(effectif):
    total = 0
    for longueur in effectif:
        total = total + effectif[longueur] * valmax_dynamique(longueur)
    return total

On multiplie, pour chaque longueur présente dans le stock, le nombre de planches par la valeur maximale obtenue après optimisation de la découpe.