Exercice 1 Polynésie – Bac NSI 2025 – 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.

mots clés: POO, algorithmique , programmation

🔎 Voir les exercices similaires ↓

📘 Sujet PDF

Polynésie – Bac NSI 2025 – Jour 2 Énoncé de l'exercice 1

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.

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”.

  1. É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.

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.

  1. Écrire le code de cette méthode.

La classe Carte possède également la méthode difference qui prend en paramètre une carte autre (de type Carte) et qui renvoie la valeur absolue de la différence entre les valeurs des deux cartes considérées.

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é.

  1. 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):
        ...

  1. É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.

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).

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

La classe Paquet possède également les méthodes suivantes :

  • la méthode prendre_carte n’a pas de paramètre et renvoie la carte choisie par l’utilisateur dont il saisit la valeur lors de l’appel de cette méthode (on demande une valeur tant que celle-ci n’est pas valable, ainsi la carte est obligatoirement une carte du paquet).
    Cette carte est supprimée du paquet ;

  • la méthode trier n’a pas de paramètre et permet de trier les cartes du paquet dans l’ordre croissant de leur valeur.

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

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

Le constructeur de la classe Joueur prend en paramètres :

  • le nom du joueur (de type str) que l’on affecte à l’attribut nom ;

  • un paquet de cartes (de type Paquet) que l’on affecte à l’attribut main.

On ajoute également les attributs cartes_ramassees qui est initialisé avec un paquet de cartes vide et penalite initialisé à 0.

class Joueur():
   def __init__(self, nom, main):
      self.nom = nom
      self.main = main
      self.cartes_ramassees = Paquet([])
      self.penalite = 0

  1. É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.

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

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

Polynésie – Bac NSI 2025 – Jour 2 Correction de l'exercice 1

Partie A – La classe Carte

1. Constructeur de la classe Carte

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

2. Méthode calcul_TdB

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

3. Méthode est_superieure_a

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

Partie B – La classe Paquet

4. Lignes 6, 7 et 10 de la classe Paquet

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

    def afficher(self):
        for carte in self.contenu:             # ligne 6
            print(carte.valeur)                # ligne 7

    def ajouter_carte(self, carte):
        self.contenu.append(carte)             # ligne 10

5. Méthode nombre_TdB

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

6. Méthode distribuer

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

Partie C – La classe Joueur

7. Instanciation du joueur J1

J1 = Joueur('Joueur 1', L[0])
    def ramasser_paquet(self, paquet):
        for carte in paquet.contenu:
            self.cartes_ramassees.ajouter_carte(carte)
        self.penalite = self.penalite + paquet.nombre_TdB()

8. Programme principal (lignes 3, 7 et 9)

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)]                # ligne 3
# mélanger cette liste de cartes
shuffle(jeu)
# instancier le paquet de cartes avec cette liste de cartes
jeu_initial = Paquet(jeu)                              # ligne 7
# distribuer 10 cartes aux deux joueurs que l'on instancie en les nommant J1 et Ordi
distri = jeu_initial.distribuer(2)                     # ligne 9
Ordi = Joueur('Ordi', distri[0])
J1 = Joueur('J1', distri[1])

Une erreur, un oubli ? Écrivez-moi : frederic.peuriere@lfcl.pt

💻 Console Python (cliquer pour afficher)

🔎 Exercices sur des thèmes similaires