Bac NSI 2026 Amérique du Nord jour 1

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

Chaque itération externe crée une nouvelle ligne. Ne pas écrire [[0]*7]*6 : les six entrées référenceraient alors la même liste et jouer un pion modifierait simultanément plusieurs lignes. La compréhension crée six objets distincts, ce qui est nécessaire pour représenter des cases indépendantes.

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

On part du bas et remonte les cases occupées. Le test ligne != -1 doit être évalué avant l’accès : Python court-circuite AND, donc on ne lit pas accidentellement la dernière ligne via l’indice -1 lorsque la colonne est pleine. L’échec ne modifie aucune case. Les paramètres sont supposés valides : colonne de 0 à 6 et joueur 1 ou 2.

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

Le joueur 1 remplit d’abord la case (5,2). Le joueur 2 joue en (5,3), puis le pion suivant du joueur 1 tombe en (4,3), car le bas de la colonne 3 est déjà occupé. L’ordre de ces trois appels respecte l’alternance des joueurs et la gravité.

Score = valeur_case(5,3) - valeur_case(5,2) - valeur_case(4,3) = 7 - 5 - 10 = -8. Les pions du joueur 2 contribuent positivement, ceux du joueur 1 négativement. Les valeurs des cases ne dépendent que de leur position géométrique, pas des pions qui bloquent effectivement des alignements : c’est une heuristique de position, pas un compte de victoires déjà réalisables.

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

Les cases vides n’ajoutent rien. Deux boucles visitent les 42 cases, et l’accumulateur ne change pas la grille. Une grille vide a score 0 ; intervertir partout les joueurs inverse le signe du score. Cette propriété fournit un test utile et explique pourquoi un joueur minimise tandis que l’autre maximise.

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

Une liste propre à chaque instance recueille ses coups suivants. La racine utilise la colonne -1, car elle représente la position avant choix et pas un coup réellement joué. Les nœuds enfants stockent les colonnes de 0 à 6 correspondant aux coups autorisés.

def colonne_score_min(self):
    meilleur = self.suivants[0]
    for fils in self.suivants:
        if fils.score < meilleur.score:
            meilleur = fils
    return (meilleur.colonne, meilleur.score)

L’initialisation se fait avec un vrai fils, pas avec un score arbitraire comme 0 qui pourrait être inférieur à tous les scores. Avec un test strict, le premier fils minimal est conservé en cas d’égalité, ce qui respecte « un des fils ». Le couple doit contenir sa colonne réelle, pas son indice dans suivants : des colonnes pleines peuvent manquer dans cette liste.

Convention nécessaire : le squelette joue avec joueur pour créer les enfants. Dans la version cohérente ci-dessous, ce paramètre désigne donc le joueur dont c’est le tour dans la grille reçue, et non celui qui vient de jouer comme l’affirme une phrase de la question. Le joueur alterne avec 3-joueur dans les sous-appels. Cette convention rend compatibles le choix min/max et les coups générés.

def calcule_score(self, niveau, joueur, grille):
    g = grille.gagnant()
    if g == 1:
        self.score = -(100 + 10 * (niveau_max - niveau))
    elif g == 2:
        self.score = 100 + 10 * (niveau_max - niveau)
    elif niveau == niveau_max:
        self.score = grille.score()
    else:
        for colonne in range(7):
            grille2 = grille.copie_grille()
            if grille2.joue(colonne, joueur):
                nouveau_noeud = Noeud(colonne)
                self.suivants.append(nouveau_noeud)
                nouveau_noeud.calcule_score(niveau + 1, 3 - joueur, grille2)
        if not self.suivants:
            self.score = 0  # grille pleine sans gagnant : nul
        elif joueur == 1:
            self.score = self.colonne_score_min()[1]
        else:
            self.score = self.colonne_score_max()[1]

On teste une victoire avant la limite de profondeur pour lui donner sa valeur terminale. Pour chaque colonne, une copie indépendante protège la grille du parent : les branches doivent partir de la même position. Seuls les coups légaux créent un enfant. Le score de l’enfant est calculé avant de sélectionner le minimum ou maximum. Le couple renvoyé par colonne_score_min/max fournit le score à l’indice 1.

Le squelette ne traite pas la grille pleine sans gagnant. La branche ajoutée if not self.suivants attribue 0 à cette partie nulle et évite de demander un minimum sur une liste vide. On suppose un nouvel arbre à chaque décision ; réutiliser les mêmes nœuds nécessiterait aussi de vider leurs anciens enfants. Une autre convention « joueur précédent » est possible, mais elle impose de changer la ligne qui joue et le choix du min/max de façon cohérente.

