Bac NSI 2026 centres étrangers groupe 1 jour 1

70 + 104 + 90 + 190 = 454 points. Les courses récompensent un temps plus court, tandis que les lancers et sauts récompensent une distance plus grande. La formule est celle du problème, pas un barème officiel d’athlétisme.

def nb_points(epreuve, valeur):
    points = 0
    if epreuve == "100m":
        points = (20 - valeur) * 10
    elif epreuve == "longueur":
        points = valeur * 20
    elif epreuve == "poids":
        points = valeur * 10
    elif epreuve == "1500m":
        points = 500 - valeur
    return points

Chaque étiquette sélectionne sa formule. Le return final commun renvoie les points calculés. Avec le squelette donné, une étiquette inconnue renverrait 0 ; une validation explicite serait une extension possible, mais les quatre épreuves sont ici garanties.

performances = athlete["performances"]
# Dans la boucle :
valeur = performances[epreuve]
total += nb_points(epreuve, valeur)

Le dictionnaire externe stocke nom, performances et score ; performances est lui-même un dictionnaire indexé par épreuve. La fonction appelle nb_points pour chaque paire épreuve/valeur puis écrit le total dans athlete["score"]. Elle modifie l’objet reçu et ne renvoie pas le score. Il faut calculer tous les scores avant de trier les athlètes.

if l[j]["score"] > l[max_index]["score"]:

max_index désigne le meilleur score trouvé dans la zone non triée. On compare la clé score de deux dictionnaires, pas les dictionnaires eux-mêmes. Après la boucle interne, cet athlète est échangé avec la position i, qui devient définitive.

Tri par sélection : à chaque position, on sélectionne le maximum parmi les éléments restants puis on le place. On n’insère pas progressivement l’élément courant parmi ses prédécesseurs, comme le ferait le tri par insertion.

(n-1)+(n-2)+…+1+0 = n(n-1)/2. La première boucle interne compare n-1 candidats, la suivante n-2, etc. Le nombre ne dépend pas de l’ordre initial des scores : même une liste déjà triée subit ces comparaisons. Le coût est donc quadratique, Θ(n²), pour cette mesure.

alex = Athlete("Alex", 13.0, 5.2, 9.0, 310.0)

L’ordre des arguments est nom, 100 m, longueur, poids, 1500 m. Le constructeur calculera son score par la méthode, donc on ne fournit pas 454 comme argument supplémentaire.

def calculer_score(self):
    return ((20 - self.m100) * 10
            + self.longueur * 20
            + self.poids * 10
            + (500 - self.m1500))

La méthode renvoie un résultat pour l’affectation self.score du constructeur. Elle lit les performances déjà initialisées ; elle ne doit pas lire self.score avant sa création. Si les performances changent plus tard, il faudra recalculer ce score stocké pour que le classement reste cohérent.

Martin 354
├─ gauche : Lena 351
│  ├─ gauche : Rayan 350
│  └─ droite : Ninon 351
└─ droite : Yanis 355
   └─ droite : Ana 356

Les scores strictement plus petits vont à gauche ; les scores égaux ou plus grands vont à droite. Ninon 351 passe donc à gauche de Martin puis à droite de Lena. Les noms ne départagent pas l’égalité : seule la règle sur le score décide.

def inserer(self, athlete):
    if athlete.score < self.valeur.score:
        if self.gauche is None:
            self.gauche = Noeud(athlete)
        else:
            self.gauche.inserer(athlete)
    else:
        if self.droite is None:
            self.droite = Noeud(athlete)
        else:
            self.droite.inserer(athlete)

Le choix de branche est effectué à chaque nœud rencontré. Dès qu’un enfant manque, le nouvel athlète est enveloppé dans un Noeud et rattaché à l’arbre. Sinon, l’appel récursif descend dans le sous-arbre choisi. La branche else inclut l’égalité de scores et applique donc la convention du sujet.

