Bac NSI 2026 Asie jour 1

INSERT INTO choregraphie (nomchore, annee, choregraphe)
VALUES ('Tout autour', 2015, 9);

Le chorégraphe est référencé par son identifiant, pas par son nom. La personne 9 doit exister pour respecter la clé étrangère. Le nom de chorégraphie doit être encore disponible puisqu’il constitue sa clé primaire.

SELECT COUNT(*)
FROM choregraphie
WHERE annee = 1983;

On filtre les lignes sur l’année puis les compte. Il ne faut pas compter les participations à ces chorégraphies, qui pourraient se répéter pour plusieurs danseurs et spectacles.

Elle renvoie le nom de chaque chorégraphie et le nom de la personne qui l’a chorégraphiée. La jointure suit choregraphe = personne.id. Elle ne renvoie pas tous les danseurs de cette œuvre : ce lien passerait par participe.

SELECT DISTINCT p.nom
FROM personne AS p
JOIN participe AS pa ON pa.idpersonne = p.id
JOIN spectacle AS s ON s.id = pa.idspectacle
WHERE s.titre = 'Tout autour';

Le titre demandé est celui du spectacle, pas le nom de la chorégraphie. Une personne peut participer à plusieurs chorégraphies dans la même représentation ; DISTINCT évite de répéter son nom dans le résultat. Si plusieurs spectacles ont ce titre, toutes leurs participations sont concernées. Une projection sur le seul nom peut confondre des homonymes ; afficher aussi l’identifiant serait utile pour les distinguer, mais la question demande les noms.

Vérifier les lignes de participe qui référencent ce spectacle et les supprimer ou les archiver selon le besoin avant d’effacer la ligne de spectacle, sauf cascade prévue. Sinon une clé étrangère pointerait vers un spectacle absent et le SGBD refuserait l’opération. Il faut cibler l’identifiant exact et préserver les autres personnes et chorégraphies, qui peuvent servir à d’autres représentations.

n += dmateriel[clef]['nb']

La première clé sélectionne le type de matériel ; la seconde sélectionne sa quantité. Le total vaut 3+1+40+2+4 = 50 objets. len(dmateriel) vaudrait seulement 5, nombre de types distincts, et ne répondrait pas à la question.

tab_clefs.append(clef)
tab_volumes.append(dico["volume"])

items() fournit à chaque tour une clé et le sous-dictionnaire associé. Les deux append sont effectués dans le même tour : les indices restent alignés entre les listes. Le volume demandé est unitaire, pas nb × volume. Sur l’exemple, les volumes sont [2,6,50,3,7].

Une stratégie gloutonne : à chaque étape, on fait un choix local immédiat, ici le plus gros objet qui peut encore entrer. Elle ne revient pas sur les objets déjà chargés pour réorganiser le contenu. Une telle stratégie peut être rapide et intuitive sans garantir le minimum global de véhicules.

Par exemple le tri par insertion, O(n²) dans le pire cas. Autre réponse valable au programme de Terminale : le tri fusion, O(n log n) dans le pire cas. Il faut préciser à quel cas correspond le coût : le tri par insertion est linéaire sur une liste déjà triée, mais ce n’est pas son pire cas.

def remplissage(dmatos, vmax):
    vol = 0
    clefs_triees = clefs_triees_selon_volume(dmatos)
    i = len(clefs_triees) - 1
    elements = []
    while i >= 0 and vol < vmax:
        clef = clefs_triees[i]
        if dmatos[clef]['nb'] == 0:
            i -= 1
        elif vol + dmatos[clef]['volume'] <= vmax:
            vol += dmatos[clef]['volume']
            elements.append(clef)
            dmatos[clef]['nb'] -= 1
        else:
            i -= 1
    return elements

Le tri est croissant mais l’indice commence à la fin : les plus gros objets sont donc examinés d’abord. Si un objet entre, on l’ajoute, réduit sa quantité et garde le même indice pour tenter un autre exemplaire. Si son stock est nul ou s’il ne tient plus, on passe au type suivant, plus petit. Chaque itération réduit une quantité ou diminue i, donc la boucle progresse. L’invariant de volume est 0 ≤ vol ≤ vmax.

