Sujet du Bac Numérique et Sciences Informatiques 2025 · Polynésie Jour 2

Cet exercice porte sur la programmation orientée objet, l'algorithmique et la programmation en Python.

Marc souhaite coder le jeu de cartes « 6 qui prend » afin d'y jouer contre l'ordinateur ou en ligne avec ses amis. Il va réaliser le code en Python en utilisant la programmation orientée objet, sans se préoccuper de l'interface graphique.

Ce jeu est composé de 104 cartes numérotées de 1 à 104. Chacune possède une ou plusieurs « têtes de bœuf » (notée TdB) qui représentent des points de pénalité. Le but est d'avoir le moins de « têtes de bœuf » possible à la fin de la partie.

Partie A: La classe Carte

On commence par créer la classe Carte pour modéliser les 104 cartes.

Le constructeur de cette classe prend en paramètre une valeur (de type int) comprise entre 1 et 104 et l'affecte à l'attribut valeur (de type int).

On ajoute l'attribut TdB (de type int) qui contient le nombre de « têtes de bœuf » qui sera calculé à l'aide de la méthode de classe calcul_TdB (définie à la question suivante) qui n'a pas de paramètre.

1.

Écrire le code du constructeur de la classe Carte.

def __init__(self, valeur):

Chaque carte possède une ou plusieurs « têtes de bœuf ». Ce nombre est déterminé de la façon suivante:

si la valeur de la carte est divisible par 11 alors la carte reçoit 5 « têtes de bœuf »;

si la valeur de la carte se termine par 0 alors la carte reçoit 3 « têtes de bœuf »;

si la valeur de la carte se termine par 5 alors la carte reçoit 2 « têtes de bœuf »;

si la valeur de la carte ne remplit aucune de ces conditions alors elle ne reçoit qu'1 « tête de bœuf ».

Attention, ces règles se cumulent. Par exemple, 55 est divisible par 11 et se termine par 5 donc la carte 55 comporte 7 « têtes de bœuf ».

2.

Écrire le code de la méthode calcul_TdB de la classe Carte afin de calculer le nombre de « têtes de bœuf » pour une carte donnée.

def calcul_TdB(self):

On veut ajouter à la classe Carte une méthode est_superieure_a qui prend en paramètre une carte autre (de type Carte) et qui renvoie True si la valeur de la carte considérée est strictement supérieure à la valeur de la carte autre.

3.

Écrire le code de cette méthode.

def est_superieure_a(self, autre):

Partie B: La classe Paquet

Maintenant que les cartes sont modélisées, on crée une classe Paquet pour gérer les différents paquets de cartes durant ce jeu.

Le constructeur de la classe Paquet prend en paramètre une liste (de type list) contenant des cartes (de type Carte) que l'on affecte à l'attribut contenu.

On ajoute deux méthodes à cette classe Paquet:

la méthode afficher permet d'afficher la valeur de toutes les cartes du paquet,

la méthode ajouter_carte prend en paramètre une carte (de type Carte) et l'ajoute au contenu du paquet considéré.

4.

Compléter le code suivant en recopiant les lignes 6, 7 et 10 sur votre copie:

class Paquet:

def __init__(self, L):

self.contenu = L

def afficher(self):

...

...

def ajouter_carte(self, carte):

...

5.

Écrire le code de la méthode nombre_TdB de la classe Paquet qui renvoie le nombre total de « têtes de bœuf » contenus sur les cartes de ce paquet.

def nombre_TdB(self):

La classe Paquet contient aussi une méthode distribuer qui prend en paramètre un entier naturel nbr correspondant au nombre de joueurs (au maximum 10) à servir et qui renvoie la liste contenant les nbr paquets.

Cette liste est initialisée avec nbr instances de classe Paquet dont le contenu est vide.

Chaque joueur reçoit 10 cartes. La première carte du paquet est donnée au premier joueur, la deuxième au deuxième joueur et ainsi de suite.

Ainsi chacun des nbr paquets contiendra 10 cartes prises du paquet sur lequel on appelle la méthode (donc enlevées de ce paquet initial).

6.

Écrire le code de la méthode distribuer de la classe Paquet.

def distribuer(self, nbr):

Partie C: La classe Joueur et modélisation du plateau de jeu

Il reste à gérer les joueurs: leur nom, leur paquet de cartes, etc. C'est le rôle de la classe Joueur.

class Joueur():

def __init__(self, nom, main):

self.nom = nom

self.main = main

self.cartes_ramassees = Paquet([])

self.penalite = 0

7.