C’est un parcours en profondeur infixe inversé : droite, nœud, gauche. Les scores les plus grands du sous-arbre droit sont ajoutés avant le score courant, puis les plus petits du gauche. Pour l’arbre précédent : Ana, Yanis, Martin, Ninon, Lena, Rayan, scores 356,355,354,351,351,350. Ninon précède Lena à score égal du fait de sa position à droite ; ce parcours n’assure donc pas la stabilité chronologique des ex æquo.

La liste classement est créée seulement lors de l’appel initial où le paramètre vaut None, puis partagée par les sous-appels. Ils y ajoutent leurs noms sans recréer de liste vide. Chaque nœud est visité une seule fois.

Si l’ABR reste équilibré, chaque insertion coûte O(log n), mais cette propriété n’est pas garantie par le code. La comparaison dépend aussi du tri choisi : un tri fusion sur liste peut donner O(n log n) sans arbre. Il faut comparer les algorithmes précis du sujet plutôt que déclarer les objets intrinsèquement plus rapides.

CODE : C est ligne 6 colonne 2, O ligne 3 colonne 6, D ligne 3 colonne 5, E ligne 2 colonne 2. Inverser ligne et colonne donnerait un autre message.

L’ordre d’insertion est SECURITY1024ABDFGHJKLMNOPQVWXZ356789. La grille commence par SECURITY1024 puis les lettres et chiffres encore absents. B est en (3,2), A en (3,1) et C en (1,3), donc [(3,2),(3,1),(1,3)].

La même clé permet à l’émetteur et au destinataire de reconstruire la même grille, utilisée pour chiffrer et déchiffrer. Elle doit rester secrète pour les tiers. Ce procédé de substitution reste un exemple pédagogique : il conserve les répétitions de caractères et ne fournit pas une sécurité adaptée aux échanges modernes.

AXU7BCDEFGHIJKLMNOPQRSTVWYZ012345689

AXU7 est conservé en tête. On parcourt ensuite A à Z puis 0 à 9, en ignorant A,X,U,7 déjà présents. Chaque caractère autorisé apparaît exactement une fois, soit 36 caractères.

def grille_vide(n):
    return [["" for _ in range(n)] for _ in range(n)]

La compréhension externe crée des lignes distinctes. [[""]*n]*n partagerait la même liste entre toutes les lignes et la modification d’une case aurait plusieurs effets. Pour n=3, on obtient [["","",""],["","",""],["","",""]].

for i in range(6):
    for j in range(6):
        grille[i][j] = ordre_insertion[indice]
        indice += 1

Les deux boucles parcourent la grille ligne par ligne, comme la construction définie. indice prend les valeurs 0 à 35. La fonction suppose une clé valide, sans répétition ni caractère étranger à l’alphabet, condition nécessaire pour que generer_ordre produise bien 36 symboles uniques.

resultat = resultat + grille[t[0] - 1][t[1] - 1]

Les couples chiffrés vont de 1 à 6, mais les indices Python de 0 à 5. Il faut retirer 1 à chacune des deux composantes. Avec 2048ALGORITHMES, (4,4),(3,3),(2,4) donne NSI. Un simple -1 sur la ligne seulement laisserait la colonne décalée.

def generer_dico(cle):
    grille = generer_grille(cle)
    dico = {}
    for i in range(6):
        for j in range(6):
            dico[grille[i][j]] = (i + 1, j + 1)
    return dico

Cette fois on passe des indices internes aux coordonnées externes : on ajoute 1. La grille ne contenant aucun doublon, chaque caractère a une unique position. Le dictionnaire permet ensuite une recherche directe par caractère, au lieu de parcourir jusqu’à 36 cases pour chaque lettre du message.

def chiffrer(cle, message):
    dico = generer_dico(cle)
    resultat = []
    for caractere in message:
        resultat.append(dico[caractere])
    return resultat

On construit le dictionnaire une fois, puis on le réutilise pour chaque symbole. Le message est supposé composé de lettres majuscules et chiffres disponibles. Les espaces, accents et minuscules ne sont pas dans ce modèle ; il faudrait annoncer une règle de traitement plutôt que les supprimer silencieusement. Le message vide produit une liste vide.

