Corrigé NSI 2026 Amérique du Nord jour 1

En résumé : le sujet NSI corrigé

Le sujet officiel NSI 2026 Amérique du Nord jour 1 couvre les grands piliers de la spécialité : programmation Python, structures de données, algorithmique, bases de données et réseaux. Le corrigé ci-dessous reprend l’essentiel des réponses attendues, avec des explications destinées à un élève qui prépare le baccalauréat.

Exercice 1 — POO, récursivité et Min-Max

Question 1 — Initialiser la grille

On doit créer une grille de 6 lignes et 7 colonnes remplie de zéros.

def __init__(self):
    self.grille = [[0 for j in range(7)] for i in range(6)]

Chaque case vide contient 0. La compréhension de liste permet de construire rapidement une grille complète.

Question 2 — Compléter la méthode joue

def joue(self, colonne, joueur):
    ligne = 5

    while ligne != -1 and self.grille[ligne][colonne] != 0:
        ligne = ligne - 1

    if ligne != -1:
        self.grille[ligne][colonne] = joueur
        return True
    else:
        return False

Question 3 — Créer la grille demandée

jeu1 = Grille()

jeu1.joue(2, 1)
jeu1.joue(3, 2)
jeu1.joue(3, 1)

Question 4 — Calcul du score

On additionne les valeurs des pions du joueur 2 et on soustrait celles du joueur 1. Le score attendu s’écrit donc :

score = valeur_case(5,3) - valeur_case(5,2) - valeur_case(4,3)

Question 5 — Méthode score

def score(self):
    s = 0

    for ligne in range(6):
        for colonne in range(7):
            if self.grille[ligne][colonne] == 1:
                s = s - valeur_case(ligne, colonne)
            elif self.grille[ligne][colonne] == 2:
                s = s + valeur_case(ligne, colonne)

    return s

Question 6 — Constructeur de Noeud

class Noeud:

    def __init__(self, colonne):
        self.colonne = colonne
        self.score = 0
        self.suivants = []

Question 7 — Méthode colonne_score_min

def colonne_score_min(self):
    meilleur = self.suivants[0]

    for noeud in self.suivants:
        if noeud.score < meilleur.score:
            meilleur = noeud

    return (meilleur.colonne, meilleur.score)

Question 8 — Principe de calcule_score

Le principe Min-Max repose sur une idée simple : le joueur 1 cherche à minimiser le score, tandis que le joueur 2 cherche à le maximiser.

Question 9 — Pourquoi niveau_max = 42 est irréaliste ?

Chaque coup peut produire jusqu’à 7 possibilités. Un arbre de profondeur 42 contiendrait environ 7^42 possibilités, ce qui est gigantesque. Le temps de calcul serait donc beaucoup trop long.

Question 10 — Fonction choisit_coup

def choisit_coup(grille, joueur):
    racine = Noeud(-1)

    racine.calcule_score(0, joueur, grille)

    if joueur == 1:
        return racine.colonne_score_min()[0]
    else:
        return racine.colonne_score_max()[0]

Exercice 2 — Réseaux, files et POO

1. Réseau Administration

Le réseau Administration est 10.42.0.80/29. Un réseau /29 contient 8 adresses, dont 6 utilisables.

• Adresse réseau : 10.42.0.80
• Adresse de diffusion : 10.42.0.87
• Adresses utilisables : 10.42.0.81 à 10.42.0.86

Une adresse possible pour le routeur E est donc 10.42.0.81.

2. Réseau de la machine 10.42.0.70

Le réseau Salle Gaming Online est 10.42.0.64/28. Il contient les adresses de 10.42.0.64 à 10.42.0.79. L’adresse 10.42.0.70 appartient donc à ce réseau.

3. Adresses des routeurs dans les réseaux /30

Un réseau /30 contient 4 adresses : réseau, deux adresses utilisables et diffusion.

• 10.42.0.16/30 : C = 10.42.0.17, F = 10.42.0.18
• 10.42.0.12/30 : C = 10.42.0.13, D = 10.42.0.14

4. Table RIP possible du routeur C

5. Coûts OSPF

