Bac NSI 2026 Antilles-Guyane jour 2

reservation.id_client référence client.id_client et reservation.id_salle référence salle.id_salle. Une réservation doit concerner un client et une salle existants. Plusieurs réservations peuvent partager ces valeurs, alors que leur propre identifiant id reste unique.

Les salles B1 et B2 sont exclues. Les tarifs des trois restantes valent 300, 350 et 2 300 ; ORDER BY sans DESC trie en ordre croissant. L’ordre du résultat est donc imposé, même si la colonne tarif_jour n’est pas affichée.

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

Le seuil inclusif comprend tout janvier, y compris le 1er janvier. Avec des dates de jour au format ISO, date > '2023-12-31' est une écriture équivalente. DISTINCT retire les répétitions : la salle 3 a plusieurs réservations. Sur l’extrait, les identifiants sont 3 et 4, sans ordre garanti.

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);

La création du client précède la référence à son identifiant. Le téléphone est une chaîne : son zéro initial doit être conservé. La durée vaut 1 jour. On ne crée pas de nouvelle salle : l’identifiant 4 existe déjà.

UPDATE salle
SET nb_places = 95
WHERE id_salle = 2;

L’identifiant 2 désigne la salle Ravel dans l’extrait. Le filtre par identifiant évite de dépendre de la différence de casse entre Ravel dans la table et RAVEL dans la phrase. On modifie la capacité, pas le tarif ni le type.

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

On additionne les durées, en jours, de toutes ses réservations. COUNT donnerait le nombre de réservations, ce qui serait différent pour une réservation de plusieurs jours. La salle 6 ne figure pas dans les extraits, mais ils ne décrivent pas nécessairement toute la base. Si aucune ligne ne correspond, SUM renvoie NULL en SQL ; COALESCE(SUM(duree), 0) serait une amélioration possible si l’application attend un zéro.

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

La société est dans client, l’association société/salle dans reservation et le type dans salle. Les trois tables sont nécessaires. DISTINCT empêche de répéter une société ayant réservé plusieurs réunions. Dans les données affichées, FleursJ apparaît une seule fois malgré ses deux réservations de RA.

nb_places est un attribut ; reserver est une méthode. Un attribut contient un état propre à l’instance, une méthode décrit une opération effectuée avec cet état. intitule, type_salle, tarif, dispo et occupant seraient aussi des exemples d’attributs.

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

Les deux attributs changent ensemble pour maintenir l’invariant : disponible implique aucun occupant. Oublier de vider occupant laisserait une salle déclarée libre mais encore associée à un client. Il ne faut pas réinitialiser son tarif, sa capacité ou son intitulé.

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

La boucle parcourt des objets Salle : on lit donc leurs attributs avec un point. Le résultat contient les intitulés et non les objets entiers. Après les deux réservations du programme fourni, on obtient ["RA", "B2", "RB"], dans l’ordre de la liste initiale. La fonction ne modifie aucune salle.

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

L’appel salle.reserver(self.client) réalise deux actions liées : il change l’occupation de la salle et renvoie son tarif. On ajoute ce tarif au total existant, au lieu de le remplacer. Le test préalable empêche d’insérer deux fois une même salle déjà occupée et d’ajouter False au total. Pour une salle libre à 350 € et un total initial de 155 €, le nouveau total vaut 505 € ; la salle devient indisponible pour tout autre séminaire qui partagerait la même instance.

Le lien R1-R2 appartient à 192.168.1.0/24. Les trois premiers octets de chaque interface doivent donc être 192.168.1. L’adresse proposée 192.168.2.3 appartient à un autre sous-réseau, 192.168.2.0/24. Le dernier octet pourrait varier, mais pas le troisième.

Une destination est ici un sous-réseau, pas un routeur. Les réseaux directement connectés ont distance 0 selon la table imposée. Pour les destinations à égalité de nombre de routeurs intermédiaires, plusieurs passerelles sont valables ; la table RIP seule ne privilégie pas le coût numérique du lien. L’adresse de passerelle est l’interface du prochain routeur sur un réseau directement partagé avec R4.

0,5 Gbit/s, soit 500 Mbit/s. Le produit coût × débit est constant : 1 × 10 = 20 × débit, en Gbit/s. Le débit de R1-R2 est donc 10/20. Le coût vingt fois plus grand correspond à un débit vingt fois plus faible, pas plus élevé.

R1 → R2 → R6 → R5, avec trois liens inter-routeurs. Le chemin R1-R2-R3-R4-R5 en utilise quatre. RIP ignore ici le coût 200 du dernier lien.

R1 → R2 → R3 → R4 → R5, soit quatre liens. R2 ne peut plus rejoindre directement R6, et passer de R4 par R6 ajouterait encore un détour inutile.