Le chiffrement symétrique utilise le même secret partagé pour chiffrer et déchiffrer. Le chiffrement asymétrique utilise une paire de clés : une clé publique peut servir à chiffrer pour un destinataire, qui déchiffre avec sa clé privée. Ainsi Alice peut protéger la clé de Polybe avec la clé publique authentifiée de Bob ; lui seul possède la clé privée correspondante. L’identité associée à la clé publique doit être vérifiée pour éviter une substitution. Changer la clé de Polybe chaque jour ne transforme pas pour autant cette substitution simple en chiffrement moderne robuste.

assert 0.10 <= pourcentage_mines <= 0.30, "Le pourcentage de mines doit être compris entre 10% et 30%."

Le paramètre est une proportion : 15,6 % est représenté par 0.156, pas 15.6. Les deux bornes sont incluses. Une grille de dimensions invalides demanderait une autre validation, distincte de cette assertion.

self.hauteur = hauteur
self.largeur = largeur
self.pourcentage_mines = pourcentage_mines

self désigne l’instance créée. Les paramètres locaux sont conservés dans des attributs pour être réutilisés par les méthodes de génération et de voisinage.

demineur_intermediaire = Demineur(16, 16, 0.156)

La recommandation est une grille de 256 cases pour environ 40 mines, soit 15,6 %. Le code de placement donné atteint 40, car il incrémente jusqu’à atteindre ou dépasser 256×0.156 = 39.936. On peut aussi donner exactement 40/256 si l’on souhaite représenter le ratio exact.

def grille_demineur_vide(self):
    return [[0 for _ in range(self.largeur)]
            for _ in range(self.hauteur)]

La boucle interne construit une ligne de largeur cases ; l’externe répète cette création hauteur fois. Les lignes sont indépendantes. Le constructeur peut ensuite affecter self.grille_demineur = self.grille_demineur_vide().

colonne = randint(0, self.largeur - 1)
if self.grille_demineur[ligne][colonne] == 0:
    self.grille_demineur[ligne][colonne] = -1
    compteur_mines += 1

Les bornes de randint sont incluses, donc le dernier indice est largeur-1. Une case déjà minée ne doit pas incrémenter le compteur : cela compterait deux fois la même mine. On suppose une grille encore vide et que la méthode est appelée une seule fois avant le calcul des nombres.

La quantité nombre_bombes du squelette est un flottant. La condition compteur_mines < nombre_bombes provoque un arrondi à l’entier supérieur si le produit n’est pas entier. Pour une politique de nombre de mines explicite, on préférera calculer un entier avec round ou une autre convention annoncée avant la boucle. Cette nuance devient visible dans l’exemple de la question suivante.

def nombre_voisines_avec_mines(self, coordonnees_case):
    nombre = 0
    for ligne, colonne in self.voisines(coordonnees_case):
        if self.grille_demineur[ligne][colonne] == -1:
            nombre += 1
    return nombre

La méthode voisines fournit seulement les coordonnées valides du voisinage, en excluant la case centrale. On compte les -1 et non les valeurs positives déjà calculées. La somme des nombres des cases voisines ne donnerait pas le nombre de mines, et pourrait compter plusieurs fois une même mine.

def generer_demineur(self):
    self.placer_mines()
    for ligne in range(self.hauteur):
        for colonne in range(self.largeur):
            if self.grille_demineur[ligne][colonne] != -1:
                self.grille_demineur[ligne][colonne] = (
                    self.nombre_voisines_avec_mines((ligne, colonne)))

L’appel place les mines sur la grille initialement vide, puis toutes les cases libres sont annotées. Si les mines ont déjà été placées par le constructeur, cet appel initial doit être omis : il ne faut pas placer les mines deux fois. Les -1 restent intacts, donc le calcul des cases suivantes ne dépend pas des chiffres déjà écrits.

L’exemple imprimé utilise demineur(6,6,0.278) mais la classe s’appelle Demineur. Il montre dix mines, alors que le placement fourni ferait ceil(36×0.278)=11. Pour obtenir dix mines, utiliser le ratio exact 10/36 ou une règle d’arrondi explicite. De plus, certains nombres de voisinage affichés dans les figures sont incohérents ; un programme doit les recalculer à partir des mines, pas recopier ces chiffres comme attendus.

