Bac NSI 2025 Polynésie jour 1

R4 et R5 sont directement reliés à R1 ; R6 se rejoint via R5. On conserve la convention de l’énoncé, qui attribue 0 à un voisin direct et 1 à une destination atteinte après un intermédiaire. Si l’on compte les liaisons franchies plutôt que les intermédiaires, ces nombres augmentent de 1, mais les meilleurs chemins restent les mêmes.

R1 → R5 → R6 → Internet. Seul R6 possède la sortie Internet ; l’atteindre via le voisin direct R5 minimise les intermédiaires. RIP ne tient pas compte ici du faible débit du lien R1-R5.

Un lien à 100 Mbit/s coûte 1 ; à 10 Mbit/s, 10 ; à 1 Mbit/s, 100. Le détour par plusieurs liens rapides évite les liens directs très coûteux. Le prochain saut est toujours R2, même lorsque la destination finale est un autre routeur.

R1 → R2 → R3 → R4 → R5 → R6 → Internet. Le coût dans le maillage vaut 10 + 1 + 1 + 1 + 1 = 14, contre 101 pour R1-R5-R6. OSPF accepte davantage de sauts si leur coût total est plus petit.

R1 → R5 → R6, de coût 100 + 1 = 101. L’autre départ disponible, R1-R4-R5-R6, coûte 102. Aucun chemin ne peut utiliser le routeur en panne ; on retire donc R2 et toutes ses liaisons avant de comparer.

Le réseau est 192.128.0.0. Au deuxième octet, seuls les deux bits de poids fort sont conservés par le masque : 10101000 AND 11000000 = 10000000. Ce masque correspond à /10, et ne se traite donc pas comme un /24.

Le broadcast est 192.191.255.255. Le complément du masque met à 1 tous les bits hôtes ; le OU les ajoute au préfixe réseau conservé.

Il reste 16 bits hôtes, donc 2¹⁶ = 65536 combinaisons. Réseau et diffusion ne s’attribuent pas à une machine, d’où 65534 adresses hôtes. La passerelle occupe déjà l’une d’elles : un pool DHCP qui doit l’exclure en conserve au plus 65533, avant d’éventuelles autres réservations. Le nombre habituellement attendu pour la capacité du sous-réseau est 65534 ; préciser ce qui est compté évite de redistribuer l’adresse de la passerelle.

def masquer(self, masque: str) -> str:
    tmp = []
    ip = self.octets()
    crible = IPv4(masque).octets()
    for i in range(4):
        tmp.append(ip[i] & crible[i])
    return '.'.join([str(octet) for octet in tmp])

Le ET porte sur les entiers correspondant au même octet. join attend des chaînes : on convertit donc chaque résultat avec str. Pour 192.168.1.100 et 255.192.0.0, les entiers calculés sont 192,128,0,0.

def adresse_suivante(self, adresse_max: str) -> str:
    assert self.adresse < adresse_max
    liste_courante = self.octets()
    liste_suivante = []
    retenue = 1
    for index in range(4):
        somme = liste_courante[3 - index] + retenue
        valeur, retenue = somme % 256, somme // 256
        liste_suivante = [str(valeur)] + liste_suivante
    return '.'.join(liste_suivante)

Une IPv4 se comporte comme un nombre à quatre chiffres en base 256. On ajoute 1 en partant du dernier octet. Le reste modulo 256 donne l’octet résultat, le quotient entier donne la retenue. On ajoute chaque nouvelle chaîne devant la liste puisque les octets sont calculés de droite à gauche.

Limite de l’assertion fournie : comparer les adresses décimales comme des chaînes ne compare pas correctement leurs valeurs numériques. Par exemple, '192.168.1.9' < '192.168.1.10' est faux. Pour rendre la borne fiable, remplacer la ligne 13 par assert self.octets() < IPv4(adresse_max).octets(). Le calcul des retenues, lui, est correct. L’exemple .255 → octet suivant .0 est un successeur numérique, pas une promesse que cette adresse est attribuable sur tout masque.

On peut jouer les cases 1 et 3. La première remplie est 2, donc son successeur est 3. En Python, ces coups auront pour indices 0 et 2.

def initialiser(n):
    return [False for _ in range(n)]

Chaque case est un booléen faux. Une compréhension crée exactement n positions ; [False] * n conviendrait aussi puisque les booléens sont immuables.

def victoire(tab):
    for etat_case in tab:
        if etat_case == False:
            return False
    return True

Dès qu’une case vide est rencontrée, la victoire est impossible et on renvoie faux. Le retour vrai doit attendre la fin de la boucle. Pour une liste vide, cette définition renvoie vrai par convention logique ; le jeu physique suppose normalement n positif.

