Bac NSI 2026 Amérique du Nord jour 2

Prêt signifie apte à s’exécuter mais en attente de processeur. Élu signifie actuellement exécuté. Bloqué signifie en attente d’une ressource ou d’un événement. Un déblocage ne donne pas automatiquement le processeur : il remet le processus parmi les prêts.

P2 est bloqué en attendant l’accès à la carte Wi-Fi ; P3 est élu puisqu’il effectue le décodage au processeur. Pour P1, la lecture attendue est prêt s’il reste exécutable mais n’a pas le processeur. Le seul fait que sa fenêtre soit cachée ne suffit toutefois pas, dans un système réel, à déterminer son état : un processus d’interface attendant un événement pourrait être bloqué. Il faut donc annoncer l’hypothèse « P1 reste prêt à s’exécuter » plutôt que confondre visibilité de la fenêtre et état système.

Plusieurs processus attendent indéfiniment des ressources détenues par d’autres processus du même groupe, sans qu’aucun puisse avancer jusqu’à la libération attendue. Avec des ressources exclusives, un cycle d’attente peut ainsi bloquer tout le groupe : P1 garde A et attend B, pendant que P2 garde B et attend A. Une simple attente d’une ressource qui sera libérée normalement n’est pas un interblocage.

Un scénario suffit : P1 obtient MIC ; avant qu’il demande CAL, P2 obtient CAL. P1 demande alors CAL et attend P2 ; P2 demande MIC et attend P1. Aucun n’atteint ses instructions de libération. Le cycle MIC/P1 → CAL/P2 → MIC est établi. Il n’est pas nécessaire de bloquer aussi P3 et P4 pour prouver qu’un interblocage est possible. Ce n’est pas garanti pour toutes les exécutions : l’entrelacement choisi le rend possible.

Elle peut exécuter réellement plusieurs processus en parallèle, améliorer la réactivité et augmenter le débit de calcul lorsque les tâches sont parallélisables. Cela ne multiplie pas automatiquement la vitesse de tout programme : les parties séquentielles, les ressources partagées et les synchronisations limitent le gain. Plusieurs processeurs n’éliminent pas non plus les interblocages.

Un SoC intègre plusieurs fonctions sur une même puce, par exemple CPU, GPU et contrôleurs. Avantage : un ensemble compact et économe en énergie, adapté à une batterie et à un appareil léger. Inconvénient : une réparation ou une évolution séparée d’un composant est difficile ; la panne ou l’obsolescence d’un élément peut imposer de remplacer l’ensemble. Les échanges courts entre composants peuvent aussi améliorer les performances.

Les nouveaux processus rejoignent la queue dès leur arrivée. Après 0-2, P2 est donc devant P1 replacé en queue. À la fin du créneau 4-6, P4 arrivé à 5 ms précède le retour de P1. Lorsqu’un processus n’a plus qu’une milliseconde à faire, on passe immédiatement au suivant : le quantum est une durée maximale, pas un créneau qui doit rester inutilisé jusqu’à son terme. Le temps total est 6+4+5+3 = 18 ms, sans inactivité ni surcoût de commutation dans ce modèle.

fp = creer_file_vide()
enfiler(fp, P1)
enfiler(fp, P2)
enfiler(fp, P3)
enfiler(fp, P4)

Enfiler ajoute en queue : le premier élément ajouté reste donc en tête. Les dictionnaires de processus sont conservés comme objets dans la file. La fonction enfiler modifie la file et renvoie None ; il ne faut pas écrire fp = enfiler(fp,P1). Cette construction fournit une liste d’attente ordonnée, sans simuler à elle seule les instants d’arrivée du chronogramme.

def execute_un_processus(file_d_attente, t):
    processus = defiler(file_d_attente)
    if processus["temps"] > quantum:
        processus["temps"] -= quantum
        enfiler(file_d_attente, processus)
        return t + quantum
    else:
        return t + processus["temps"]

Si le temps restant dépasse le quantum, on le diminue puis remet le même dictionnaire en queue. Sinon le processus finit, reste hors de la file et consomme exactement son temps restant. L’égalité temps = quantum appartient à la branche de fin : réenfiler un processus de temps nul serait inutile. Le code demandé ne remet pas explicitement temps à zéro pour l’objet terminé ; il suffit à la simulation puisque cet objet n’est plus planifié. Une application conservant un historique pourrait mettre à jour ce champ après avoir sauvé la durée à ajouter.