Écrire une commande Python permettant d'instancier le joueur nommé « Joueur 1 » ayant pour paquet de cartes L[0] et qui affecte l'objet créé à la variable J1.

La classe Joueur possède également la méthode ramasser_paquet qui prend en paramètre un paquet (de type Paquet), l'ajoute à l'attribut cartes_ramassees, et met à jour l'attribut penalite en lui ajoutant le nombre total de « têtes de bœuf » contenus dans le paquet ramassé.

Maintenant que les trois classes sont prêtes, on initialise le jeu pour deux joueurs dans le programme principal.

8.

Compléter le script ci-dessous en recopiant les lignes 3, 7 et 9 sur votre copie:

1 from random import *

2 # créer les 104 cartes du jeu initial grâce à une liste par compréhension

3 jeu = [... for i in range (...,...)]

4 # mélanger cette liste de cartes

5 shuffle(jeu)

6 # instancier le paquet de cartes avec cette liste de cartes

7 jeu_initial =...

8 # distribuer 10 cartes aux deux joueurs que l'on intancie en les nommant `J1` et `Ordi`.

9 distri =...

10 Ordi = Joueur("Ordi", distri[0])

11 J1 = Joueur("J1", distri[1])

EXERCICE 2 (6 points)

Cet exercice porte sur la programmation Python, la programmation orientée objet, les bases de données relationnelles et les requêtes SQL.

Cet exercice est composé de deux parties indépendantes.

Partie A

Dans cette partie, nous allons utiliser une base de données sur les champignons. Le tableau ci-dessous nous donne un extrait du résultat obtenu, après avoir effectué la requête suivante:

SELECT * FROM champignon; id · nom · id_ordre · lamelle · couleur · chapeau_min · chapeau_max · pied_min · pied_max

1 · champignon de Paris · 1 · oui · blanc · 4 · 10 · 2 · 5

2 · champignon noir · 2 · non · noir · 2 · 10 · 0 · 0

3 · coprin chevelu · 1 · oui · blanc · 5 · 20 · 10 · 40

4 · bolet à pied rouge · 3 · non · jaune · 7 · 19 · 5 · 15

5 · amanite des Césars · 4 · oui · orange · 8 · 20 · 8 · 15

Les attributs nom, lamelle et couleur sont des chaines de caractères. La taille du chapeau et la longueur du pied des champignons sont des nombres exprimés en centimètres.

1.

Mathilde vient de trouver un champignon avec des lamelles et de couleur orange. Écrire la requête qu'elle doit écrire pour avoir la liste des noms des champignons possibles pour sa trouvaille.

2.

Par ailleurs, Romain a trouvé un champignon sans pied et un chapeau de 15 cm. Écrire la requête qu'il doit écrire pour avoir la liste des noms des champignons possibles pour son spécimen.

Les champignons sont classés selon différents ordres selon la table ordre suivante où l'on trouve également la classe à laquelle appartient chaque ordre. Voici le contenu de la table ordre.

table ordre

id

nom

classe

1 · agaricales · agaricomycètes

2 · trémellales · phragmabasidiomycètes

3 · bolétales · agaricomycètes

4 · amanitales · agaricomycètes

5 · cantharellales · agaricomycètes

6 · polyporales · basidiomycètes

7 · clavariales · homobasidiomycètes

8 · tricholomatales · agaricomycètes

3.

Donner la clé étrangère de la table champignon faisant référence à la clé primaire id de la table ordre.

4.

Écrire la requête permettant d'obtenir la liste des noms des champignons appartenant à la classe des agaricomycètes.

Le champignon nommé amanite solitaire est un champignon blanc qui appartient à l'ordre des amanitales. Il possède des lamelles. Son chapeau mesure entre 6 et 20 cm et son pied entre 4 et 10 cm.

5.

Écrire une requête permettant d'ajouter ce champignon avec l' id 56 dans la table champignon.

On décide d'ajouter les différentes toxicités des champignons en ajoutant un attribut id_toxicite dans la relation champignon et une table toxicite. Voici le contenu de la table toxicite:

id_tox

type

effets

1 · très toxique · Entrainant la mort

2 · toxique · Entrainant des problèmes digestifs ou nerveux

3 · à rejeter · Champignons suspects ou ayant un mauvais gout

4 · comestible · Champignons pouvant être consommés

6.

Écrire le schéma relationnel de la base de données contenant ces trois tables en soulignant les clés primaires et en faisant précéder les clés étrangères du caractère #.

Une erreur s'est glissée dans cette table: le champignon de nom amanite citrine est très toxique car son ingestion peut entrainer la mort.