def indice_premiere_case_occupee(tab):
    for i in range(len(tab)):
        if tab[i]:
            return i
    return None

On parcourt les indices de gauche à droite et on retourne immédiatement le premier vrai. Si aucun n’est trouvé, le retour est None. L’indice 0 est une réponse valide : il ne doit pas être confondu avec l’absence de résultat.

def coup_valide(tab, case):
    if type(case) is not int or case < 0 or case >= len(tab):
        return False
    if case == 0:
        return True
    premier = indice_premiere_case_occupee(tab)
    return premier is not None and not victoire(tab) and case == premier + 1

On contrôle les bornes avant de manipuler la case. L’indice 0 est toujours autorisé s’il existe. Pour les autres indices, il faut un premier pion, un plateau pas déjà plein, et viser exactement la position suivante.

Tester premier is not None est nécessaire : un premier pion d’indice 0 autorise précisément l’indice 1. Un test if premier le rejetterait par erreur. Le test de type exclut aussi les booléens, qui sont des sous-types d’entier en Python.

def changer_case(tab, case):
    if coup_valide(tab, case):
        tab[case] = not tab[case]
    return tab

not inverse directement un booléen. Le tableau est modifié en place uniquement dans la branche valide, puis le même objet est retourné. La fonction n’a pas à dupliquer les règles de légalité : elle réutilise coup_valide.

print('Vider case ' + str(n))

On convertit l’entier en chaîne avant la concaténation. L’alternative print('Vider case', n) donne également le bon affichage grâce à l’espace ajouté par print.

Vider case 1
Vider case 3
Remplir case 1
Vider case 2
Vider case 1

L’appel commence par vider(1), puis vide 3, rétablit 1 et termine avec vider(2). Ce dernier ne produit rien pour ses appels d’argument 0, puis affiche vider 2 et vider 1. On doit suivre l’ordre d’exécution, pas seulement lister les appels directs de vider 3.

def remplir(n):
    if n == 1:
        print('Remplir case 1')
    elif n > 1:
        remplir(n - 1)
        vider(n - 2)
        print('Remplir case ' + str(n))
        remplir(n - 2)

Pour remplir n, on commence par remplir les n-1 premières cases. On vide ensuite les n-2 premières : la première case occupée devient n-1 et autorise alors n. On remplit n, puis on restaure les n-2 premières. C’est l’inversion, dans l’ordre inverse, des opérations de vider.

Les fonctions manipulent des préfixes d’un plateau plus grand : « vider les deux premières cases » ne signifie pas que le plateau global a seulement deux cases. Cette distinction permet de relier leurs appels récursifs aux règles du jeu.

Non. Le nombre d’actions suit T(n) = T(n - 1) + 2T(n - 2) + 1, avec T(0)=0 et T(1)=1. Il croît exponentiellement, de l’ordre de 2ⁿ. Les premières valeurs 1,2,5,10,21 montrent déjà la croissance ; à 2000, afficher la solution est irréaliste.

En plus, la profondeur de récursion croît avec n et peut dépasser la limite de Python. Augmenter cette limite ou écrire une version itérative n’éliminerait pas le nombre astronomique de coups à produire.

gen_mdp(8, True, True, False)

8 satisfait la longueur minimale et False interdit les caractères spéciaux. Cet appel autorise les deux types de lettres ; il ne garantit pas que chacun apparaisse, distinction étudiée en Q5.

minuscules = [chr(i) for i in range(97, 123)]
majuscules = [chr(i) for i in range(65, 91)]
caracteres_speciaux = ([chr(i) for i in range(33, 48)]
                      + [chr(i) for i in range(58, 65)])

Les bornes droites de range sont exclues :123 inclut le code 122 de z,91 inclut 90 de Z. Les deux intervalles spéciaux évitent les chiffres 48 à 57, qui ne sont pas autorisés dans cette fonction. On obtient 26 minuscules,26 majuscules et 22 spéciaux.

if cont_min:
    jeu_caracteres = jeu_caracteres + minuscules
if cont_maj:
    jeu_caracteres = jeu_caracteres + majuscules
if cont_spe:
    jeu_caracteres = jeu_caracteres + caracteres_speciaux

Les trois tests sont indépendants : plusieurs catégories peuvent être activées à la fois. Une chaîne de elif n’en ajouterait qu’une, ce qui serait faux. L’assertion garantit qu’au moins une catégorie est choisie, donc que la liste n’est pas vide.

mot_de_passe = mot_de_passe + jeu_caracteres[randint(0, n - 1)]

Les indices valides vont de 0 à n-1. Utiliser n comme borne pourrait produire un indice hors liste. Chaque tirage ajoute un caractère à la chaîne en construction.

