Bac NSI 2025 Polynésie jour 2

class Carte:
    def __init__(self, valeur):
        self.valeur = valeur
        self.TdB = self.calcul_TdB()

On stocke la valeur avant d’appeler le calcul, car la méthode en a besoin. calcul_TdB() renvoie le nombre de pénalités, que le constructeur affecte à l’attribut. Le sujet parle de « méthode de classe », mais l’interface décrite ici est une méthode d’instance utilisant self.

def calcul_TdB(self):
    total = 0
    if self.valeur % 11 == 0:
        total += 5
    if self.valeur % 10 == 0:
        total += 3
    if self.valeur % 10 == 5:
        total += 2
    if total == 0:
        total = 1
    return total

Les tests sont indépendants : 55 vérifie la divisibilité par 11 et la terminaison par 5, donc reçoit 5 + 2 = 7 pénalités. Une chaîne de elif ignorerait le second critère. La pénalité de base 1 n’est attribuée que si aucun critère n’a contribué, et ne s’ajoute pas aux autres.

def est_superieure_a(self, autre):
    return self.valeur > autre.valeur

On compare les attributs numériques, pas les objets eux-mêmes. Deux valeurs égales donnent faux puisque la comparaison est stricte. La méthode fournie difference(autre) renverra quant à elle la valeur absolue de leur différence.

class Paquet:
    def __init__(self, L):
        self.contenu = L

    def afficher(self):
        for carte in self.contenu:
            print(carte.valeur)

    def ajouter_carte(self, carte):
        self.contenu.append(carte)

Le paquet contient des objets Carte, donc on affiche leur attribut valeur. append ajoute l’objet carte en fin de liste ; il ne faut pas ajouter seulement sa valeur, sinon le paquet mélangerait objets et entiers.

def nombre_TdB(self):
    total = 0
    for carte in self.contenu:
        total += carte.TdB
    return total

On additionne les pénalités déjà calculées sur les objets Carte. Le retour reste après la boucle. Pour un paquet vide, le total est 0 ; pour les cartes 5, 10 et 55, il vaut 2 + 3 + 7 = 12.

def distribuer(self, nbr):
    paquets = [Paquet([]) for _ in range(nbr)]
    for tour in range(10):
        for joueur in range(nbr):
            carte = self.contenu.pop(0)
            paquets[joueur].ajouter_carte(carte)
    return paquets

La boucle extérieure fait les dix tours et l’intérieure sert successivement tous les joueurs. pop(0) enlève la première carte du paquet source. Avec deux joueurs et un paquet initial ordonné, le premier reçoit 1, 3, 5…19, et le second 2, 4, 6…20.

La compréhension crée un objet Paquet différent pour chaque joueur. [Paquet([])] * nbr serait incorrect : tous les joueurs partageraient le même paquet. La fonction suppose, comme la distribution du jeu, au moins 10 * nbr cartes disponibles ; un vrai service peut vérifier cette précondition avant de commencer.

J1 = Joueur('Joueur 1', L[0])

L[0] est déjà un Paquet : on le transmet directement. La chaîne « Joueur 1 » est le nom affichable, tandis que J1 est le nom de la variable Python.

from random import *
jeu = [Carte(i) for i in range(1, 105)]
shuffle(jeu)
jeu_initial = Paquet(jeu)
distri = jeu_initial.distribuer(2)
Ordi = Joueur("Ordi", distri[0])
J1 = Joueur("J1", distri[1])

La borne 105 est exclue, donc les 104 valeurs de 1 à 104 sont créées. shuffle mélange la liste en place ; on ne doit pas affecter son retour, qui vaut None. Après distribution, 20 cartes ont quitté le paquet source, où il en reste 84.

SELECT nom
FROM champignon
WHERE lamelle = 'oui' AND couleur = 'orange';

Les deux conditions sont nécessaires simultanément. On conserve la casse des valeurs de l’extrait : oui est une chaîne et non un booléen SQL.

SELECT nom
FROM champignon
WHERE pied_min = 0 AND pied_max = 0
AND chapeau_min <= 15 AND chapeau_max >= 15;