Chaque niveau possède jusqu’à sept choix. Le nombre de nœuds peut donc croître comme 1 + 7 + 7² + … + 7⁴², dont le dernier terme dépasse 10³⁵. Les colonnes pleines et les victoires réduisent le nombre réel de branches, mais l’espace à explorer reste immense. Chaque nœud demande aussi une copie de grille et un calcul. Une profondeur limitée avec heuristique est donc nécessaire pour une réponse rapide ; l’élagage alpha-bêta est une amélioration possible sans changer le résultat d’une profondeur donnée.

def choisit_coup(grille, joueur):
    racine = Noeud(-1)
    racine.calcule_score(0, joueur, grille)
    if not racine.suivants:
        return -1  # aucun coup : partie terminée ou profondeur nulle
    if joueur == 1:
        return racine.colonne_score_min()[0]
    return racine.colonne_score_max()[0]

L’arbre commence à la position courante au niveau 0, en passant le joueur qui doit agir selon la convention de la correction précédente. On choisit ensuite la colonne de l’enfant optimal, à l’indice 0 du couple. La fonction ne joue pas le coup : elle recommande une colonne. On suppose normalement une partie non terminée et niveau_max ≥ 1 ; -1 exprime explicitement l’absence de coup dans les autres cas.

6 adresses utilisables : un /29 laisse trois bits, donc 2³ - 2 = 6. Le bloc va de 10.42.0.80 à .87 ; les hôtes vont de 10.42.0.81 à 10.42.0.86. E peut recevoir par exemple 10.42.0.81. Les .80 et .87 sont réservées.

Gaming Online : son réseau 10.42.0.64/28 couvre les adresses .64 à .79, avec des hôtes .65 à .78. .70 appartient à cet intervalle. L’adresse ne permet pas à elle seule d’identifier une personne.

Un /30 contient quatre adresses : réseau, deux hôtes, diffusion. C reçoit la première adresse hôte puisqu’il précède F comme D dans l’alphabet. Les routeurs ont plusieurs interfaces, donc C possède bien deux adresses distinctes selon le lien.

La table reprend les mêmes destinations de service que celle de B. La route vers l’Administration a deux choix ex æquo, via B-E ou D-E. Le prochain saut est toujours une interface directement reliée à C. Le routeur ne remplace pas la passerelle par l’adresse de la destination finale.

Chaque division du débit par dix multiplie le coût par dix. La métrique est sans unité dans ce modèle.

A → B → C → D, de coût 1 + 10 + 1 = 12, ou A → B → E → D, de même coût 12. Le lien direct B-D coûte 100 à lui seul : A-B-D coûterait 101. Ces deux routes ex æquo sont toutes deux optimales ; il n’y a pas de raison de refuser l’une des deux.

Le segment TCP est encapsulé dans le paquet IP, qui le transporte comme charge utile. Le segment TCP contient à son tour les données applicatives et son propre en-tête. Ce n’est pas le paquet IP qui est à l’intérieur d’un segment TCP.

Une file applique FIFO : le premier paquet arrivé attend le moins et est transmis avant les suivants. Cela conserve l’ordre d’arrivée au niveau de cette file et évite qu’un ancien paquet reste toujours derrière les nouveaux. Une pile LIFO favoriserait les derniers reçus et pourrait retarder indéfiniment les plus anciens si les arrivées continuent. Cela ne signifie pas que tout le réseau garantit un ordre de livraison de bout en bout.

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

La file est vide, donc sa taille courante vaut 0. La capacité maximale est reçue en paramètre et conservée. L’invariant à maintenir ensuite est self.t égal au nombre de paquets réellement dans self.f. Le compteur doit donc augmenter à chaque enfile et diminuer à chaque transmission avec defile.

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

L’inégalité est stricte : avec t = t_max - 1, le dernier emplacement est accepté et le compteur devient t_max. À t = t_max, le paquet est refusé et rien ne change, ni la file ni son compteur. Renvoyer True sans enfiler ou augmenter t lors d’un refus romprait le lien entre état logique et contenu.

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

Sous t_min, l’acceptation est systématique. Entre les deux seuils, True au tirage signifie accepter dans le squelette donné ; False signifie refuser. À partir de t_max, aucun tirage ne doit pouvoir accepter un paquet. Le return False final couvre le tirage défavorable et la saturation. Les égalités sont importantes : t = t_min appartient à la zone aléatoire et t = t_max à la zone refusée.

