Corrigé NSI 2026 Amérique du Nord jour 2

En résumé : le sujet NSI corrigé

Le sujet officiel NSI 2026 Amérique du Nord jour 2 couvre plusieurs notions classiques du programme : états des processus, interblocage, ordonnancement, files, programmation orientée objet, arbres binaires, récursivité, SQL et dictionnaires. Cette page propose une correction lisible, avec les réponses attendues et les conseils qui permettent de viser une très bonne copie.

Exercice 1 — Processus, interblocage et Round Robin

Question 1 — États d’un processus

Création → Prêt
Prêt --élection--> Élu
Élu --préemption--> Prêt
Élu --blocage--> Bloqué
Bloqué --déblocage--> Prêt

À placer sur le schéma : gauche = prêt, droite = élu, bas = bloqué. Les flèches correspondent à l’élection, au blocage et au déblocage.

Question 2 — État des processus

• P1 : prêt.
• P2 : bloqué, car il attend la carte WIFI.
• P3 : élu, car il décode la musique.

Question 3 — Interblocage

P1 possède A et attend B
P2 possède B et attend A

Question 4 — Justifier l’interblocage

P1 demande MIC puis CAL, alors que P3 demande CAL puis MIC.

P1 obtient MIC
P3 obtient CAL
P1 attend CAL
P3 attend MIC

Les deux processus s’attendent mutuellement : il y a interblocage.

Question 5 — Intérêt de plusieurs processeurs

Plusieurs processus peuvent réellement s’exécuter simultanément. Les performances augmentent et le temps d’attente peut diminuer.

Question 6 — Système sur puce

• Avantage : faible consommation énergétique ou gain de place.
• Inconvénient : réparation difficile ou évolution matérielle limitée.

Question 7 — Ordonnancement Round Robin

0-2   : P1
2-4   : P2
4-6   : P1
6-8   : P3
8-10  : P2
10-12 : P4
12-14 : P1
14-16 : P3
16-17 : P4
17-18 : P3

La fin de l’exécution est donc à 18 ms.

Question 8 — Créer la file

fp = creer_file_vide()

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

Question 9 — execute_un_processus

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

Question 10 — execute_tous_processus

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

Exercice 2 — Tennis, POO et arbres binaires

Question 1 — Instancier Pegula

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

Question 2 — ajouter_victoire

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

Question 3

swiatek.ajouter_victoire(paloni)

Question 4 — Tri par insertion

O(n²)

Question 5 — Tri complet

Paloni : 4843
Gauff : 6063
Pegula : 6101
Swiatek : 7470
Sabalenka : 10541

0 : [swiatek, gauff, paloni, sabalenka, pegula]
1 : [gauff, swiatek, paloni, sabalenka, pegula]
2 : [gauff, paloni, swiatek, sabalenka, pegula]
3 : [paloni, gauff, swiatek, sabalenka, pegula]
4 : [paloni, gauff, swiatek, pegula, sabalenka]
5 : [paloni, gauff, pegula, swiatek, sabalenka]

Question 6 — resultat_match

def resultat_match(self, score):
    self.score = score
    nb_set_joueuse1 = 0
    nb_set_joueuse2 = 0
    for s1, s2 in score:
        if s1 > s2:
            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)

Question 7

Chaque match dépend de deux matchs précédents. Chaque nœud possède donc deux fils : c’est un arbre binaire.

Question 8 — Créer le tournoi

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

Question 9

tournoi.gauche.racine.joueuse1 = gauff

Question 10

Question 11 — mise_a_jour

6  if self.gauche.racine.gagnante is not None
7  self.racine.joueuse1
13 if self.droit.racine.gagnante is not None
14 self.racine.joueuse2
16 self.droit.mise_a_jour()

Exercice 3 — SQL et dictionnaires

Question 1 — Clé primaire

num_dossard est une clé primaire car chaque dossard est unique et identifie un seul coureur.

Questions 2 à 8 — Requêtes SQL

SELECT nom, prenom
FROM coureur
ORDER BY nom;

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

SELECT COUNT(*)
FROM coureur;

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

DELETE FROM coureur
WHERE num_dossard = 137;

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

SELECT num_dossard, nom, prenom, temps
FROM coureur
WHERE sexe = 'F'
AND annee < 1986
AND id_epreuve = 2
ORDER BY temps;

Question 9

dict_perf_5km[2025][2] vaut 1000.

Question 10

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

Question 11 — scratch

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

Questions 12 à 15

• i_cat vaut SH, position 2.
• Erreur : local variable 'i_cat' referenced before assignment.
• assert cat in categories, "Catégorie inconnue"
• mystere(dict_perf_5km, 'SH') renvoie 1000.

Question 16 — records

def records(dico):
    resultats = []
    for categorie in range(6):
        meilleur = 24 * 3600
        for annee in dico:
            if dico[annee][categorie] < meilleur:
                meilleur = dico[annee][categorie]
        resultats.append(meilleur)
    return resultats

Méthode bac : réussir ce sujet NSI jour 2

• Bien distinguer les états prêt, élu et bloqué.
• Pour l’interblocage, montrer une attente circulaire entre ressources.
• Pour Round Robin, avancer par tranches de quantum et remettre en file les processus non terminés.
• Pour la POO, ne pas oublier self et l’actualisation des attributs.
• Pour les arbres binaires, raisonner récursivement.
• Pour SQL, vérifier les champs, les conditions, les jointures et les tris.

Compléter ses révisions en NSI

FAQ — Corrigé NSI 2026 Amérique du Nord jour 2