def execute_tous_processus(file_d_attente):
    t = 0
    while not est_vide(file_d_attente):
        t = execute_un_processus(file_d_attente, t)
    return t

L’appel renvoie la nouvelle date courante ; il faut l’affecter à t plutôt que l’ajouter encore une fois. Chaque créneau diminue le travail restant et finit par retirer un processus, donc la boucle termine si les durées et le quantum sont positifs. Une file vide renvoie 0 immédiatement. Cette partie ignore explicitement les arrivées : elle ne reproduit donc pas exactement l’ordre de la question 7, même si le total de travail reste 18 ms.

pegula = Joueuse("Pegula", "Jessica", "USA", 29, 6101)

Les arguments suivent l’ordre du constructeur. Les compteurs de victoire et défaite sont initialisés automatiquement à zéro et ne sont pas à fournir.

def ajouter_victoire(self, adversaire):
    self.victoire += 1
    adversaire.defaite += 1

self est la gagnante sur laquelle la méthode est appelée. adversaire est un autre objet Joueuse. Les deux compteurs changent sur deux instances différentes ; on ne doit pas incrémenter les défaites de self. Les points WTA ne sont pas modifiés, faute de règle d’attribution fournie.

swiatek.ajouter_victoire(paloni)

L’objet placé avant le point est la gagnante, puisque la méthode augmente sa victoire. L’adversaire transmis reçoit la défaite.

Quadratique : O(n²).

Le préfixe traité reste trié après chaque itération externe. Paloni, à 4 843 points, remonte deux places ; Sabalenka, à 10 541, ne bouge pas lors de son insertion. Pegula, à 6 101, dépasse Sabalenka puis Swiatek, mais reste après Gauff, à 6 063. On n’ajoute pas de ligne lorsqu’aucun échange n’a lieu, car le tableau demande les échanges, pas les tours de boucle.

def resultat_match(self, score):
    self.score = score
    nb_set_joueuse1 = 0
    nb_set_joueuse2 = 0
    for jeux1, jeux2 in score:
        if jeux1 > jeux2:
            nb_set_joueuse1 += 1
        else:
            nb_set_joueuse2 += 1
    if nb_set_joueuse1 > nb_set_joueuse2:
        self.gagnante = self.joueuse1
        self.perdante = self.joueuse2
    else:
        self.gagnante = self.joueuse2
        self.perdante = self.joueuse1
    self.gagnante.ajouter_victoire(self.perdante)

Chaque tuple décrit les jeux gagnés dans un set. Le match se décide au nombre de sets gagnés, pas à la somme des jeux. Pour [(7,5),(4,6),(7,6)], la joueuse 1 gagne les sets 1 et 3 : elle remporte le match 2-1. Les références gagnante et perdante pointent vers les objets déjà existants ; on ne crée pas de nouvelles joueuses. L’appel final met à jour les deux bilans une seule fois.

On suppose un score terminé et valide sans égalité, comme l’indique l’énoncé. Cette méthode doit être appelée une fois pour enregistrer le match ; si l’application permet de corriger un score déjà saisi, il faudrait d’abord annuler l’ancien effet sur les compteurs ou gérer explicitement cet état. Cette extension n’est pas fournie par le simple squelette.

Chaque match d’un tour réunit les gagnantes de deux matchs du tour précédent. Le nœud du match possède donc deux sous-arbres, un par provenance. À partir des quarts seulement, les quatre quarts sont les feuilles, les demi-finales leurs parents et la finale la racine. Ce sont les matchs, et non directement les joueuses, qui constituent les nœuds du modèle.

tournoi = Arbre(F,
    Arbre(D1, Arbre(Q1, None, None), Arbre(Q2, None, None)),
    Arbre(D2, Arbre(Q3, None, None), Arbre(Q4, None, None)))

