Bac NSI 2025 — Amérique du Sud — Sujet 2

Sujet officiel du baccalauréat général, épreuve d'enseignement de spécialité numérique et sciences informatiques, session 2025, Amérique du Sud, jour 2 (épreuve du 14 novembre 2025). Durée 3 heures 30, calculatrice non autorisée. Le sujet comporte 3 exercices indépendants, à traiter tous les trois. Barème : exercice 1 (6 points, 12 questions), exercice 2 (6 points, 10 questions), exercice 3 (8 points, 16 questions) — soit 38 questions au total.

Exercice 1 (6 points) — Bases de données relationnelles, SQL et programmation Python

Cet exercice porte sur les bases de données relationnelles, les requêtes SQL, la programmation en Python et la manipulation de listes.

Dans cet exercice, 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 et OR) et JOIN ... ON ;
• construire des requêtes d'insertion et de mise à jour à l'aide de UPDATE, INSERT et DELETE ;
• affiner les recherches à l'aide de DISTINCT et ORDER BY.

Le but de cet exercice est d'établir une prédiction de la météo du jour en utilisant les observations du jour précédent de plusieurs stations météorologiques voisines.

Partie A

Une version simplifiée des observations peut être représentée sous forme de tables dont la description est donnée ci-dessous (figure 1). Les clés primaires sont soulignées et les clés étrangères sont indiquées par un # :

station (idStat, nom, latitude, longitude, hauteur) — idStat : INT (clé primaire, soulignée), nom : TEXT, latitude : REAL, longitude : REAL, hauteur : REAL.