Pour vmax = 160, trois chaises occupent 150 ; un chapeau_B ajoute 7 et un chapeau_A ajoute 3, soit exactement 160. Les quantités restantes deviennent 37 chaises, 3 chapeaux_B et 1 chapeau_A, les costumes restant inchangés. La fonction ne vérifie pas une capacité en poids : le champ poids est fourni mais la consigne de cette partie ne porte que sur le volume.

def nb_voitures(dmatos, vmax):
    for clef in dmatos:
        if dmatos[clef]["nb"] > 0 and dmatos[clef]["volume"] > vmax:
            raise ValueError("Un objet dépasse la capacité du véhicule")
    nombre = 0
    while remplissage(dmatos, vmax) != []:
        nombre += 1
    return nombre

Chaque appel remplit un nouveau véhicule et retire les objets chargés du stock. La première liste vide indique que plus rien ne reste à charger, sous la condition que chaque objet puisse entrer seul. La vérification initiale explicite cette condition ; sans elle, un objet trop volumineux pourrait rester alors que la fonction renvoie []. On suppose aussi des volumes strictement positifs, des quantités non négatives et une capacité positive.

Le nombre obtenu est celui de cette stratégie gloutonne, pas une garantie de minimum absolu. La fonction consomme le stock en place : pour conserver l’inventaire initial, il faudrait travailler sur une copie des sous-dictionnaires, pas seulement sur une copie superficielle du dictionnaire externe.

Somme = 1×0,7 + 3×(-0,2) + 0,1 = 0,2. Elle est positive, donc la sortie vaut 1. Le biais est ajouté une fois, après la somme des produits. Les entrées ne sont pas les poids : x2=3 multiplie bien le poids négatif -0,2.

set_biais est une méthode ; poids est un attribut. biais est également un attribut ; get_biais, get_poids et set_poids sont d’autres méthodes. Le paramètre nb_entrees n’est pas conservé comme attribut portant ce nom.

detecteur = DetecteurSpam(2)
detecteur.set_poids([0.7, -0.2])
detecteur.set_biais(0.1)

Le constructeur initialise deux poids nuls ; les méthodes les remplacent ensuite. Le nombre 2 indique la dimension du modèle, pas le nombre d’exemples de son entraînement.

Elle vérifie que le nouveau vecteur possède autant de poids que le modèle a d’entrées. Si les longueurs diffèrent, une AssertionError interrompt l’affectation. Elle ne vérifie ni le type numérique des poids ni leur pertinence pour classer des emails. Le corps de la méthode utilise le nom nouveaux_poids ; la variante singulière dans la phrase du sujet est une coquille.

def fonction_activation(self, valeur):
    if valeur >= 0:
        return 1
    return 0

Le cas zéro appartient à la classe 1. Ce choix influence les premiers exemples puisque le constructeur crée des poids et un biais nuls : au départ, toutes les sommes valent 0 et toutes les prédictions valent donc 1.

def prediction(self, entrees):
    somme = 0
    for i in range(len(entrees)):
        somme += entrees[i] * self.poids[i]
    somme += self.biais
    sortie = self.fonction_activation(somme)
    return sortie

Chaque entrée est multipliée par son poids au même indice. Le biais est ajouté hors de la boucle, exactement une fois. L’activation est ensuite appelée sur la somme complète. Pour les poids [0.5,-0.1,0.2], le biais 0.2 et les entrées [0.1,0.3,0.2], la somme vaut 0.05-0.03+0.04+0.2 = 0.26, donc la sortie est 1. Le sujet garantit ici l’égalité des dimensions.

O(n), linéaire : n produits et n accumulations dans la boucle, suivis d’un ajout et d’un test de coût constant. Le nombre d’exemples d’entraînement n’intervient pas dans le coût d’une seule prédiction.

echantillon[1] = [0.2,0.1] et echantillon[2][1] = 0.8. Le premier accès choisit le deuxième exemple, le second la deuxième caractéristique du troisième exemple.