Chaque feuille doit aussi être un objet Arbre contenant son Match. Les enfants absents sont None. L’objet F est la valeur racine de tournoi, pas l’arbre lui-même. Les mêmes objets Match sont partagés avec les variables Q1, D1, etc. : modifier un match par sa variable se voit donc dans l’arbre.

tournoi.gauche.racine.joueuse1 = gauff

tournoi.gauche est l’arbre de la demi-finale D1 ; .racine est le Match D1 ; .joueuse1 est l’emplacement réservé à la gagnante du quart gauche Q1. Le détour par racine est indispensable car Arbre ne possède pas directement d’attribut joueuse1.

Il comporte une fonction qui s’appelle elle-même, directement ou indirectement, pour résoudre un sous-problème. Un mécanisme de terminaison arrête ces appels, par exemple l’arrivée sur un sous-arbre absent ou un état déjà renseigné. Une simple répétition par boucle n’est pas de la récursivité.

def mise_a_jour(self):
    if self.racine.joueuse1 is None:
        if self.gauche is not None:
            if self.gauche.racine.gagnante is not None:
                self.racine.joueuse1 = self.gauche.racine.gagnante
            else:
                self.gauche.mise_a_jour()
    if self.racine.joueuse2 is None:
        if self.droit is not None:
            if self.droit.racine.gagnante is not None:
                self.racine.joueuse2 = self.droit.racine.gagnante
            else:
                self.droit.mise_a_jour()

Pour chaque côté, on ne remplit qu’un emplacement encore vide. Si le match enfant a déjà une gagnante, on la copie au tour supérieur. Sinon on descend dans ce sous-arbre pour mettre à jour ses matchs précédents. Les feuilles n’ont pas d’enfants, ce qui arrête naturellement la descente. Cette fonction ne joue pas les matchs et ne détermine pas une gagnante : elle propage seulement les résultats déjà saisis.

Par exemple, après les résultats de Q1 et Q2, un appel sur la racine F descend vers D1 et complète ses deux participantes, mais F n’a toujours pas de joueuse1 tant que la demi-finale D1 n’a pas été jouée. Après saisie de son résultat, un nouvel appel copie sa gagnante dans F. Le test des emplacements déjà renseignés évite d’effacer un résultat existant.

Il est attribué automatiquement, unique et non nul pour chaque inscription. Deux coureurs homonymes peuvent donc être distingués. Puisque chaque coureur ne participe qu’à une seule épreuve dans le modèle, ce dossard suffit à identifier la ligne sans le combiner à id_epreuve.

La requête liste les noms et prénoms de tous les inscrits, triés par nom croissant. Dans l’extrait : BODIANE Lola, BRELET Sandra, DA SILVA José, HANG LI Léo. Les personnes portant le même nom ne seraient pas nécessairement triées par prénom, car ce second critère n’est pas demandé. La collation du SGBD détermine les détails de l’ordre alphabétique.

SELECT nom, prenom
FROM coureur
WHERE sexe = 'F';

On filtre avec la codification F du sujet. Aucun filtre sur la distance n’est demandé, donc les deux épreuves sont concernées.

SELECT COUNT(*) FROM coureur;

COUNT(*) compte les lignes de la table entière. Les quatre lignes imprimées ne sont qu’un extrait : on ne peut déduire le total réel de la seule illustration.

INSERT INTO coureur (nom, prenom, annee, sexe, id_epreuve, temps)
VALUES ('REMY', 'Patrice', 1973, 'H', 1, 0);

Le dossard n’est pas fourni : il est généré automatiquement par la base. id_epreuve = 1 correspond au 5 km, alors que la valeur 5 décrit une distance, pas un identifiant. Le temps vaut initialement zéro.

DELETE FROM coureur WHERE num_dossard = 137;

La suppression cible la clé de l’inscription. On ne supprime pas l’épreuve à laquelle il était inscrit, qui reste partagée par les autres coureurs.

SELECT e.distance, e.horaire
FROM coureur AS c
JOIN epreuve AS e ON c.id_epreuve = e.id_epreuve
WHERE c.num_dossard = 256;

La table coureur fournit l’épreuve choisie ; la table epreuve en donne les caractéristiques. Le dossard 256 n’est pas dans l’extrait, donc seule la requête peut être fournie, pas une distance inventée.

