Bac NSI — Nouvelle-Calédonie 2022 (Jour 2)

Présentation de l'épreuve

Sujet officiel du baccalauréat général, épreuve de spécialité Numérique et Sciences Informatiques, session 2022, Nouvelle-Calédonie, jour 2 (code sujet 22-NSIJ2NC1). Durée 3h30, calculatrice interdite. Le sujet comporte 5 exercices indépendants notés chacun sur 4 points ; le candidat en traite 3 au choix.

Exercice 1 — Programmation orientée objet (jeu vidéo)

L'objectif est de programmer un jeu de plateau sur le thème des chevaliers de la table ronde, dans lequel des personnages accomplissent des missions, récupèrent des objets (gagnant ou perdant des points de vie) et peuvent s'affronter.

Partie 1 — Déplacement. Les personnages évoluent dans un repère à trois axes ; leur position est repérée par les attributs x, y, z.

1. a) Recopier et compléter le constructeur de la classe Personnage qui positionne un personnage aux coordonnées choisies :

class Personnage:
    def __init__(self, coordx, coordy, coordz):
        ...

b) Écrire une méthode avancex qui augmente d'une unité la coordonnée x. c) Écrire une méthode raz qui remet toutes les coordonnées à zéro. d) Écrire une méthode coord qui renvoie les coordonnées sous forme de tuple.

2. En utilisant ces méthodes, écrire les instructions permettant de : a) créer un personnage arthur à la position (5,5,5) ; b) augmenter d'une unité sa coordonnée x ; c) afficher ses coordonnées.

Partie 2 — Points de vie. La classe Personnage est enrichie d'un attribut vie et de méthodes liées aux rencontres du jeu :

import random
 
class Personnage:
    def __init__(self, coordx, coordy, coordz, point_de_vie):
        ...  # défini dans la partie 1
        self.vie = point_de_vie
 
    def get_etat(self):
        return self.vie
 
    def newgame(self):
        ...  # à définir
 
    def potionmystere(self):
        if random.randint(1, 2) == 1:
            nbPoint = -1
        else:
            nbPoint = +1
        self.vie = self.vie + nbPoint
 
    def piege(self):
        self.vie = self.vie - 10
 
    def repos(self):
        self.vie = self.vie + 5

1. Indiquer les valeurs possibles de valeurMerlin après :

merlin = Personnage(4, 5, 8, 15)
merlin.potionmystere()
valeurMerlin = merlin.get_etat()

2. Indiquer la valeur de valeurMerlin après :

merlin = Personnage(4, 5, 8, 20)
merlin.piege()
merlin.piege()
valeurMerlin = merlin.get_etat()

3. Écrire la méthode newgame qui, si les points de vie sont inférieurs ou égaux à 0, ramène les coordonnées du personnage à (0,0,0) et lui attribue 15 points de vie.

Pour intégrer les combats, on ajoute deux méthodes à la classe :

def perdre_vie(self, points):
    self.vie = self.vie - points
    self.newgame()
 
def attaquer(self, autre):
    autre.perdre_vie(self.degats)

4. Écrire un programme qui : a) crée une instance lancelot (coordonnées 5,5,5 ; 15 points de vie ; 3 points de dégâts) ; b) crée une instance sorcier (coordonnées 6,5,5 ; 15 points de vie ; 2 points de dégâts) ; c) fait attaquer le sorcier par lancelot une première fois ; d) fait attaquer lancelot par le sorcier en retour ; e) fait attaquer quatre fois de suite le sorcier par lancelot ; f) affiche les points de vie des deux personnages.

Exercice 2 — Arbres binaires

Le personnage Mélusine part d'un point A et peut se rendre à n'importe quel autre point d'un arbre binaire ; sous chaque lettre se cache un objet de valeur donnée. Structure de l'arbre : A a pour fils gauche B et fils droit F ; B a pour fils gauche C et fils droit D ; C a pour unique fils (gauche) E ; F a pour fils gauche G et fils droit H ; G a pour unique fils (gauche) I ; H a pour unique fils (droit) J.

1. Indiquer pourquoi il s'agit d'un arbre binaire.

2. On attribue une valeur à chaque lettre : V = {'A': 1, 'B': 2, 'C': 3, 'D': 5, 'E': 10, 'F': 15, 'G': 4, 'H': 5, 'I': 5, 'J': 7}. a) Indiquer le type de V. b) Écrire l'instruction accédant à la valeur 7 stockée dans V. c) Écrire une fonction somme(W) qui renvoie la somme des valeurs d'un dictionnaire W du même type que V. d) Écrire une fonction VMax(W) qui renvoie la lettre associée à la valeur maximale de W.

3. Indiquer, en justifiant, le rôle de l'algorithme suivant (T désigne un arbre) :

CALCUL(T : arbre) :
DEBUT
  si T n'est pas un arbre vide :
    x <- racine de T
    renvoyer 1 + CALCUL(sous-arbre gauche de x) + CALCUL(sous-arbre droit de x)
  sinon :
    renvoyer 0
FIN

4. On applique l'algorithme suivant à l'arbre décrit ci-dessus :

VISITE(T : arbre) :
DEBUT
  si T n'est pas un arbre vide :
    x <- racine de T
    afficher clé de x
    VISITE(sous-arbre gauche de x)
    VISITE(sous-arbre droit de x)
  fin si
FIN