observation (idObs, #idStat, date, precip, forceVent, dirVent, temp) — idObs : INT (clé primaire, soulignée), #idStat : INT (clé étrangère vers station), date : TEXT au format 'AAAAMMJJHH', precip : REAL, forceVent : REAL, dirVent : INT, temp : REAL.

Dans cette partie, on considère les observations météorologiques de la Nouvelle-Calédonie. La table station contient l'identifiant idStat, le nom nom et les coordonnées géographiques de toutes les stations météorologiques. La table observation contient l'identifiant idStat de l'observation, la date de l'observation date, la hauteur de précipitation precip, la force du vent forceVent, la direction du vent dirVent et la température temp heure par heure de toutes les stations.

Extrait de la table station :

Extrait de la table observation :

1. Donner le résultat de la requête ci-dessous en considérant les extraits de table fournis.

SELECT nom
FROM station
WHERE latitude = -22.276000 AND longitude = 166.452833

2. Écrire une requête permettant d'obtenir le nom de toutes les stations météorologiques triées par ordre alphabétique.

En SQL, la fonction d'agrégation COUNT permet de compter le nombre d'enregistrements dans une table. Pour connaître le nombre de lignes totales dans une colonne, la syntaxe est la suivante :

SELECT COUNT(nom_colonne)
FROM table

Par exemple, pour compter le nombre de stations météorologiques de la Nouvelle-Calédonie, la requête est la suivante :

SELECT COUNT(idStat)
FROM station

Dans la table observation, les relevés météorologiques sont effectués au même moment pour toutes les stations (date identique). Ainsi, chaque station a le même nombre de relevés.

3. Écrire une requête permettant d'obtenir la force et la direction du vent à BOURAKE le 2 janvier 2023 à 14h.

4. Écrire une requête permettant d'obtenir le nombre total de relevés en Nouvelle-Calédonie.

On souhaite regrouper toutes les informations dans une seule table meteo.

5. Écrire le schéma relationnel de la table meteo en supprimant les données hauteur, precip, forceVent et dirVent.

Partie B

Les données collectées sont stockées dans un unique fichier texte au format csv (Comma Separated Values, valeurs séparées par des virgules). Le module Python csv implémente des classes pour lire et écrire des données tabulaires au format csv.

On fournit ci-dessous un extrait du fichier observations.csv (figure 2) qui donne heure par heure les précipitations en millimètre, la force du vent en mètre par seconde et la direction du vent en degré (de 0 à 360 degrés) ainsi que la température en degré Celsius de la journée du 01/01/2024 pour toutes les stations météorologiques de Nouvelle-Calédonie (source : d'après meteo.data.gouv) :

ID_STATION,NOM_STATION,LATITUDE,LONGITUDE,ALTITUDE,AAAAMMJJHH,PRECIPITATION,FORCE_VENT,DIR_VENT,TEMPERATURE
98801001,BELEP AEROD.,-19.719833,163.661000,88,2024010100,0.0,5.0,80,25.7
98801001,BELEP AEROD.,-19.719833,163.661000,88,2024010101,0.0,4.5,80,25.9
98801001,BELEP AEROD.,-19.719833,163.661000,88,2024010102,0.0,4.8,80,26.1
98801001,BELEP AEROD.,-19.719833,163.661000,88,2024010103,0.0,5.2,90,26.4
98801001,BELEP AEROD.,-19.719833,163.661000,88,2024010104,0.0,5.5,90,26.4
98801001,BELEP AEROD.,-19.719833,163.661000,88,2024010105,0.0,5.1,80,26.3
98801001,BELEP AEROD.,-19.719833,163.661000,88,2024010106,0.0,4.8,80,26.6
98801001,BELEP AEROD.,-19.719833,163.661000,88,2024010107,0.0,4.9,90,27.3
98801001,BELEP AEROD.,-19.719833,163.661000,88,2024010108,0.0,5.4,90,29.5
98801001,BELEP AEROD.,-19.719833,163.661000,88,2024010109,0.0,6.2,80,30.2
98801001,BELEP AEROD.,-19.719833,163.661000,88,2024010110,0.0,7.3,80,29.5
98801001,BELEP AEROD.,-19.719833,163.661000,88,2024010111,0.6,7.0,90,28.3
98801001,BELEP AEROD.,-19.719833,163.661000,88,2024010112,0.0,6.9,90,30.7

Pour la suite de l'exercice, on dispose du code Python donné en annexe ainsi que de la documentation suivante :

DOCUMENTATION :

• with open('mon_fichier.csv', 'r') as csvfile, ouvre le fichier mon_fichier.csv en mode lecture (r) ;
• csv.reader(csvfile, delimiter=','), renvoie un objet lecteur, qui itérera sur les lignes de l'objet csvfile donné. Chaque ligne lue depuis le fichier csv est renvoyée comme une liste de chaînes de caractères.

Dans la console, on saisit la suite d'instructions suivante :

>>> liste_obs = creation_liste_obs('observations.csv')
>>> liste_obs = supp_champs(liste_obs)
>>> transtype(liste_obs)
>>> liste_obs[0]
[98801001, 'BELEP AEROD.', -19.719833, 163.661, 88, 2024010100, 0.0, 5.0, 80, 25.7]

6. Expliquer cette liste de commandes et le résultat obtenu.

Dans la suite de l'exercice, la variable liste_obs est initialisée avec les valeurs du fichier observations.csv.

La fonction distance renvoie la distance entre deux points définis par leur latitude et leur longitude. Cette fonction utilise des fonctions du module Python math.

7. Donner la ligne de commande nécessaire à l'utilisation du module Python math.

On rappelle que les informations relatives à une observation sont données dans l'ordre suivant :

ID_STATION,NOM_STATION,LATITUDE,LONGITUDE,ALTITUDE,AAAAMMJJHH,PRECIPITATION,FORCE_VENT,DIR_VENT,TEMPERATURE

8. Compléter les lignes 40 et 41 de la fonction coord, qui prend en paramètres une liste d'observations l_obs et un nom de station stat_ref, et qui renvoie un tuple composé de sa latitude et sa longitude.

On considère la fonction liste_stations qui prend en paramètres une liste d'observations l_obs, un nom de station stat_ref et un flottant dist, et qui renvoie la liste des identifiants ID_STATION des stations données dans la liste l_obs situées à une distance inférieure à dist de la station de référence stat_ref.

9. Écrire un algorithme en pseudo-code de la fonction liste_stations.

10. Écrire une fonction nettoyage qui prend en paramètres une liste d'observations l_obs et une station de référence stat_ref (nom de la station), et qui renvoie la liste des températures des stations données dans la liste d'observations l_obs situées à une distance inférieure à 2000 unités de la station de référence stat_ref.

11. Écrire la fonction moyenne qui calcule et renvoie la moyenne de toutes les valeurs de type float contenues dans la liste passée en paramètre.

On considère maintenant le fichier observations2.csv donnant heure par heure les observations de la journée du 01/01/2024 pour toutes les stations météorologiques de France.

12. Donner les commandes permettant d'obtenir la moyenne des températures des stations situées à moins de 2000 unités de la station Paris_11 le 1er janvier 2024.

ANNEXE — code Python fourni :

import csv
 
def creation_liste_obs(fichier):
    liste_obs = []
    with open(fichier, 'r') as csvfile:
        fic = csv.reader(csvfile, delimiter=',')
        for ligne in fic:
            liste_obs.append(ligne)
    return liste_obs
 
def supp_champs(L):
    res = []
    for i in range(1, len(L)):
        res.append(L[i])
    return res
 
def transtype(L):
    i = 0
    while i < len(L):
        L[i] = [int(L[i][0]),
                L[i][1],
                float(L[i][2]),
                float(L[i][3]),
                int(L[i][4]),
                int(L[i][5]),
                float(L[i][6]),
                float(L[i][7]),
                int(L[i][8]),
                float(L[i][9])]
        i = i + 1
 
def distance(p1, p2):
    """Renvoie la distance entre deux points définis par leur
    latitude et leur longitude. p1 et p2 sont des tuples
    (latitude, longitude)"""
    # Cette fonction n'est pas à compléter
 
def coord(l_obs, stat_ref):
    """Renvoie la latitude et la longitude données dans la
    liste d'observations l_obs de la station stat_ref"""
    # Cette fonction est à compléter à la question 8.
    for obs in l_obs:
        if ... :
            return ..., ...
 
def liste_stations(l_obs, stat_ref, dist):
    """Renvoie la liste des identifiants ID_STATION des
    stations données dans la liste l_obs situées à une distance
    inférieure à dist de la station de référence stat_ref"""
    # Cette fonction n'est pas à compléter
 
def nettoyage(l_obs, stat_ref):
    """Renvoie la liste des températures des stations données
    dans la liste d'observations l_obs situées à une distance
    inférieure à 2000 unités de la station de référence
    stat_ref."""
    # Cette fonction est à compléter à la question 10.
 
def moyenne(L):
    """Calcule et renvoie la moyenne de tous les nombres
    contenus dans la liste passée en paramètre. L est une liste de
    flottants."""
    # Cette fonction est à compléter à la question 11.

Exercice 2 (6 points) — Structure de pile, programmation orientée objet et algorithmique

Cet exercice porte sur la structure de pile, la programmation objet et l'algorithmique.

Défi Tubes est un jeu à un joueur. Le joueur dispose de 4 tubes. Chaque tube peut contenir de 0 à 3 phases. Chaque phase possède une couleur. Il y a 3 couleurs possibles. On peut s'imaginer ces phases comme des palets de couleur dans le tube. Pour modéliser les couleurs, on utilisera les entiers 1, 2 et 3. Lorsqu'un tube contient 0 phase, on dit que le tube est vide. Lorsqu'il en a 3, on dit qu'il est plein. Lorsqu'un tube n'est pas vide, sa dernière couleur est la couleur de sa phase supérieure (celle la plus proche de l'ouverture du tube).

Exemple (figure 1) : un tube contenant, du fond vers l'ouverture, les couleurs 2 puis 1 puis 1 — sa dernière couleur est donc 1.

Le jeu Défi Tube consiste à verser successivement la dernière couleur d'un tube dans un autre tube, avec les contraintes suivantes :

• on ne peut rien verser dans un tube plein ;
• pour verser un tube 1 dans un tube 2 (les deux tubes concernés par un versement, pas nécessairement les tubes numérotés 1 et 2 du jeu), il faut que la dernière couleur du tube 1 soit la même que celle du tube 2 ou que le tube 2 soit vide. Dans ces deux cas, on retire la dernière couleur du tube 1 pour qu'elle devienne la dernière couleur du tube 2. On réitère cela tant que la dernière couleur du tube 1 est la même et que le tube 2 n'est pas plein.

Le jeu se termine lorsque 3 des 4 tubes sont pleins et que leurs 3 phases sont de même couleur.

Les figures 2 à 5 ci-dessous représentent un exemple de partie du jeu Défi Tube (dans chaque tube, la valeur du bas est celle du fond, la valeur du haut est la dernière couleur) :

• Figure 2 — état initial. tube 1 : fond 1, dessus 3 (2 phases, 1 place libre). tube 2 : fond 3, dessus 3 (2 phases). tube 3 : fond 2, dessus 2 (2 phases). tube 4 : fond 2, milieu 1, dessus 1 (3 phases, plein).
• Figure 3 — on a versé le tube 1 dans le tube 2. tube 1 : 1 (1 phase). tube 2 : 3, 3, 3 (plein). tube 3 : inchangé (fond 2, dessus 2). tube 4 : inchangé (fond 2, milieu 1, dessus 1).
• Figure 4 — on a versé le tube 4 dans le tube 1. tube 1 : 1, 1, 1 (plein). tube 2 : inchangé, 3, 3, 3 (plein). tube 3 : inchangé (fond 2, dessus 2). tube 4 : 2 (1 phase).
• Figure 5 — on a versé le tube 3 dans le tube 4. tube 1 : inchangé, 1, 1, 1 (plein). tube 2 : inchangé, 3, 3, 3 (plein). tube 3 : vide. tube 4 : 2, 2, 2 (plein).

À la figure 5, la partie est terminée (3 des 4 tubes — 1, 2 et 4 — sont pleins d'une seule couleur).

1. Donner un exemple d'une autre séquence de versements qui aurait permis de terminer le jeu en partant de la situation de la figure 4.

Ainsi le déroulement du jeu n'est pas unique.

Partie A : Les tubes

Pour modéliser le jeu Défi Tube, chaque tube sera représenté par une pile finie de taille maximale 3. Les tubes sont modélisés par des objets de la classe tube dont le code est donné ci-dessous.

class tube:
    def __init__(self):
        self.taille = 0
        self.contenu = [0, 0, 0]
 
    def est_vide(self):
        return self.taille == 0
 
    def empiler(self, couleur):
        if self.taille < 3:
            self.contenu[self.taille] = couleur
            self.taille = self.taille + 1
 
    def depiler(self):
        if self.taille > 0:
            self.taille = self.taille - 1
            couleur = self.contenu[...]
            self.contenu[self.taille] = 0
            return ...
        else:
            return ...

Chaque instance de la classe tube a deux attributs : l'attribut taille représente le nombre d'éléments non nuls dans le tube ; l'attribut contenu représente la liste (de taille 3) des éléments du tube. Lorsqu'une phase n'est pas vide, elle contient une couleur 1, 2 ou 3. Lorsqu'une phase est vide, sa valeur est 0.

Par exemple, le tube contenant, du fond vers l'ouverture, les couleurs 1 puis 3 (2 phases, la troisième place restant libre) sera modélisé avec la classe tube par le code :

t = tube()
t.taille = 2
t.contenu = [1, 3, 0]

2. Expliquer ce qu'est la structure de pile en précisant ce que sont les méthodes empiler et depiler.

3. Expliquer les lignes 11 et 12 du code de la classe tube (celles de la méthode empiler).

4. Recopier et compléter le code de la méthode depiler précédente. Lorsque le tube est vide, la méthode depiler doit renvoyer -1.

5. Écrire une méthode est_plein de la classe tube. Cette méthode renvoie True si le tube est plein et False si le tube n'est pas plein.

6. Écrire une méthode est_homogene de la classe tube qui renvoie True si le tube est plein et si son contenu est composé de trois fois la même couleur, et qui renvoie False sinon.

7. Écrire une méthode derniere_couleur de la classe tube qui renvoie le numéro de la dernière couleur du tube. Si le tube est vide, la méthode renverra la valeur -1.

Le code incomplet d'une méthode verser de la classe tube est donné ci-dessous :

def verser(self, other):
    while ... :
        couleur = self.depiler()
        other.empiler(couleur)

8. Recopier et compléter le code de cette méthode verser afin de verser l'instance self de la classe tube dans l'instance other. On veillera à vérifier toutes les conditions nécessaires au bon déroulement de cette opération.

Partie B : Le jeu

Pour modéliser le jeu, on appellera état du jeu une liste de 4 tubes. Le code suivant permet de représenter l'état de la figure 2.

tube1 = tube()
tube1.contenu = [1, 3, 0]
tube1.taille = 2
tube2 = tube()
tube2.contenu = [3, 3, 0]
tube2.taille = 2
tube3 = tube()
tube3.contenu = [2, 2, 0]
tube3.taille = 2
tube4 = tube()
tube4.contenu = [1, 1, 2]
tube4.taille = 3
etat = [tube1, tube2, tube3, tube4]

9. En utilisant la méthode verser et la variable etat représentant la figure 2, écrire un code permettant de faire passer la variable etat de la représentation en figure 2 à celle de la figure 3.

10. Écrire une fonction gagne qui prend comme argument un état et qui renvoie True si la partie est terminée et False sinon.

Exercice 3 (8 points) — Programmation Python, graphes et réseaux

Cet exercice porte sur la programmation Python, les graphes et les réseaux.

Partie A

On considère un réseau d'antennes radios, où des disques représentent la zone d'émission de chaque antenne (figure 1). Pour éviter toute interférence, deux antennes « proches » géographiquement doivent émettre à des fréquences différentes.

On modélise ce réseau d'antennes par un graphe non orienté, appelé graphe d'interférences, dont les sommets sont les antennes numérotées de 1 à n (n entier naturel supérieur ou égal à 1), deux sommets étant reliés par une arête si leurs zones d'émission s'intersectent.

Soit G le graphe associé au réseau d'antennes (figure 2) : 9 sommets, numérotés de 1 à 9, avec les arêtes suivantes : 1-2, 1-5, 2-3, 2-4, 2-5, 3-4, 3-8, 4-5, 4-6, 5-6, 5-7, 8-9 (soit 12 arêtes au total — le sommet 9 n'est relié qu'au sommet 8, le sommet 7 n'est relié qu'au sommet 5).

Les fréquences à allouer sont associées à des couleurs comme rouge, vert, jaune, bleu, etc. Pour éviter les interférences, la coloration doit être une coloration propre : deux sommets adjacents ne peuvent recevoir la même couleur.

Dans cet exercice, on représente le graphe G par un dictionnaire de listes d'adjacence dont les clés sont les sommets (de type int) et les valeurs sont des listes de voisins du sommet clé, chaque liste contenant des éléments de type int (les voisins étant donnés dans l'ordre croissant).

1. Donner la valeur associée à la clé 1 dans ce dictionnaire.

2. Écrire une fonction voisins, qui prend en paramètres un dictionnaire et un entier, telle que voisins(graphe, k) renvoie une liste contenant les voisins du sommet k dans le graphe modélisé par le dictionnaire de listes d'adjacence graphe.

Exemple :

>>> voisins(G, 2)
[1, 3, 4, 5]

L'algorithme de Welsh et Powell consiste à colorer séquentiellement le graphe en visitant les sommets par ordre de degrés décroissants. Le degré d'un sommet d'un graphe non orienté est le nombre d'arêtes dont le sommet est une extrémité. L'idée est que les sommets ayant beaucoup de voisins sont plus difficiles à colorer : il faut les colorier en premier.

3. Écrire la fonction degre_du_sommet qui prend en paramètres un graphe modélisé par le dictionnaire de listes d'adjacence graphe et un sommet sommet, et qui renvoie le degré du sommet sommet.

Exemple :

>>> degre_du_sommet(G, 2)
4

4. Écrire la fonction degre_sommets qui prend en paramètre un graphe modélisé par le dictionnaire de listes d'adjacence graphe et qui renvoie la liste des tuples (sommet, degre) de chaque sommet du graphe.

Exemple :

>>> degre_sommets(G)
[(1, 2), (2, 4), (3, 3), (4, 4), (5, 5), (6, 2), (7, 1), (8, 2), (9, 1)]

On définit la fonction tri_liste ci-après :

def tri_liste(l_deg):
    """l_deg : liste de tuples (sommets, degré).
    Trie la liste l_deg par degrés décroissants"""
    for i in range(len(l_deg) + 1):
        som_max = i
        deg_max = l_deg[i][1]
 
        for j in range(i + 1, len(l_deg)):
            if deg_max < l_deg[j][1]:
                som_max = j
                deg_max = l_deg[j][1]
        temp = l_deg[i]
        l_deg[i] = l_deg[som_max]
        l_deg[som_max] = temp
    return l_deg

À l'exécution, tri_liste([(1, 2), (2, 2), (3, 3)]) renvoie l'erreur suivante :

IndexError: list index out of range

5. Commenter puis corriger cette erreur.

6. Choisir, parmi les tris proposés, celui qui correspond à la fonction tri_liste : tri par insertion, tri par sélection, tri fusion, tri bulle.

7. Écrire une fonction tri_sommets qui prend en paramètre un graphe graphe et qui ne renvoie que la liste des sommets du graphe graphe triés par degré décroissant. On pourra utiliser les fonctions définies dans les questions précédentes.

Exemple :

>>> tri_sommets(G)
[5, 2, 4, 3, 1, 6, 8, 7, 9]

On suppose que le graphe est planaire, c'est-à-dire qu'il existe une représentation de ce graphe dans un plan pour laquelle les arêtes ne se croisent pas, et on définit la fonction coloration ci-après.

def coloration(g):
    """Renvoie une coloration du graphe g"""
    # Algorithme de Welsh-Powell, limité à 4 couleurs
 
    couleur = ['Rouge', 'Bleu', 'Vert', 'Jaune']
    coloration_sommets = {}
    for s_i in g:
        coloration_sommets[s_i] = None
    for s_i in tri_sommets(g):
        couleurs_voisins_s_i = [coloration_sommets[s_j] for s_j in voisins(g, s_i)]
        k = 0
        while couleur[k] in couleurs_voisins_s_i:
            k = k + 1
        coloration_sommets[s_i] = couleur[k]
    return coloration_sommets

8. Donner le type et le contenu de la variable coloration_sommets de la fonction coloration ci-dessus pour le graphe G, après exécution de la boucle des lignes 7 et 8 (celle qui initialise coloration_sommets).

9. Recopier et compléter le retour de la fonction coloration appliquée au graphe G donné plus haut, dont le début est {1: 'Vert', 2: ..., ...}.

Partie B

On s'intéresse maintenant à un réseau informatique (figure 3). Dans cette partie, les adresses IP sont composées de 4 octets, soit 32 bits. Elles sont notées X1.X2.X3.X4, où X1, X2, X3 et X4 sont les représentations décimales des 4 octets. La notation X1.X2.X3.X4/n signifie que les n premiers bits de l'adresse IP représentent la partie « réseau », les bits suivants représentent la partie « hôte ».

Description du réseau (figure 3) : le réseau local L1 (adresse IP de l'ordinateur P1 : 190.12.10.25/24, relié à un switch S1) est relié à un routeur R1. Le réseau local L2 (adresse réseau 12.128.0.0, masque de sous-réseau 255.255.0.0, switch S2, ordinateur P2) est relié à un routeur R9. Neuf routeurs (R1 à R9) forment le cœur du réseau, reliés par les liaisons suivantes (avec leur débit) : R1–R2 (1 Gb/s), R1–R5 (10 Gb/s), R2–R3 (100 Mb/s), R2–R5 (100 Mb/s), R2–R4 (100 Mb/s), R5–R4 (1 Gb/s), R5–R6 (10 Gb/s), R5–R7 (100 Mb/s), R4–R6 (10 Gb/s), R4–R3 (1 Gb/s), R3–R8 (10 Gb/s), R8–R9 (1 Gb/s).

Extrait de l'arborescence du système de fichiers de l'ordinateur P2 (figure 4) : la racine / contient les répertoires bin, etc, home et lib. home contient les répertoires picky, maurice et timothee. timothee contient le répertoire travail, le répertoire photos (qui contient le fichier photo1.png), le fichier fic1.txt et le répertoire important (qui contient le fichier prog1.py). travail contient les répertoires TP (qui contient le fichier prog2.py) et cours.

Extrait du manuel de la commande cp (figure 5) :

NAME
    cp - copy files and directories
 
SYNOPSIS
    cp [OPTION]... [-T] SOURCE DEST
    cp [OPTION]... SOURCE... DIRECTORY
    cp [OPTION]... -t DIRECTORY SOURCE...
 
DESCRIPTION
    Copy SOURCE to DEST, or multiple SOURCE(s) to DIRECTORY.

10. Donner une commande en ligne qui permet de copier le fichier prog1.py dans le répertoire TP lorsqu'on se trouve dans le répertoire nommé important.

11. Donner la commande qui permet de vérifier si l'ordinateur P1 est accessible lorsque l'on travaille sur l'ordinateur P2.

12. Donner une adresse possible pour l'ordinateur P2 du réseau local L2.

Dans le cadre du protocole RIP, le chemin emprunté par les informations est celui qui aura la distance la plus petite en nombre de sauts. Dans le cadre du protocole OSPF, le chemin emprunté par les informations est celui qui aura le coût total minimal.

Extrait des tables de routage (chaque routeur ne connaît, dans cet extrait, que sa route vers le réseau où se trouve R9) :

13. Donner le chemin emprunté par un paquet de données allant de l'ordinateur P1 à l'ordinateur P2, en utilisant l'extrait de la table de routage.

14. Donner le nom du protocole de routage qui semble être utilisé.

Dans les questions suivantes, on utilise le protocole de routage OSPF. Pour calculer le coût C d'une liaison, on utilise la formule C = 10⁸ / BP, où BP est la bande passante en bits par seconde.

15. Calculer les coûts pour des liaisons de 100 Mbit/s, 1 Gbit/s et 10 Gbit/s.

16. Déterminer la route qui sera empruntée par le paquet de données envoyé de l'ordinateur P1 à l'ordinateur P2, en respectant le protocole OSPF.