Le sujet ne donne pas la loi du tirage ; on ne peut donc pas annoncer une probabilité numérique de refus. La méthode illustre une réaction avant saturation afin d’éviter que tous les émetteurs TCP ralentissent simultanément après une perte massive.

Le même numéro existe dans plusieurs rues : un numéro 13 rue Turing et un numéro 13 rue de la mer sont deux immeubles distincts. Le numéro seul ne garantit donc pas l’unicité. id_immeuble fournit un identifiant indépendant de l’adresse.

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

Le tri demandé porte sur l’identifiant, pas sur le numéro dans la rue ni sur la hauteur. ASC est facultatif car c’est l’ordre par défaut, mais rend le choix explicite.

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

Les deux contraintes doivent être satisfaites simultanément. « Au moins » inclut le cinquième étage. La table appartement contient déjà toutes les informations nécessaires, donc une jointure n’est pas requise.

Des appartements peuvent encore référencer l’immeuble 16. Les supprimer de la table parent sans traiter ces références laisserait des clés étrangères orphelines. Un SGBD qui contrôle cette contrainte refuse normalement l’opération, sauf cascade explicitement configurée. Pour effacer les données d’un immeuble détruit, il faut traiter d’abord les appartements associés puis l’immeuble, dans une transaction si possible.

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

L’ordre explicite des colonnes évite de confondre identifiant 140 et numéro de rue 13. La clé 140 est supposée disponible pour cette nouvelle construction.

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

La nouvelle valeur dépend de l’ancienne, qu’il n’est pas nécessaire de connaître dans le code de la requête. La condition cible un seul appartement ; elle ne modifie pas les autres prix de l’immeuble.

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

Le prix appartient à appartement, la rue à immeuble. La jointure sélectionne les bonnes lignes avant MAX. La requête renvoie un prix unique, pas l’identifiant de l’appartement qui l’atteint ; plusieurs appartements peuvent avoir ce même prix. S’il n’y a aucun appartement correspondant, MAX renvoie NULL.

[3,8], [3,5], [1,8], [1,2], [1,5], [2,5]. Pour chaque premier élément, on cherche seulement à sa droite une valeur strictement plus grande. [2,8] n’est pas une sous-séquence, car 8 apparaît avant 2 ; [1,3] ne respecte pas non plus l’ordre original.

[1, 2, 5]

Elle a longueur 3. Les longueurs optimales terminant à chaque position sont [1,1,2,2,3]. Aucun élément ne permet de prolonger une chaîne jusqu’à 4 : 8 ne peut être suivi ni de 2 ni de 5, et le 3 initial ne peut pas précéder le 1 ou le 2 dans une suite croissante. Garder ces trois immeubles impose donc d’en retirer deux.

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

Une violation locale suffit : une égalité doit être refusée autant qu’une diminution. Si toutes les paires consécutives croissent, la transitivité garantit la croissance de toute la liste. Les listes vide ou d’un élément satisfont cette propriété sans comparaison. Placer return True dans la boucle arrêterait le contrôle après la première paire seulement.

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

La sous-séquence réduite à tab[i] justifie l’initialisation à 1. Chaque prédécesseur admissible j est placé avant i et porte une valeur plus petite ; on prolonge sa meilleure chaîne avec tab[i]. Le cas i=0 n’a aucun prédécesseur possible. La fonction globale prend le maximum sur toutes les positions finales : une meilleure chaîne ne se termine pas nécessairement au dernier élément. Le code fourni suppose tab non vide, car max([]) n’est pas défini.

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)

Les cases antérieures de dyn sont déjà terminées lorsque l’on calcule dyn[i]. Le maximum conserve la meilleure des chaînes qui peuvent précéder tab[i]. Pour L2, dyn devient [1,1,2,2,3]. On renvoie le maximum de toute la table, pas seulement dyn[-1]. Pour accepter aussi une liste vide, ajouter au début if not tab: return 0 ; cette extension évite max([]) sans changer les résultats demandés.

Chaque état dyn[i] est calculé une seule fois et conservé. Les deux boucles font n(n-1)/2 comparaisons, donc O(n²) temps et O(n) mémoire pour la table. La version récursive sans cache peut recalculer les mêmes états très souvent, jusqu’à un nombre exponentiel d’appels sur une liste croissante. L’itération évite aussi une pile d’appels de profondeur linéaire et sa limite dans Python. Ce sont deux avantages distincts : partage des calculs et absence de récursion.