7.

Écrire la requête permettant de corriger cette erreur dans la table champignon.

8.

Écrire une requête permettant d'obtenir les noms des champignons de l'ordre des amanitales de toxicité très toxique.

EXERCICE 2 (6 points)

Cet exercice porte sur la programmation Python, la programmation orientée objet, les bases de données relationnelles et les requêtes SQL.

Cet exercice est composé de deux parties indépendantes.

Partie A

Dans cette partie, nous allons utiliser une base de données sur les champignons. Le tableau ci-dessous nous donne un extrait du résultat obtenu, après avoir effectué la requête suivante:

SELECT * FROM champignon; id · nom · id_ordre · lamelle · couleur · chapeau_min · chapeau_max · pied_min · pied_max

1 · champignon de Paris · 1 · oui · blanc · 4 · 10 · 2 · 5

2 · champignon noir · 2 · non · noir · 2 · 10 · 0 · 0

3 · coprin chevelu · 1 · oui · blanc · 5 · 20 · 10 · 40

4 · bolet à pied rouge · 3 · non · jaune · 7 · 19 · 5 · 15

5 · amanite des Césars · 4 · oui · orange · 8 · 20 · 8 · 15

Les attributs nom, lamelle et couleur sont des chaines de caractères. La taille du chapeau et la longueur du pied des champignons sont des nombres exprimés en centimètres.

Partie B

Quentin fait quelques recherches afin de trouver les recettes possibles avec des champignons selon les saisons. Il trouve notamment les informations suivantes pour le lactaire délicieux:

Lactaire délicieux:

localisation: sous les pins

saison: été

recette: lactaires grillés à l'huile d'olive

cuisson: 12 minutes à feu moyen

Pour chaque champignon, il souhaite stocker les informations dans un objet de la classe Champignon définie ci-dessous:

class Champignon():

def __init__(self, nom, lieu, saison, recette, cuisson):

self.nom = nom

self.localisation = lieu

self.saison = saison

self.recette = recette

self.cuisson = cuisson

Donc l'instruction permettant d'instancier l'objet champignon1 du champignon lactaire délicieux est la suivante:

champignon1 = Champignon('Lactaire délicieux', 'Sous les pins', 'été', 'Lactaires grillés à l\'huile d\'olive', '12 minutes à feu moyen')

Quentin décide de stocker l'ensemble des instances de classe Champignon dans une variable liste_champi de type list.

9.

Recopier et compléter le programme ci-dessous permettant d'afficher le(s) nom(s) des champignons que l'on trouve lors de la saison été.

for e in liste_champi:

if...... == 'été':

print(...)

La plaque de cuisson de Quentin est défectueuse. Il ne peut cuire des aliments qu'à feu moyen. Il écrit donc rapidement le programme suivant afin de savoir s'il peut cuire ses champignons à feu moyen.

for c in liste_champi:

if c.nom == 'Lactaire délicieux':

return c.cuisson == 'feu moyen'

Ce programme renvoie False, alors que le lactaire délicieux se cuisine bien à feu moyen.

10.

Expliquer pourquoi il n'obtient pas le résultat attendu alors que Quentin n'a fait aucune erreur dans sa liste de champignons.

Malgré ce problème, Quentin ne souhaite pas modifier son travail et téléphone à son ami Iris qui lui fournit une fonction recherche_textuelle qui prend en paramètre deux chaînes de caractères texte et mot et qui retourne True si mot est un mot appartenant à texte et False sinon.

>>> recherche_textuelle('dans une forêt', 'forêt')

True

>>> recherche_textuelle('près de la mer', 'mare')

False

11.

Corriger le programme de la question précédente en utilisant la fonction recherche_textuelle.

Exercice 3 (8 points)

Dans cet exercice il est question de tableaux, de dictionnaires, de recherche de chemins dans un graphe, de piles, de files et de POO.

On considère une liste de mots de quatre lettres. Par exemple gars, grue, mars, mors, ours, purs, durs...

Deux mots sont voisins s'ils ne diffèrent que d'une seule lettre sans se soucier de l'ordre des lettres dans les mots. Par exemple:

mars et mors sont voisins (on change le a en o);

mors et ours sont voisins (on change le m en u);

grue et ours ne sont pas voisins (il faudrait changer g en o et e en s).

L'exercice consiste à partir d'un mot de départ (par exemple mars) pour atteindre un mot de destination (par exemple ours) en passant de voisins en voisins et en empruntant le moins de voisins possible.