a) Indiquer l'affichage obtenu. b) Indiquer le type de parcours réalisé.

Exercice 3 — Bases de données et SQL (chevaliers de la table ronde)

Pour un jeu vidéo sur le thème des chevaliers de la table ronde, une base Chevalier comporte deux tables.

Personnage(Idperso, nom, frere_de, points, Idqualite) :

(NC = « Non communiqué »)

Qualite(Idqualite, nom_qualite) : 1 apprenti chevalier, 2 magicien, 3 preux chevalier, 4 espion, 5 seigneur, 6 sage, 7 grand chevalier.

1. Écrire une requête affichant le nom et les points de tous les personnages.
2. Le frère d'Arthur ne s'appelle pas Keud mais Antor : écrire la requête de correction.
3. Écrire une requête ajoutant le nom_qualite « roi » à la table Qualite, d'Idqualite 8.
4. Écrire une requête créant un quatorzième personnage : le roi Arthur, 100 points.
5. Écrire une requête affichant le nom et le nom de qualité des personnages ayant 40 points.
6. On applique UPDATE Personnage SET points = points + 10 WHERE points < 40;. Indiquer les points d'Arthur, Perceval et Merlin après cette mise à jour.

Exercice 4 — Réseau : adressage IP et protocoles de routage

On teste un jeu vidéo en réseau réparti dans trois salles T1, T2, T3 (postes portables reliés à des commutateurs S1, S2, S3), plus un serveur relié par S4. Quatre routeurs R1 à R4 interconnectent l'ensemble. On rappelle qu'un masque /n en notation CIDR indique que les n premiers bits identifient le réseau.

Extrait des adresses (masque /24 partout) :

1. a) Donner l'adresse du réseau local de Portable 3 (relié à S1, comme Portable 1). b) Donner une adresse IP possible pour Portable 3. c) Donner, en justifiant, le nombre d'adresses encore disponibles pour Portable 4 (réseau T2, relié à S2).

2. Donner les adresses IP des trois interfaces de R3, chacune étant la première disponible sur la plage d'adressage du réseau connecté.

3. Portable 1 veut communiquer avec Portable 5. a) Donner trois parcours possibles. b) Donner le plus court chemin au sens RIP (nombre de sauts). c) La liaison R1-R2 se rompt : donner le nouveau plus court chemin RIP.

4. La liaison R1-R2 est rétablie avec un nouveau câble. Parmi Internet, VGA, Ethernet, HDMI, indiquer le type de câble utilisé.

5. Le protocole OSPF calcule un coût = 10^9 / d (d en bit/s). Débits (en Mbps) : R1-R4 : 1000 ; R2-R3 : 10 ; R2-R4 : 1000 ; R3-R4 : 20 ; R1-R2 : inconnu. a) La liaison R1-R2 a un coût de 10 : calculer son débit en Mbps. b) Pour transmettre de Portable 1 vers Portable 5 (R1 doit envoyer à R2), déterminer le chemin de meilleur coût et l'indiquer, en justifiant.

Exercice 5 — Réseau : masques et tables de routage RIP

1. Un masque de réseau, codé sur 32 bits, doit être une suite de 1 suivie d'une suite de 0 pour être valide (exemple : 255.255.192.0 correspond à /18 et est valide ; 255.252.128.0 n'est pas valide, un 0 y est intercalé entre deux 1). a) Indiquer, en justifiant, si 255.255.225.0 et 255.255.224.0 sont des masques valides. b) On dispose d'une fonction convBin qui convertit une liste de 4 entiers (0 à 255) en la liste de ses 32 bits (exemple : convBin([255,255,192,0]) renvoie 18 chiffres 1 suivis de 0). On considère /0 et /32 comme valides. Écrire la fonction cidr(bits) qui renvoie l'entier n de la notation CIDR si bits correspond à un masque valide, -1 sinon.

2. Parmi les commandes suivantes, indiquer celle qui affiche la table de routage : dir/ls ; cacls/chmod ; route print/ip route/route -n ; ping ; tracert/traceroute.

3. Un réseau de 3 routeurs R1, R2, R3 (chacun avec deux interfaces eth0/eth1) est organisé ainsi : R1(eth0 : 192.168.1.1, eth1 : 192.168.2.1) — R2(eth0 : 192.168.2.2, eth1 : 192.168.3.2) — R3(eth0 : 192.168.3.3, eth1 : 192.168.4.3), avec un PC sur le réseau de R1-eth0 et un serveur sur celui de R3-eth1. La table de routage indique, pour chaque destination, l'interface de sortie, le routeur suivant (« direct » si connecté, sinon l'adresse d'entrée chez le routeur suivant) et le nombre de sauts.

   a) À l'étape 1 (mise en service), chaque routeur ne connaît que ses réseaux directement connectés. Compléter les tables de R2 et R3.

   b) À l'étape 2, R2 envoie d'abord sa table à ses voisins (qui se mettent à jour), puis R1 et R3 envoient la leur à R2 (qui se met à jour à son tour). Compléter la table de R1 à l'étape 2, sachant que celle de R2 se stabilise alors à : 192.168.2.0/24 (direct, saut 0), 192.168.3.0/24 (direct, saut 0), 192.168.1.0/24 (via 192.168.2.1, saut 1), 192.168.4.0/24 (via 192.168.3.3, saut 1).

   c) À l'étape 3 (même mécanisme), compléter à nouveau la table de R1.