Bac blanc février 2026 - corrigé

EXERCICE 1

1.

def __init__(self, valeur:int):
    self.valeur = valeur
    self.TdB = 0

2.

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

    # si aucune des conditions
    if tdb == 0:
        tdb = 1
    self.Tdb = tdb

def est_superieure(self, autre:carte) -> bool:
    return self.valeur > autre.valeur

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

    def afficher(self):
        cartes = ""
        for carte in self.contu
            cartes += str(carte.valeur) + " "
        print cartes

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

def nombre_TdB(self)-> int:
    return sum([carte.TdB for carte in self.contenu])

def distribuer(self, nbr: int):
    distri = [ Paquet([]) for _ in range(nbr) ]
    for _ in range(10):
        for joueur in range(nbr):
            carte_tiree = self.contenu.pop()
            distri[joueur].ajouter_carte(carte_tiree)
    return distri

7.

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

from random import *
# créer les 104 cartes du jeu initial grâce à une liste par compréhension
jeu = [Carte(i) for i in range (1, 105)]
# mélanger cette liste de cartes
shuffle(jeu)
# instancier le paquet de cartes avec cette liste de cartes
jeu_initial = Paquet(jeu)
# distribuer 10 cartes aux deux joueurs que l'on intancie en les nommant `J1` et `Ordi`
distri = jeu_initial.distribuer(2)
Ordi = Joueur("Ordi", distri[0])
J1 = Joueur("J1", distri[1])

EXERCICE 2

1.

SELECT nom
FROM champignon
WHERE lamelle = 'oui' and couleur = 'orange'

2.

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

id_ordre est une clé étrangère de champignon qui fait référence à la clé primaire de ordre : id.

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

INSERT INTO champignon
VALUES
(56, 'amanite solitaire', 4,'oui','blanc', 6, 20, 4, 10)

6.

Voici le schéma relationnel de la base de données:

champignon(id INTEGER, nom VARCHAR(50), #id_ordre INTEGER, lamelle CHAR(3), couleur VARCHAR(20), chapeau_min INTEGER, chapeau_max INTEGER, pied_min INTEGER, pied_max INTEGER, #id_toxicite INTEGER)

ordre(id INTEGER, nom VARCHAR(50), classe VARCHAR(50))

toxicite(id_tox INTEGER, type VARCHAR(50), effet VARCHAR(255))

7.

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

8.

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

9.

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

10.

Pour que l'expression ch1 == ch2 soit évaluée à True, il faut que les deux chaînes de caractères contiennent le même nombre de caractères, tous identiques. "12 minutes à feu moyen" == "feu moyen" est donc faux.

11.

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

EXERCICE 3

Partie A

1. Une pile est un type abstrait avec les primitives : empiler, depiler et est_vide. Le principe d'entrée et de sortie des éléments de la pile est LIFO (Last In, First Out).

2. Une file est aussi un type abstrait avec les primitives : enfiler, defiler et est_vide. Le principe d'entrée et de sortie des éléments de la file est FIFO (First In, First Out).

3. La relation "être voisin" est symétrique. En effet, si on ne change qu'une lettre pour passer du mot1 ou mot2, alors on ne change qu'une lettre pour passer du mot2 au mot1. Un graphe non orienté modélise cette situation.

Voici le graphe avec les mots gars, mars, mors, ours, purs.

graph LR
    gars --- mars
    mars --- mors
    mors --- ours
    ours --- purs

Partie B

5.

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

La ligne 3 parcourt toutes les lettres de mot2. La ligne 4 teste si cette lettre est présente dans la liste des lettres de mot1 : tab. Si c'est le cas, on retire la première occurrence avec remove. À la fin des itérations toute lettre de mot2 que l'on peut associer à une lettre de mot1 aura été retirée de tab. Les lettres qui restent dans tab correspondent alors à celles qu'il faut modifier pour passer de mot2 à mot1, c'est bien la distance entre mot1 et mot2.

7.

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

Partie C

8.

Troisième tour de la boucle

• on défile 'mors'.
• Les voisins de 'mors' sont 'mars' et 'ours'. 'mars' est déjà dans parent. Seul 'ours' est ajouté :
• parent={'mars' : None,'gars':'mars,'mors':'mars', 'ours':'mors'}
• 'ours' est ajouté à file_voisins : file_voisins = ['ours']

Quatrième tour de la boucle

• on défile 'ours'.
• Les voisins de 'ours' sont 'mors' et 'purs', 'mors' est déjà dans parent
• parent = {'mars' : None, 'gars ': 'mars', 'mors ' : 'mars', 'ours':'mors', 'purs': 'ours'}
• 'purs' est ajouté à file_voisins : file_voisins = ['purs']

Cinquième tour de la boucle

• la variable mot est 'ours' qui est le mot final. La boucle s'arrête et renvoie parent.

9.

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

10.

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

11.

Il suffit d'assembler les fonctions des questions précédentes :

def chercher_chemin(mot1, mot2):
    parent = dic_parent(mot1, mot2)
    ma_pile = renvoie_pile(parent, mot2)
    return construit_chemin(ma_pile)