Bac NSI — Centres étrangers 2021 (Jour 1) : sujet et corrigé

Présentation de l'épreuve

Épreuve écrite de spécialité NSI, session 2021, Centres étrangers (groupe 1), jour 1. Durée : 3h30, calculatrice interdite. 5 exercices notés sur 4 points, le candidat en choisit 3.

Exercice 1 — Programmation objet : chiffrement de César

On chiffre des chaînes en majuscules (alphabet "ABCDEFGHIJKLMNOPQRSTUVWXYZ") par décalage d'une clé entière fixée.

class CodeCesar:
    def __init__(self, cle):
        self.cle = cle
        self.alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 
    def decale(self, lettre):
        num1 = self.alphabet.find(lettre)
        num2 = num1 + self.cle
        if num2 >= 26:
            num2 = num2 - 26
        if num2 < 0:
            num2 = num2 + 26
        nouvelle_lettre = self.alphabet[num2]
        return nouvelle_lettre

1. Résultat de :

code1 = CodeCesar(3)
print(code1.decale('A'))
print(code1.decale('X'))

2. Avec la clé 3, chaque lettre est décalée de 3 rangs (A→D, B→E, etc.). Ajouter à CodeCesar une méthode cryptage(self, texte) qui chiffre texte lettre par lettre avec self.cle. Exemple : CodeCesar(3).cryptage("NSI") renvoie 'QVL'.

3. Écrire un programme qui demande la clé, crée un objet CodeCesar, demande le texte, puis affiche le texte chiffré via cryptage.

4. On ajoute :

def transforme(self, texte):
    self.cle = -self.cle
    message = self.cryptage(texte)
    self.cle = -self.cle
    return message

Que va afficher print(CodeCesar(10).transforme("PSX")) ? Expliquer.

Exercice 2 — Structures de données : dictionnaires (vélos en libre-service)

La flotte de vélos est un dictionnaire id_velo : dict_velo, avec dict_velo = {"type": "electrique"/"classique", "etat": 1(disponible)/0(en déplacement)/-1(en panne), "station": nom de la dernière station}.

flotte = {
    12: {"type": "electrique", "etat": 1, "station": "Prefecture"},
    80: {"type": "classique", "etat": 0, "station": "Saint-Leu"},
    45: {"type": "classique", "etat": 1, "station": "Baraban"},
    41: {"type": "classique", "etat": -1, "station": "Citadelle"},
    26: {"type": "classique", "etat": 1, "station": "Coliseum"},
    28: {"type": "electrique", "etat": 0, "station": "Coliseum"},
    74: {"type": "electrique", "etat": 1, "station": "Jacobins"},
    13: {"type": "classique", "etat": 0, "station": "Citadelle"},
    83: {"type": "classique", "etat": -1, "station": "Saint-Leu"},
    22: {"type": "electrique", "etat": -1, "station": "Joffre"},
}

1.a. Que renvoie flotte[26] ? 1.b. Que renvoie flotte[80]["etat"] ? 1.c. Que renvoie flotte[99]["etat"] ?

2. Fonction :

def proposition(choix):
    for v in flotte:
        if flotte[v]["type"] == choix and flotte[v]["etat"] == 1:
            return flotte[v]["station"]

2.a. Quelles sont les valeurs possibles de choix ? 2.b. Que renvoie la fonction pour une de ces valeurs ?

3.a. Écrire un script affichant les identifiants des vélos disponibles à la station "Citadelle". 3.b. Écrire un script affichant identifiant et station de tous les vélos électriques qui ne sont pas en panne.

4. Table des positions GPS des stations :

stations = {
    'Prefecture': (49.8905, 2.2967),
    'Saint-Leu': (49.8982, 2.3017),
    'Coliseum': (49.8942, 2.2874),
    'Jacobins': (49.8912, 2.3016),
}

On dispose de distance(p1, p2), renvoyant la distance en mètres entre deux positions GPS (ex : distance((49.8905,2.2967),(49.8912,2.3016)) renvoie 9591). Écrire une fonction qui, pour chaque station à moins de 800 mètres de l'utilisateur (coordonnées données en tuple), affiche son nom, la distance, et les identifiants des vélos disponibles (une station sans vélo disponible n'est pas affichée).