SELECT c.num_dossard, c.nom, c.prenom, c.temps
FROM coureur AS c
JOIN epreuve AS e ON e.id_epreuve = c.id_epreuve
WHERE c.sexe = 'F' AND c.annee < 1986 AND e.distance = 10
ORDER BY c.temps ASC;

La limite « avant 1986 » est stricte ; 1986 est exclu. Le plus petit temps arrive en tête. L’énoncé suppose tous les temps enregistrés : aucun filtre de résultat manquant n’est nécessaire ici. Dans une application conservant des non-partants à temps 0, il faudrait les exclure du classement, sinon ils seraient incorrectement premiers. Filtrer directement id_epreuve=2 serait également valable pour la table donnée, mais la jointure exprime explicitement la distance demandée.

1000 secondes, meilleure performance Senior Homme en 2025. La clé externe est l’année ; l’indice 2 sélectionne la troisième catégorie, SH.

dict_perf_5km[2026] = [1004, 1016, 1000, 1140, 1023, 1024]

L’ordre des six catégories doit rester identique d’une année à l’autre. La clé 2026 est un entier, comme les années déjà enregistrées. Si cette clé existait, l’affectation remplacerait sa liste ; elle ne créerait pas une seconde entrée pour la même année.

def scratch(dico, annee):
    meilleur = dico[annee][0]
    for temps in dico[annee]:
        if temps < meilleur:
            meilleur = temps
    return meilleur

Le meilleur temps est le plus petit. Initialiser avec le premier résultat, plutôt qu’avec zéro, garantit une valeur de référence réellement présente. À chaque itération, meilleur est le minimum des temps déjà parcourus. Pour 2024, la liste [1012,1010,1000,1036,1022,1098] donne 1000. La liste contient six catégories selon le contrat, donc son premier élément existe.

2. SH est le troisième élément de categories, donc son indice vaut 2. La boucle repère cet indice avant de consulter chaque liste annuelle.

Le troisième : « local variable 'i_cat' referenced before assignment ». Aucune comparaison n’a réussi, donc i_cat n’a jamais reçu de valeur ; sa lecture lors de la première année provoque une UnboundLocalError. La formulation exacte du message varie selon la version de Python, mais c’est cette erreur de variable locale non initialisée. Ce n’est ni une erreur d’indentation ni un dépassement d’indice de liste.

assert cat in categories, "Catégorie inconnue : " + cat

Le test interrompt immédiatement la fonction si le code n’appartient pas aux six catégories. Le message explique la faute plutôt que de laisser apparaître une erreur technique plus loin. Dans une application de production, une validation explicite avec exception contrôlée serait préférable car Python peut désactiver les assertions avec l’option -O ; ici l’assertion est précisément demandée.

1000.0 : la fonction calcule la moyenne des meilleurs temps SH enregistrés chaque année. Après ajout de 2026 : (900 + 1100 + 1000 + 1000 + 1000) / 5 = 1000. Avant cet ajout, les quatre premières valeurs avaient déjà la même moyenne. L’opérateur / renvoie un flottant en Python. Cette valeur n’est ni le record global SH (900) ni la moyenne de tous les coureurs, puisque le dictionnaire ne contient que les meilleurs temps annuels.

def records(dico):
    meilleurs = [24 * 60 * 60] * 6
    for annee in dico:
        for i in range(6):
            if dico[annee][i] < meilleurs[i]:
                meilleurs[i] = dico[annee][i]
    return meilleurs

Le plafond 86 400 secondes sert de sentinelle supérieure ou égale à tous les temps admis. Chaque catégorie possède son propre minimum, mis à jour pour chaque année. On obtient [998,1010,900,959,1002,980], y compris après ajout de 2026, qui ne bat aucun de ces records. Réinitialiser meilleurs à l’intérieur de la boucle annuelle ferait perdre les records des années précédentes.

Le dictionnaire doit contenir au moins une année pour que la notion de record soit définie. Sur un dictionnaire vide, ce code renvoie les sentinelles ; une version d’application devrait refuser ce cas ou représenter explicitement l’absence de record. On pourrait aussi initialiser à une copie de la première année lorsqu’elle est garantie, ce qui éviterait la sentinelle.