Une dimension mesurée doit appartenir à l’intervalle stocké : on ne cherche pas seulement un maximum ou un minimum égal à 15. « Sans pied » est ici représenté par un intervalle de longueur nulle 0 à 0. Dans l’extrait, le champignon noir est sans pied, mais son chapeau ne dépasse pas 10 cm : aucune des cinq lignes ne satisfait l’ensemble.

id_ordre est la clé étrangère. Par exemple, la valeur 4 d’une ligne de champignon renvoie à l’ordre amanitales.

SELECT champignon.nom
FROM champignon JOIN ordre ON champignon.id_ordre = ordre.id
WHERE ordre.classe = 'agaricomycètes';

La classe appartient à la table ordre, tandis que le nom recherché appartient à champignon. La jointure suit l’identifiant d’ordre ; on qualifie le nom de champignon pour éviter l’ambiguïté avec ordre.nom.

INSERT INTO champignon
(id, nom, id_ordre, lamelle, couleur, chapeau_min, chapeau_max, pied_min, pied_max)
VALUES (56, 'amanite solitaire', 4, 'oui', 'blanc', 6, 20, 4, 10);

On utilise l’identifiant 4 de l’ordre amanitales, et non son nom dans la colonne étrangère. Nommer les colonnes explicite l’ordre des valeurs et évite d’inverser les bornes du chapeau et du pied.