R1 → R2 → R3 → R4 → R5, coût 20 + 50 + 1 + 20 = 91. La route RIP par R6, plus courte en nombre de liens, coûte 20 + 100 + 200 = 320. OSPF garde donc le chemin utilisé pendant la panne malgré le rétablissement, car ses liaisons sont globalement moins coûteuses. Le trajet par R2-R6-R4-R5 coûterait 190, lui aussi supérieur à 91.

Les sept anciennes liaisons sont conservées. Ajouter R1-R7 via 114.156.4.0/24, R1-R8 via 178.115.8.0/24, R3-R7 via 192.162.2.0/24, R5-R7 via 12.14.8.0/24 et R6-R8 via 10.7.2.0/24.

On compare les trois premiers octets, puisque toutes les interfaces sont en /24. Il faut lire exactement 192.162.2 pour R3-R7 : ce n’est pas 192.168.2, réseau de R4-R6.

RIP correspond à B : chaque ville joue le rôle d’un routeur traversé. OSPF correspond à A : les poids des liens peuvent représenter les durées, dont la somme est minimisée. L’analogie porte sur les métriques, pas sur une identité entre débit informatique et durée routière.

V3, V2, V4, V1, V6, V5, avec l’ordre des voisins du dictionnaire. La file commence par V3 ; elle reçoit V2 puis V4. V2 découvre V1 et V6 ; V4 découvre V5, tandis que V6 est déjà découvert. Les couches de distances sont donc {V3}, {V2,V4}, puis {V1,V6,V5}.

La troisième ligne imprimée omet V6, alors que le deuxième tour parcourt les deux voisins encore non visités V3 et V6 de V2. Le code découvre ensuite V4 depuis V3, puis réécrit son prédécesseur à V6 au quatrième tour, car V4 est déjà en file mais n’a pas encore été extrait. Les états ci-dessus suivent exactement le programme. Il faut préciser « début » ou « fin » de tour pour éviter un décalage de lecture.

['V1', 'V2', 'V6', 'V5']

À l’arrivée, les prédécesseurs donnent V5 ← V6 ← V2 ← V1 ← None. La boucle construit donc [V5,V6,V2,V1], puis reverse remet le chemin dans le sens du départ.

Ce résultat est bien un plus court chemin pour l’exemple, mais le programme n’est pas fiable sur tout graphe : un sommet déjà en file peut voir son prédécesseur réécrit avec un chemin plus long. Exemple : A relié à B et C ; B relié à C ; C relié à D. Avec les voisins de A dans l’ordre B,C, le code peut remplacer le prédécesseur de C par B et renvoyer A-B-C-D au lieu de A-C-D. La réparation consiste à marquer un sommet dès sa première découverte, par exemple en testant voisin not in precedent, et à ne jamais réécrire son prédécesseur ensuite.

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

Les clés représentent des longueurs et les valeurs des quantités. Les longueurs absentes ne sont pas ajoutées avec une quantité nulle, conformément à la représentation choisie.

effectif[10] * prix[10]

On multiplie leur nombre par 30 €, prix d’une planche de 10 m. La garantie de présence rend l’accès effectif[10] valide. Écrire 10 * effectif[10] calculerait la longueur totale en mètres, pas la valeur en euros.

5 in effectif

L’opérateur in sur un dictionnaire teste ses clés. Comme une clé n’existe que si son effectif est positif, ce test répond exactement à la question. effectif[5] > 0 provoquerait KeyError si la longueur 5 est absente.

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

Chaque longueur présente contribue quantité × prix unitaire. Pour {1:3,2:4,4:1}, le résultat est 3×1 + 4×5 + 1×9 = 32 €. L’itération parcourt les clés du dictionnaire ; elle ne suppose pas que toutes les longueurs de 1 à 10 sont présentes. Un dictionnaire vide renvoie 0.

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

Deux cas sont nécessaires : augmenter une quantité existante ou créer une nouvelle longueur. Sur l’exemple, la longueur 1 passe de 3 à 5 ; la longueur 2 est ajoutée avec quantité 2 ; la longueur 5 reste à 5. La fonction modifie le dictionnaire reçu, sans devoir en renvoyer un nouveau. On parcourt autre_effectif : l’ajout de clés à effectif ne modifie donc pas la structure parcourue.

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

La précondition garantit que l’accès existe et que le décrément ne devient pas négatif. On supprime uniquement quand la dernière planche est vendue. Cela maintient l’invariant utilisé à la question 3 : une clé présente correspond à un stock positif. Par exemple {1:3,5:1} devient {1:2,5:1} après vendre(...,1), puis {1:2} après vendre(...,5).