Les mots utilisés, du mot de départ au mot de destination, forment alors le chemin emprunté. Par exemple mars, mors, ours est le chemin qui relie le mot mars au mot ours.

On considère qu'il est toujours possible de trouver un tel chemin.

Partie A

Pour résoudre notre problème nous aurons besoin, entre autres, d'une structure de pile, d'une structure de file et d'un graphe.

1.

Décrire le fonctionnement d'une Pile.

2.

Décrire le fonctionnement d'une File.

Exercice 3 (8 points)

Dans cet exercice il est question de tableaux, de dictionnaires, de recherche de chemins dans un graphe, de piles, de files et de POO.

On considère une liste de mots de quatre lettres. Par exemple gars, grue, mars, mors, ours, purs, durs...

Deux mots sont voisins s'ils ne diffèrent que d'une seule lettre sans se soucier de l'ordre des lettres dans les mots. Par exemple:

mars et mors sont voisins (on change le a en o);

mors et ours sont voisins (on change le m en u);

grue et ours ne sont pas voisins (il faudrait changer g en o et e en s).

L'exercice consiste à partir d'un mot de départ (par exemple mars) pour atteindre un mot de destination (par exemple ours) en passant de voisins en voisins et en empruntant le moins de voisins possible.

Les mots utilisés, du mot de départ au mot de destination, forment alors le chemin emprunté. Par exemple mars, mors, ours est le chemin qui relie le mot mars au mot ours.

On considère qu'il est toujours possible de trouver un tel chemin.

Partie A: Modélisation par un graphe

3.

Expliquer pourquoi un graphe non orienté est adapté à la situation.

4.

Dessiner le graphe si la liste de mots est: gars, mars, mors, ours et purs.

Partie B: Calcul des distances et des voisins

La distance entre deux mots est le nombre minimum de lettres qu'il faut modifier pour passer de l'un à l'autre. Par exemple, la distance entre mars et mors est 1 tandis que la distance entre grue et ours est 2.

Deux mots sont voisins si et seulement si la distance entre eux vaut 1.

Dans toute cette partie, on dispose d'une variable globale TAB_MOTS, un tableau (type list en Python) dont les éléments sont des chaînes de quatre caractères qui correspondent à des mots.

5.

Recopier et compléter la fonction chaine_vers_tab(mot) ci-dessous. Cette fonction prend en paramètre une chaîne de quatre caractères et renvoie un tableau (type list en Python) dont les éléments sont les caractères de cette chaîne.

6.

Expliquer pourquoi la fonction ci-dessous renvoie effectivement la distance entre les deux mots mot1 et mot2, deux chaînes de quatre caractères:

def distance(mot1, mot2):

tab = chaine_vers_tab(mot1)

for lettre in mot2:

if lettre in tab:

tab.remove(lettre)

return len(tab)

7.

Recopier et compléter la fonction renvoie_voisins(mot) qui renvoie un tableau dont les éléments sont les mots de TAB_MOTS qui sont voisins de mot, une chaîne de quatre caractères, passé en paramètre.

Partie C: Recherche du plus court chemin

On dispose d'une classe File (méthodes est_vide(), defiler(), enfiler(element)) et d'une classe Pile (méthodes est_vide(), depiler(), empiler(element)).

La fonction dic_parent(mot_depart, mot_final) ci-dessous renvoie le chemin sous la forme d'un dictionnaire {sommet parcouru: sommet précédent}:

def dic_parent(mot_depart, mot_final):

file_voisins = File()

parent = {mot_depart: None}

mot = mot_depart

file_voisins.enfiler(mot)

while not file_voisins.est_vide() and not mot == mot_final:

mot = file_voisins.defiler()

for voisin in renvoie_voisins(mot):

if not voisin in parent:

parent[voisin] = mot

file_voisins.enfiler(voisin)

return parent

8.

Poursuivre le déroulement de la fonction pas à pas (avec 'mars' pour mot de départ et 'ours' pour mot final) en détaillant chaque tour de boucle jusqu'à l'issue de la fonction.

9.

Recopier et compléter la fonction renvoie_pile(parent, mot_final) qui renvoie une pile dont le premier élément empilé est le mot final et dont le sommet est le mot de départ.

10.

Recopier et compléter la fonction construit_chemin(ma_pile) qui prend en paramètre une pile de mots et renvoie un tableau contenant les mots du chemin dans le bon ordre.

11.

Coder, en utilisant les fonctions précédentes, la fonction chercher_chemin(mot_depart, mot_final) qui renvoie un tableau constitué des mots du chemin du mot de départ au mot final.