Corrigé bac NSI 2026 Métropole jour 1 — Exercice 3 : Plateforme de débats : arbre des arguments en POO et base de données SQL

Cet exercice porte sur les arbres, l'algorithmique des arbres, et les bases de données.

On s'intéresse au fonctionnement interne d'une plateforme en ligne dédiée spécifiquement aux débats. Plutôt que de lister des messages des utilisateurs dans l'ordre chronologique, les différentes contributions sont structurées de façon arborescente afin de mieux comprendre les liens entre les arguments. Chaque contribution vient se rattacher à une affirmation, soit afin d'appuyer cette affirmation avec un argument pour, soit afin de l'attaquer avec un argument contre.

Cet exercice contient deux parties indépendantes l'une de l'autre.

Partie A : structure arborescente des arguments

Dans cette partie on modélise un arbre de débat pour un sujet de débat. La figure 1 montre un exemple d'arbre de débat.

Dans un arbre de débat, chaque nœud est une affirmation, et il y en a de trois sortes :

• le sujet du débat (dans le parallélogramme) est une affirmation, c'est le point de départ du débat ;
• un argument pour (dans un rectangle aux coins arrondis) peut venir soutenir une affirmation, cet argument est lui-même une affirmation ;
• un argument contre (dans un hexagone) peut venir attaquer une affirmation, cet argument est lui-même une affirmation.

De plus, chaque affirmation peut être likée (j'aime) ou dislikée (je n'aime pas) par les utilisateurs.

1. Indiquer le nom donné au nœud « point de départ du débat » dans le vocabulaire des arbres.

2. Indiquer en justifiant si un arbre de débat est un arbre binaire ou non.

On modélise la structure d'arbre de débat à l'aide de la classe suivante :

class Affirmation:
    def __init__(self, phrase):
        """
        Création d'un objet Affirmation à partir d'une
        phrase (str).
        """
        self.contenu = phrase
        self.sorte = "" # vaudra "sujet", "pour" ou "contre"
                        # vaut "" avant ajout dans l'arbre
        self.arguments = []
        self.nb_likes = 0
        self.nb_dislikes = 0

3. Donner le nom et le type de chaque attribut de la classe Affirmation.

On souhaite ajouter à cette classe une méthode soutenir qui permet d'ajouter un argument pour à l'affirmation.

On suppose à disposition une méthode contrer similaire qui permet d'ajouter un argument contre à l'affirmation.

def soutenir(self, argument):
    """
    Ajoute l'Affirmation `argument` comme argument pour de
    l'Affirmation `self`.

    Précondition : l'Affirmation ne doit pas avoir déjà été
    utilisée, ni comme sujet, ni comme pour, ni comme
    contre, ce qu'on vérifie grâce à son attribut `sorte`.
    """
    assert argument.sorte == ...
    ... .append(argument)
    argument.sorte = "..."

4. Recopier et compléter les lignes 10 à 12 de la méthode soutenir, en respectant sa documentation.

Pour mesurer les débats les plus vifs, la plateforme de débats dispose de plusieurs mesures.

5. Écrire la méthode nb_contre qui permet d'obtenir le nombre d'arguments contre directement rattachés à cette Affirmation.

On s'intéresse à la méthode mystere suivante, qui utilise la méthode nb_contre :

def mystere(self):
    m = self.nb_contre()
    for arg in self.arguments:
        candidat = arg.mystere()
        if candidat > m:
            m = candidat
    return m

6. Expliquer par une phrase ce que renvoie la méthode mystere.

Afin de trancher le débat dans sa globalité, on souhaite évaluer une Affirmation, en tenant compte de la totalité des likes et des dislikes de chaque argument, et en tenant compte du fait que ces arguments soient pour ou contre. Si l'évaluation est positive le pour l'emporte, si elle est négative le contre l'emporte.

La formule pour l'évaluation d'une affirmation correspond à la somme de ses likes et des évaluations de ses arguments pour, à laquelle on soustrait ses dislikes et les évaluations de ses arguments contre.

7. Écrire, en utilisant uniquement des lignes de code choisies parmi les lignes suivantes, une méthode evaluation qui renvoie le résultat du calcul décrit dans la formule ci-dessus. Les lignes ne sont pas toutes à utiliser et l'indentation est à adapter.

def evaluation(self):
def evaluation():
total = self.nb_likes + self.nb_dislikes
total = self.nb_likes - self.nb_dislikes
total = self.nb_dislikes - self.nb_likes
total = self.nb_likes * self.nb_dislikes
for arg in self.arguments:
for arg in self.arguments_pour:
for arg in self.arguments_contre:
if arg.sorte == "sujet":
if arg.sorte == "pour":
if arg.sorte == "contre":
else:
total = arg.evaluation()
total = total + arg.evaluation()
total = total - arg.evaluation()
total = total * arg.evaluation()
return total
return 1 + total