champignon(id, nom, #id_ordre, lamelle, couleur, chapeau_min, chapeau_max, pied_min, pied_max, #id_toxicite)

ordre(id, nom, classe)

toxicite(id_tox, type, effets)

id_ordre référence ordre.id et id_toxicite référence toxicite.id_tox. Une clé étrangère n’est pas automatiquement unique : plusieurs champignons peuvent partager la même toxicité ou le même ordre.

UPDATE champignon
SET id_toxicite = 1
WHERE nom = 'amanite citrine';

La valeur 1 référence la catégorie demandée dans la table toxicite. On modifie la référence de cette ligne, pas le libellé de toute la catégorie. Cette instruction applique la donnée de l’exercice ; elle ne constitue pas une affirmation validée de toxicologie.

SELECT champignon.nom
FROM champignon
JOIN ordre ON champignon.id_ordre = ordre.id
JOIN toxicite ON champignon.id_toxicite = toxicite.id_tox
WHERE ordre.nom = 'amanitales' AND toxicite.type = 'très toxique';

Les deux jointures rendent les libellés disponibles. Le filtre exige à la fois l’ordre et la toxicité ; on ne remplace pas leurs noms par des identifiants supposés constants lorsque le schéma permet de les chercher.

for e in liste_champi:
    if e.saison == 'été':
        print(e.nom)

Chaque élément est un objet, donc ses champs s’accèdent avec le point. La comparaison porte sur la saison, tandis que l’affichage porte sur le nom.

La valeur de c.cuisson est '12 minutes à feu moyen', pas exactement 'feu moyen'. L’égalité compare les chaînes entières et donne donc faux, même si la seconde est incluse dans la première.

Le fragment imprimé utilise aussi return hors de toute fonction : copié seul au niveau du module, il provoque une erreur de syntaxe. L’explication de la comparaison suppose qu’il était placé dans une fonction, comme le laisse entendre le commentaire du sujet.

for c in liste_champi:
    if c.nom == 'Lactaire délicieux':
        print(recherche_textuelle(c.cuisson, 'feu moyen'))

La cuisson complète est le texte à parcourir ; « feu moyen » est l’expression recherchée. Cette version de script affiche le booléen. Si l’on place le fragment dans une fonction, on peut retourner ce même appel au lieu de l’afficher.

Une pile suit le principe LIFO, dernier entré, premier sorti. Empiler ajoute au sommet ; dépiler retire et renvoie le sommet. Si on empile A puis B puis C, on dépile C, puis B, puis A : cette inversion d’ordre servira à reconstruire le chemin.

Une file suit FIFO, premier entré, premier sorti. Enfiler ajoute en queue ; défiler retire la tête. A, B et C enfilés dans cet ordre ressortent A, B, C. Cela permet au parcours en largeur d’explorer les sommets dans l’ordre de leur découverte.

Le remplacement de lettre est réversible : si A peut devenir B en un changement, B peut devenir A en rétablissant la lettre. Le voisinage est donc symétrique ; une arête sans orientation décrit cette relation.

Il comporte les quatre arêtes gars-mars, mars-mors, mors-ours et ours-purs. Toute autre paire exige au moins deux changements, donc n’a pas d’arête directe. Un graphe doit conserver aussi les sommets, pas seulement une liste de transitions.

def chaine_vers_tab(mot):
    tab_lettres = []
    for lettre in mot:
        tab_lettres.append(lettre)
    return tab_lettres

La boucle conserve les caractères dans leur ordre initial et leurs répétitions. Pour ours, on obtient ['o', 'u', 'r', 's']. Même si le calcul de distance ignore ensuite l’ordre, il doit encore conserver le nombre d’occurrences de chaque lettre.

def distance(mot1, mot2):
    tab = chaine_vers_tab(mot1)
    for lettre in mot2:
        if lettre in tab:
            tab.remove(lettre)
    return len(tab)

La liste commence avec toutes les occurrences des lettres du premier mot. Chaque lettre du second retire au plus une occurrence identique encore disponible. Après ce couplage, les lettres restantes du premier mot n’ont pas d’équivalent : il faut les remplacer. Comme les mots ont la même longueur, le nombre de lettres manquantes de l’autre côté est identique.

Pour grue et ours, on apparie r et u ; g et e restent, donc la distance vaut 2. Avec des répétitions, remove ne retire qu’une occurrence, ce qui est essentiel. Un ensemble de lettres donnerait des réponses fausses. Deux anagrammes ont ici une distance 0, même si leurs positions diffèrent.

def renvoie_voisins(mot):
    tab_voisins = []
    for voisin_possible in TAB_MOTS:
        if distance(mot, voisin_possible) == 1:
            tab_voisins.append(voisin_possible)
    return tab_voisins

On teste chaque candidat avec la distance égale à 1. Une distance 0 n’est pas admise : le mot lui-même, ainsi que ses anagrammes selon cette définition, ne sont pas voisins par un remplacement exactement. Le résultat est une nouvelle liste, dans l’ordre de TAB_MOTS.

Au tour 3, mars est déjà connu ; seul ours est découvert. Le tour 4 défile ours, puis traite quand même ses voisins avant de retester la condition de boucle : mors est connu et purs est ajouté. Le test suivant voit mot == mot_final et arrête la boucle.

{'mars': None, 'gars': 'mars', 'mors': 'mars',
 'ours': 'mors', 'purs': 'ours'}

La file conserve donc purs à la fin. Le dictionnaire contient des sommets explorés qui ne sont pas sur le chemin final, comme gars et purs. Il ne faut pas le confondre avec la seule liste mars-mors-ours.

def renvoie_pile(parent, mot_final):
    ma_pile = Pile()
    mot = mot_final
    while mot is not None:
        ma_pile.empiler(mot)
        mot = parent[mot]
    return ma_pile

On remonte le parent de chaque mot jusqu’à None, qui marque le prédécesseur du départ. Pour ours, on empile ours, puis mors, puis mars. Ne pas arrêter avant d’empiler le départ : il doit figurer dans le chemin.

def construit_chemin(ma_pile):
    tab = []
    while not ma_pile.est_vide():
        mot = ma_pile.depiler()
        tab.append(mot)
    return tab

Le sommet est le départ. Dépiler fournit donc mars, mors, ours et remet la chaîne de parents dans l’ordre du trajet. La pile est consommée par cette fonction ; le tableau obtenu garde les mots.

def chercher_chemin(mot_depart, mot_final):
    parent = dic_parent(mot_depart, mot_final)
    ma_pile = renvoie_pile(parent, mot_final)
    return construit_chemin(ma_pile)

Chaque fonction a une responsabilité : explorer, remonter les parents, remettre le chemin dans l’ordre. Le parcours en largeur découvre les sommets à distance croissante, donc le premier parent enregistré pour le but donne un plus court chemin dans ce graphe non pondéré.

Si départ et arrivée sont identiques, la pile contient ce seul mot et le résultat est une liste de longueur 1. Si aucun chemin n’existait, il faudrait tester la présence du but dans parent avant la reconstruction ; le sujet garantit son existence.