def entrainement(self, echantillon, cibles, taux=0.1):
    nb_erreurs = 0
    for i in range(len(echantillon)):
        entrees = echantillon[i]
        cible = cibles[i]
        predict = self.prediction(entrees)
        if predict != cible:
            nb_erreurs += 1
            erreur = cible - predict
            for j in range(len(self.poids)):
                self.poids[j] += taux * erreur * entrees[j]
            self.biais += taux * erreur
    return nb_erreurs

La cible et l’exemple partagent le même indice i. L’erreur signée vaut +1 si l’on aurait dû répondre 1, -1 si l’on aurait dû répondre 0. Elle oriente la mise à jour du biais et de chaque poids. Un exemple correctement classé ne change rien. Les poids modifiés sont immédiatement utilisés pour l’exemple suivant : l’ordre des exemples influence donc la trajectoire de l’apprentissage.

Le compteur indique les erreurs rencontrées pendant cette époque, avant chaque correction locale, pas forcément le nombre d’exemples mal classés par le modèle final de l’époque. En revanche, une époque sans erreur ne modifie aucun poids et prouve que le modèle courant classe correctement tous les exemples parcourus.

emails = [[0,0], [0,1], [1,0], [1,1]]
spams = [0,0,0,1]
detecteur = DetecteurSpam(2)
for epoque in range(1, 1001):
    erreurs = detecteur.entrainement(emails, spams)
    if erreurs == 0:
        print(epoque)
        break
else:
    print(-1)

range(1,1001) autorise exactement mille époques, comptées à partir de 1. Le else de la boucle ne s’exécute que si aucun break n’a été rencontré : -1 signifie alors « pas d’époque sans erreur dans la limite fixée ». Il ne prouve pas une impossibilité mathématique d’apprentissage. On peut aussi écrire la même logique avec while et un compteur.

La cible correspond à une porte ET, qui est linéairement séparable. Par exemple poids [1,1], biais -1.5 distinguent le seul point (1,1) des trois autres. Ce petit modèle n’est pas un détecteur fiable du spam réel : il apprend uniquement la règle et les exemples choisis. Près du seuil zéro, les arrondis flottants peuvent changer le nombre exact d’époques observé ; on évite donc de confondre ce nombre dépendant de l’implémentation avec une propriété universelle de ET.

Les trois premiers octets : 192.168.20, soit 24 bits. Le dernier octet est la partie machine et ne fait pas partie du préfixe fixe.

2 : 32-30 = 2 bits machine, donc 4 adresses dont deux réservées. Un /30 est ainsi adapté au lien point à point entre deux interfaces.

Les deux réseaux de liaison sont directement connectés à R2, donc sans passerelle intermédiaire et à distance 0 dans la convention du sujet. Pour les LAN distants, l’interface est celle de R2, tandis que la passerelle est l’adresse du voisin sur le lien partagé. Ces deux colonnes ne doivent pas être échangées.

(255, 255, 255, 252)

Les 24 premiers bits sont trois octets à 255. Le dernier octet a six bits réseau à 1 puis deux bits machine à 0 : 11111100₂ = 252.

255 s’écrit 11111111 sur huit bits. Le ET bit à bit conserve chaque bit de A, car 0 ET 1 = 0 et 1 ET 1 = 1. La restriction 0≤A≤255 garantit que A tient dans ces huit positions.

Oui. Les deux premiers octets sont conservés et identiques ; le dernier est annulé par &0. Pour le troisième : 189 = 10111101, 191 = 10111111 et 252 = 11111100. Dans les deux cas, le ET donne 10111100 = 188. Les deux adresses masquées sont donc (172,20,188,0), réseau /22.

def meme_reseau(adresse1, adresse2, masque):
    for i in range(4):
        octet1 = adresse1[i] & masque[i]
        octet2 = adresse2[i] & masque[i]
        if octet1 != octet2:
            return False
    return True

Une seule différence de préfixe suffit à conclure que les réseaux diffèrent. True est renvoyé après les quatre octets, sinon on ne contrôlerait que le premier. Les entrées sont supposées des tuples d’octets valides et le masque un masque réseau cohérent.

def diffuser(self):
    while not self.file.est_vide():
        paquet = self.file.defiler()
        orig, donnees = paquet
        for m in self.machines:
            if m != orig:
                self.machines[m].enfiler(paquet)