Partie B : base de données des utilisateurs et de leurs contributions

Dans cette partie, on pourra utiliser les clauses du langage SQL pour :

• construire des requêtes d'interrogation à l'aide de SELECT, FROM, WHERE (avec les opérateurs logiques AND, OR) et JOIN ... ON ;
• construire des requêtes d'insertion et de mise à jour à l'aide de UPDATE, INSERT et DELETE.

Pour manipuler toutes les informations sur plusieurs sujets de débats, la plateforme dispose d'un Système de Gestion de Bases de Données (SGBD).

8. Parmi les propositions suivantes, indiquer celles qui font partie des rôles d'un SGBD :

• [a)] sécuriser les accès à la base de données ;
• [b)] assurer l'alimentation électrique des serveurs ;
• [c)] assurer la persistance des données même en cas de panne matérielle ;
• [d)] gérer les accès en parallèle de plusieurs utilisateurs ;
• [e)] assurer des connexions en HTTPS au serveur.

Pour gérer les données, le schéma relationnel utilisé est représenté sur la figure 2 (transcrit ici en notation textuelle : clés primaires soulignées, clés étrangères précédées d'un « # ») :

La clé primaire de chaque table correspond à l'ensemble de ses attributs soulignés. Chaque attribut précédé d'un « # » est une clé étrangère.

L'attribut sorte de la table affirmation peut valoir 'sujet' quand c'est l'affirmation initiale d'un sujet de débat, ou bien 'pour' ou 'contre' quand c'est une réponse à une autre affirmation (référencée par l'attribut aff_repondue). L'attribut contenu correspond à la phrase elle-même de l'affirmation.

L'attribut sorte de la table reaction peut valoir 'like' ou 'dislike', et s'applique à l'affirmation référencée par l'attribut aff_reagie.

Voici des exemples d'extraits des tables affirmation et reaction. On a omis, pour ces exemples, les attributs auteur et contenu de la table affirmation :

9. Indiquer en justifiant quel autre attribut de la table utilisateur aurait aussi pu servir de clé primaire.

On rappelle que la fonction d'agrégation COUNT permet de compter les éléments du résultat d'une requête en plaçant COUNT(*) dans la clause SELECT.

10. Écrire une requête SQL permettant d'obtenir le nombre d'affirmations qui ont 50 likes ou plus.

11. Écrire une requête qui permet d'obtenir les contenus des sujets et leur nombre de likes, créés par les utilisateurs dont les prénom et nom sont respectivement 'Pierre' et 'Durand'.

Le mot-clé AS permet de donner un autre nom à une table au sein d'une requête. Il est notamment nécessaire lorsqu'on a besoin de faire la jointure d'une table avec elle-même. On considère la requête SQL suivante :

SELECT aff.contenu, rep.contenu
FROM affirmation AS aff JOIN affirmation AS rep
  ON rep.affirmation_repondue = aff.id_affirmation
WHERE rep.nb_likes >= 2 * aff.nb_likes
  AND rep.sorte = 'contre'

12. Donner une interprétation en français de ce que permet d'obtenir la requête ci-dessus.

L'utilisateur au pseudo 'i<3descartes' approuve par un like l'affirmation 'Cogito ergo sum' qui a l'id_aff 108.

13. Recopier et compléter les deux requêtes SQL suivantes, permettant de mettre à jour les informations de la base de données suite à cette action.

... reaction
VALUES (..., ..., ...);;

... affirmation
SET nb_likes = ...
WHERE ... = ...;;

L'utilisateur au pseudo 'i<3rgpd' souhaite faire valoir son droit à l'effacement, et supprimer son compte utilisateur et toutes les données qui y sont liées. Dans cette situation, la plateforme de débat, qui souhaite maintenir la qualité des échanges, suit la procédure suivante :

• elle anonymise toutes les affirmations de l'utilisateur (en remplaçant l'attribut auteur par la valeur NULL), considérant que les affirmations elle-mêmes ne sont pas des données personnelles ;
• elle supprime toutes les réactions de l'utilisateur (mais sans toucher au nombres de likes et de dislikes des affirmations correspondantes) ;
• et enfin elle supprime l'utilisateur lui-même.

14. Expliquer pourquoi il est nécessaire de supprimer les réactions de l'utilisateur avant de supprimer l'utilisateur.

15. Écrire les trois requêtes qui permettent la suppression des données du compte de 'i<3rgpd' en suivant la procédure décrite ci-dessus.