10 € en deux planches de 2 m. Les cinq partitions couvrent toutes les possibilités sans distinguer l’ordre des morceaux. Une coupe n’est donc pas toujours avantageuse, mais celle-ci rapporte 1 € de plus que la vente entière.

Pour n ≤ 3, on renvoie prix[n] parce que les comparaisons précédentes ont prouvé qu’aucune découpe n’améliore ces trois petites longueurs. Les autres appels portent sur des longueurs strictement plus petites, donc ils finissent par atteindre ces cas. Ce choix de base dépend du tableau de prix fourni ; il ne serait pas automatiquement vrai avec d’autres tarifs.

valmax(1) = prix[1] = 1 ; valmax(2) = prix[2] = 5 ; valmax(3) = prix[3] = 8. Puis :

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

L’option prix[4] conserve la possibilité de ne pas couper. Les autres options choisissent un morceau vendu entier et optimisent le reste.

Toute vente optimale a deux formes. Soit la planche reste entière et rapporte prix[n]. Soit elle est découpée : choisir l’un des morceaux finaux de longueur n-k, avec 1 ≤ k ≤ n-1, rapporte prix[n-k], et les k mètres restants doivent être vendus de façon optimale, soit valmax(k). S’ils ne l’étaient pas, remplacer leur découpe par une meilleure augmenterait la valeur totale, contredisant l’optimalité.

Le maximum sur tous les k couvre donc toutes les découpes possibles. On ne suppose pas qu’il n’y aura que deux morceaux : le morceau restant est lui-même optimisé récursivement et peut contenir de nombreuses coupes. Le modèle ignore les pertes de scie et les coûts de découpe, car aucune donnée de ce type n’est fournie.

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

longueur désigne ici la longueur du reste optimisé. La partie vendue entière mesure n-longueur. range(1,n) évite une planche vide et garantit que l’appel récursif porte sur une longueur strictement inférieure. maximum est initialisé au prix de la planche entière. Le return du cas de base évite d’utiliser un maximum non initialisé quand n ≤ 3.

Une première fois directement lorsque la boucle de valmax(7) atteint longueur = 5. Une seconde fois dans l’appel valmax(6), lui-même déclenché lorsque la boucle principale atteint longueur = 6. Les appels sur des longueurs inférieures à 5 ne peuvent pas rappeler 5, donc il y en a exactement deux. Le résultat calculé la première fois est perdu après le retour : rien ne le mémorise pour la seconde branche.

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

Une valeur différente de -1 est déjà connue et peut être renvoyée sans calcul supplémentaire. Sinon on explore les découpes, puis on mémorise le maximum une fois le calcul terminé. Les appels récursifs doivent utiliser valmax_dynamique, pas l’ancienne valmax, sinon la mémoire serait contournée. Si les tarifs changent, le cache doit être réinitialisé, car ses valeurs dépendent de prix.

Cinq appels récursifs directs, sur les longueurs 1, 2, 3, 4 et 5. Ces valeurs sont toutes en cache, donc chacun renvoie immédiatement, sans produire de nouvel appel récursif. Dire zéro confondrait « aucun calcul récursif supplémentaire sous ces appels » avec « aucun appel ». Si l’on comptait aussi l’appel initial sur 6, on aurait six invocations au total.

Avec le code complété ci-dessus, il terminerait tout de même et calculerait les bonnes valeurs pour les longueurs 1 à 10. Les appels portent toujours sur des entiers positifs plus petits. Lorsque n = 1, range(1,1) est vide : maximum reste prix[1], cette valeur est mémorisée puis renvoyée. Pour 2 et 3, les petites découpes sont ensuite comparées et redonnent 5 et 8. Il n’y a donc ni boucle infinie ni accès à un indice négatif.

La différence est un petit surcroît de travail pour redécouvrir les bases déjà connues. Le cas de terminaison n’est plus une lecture immédiate d’un cache initial, mais la boucle vide au plus petit n. Ce détail montre pourquoi il faut analyser le programme exact au lieu d’affirmer qu’une récursion doit forcément posséder une instruction explicite if n == 1.

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

Les planches sont indépendantes dans le modèle : on peut optimiser chacune sans contrainte commune ni coût de découpe. Pour chaque longueur, une valeur optimale est multipliée par la quantité. Le cache global est partagé entre toutes les longueurs du stock ; il ne faut pas le réinitialiser dans la boucle. Pour {1:3,2:4,4:1}, on obtient 3×1 + 4×5 + 1×10 = 33 €, contre 32 € sans découpe. Le stock reste inchangé : cette fonction estime une valeur, elle ne simule pas les ventes ni les coupes.