Exercice 3 — Arbres binaires de recherche

Un arbre binaire de recherche vérifie, pour chaque nœud X : les valeurs du sous-arbre gauche sont strictement inférieures à X, celles du sous-arbre droit sont supérieures ou égales à X.

ABR construit en insérant, dans cet ordre, [26, 3, 42, 15, 29, 19, 13, 1, 32, 37, 30].

1. On insère 25 dans un nouveau nœud. Indiquer sous quel nœud il s'insère, et s'il devient fils gauche ou droit, en détaillant le raisonnement.

2. Le fils gauche du nœud de valeur 29 est vide. Quelles valeurs entières pourrait-il légitimement contenir, compte tenu des règles de l'ABR ?

3. Avec :

def Parcours(A):
    Afficher(A.valeur)
    Parcours(A.fils_gauche)
    Parcours(A.fils_droit)

a. Donner la liste des valeurs affichées, dans l'ordre. b. De quel type de parcours s'agit-il (préfixe, suffixe, ou infixe) ?

4. Écrire Parcours2, qui affiche les valeurs de l'arbre dans l'ordre croissant.

Exercice 4 — Réseau : adressage IP et CIDR

Réseau composé de 8 PC, 3 switchs (SWITCH1, SWITCH2, SWITCH3) et 3 routeurs, organisés en trois sous-réseaux locaux reliés entre eux par les routeurs : SWITCH1 dessert un réseau en 172.16.0.0/16 (PC1, PC2, PC3), SWITCH2 dessert le réseau 192.168.20.0/24 (PC6 : 192.168.20.11/24, PC7 : 192.168.20.10/24, PC8 : adresse à déterminer), SWITCH3 dessert le réseau 192.168.0.0/24 (PC4, PC5).

1.a. Combien d'octets compose une adresse IPv4 ? 1.b. PC7 a pour adresse 192.168.20.10/24. Donner sa conversion en binaire, sur 4 octets. 1.c. Donner le masque de sous-réseau en notation binaire pour /24. 1.d. En déduire le masque en notation décimale.

2. L'adresse du réseau s'obtient par un ET logique bit à bit entre l'adresse IP de PC7 et le masque. Donner l'adresse réseau en binaire, puis en décimal.

3. Parmi ces propositions, laquelle/lesquelles pourrai(en)t être l'adresse IP de PC8 (connecté au même réseau que PC6 et PC7) ? 192.168.20.0 / 192.256.20.11 / 192.168.20.30 / 192.168.20.230 / 192.168.20.260 / 192.168.27.11

4. On dispose de dec_bin(n), qui prend un entier entre 0 et 255 et renvoie une liste de 8 éléments (sa conversion binaire). Exemple : dec_bin(10) renvoie [0,0,0,0,1,0,1,0]. Écrire IP_bin(adresse), qui prend une liste de 4 entiers (une IP en décimal) et renvoie une liste de 4 listes (sa conversion binaire), en réutilisant dec_bin. Exemple : IP_bin([192,168,0,1]) renvoie [[1,1,0,0,0,0,0,0],[1,0,1,0,1,0,0,0],[0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,1]].

Exercice 5 — Piles

Fonctions disponibles : empiler(P, e), depiler(P), est_vide(P), creer_pile().

Pile P d'origine (sommet → fond) : 4, 7, 1, 5.

1. En partant de cette pile et en appliquant successivement empiler(P,8), puis depiler(P), puis est_vide(P), indiquer le contenu de P et la valeur renvoyée par chaque appel.

2. Avec :

def transforme(P):
    Q = creer_pile()
    while not est_vide(P):
        v = depiler(P)
        empiler(Q, v)
    return (P, Q)

Que renvoie transforme(P) pour P = 4,7,1,5 (sommet→fond), et que devient P ?

3. Écrire maximum(P), qui renvoie la valeur maximale de la pile P (on autorise que P soit vide après exécution).

4.a. Décrire une stratégie (langage naturel et/ou schéma) pour une fonction taille(P) renvoyant le nombre d'éléments de P. 4.b. Donner le code Python de taille(P).

Bac NSI — Centres étrangers 2021 (Jour 1)

Sujet