Avec la formule coût = 10^10 / débit, on obtient : 10 Gb/s → 1 ; 1 Gb/s → 10 ; 100 Mb/s → 100.

6. Chemin OSPF de A vers Application

Le réseau Application est relié au routeur D. Le chemin A → B → C → D a un coût total de 12. Le chemin A → B → E → D a également un coût de 12. Ils sont donc préférables au chemin direct A → B → D, dont le coût est 101.

7. Encapsulation TCP/IP

Les données d’un segment TCP sont transportées dans un paquet IP : on dit que TCP est encapsulé dans IP.

8. File ou pile ?

Une file fonctionne en FIFO : le premier paquet arrivé est le premier transmis. Une pile fonctionne en LIFO : le dernier arrivé serait traité en premier. Pour un routeur, la file est donc plus adaptée et plus équitable.

9 et 10. Routeur_DROP_TAIL

class Routeur_DROP_TAIL:

    def __init__(self, t_max):
        self.f = cree_file()
        self.t_max = t_max
        self.t = 0

    def recoit(self, p):
        if self.t < self.t_max:
            enfile(self.f, p)
            self.t = self.t + 1
            return True
        return False

11. Routeur_ALEA

def recoit(self, p):
    if self.t < self.t_min:
        enfile(self.f, p)
        self.t = self.t + 1
        return True

    elif self.t_min <= self.t < self.t_max:
        if self.tirage_au_sort():
            enfile(self.f, p)
            self.t = self.t + 1
            return True
        return False

    return False

Exercice 3 — SQL, récursivité et programmation dynamique

Partie A — Bases de données SQL

Le numéro dans la rue n’est pas une clé primaire, car plusieurs immeubles peuvent avoir le même numéro dans des rues différentes. On utilise donc id_immeuble.

Requêtes SQL attendues

SELECT id_immeuble
FROM immeuble
WHERE rue_immeuble = 'la mer'
ORDER BY id_immeuble;

SELECT id_appart
FROM appartement
WHERE id_immeuble = 16
AND etage_appart >= 5;

INSERT INTO immeuble
(id_immeuble, nb_etage_immeuble, numero_immeuble, rue_immeuble)
VALUES
(140, 6, 13, 'Turing');

UPDATE appartement
SET prix_appart = 2 * prix_appart
WHERE id_appart = 603;

SELECT MAX(prix_appart)
FROM appartement
JOIN immeuble
ON appartement.id_immeuble = immeuble.id_immeuble
WHERE rue_immeuble = 'la mer';

Partie B — Plus longue sous-séquence strictement croissante

Pour L2 = [3, 1, 8, 2, 5], la plus longue sous-séquence strictement croissante est [1, 2, 5], de longueur 3.

Fonction est_strict_croissante

def est_strict_croissante(seq):
    for i in range(len(seq) - 1):
        if seq[i] >= seq[i + 1]:
            return False
    return True

Fonction récursive llsc_fin

def llsc_fin(tab, i):
    if i == 0:
        return 1

    max_len = 1

    for j in range(i):
        if tab[j] < tab[i]:
            max_len = max(max_len, llsc_fin(tab, j) + 1)

    return max_len

Programmation dynamique llsc_dyn

def llsc_dyn(tab):
    n = len(tab)
    dyn = [1] * n

    for i in range(1, n):
        for j in range(i):
            if tab[j] < tab[i]:
                dyn[i] = max(dyn[i], dyn[j] + 1)

    return max(dyn)

Méthode bac : réussir ce sujet NSI

• Écrire du code Python lisible, correctement indenté et conforme aux noms donnés dans le sujet.
• Justifier les calculs CIDR : nombre d’adresses, adresse réseau, diffusion, adresses utilisables.
• Distinguer clairement RIP, qui minimise le nombre de sauts, et OSPF, qui minimise un coût lié au débit.
• Pour SQL, vérifier la table concernée, les clés primaires, les clés étrangères et la nécessité d’une jointure.
• Pour la programmation dynamique, expliquer le rôle du tableau dyn et l’intérêt de mémoriser les résultats intermédiaires.

Compléter ses révisions en NSI

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