def visibilite(self, coordonnees_case):
    ligne, colonne = coordonnees_case
    if self.grille_visibilite[ligne][colonne]:
        return
    if self.grille_demineur[ligne][colonne] == -1:
        for i in range(self.hauteur):
            for j in range(self.largeur):
                self.grille_visibilite[i][j] = True
        return
    self.grille_visibilite[ligne][colonne] = True
    if self.grille_demineur[ligne][colonne] == 0:
        for voisine in self.voisines(coordonnees_case):
            self.visibilite(voisine)

On marque une case avant de visiter ses voisines, sinon les appels pourraient revenir indéfiniment sur le même zéro. Une case numérotée est révélée mais ne propage pas. Un zéro révèle sa composante de zéros et sa frontière de cases numérotées. Une mine cliquée révèle toute la grille comme demandé. Depuis un zéro correctement calculé, aucune voisine n’est une mine, donc la propagation ne déclenche pas de défaite.

Les figures 3 et 4 imprimées ne sont pas cohérentes avec leurs mines : en (1,3), la mine (2,4) impose le nombre 1, et non 0. Les cases (3,0),(3,1),(3,2) devraient valoir 2, non 1. Avec les mines réellement dessinées, cliquer (0,3) révèle les colonnes 1 à 5 des lignes 0 et 1, soit dix cases. La correction et l’atelier utilisent ces nombres recalculés ; ils ne prolongent pas la propagation à partir du faux zéro imprimé.

Meilleur_score.joueur référence Joueur.id_joueur ; Meilleur_score.niveau référence Demineur.niveau. Un meilleur score doit être associé à un compte et à un niveau existants.

SELECT niveau, score
FROM Meilleur_score
WHERE joueur = 2;

Ces deux lignes sont les meilleurs scores du joueur 2, Raptor. La requête ne fixe pas d’ordre ; si l’affichage doit reproduire exactement expert avant intermédiaire, on peut ajouter ORDER BY niveau. D’autres requêtes accidentellement équivalentes sur cet extrait ne décriraient pas aussi clairement le même besoin.

UPDATE Joueur
SET mot_de_passe = 'cGhhxDE4'
WHERE id_joueur = 4;

L’identifiant 4 cible Kirna sans modifier les autres comptes. Cette écriture répond au schéma simplifié du sujet ; un service réel ne stocke pas un mot de passe en clair mais une empreinte de mot de passe salée calculée par un mécanisme adapté.

Raptor a un score expert 1196 et un temps 366 : les trois conditions sont remplies. Kirna a bien plus de 1000 points mais son temps vaut exactement 400, exclu par le test strict. Les autres lignes ne sont pas expert.

INSERT INTO Demineur (niveau, dimension, "pourcentage mines")
SELECT 'débutant', dimension, "pourcentage mines"
FROM Demineur WHERE niveau = 'facile';

UPDATE Meilleur_score
SET niveau = 'débutant'
WHERE niveau = 'facile';

DELETE FROM Demineur WHERE niveau = 'facile';

Cette séquence préserve les références même avec des clés étrangères contrôlées immédiatement : créer d’abord le niveau cible, déplacer ensuite les scores, puis retirer l’ancien niveau. Deux UPDATE naïfs, parent puis enfants ou inversement, peuvent violer la contrainte intermédiaire si la mise à jour n’est pas en cascade ou différée. Les trois commandes doivent être exécutées ensemble dans une transaction.

Le tableau du sujet écrit « pourcentage mines » avec un espace. Les guillemets doubles ci-dessus citent cet identifiant SQL ; si le schéma implémenté utilise pourcentage_mines, il faut employer ce nom réel. La séquence suppose que débutant n’existe pas déjà. Avec une clé étrangère ON UPDATE CASCADE explicitement configurée, une mise à jour du niveau parent aurait aussi suffi, mais cette configuration n’est pas annoncée.