Même avec gen_mdp(12, True, False, True), chaque tirage peut choisir une minuscule : il est possible d’obtenir 12 lettres sans aucun spécial. Inversement, tous les tirages peuvent choisir des spéciaux. Les booléens autorisent une catégorie, ils n’imposent pas sa présence.

Pour garantir la composition, il faudrait choisir d’abord un caractère de chaque catégorie obligatoire, compléter jusqu’à la longueur voulue et mélanger les positions. Pour un véritable secret, on utiliserait aussi une source aléatoire adaptée à la sécurité, comme secrets, plutôt que le générateur random de l’exercice.

mot_de_passe est la clé primaire de compte, donc chaque valeur doit être unique dans toute la table. Une seconde ligne contenant le même mot de passe serait rejetée même si son site diffère. C’est une contrainte du schéma choisi, pas une impossibilité générale du Web.

SELECT url FROM site;

Une ligne de site porte une URL. La table compte n’est pas nécessaire pour cette liste.

UPDATE compte
SET mot_de_passe = 'yhTS?d@UTJe'
WHERE mot_de_passe = '@rDfohpj!&';

Le filtre sur l’ancienne clé identifie une seule ligne. La question demande explicitement de ne pas changer la date ; une application réelle devrait normalement mettre cette information à jour aussi.

SELECT DISTINCT id_site
FROM compte
WHERE renouvellement < '2024-03-20';

« Plus d’un an » exclut la date exactement égale au 20 mars 2024 : on utilise un test strict. DISTINCT évite de répéter un site qui possède plusieurs comptes anciens, comme Votremailp dans l’extrait.

À longueur fixe et avec les zéros initiaux, l’ordre lexicographique compare d’abord l’année, puis le mois, puis le jour : il coïncide avec l’ordre chronologique. En JJ-MM-AAAA, comparer les jours d’abord ferait par exemple placer 02-01-2025 avant 31-12-2024, alors que la première date est plus récente.

SELECT compte.utilisateur, compte.mot_de_passe
FROM compte JOIN site ON compte.id_site = site.id
WHERE site.nom_site = 'Votremailp'
ORDER BY compte.renouvellement;

La jointure permet de filtrer avec le nom du site tout en affichant les données des comptes. Le tri croissant met le renouvellement de 2018 avant celui de 2022. Ne pas coder directement l’identifiant 4 : la requête doit rester valable si cet identifiant change.

Les données d’un site, son nom et son URL, ne sont stockées qu’une fois même si Alice y possède plusieurs comptes. Si l’URL change, une seule mise à jour suffit et tous les comptes retrouvent la même valeur via la référence. Cela réduit la redondance et les incohérences possibles.

chiffrement('gestionnaire.db', '../Perso/secret.db', '../Perso/cle')

La source se trouve dans le répertoire courant. .. remonte de Documents vers home, puis on entre dans Perso pour la destination et la clé. Un chemin est un argument de la fonction : il n’est pas nécessaire de déplacer le répertoire courant.

 A3 : 10100011
 59 : 01011001
XOR : 11111010 = FA

On compare les huit positions indépendamment : le résultat est 1 si les bits diffèrent. On regroupe ensuite en deux paquets de quatre :1111 vaut F et 1010 vaut A.

Les quatre possibilités donnent a dans la dernière colonne. On peut aussi utiliser l’associativité : (a XOR b) XOR b = a XOR (b XOR b) = a XOR0 = a.

Il est symétrique : la même clé permet de chiffrer et déchiffrer. Réappliquer XOR avec cette clé à chaque bit du texte chiffré rend le bit source, d’après la propriété démontrée.

La seule égalité de taille ne suffit pas à prouver la sécurité : une clé de masque jetable doit être aléatoire, secrète et non réutilisée. Ces propriétés ne sont pas garanties par la simple description de la fonction.

chmod 600 secret.db

-rw-r--r-- donne lecture-écriture à Alice, lecture au groupe eleves et lecture aux autres utilisateurs. Tout utilisateur autorisé à traverser les répertoires peut donc lire et copier le fichier pour l’analyser hors ligne.

chmod600 garde lecture et écriture pour Alice et retire les droits au groupe et aux autres. Elle doit aussi protéger la clé, le fichier source non chiffré et les répertoires concernés. Restreindre l’accès ne renforce pas mathématiquement le chiffrement, mais réduit les possibilités d’en récupérer une copie.

Cette question analyse les quatre critères reproduits dans le PDF. Il ne faut pas transformer une recommandation datée de longueur minimale en garantie actuelle suffisante pour tous les comptes.