On vide progressivement la file du réseau. machines associe une adresse à la file de réception de cette machine. Le paquet complet doit être envoyé, en conservant l’adresse orig dont le routeur aura besoin comme passerelle dans sa mise à jour. Envoyer seulement donnees ferait perdre cette origine. Le réseau diffusant à toutes les machines est une simplification explicite du simulateur, pas une description générale de toute communication Ethernet.

{
    (172,64,0,0): (1, None, 0),
    (172,60,0,0): (0, (172,58,0,2), 1),
    (192,168,47,0): (0, (172,58,0,2), 2),
    (172,62,0,0): (1, (172,64,0,2), 1),
    (192,168,72,0): (1, (172,64,0,2), 1)
}

Le réseau 192.168.72.0 est nouveau : on l’ajoute avec la distance annoncée 0 plus un saut vers le voisin. Pour 172.62.0.0, la nouvelle distance 1 améliore l’ancienne 2 : on remplace interface et passerelle. Le réseau directement connecté 172.64.0.0 garde sa distance 0. Les propositions vers 172.60.0.0 (coût 2 contre 1) et 192.168.47.0 (2 contre 2) n’améliorent rien, donc sont ignorées. Une égalité ne modifie pas le choix existant dans ce code.

if adresse not in self.table or d + 1 < self.table[adresse][2]:
    self.table[adresse] = (i_interf, passerelle, d + 1)
    a_ete_modif = True

L’ordre des deux termes de OR protège l’accès à une clé absente : si l’adresse est nouvelle, le second terme n’est pas évalué. La composante d’indice 2 contient la distance. Le drapeau conserve True dès qu’une modification intervient, afin de n’envoyer qu’une annonce après avoir traité tous les vecteurs. Le modèle n’accepte que les améliorations ; il ne suffit pas à gérer le retrait ou la dégradation d’une route après panne.

if i_interf != i:
    res.append((adresse, dist))

La méthode ne renvoie que destination et distance, pas la passerelle ni l’indice local, qui n’auraient pas le même sens chez le voisin. L’exclusion correspond au principe de split horizon dans ce modèle : ne pas annoncer sur une interface une route que l’on emprunte par cette même interface. Cela réduit les retours d’informations inutiles, sans prouver à lui seul l’absence de toute boucle dans toutes les variantes de RIP.

def envoyer_vecteurs(self, i_interf):
    for i in range(len(self.interfaces)):
        if i != i_interf:
            adresse = self.interfaces[i].adresse
            v = self.vecteurs(i)
            paquet = (adresse, v)
            self.interfaces[i].sortie.enfiler(paquet)

Le paramètre i_interf indique l’interface par laquelle l’information vient d’arriver ; cette sortie est ignorée pour l’annonce déclenchée. Pour chaque autre interface, vecteurs(i) applique son propre filtrage. L’origine du paquet est l’adresse de l’interface émettrice. On enfile dans sortie, la file du réseau, et non dans file, la file de réception de l’interface. Lorsque i_interf vaut -1, aucun indice valide n’est exclu.

for routeur in routeurs:
    routeur.envoyer_vecteurs(-1)

continuer = True
while continuer:
    for reseau in reseaux:
        reseau.diffuser()
    for routeur in routeurs:
        routeur.traitement()
    continuer = False
    for reseau in reseaux:
        if not reseau.file.est_vide():
            continuer = True

Un tour distribue d’abord les annonces en attente des réseaux vers les interfaces, puis chaque routeur traite ses réceptions et peut produire de nouvelles annonces. La condition de poursuite est examinée après ces deux phases. Si tous les réseaux sont vides à ce moment, toutes les réceptions ont été traitées et plus aucune amélioration ne produit de paquet. Mettre continuer=False à la fin de chaque réseau sans conserver un True précédent pourrait arrêter à tort alors qu’un autre réseau contient encore des paquets.

Le modèle suppose une topologie fixe et ne traite que des distances nouvellement découvertes ou strictement améliorées, ce qui conduit à un état stable sur cet exemple fini. Un protocole réel comporte aussi annonces périodiques, temporisations et gestion des routes devenues inaccessibles ; ces mécanismes ne doivent pas être inventés dans ce script simplifié.