Bac NSI 2025 Métropole remplacement jour 2

Les lettres distinctes de la clé sont E, P, R, U, V, D, N, S, I, dans cet ordre. On ne trie pas cette partie : seul le complément alphabétique est trié. W ne doit pas réapparaître dans le remplissage.

assert 'W' not in clef

La condition doit être vraie pour continuer. Avec une clé contenant W et les assertions actives, une AssertionError est levée. Cela vérifie l’hypothèse demandée ; le code suppose par ailleurs des lettres majuscules de l’alphabet retenu.

def creer_carre(liste_clef):
    carre = [[0 for i in range(5)] for j in range(5)]
    for i in range(25):
        carre[i // 5][i % 5] = liste_clef[i]
    return carre

i // 5 donne le numéro de ligne et i % 5 la colonne. L’indice 4 est encore en(0,4), l’indice 5 passe en(1,0), et 24 est en(4,4). La compréhension imbriquée crée cinq lignes distinctes.

digrammes.append(message[i] + message[i + 1])

Dans cette branche, les deux lettres consécutives sont différentes : on les ajoute telles quelles et on avance de 2. Dans la branche des doublons, on ajoute X après la première et on n’avance que de 1 pour retraiter la seconde.

['BO', 'NJ', 'OU', 'RX']

Aucun doublon adjacent ne force d’insertion. Les six premières lettres donnent trois paires ; le R final reçoit X pour compléter la dernière.

Le message chiffré est HVQGNVCU. L’ordre des deux lettres de chaque rectangle doit rester lié à leurs lignes respectives ; permuter les coins inverserait le résultat.

def ligne_colonne(lettre, carre):
    for i in range(5):
        for j in range(5):
            if carre[i][j] == lettre:
                return (i, j)

Les deux boucles inspectent les 25 cases et renvoient le couple dès qu’elles rencontrent la lettre. L’unicité dans le carré rend ce résultat non ambigu. Pour une lettre absente, Python renverrait implicitement None ; les entrées du chiffrement doivent donc respecter l’alphabet choisi.

def sur_la_meme_ligne(digramme, carre):
    i1, j1 = ligne_colonne(digramme[0], carre)
    i2, j2 = ligne_colonne(digramme[1], carre)
    return i1 == i2

On compare seulement les premières coordonnées. Les colonnes peuvent différer. RT donne faux, PL donne vrai. La fonction analogue sur_la_meme_colonne compare les deux secondes coordonnées.

def chiffrer_digramme(digramme, carre):
    lettre1 = digramme[0]
    lettre2 = digramme[1]
    i1, j1 = ligne_colonne(lettre1, carre)
    i2, j2 = ligne_colonne(lettre2, carre)
    if sur_la_meme_ligne(digramme, carre):
        digramme_chiffre = carre[i1][(j1 + 1) % 5] + carre[i2][(j2 + 1) % 5]
    elif sur_la_meme_colonne(digramme, carre):
        digramme_chiffre = carre[(i1 + 1) % 5][j1] + carre[(i2 + 1) % 5][j2]
    else:
        digramme_chiffre = carre[i1][j2] + carre[i2][j1]
    return digramme_chiffre

Dans une colonne, on change les indices de ligne et conserve les colonnes. Le modulo 5 assure le retour du bord inférieur vers la première ligne. Dans le cas rectangle, on conserve i1, i2 et on échange j1,j2.

Le cas même ligne est testé avant même colonne. Avec un digramme XX, que la règle de remplissage du sujet peut produire, ce code applique donc le cas de ligne. Une variante pratique devrait définir un caractère de remplissage de remplacement ; le sujet ne le prévoit pas.

def chiffrer_playfair(message, clef):
    carre = creer_carre(creer_liste_clef(clef))
    digrammes = couper_en_digrammes(message)
    resultat = ''
    for digramme in digrammes:
        resultat += chiffrer_digramme(digramme, carre)
    return resultat

Le carré est construit une fois, puis réutilisé pour toutes les paires. La concaténation conserve leur ordre. Pour VIVELANSI et PLAYFAIR, on obtient TBTHAYOMCT. Le message vide donne une chaîne vide.

Ce chiffrement historique sert ici à étudier tableaux et chaînes ; il ne convient pas à la protection actuelle de données sensibles. Le découpage avec des X n’est pas toujours réversible sans convention supplémentaire pour distinguer les X ajoutés des X réels.

ls -l

L’option -l demande le format long : type et permissions, nombre de liens, propriétaire, groupe, taille, date et nom. Une simple commande ls ne montre pas ces colonnes par défaut.

On écarte le premier tiret, qui indique le type de fichier, puis on découpe les neuf caractères en trois blocs. Le x du propriétaire ne donne pas automatiquement ce droit au groupe.

rm concat.pls

Le propriétaire indiqué est root. La commande de suppression est rm ; sa réussite dépend des droits sur le répertoire contenant l’entrée, et pas seulement des permissions de lecture/écriture du fichier. L’invite de la capture est celle d’alovelace, ce qui ne change pas le fait que la question se place du côté du propriétaire.

g cible le groupe ; -retire les droits ; wx retire l’écriture et l’exécution. La lecture du groupe reste en place, et les droits user/other ne changent pas.

Le fichier appartient à root. Si alovelace exécute la commande sans privilège particulier, elle échoue : être membre du groupe ne suffit pas pour modifier les permissions. L’état « après » décrit l’effet demandé lorsque la commande est lancée par le propriétaire ou avec l’autorisation nécessaire.

6. r, w,-donnent 110, soit 1×4 + 1×2 + 0×1 = 6. Le caractère tiret vaut 0, il ne représente pas un nombre négatif.

def bin_to_oct(chaine):
    return 4 * int(chaine[0]) + 2 * int(chaine[1]) + int(chaine[2])

Les caractères doivent être convertis en entiers avant la somme pondérée. Trois bits représentent une valeur de 0 à 7, donc un unique chiffre octal. La fonction renvoie un entier, comme demandé par les exemples 101→5 et 011→3.

'110101100'

Les trois groupes deviennent 110,101,100. La fonction ne vérifie pas si une lettre est à la bonne position : elle remplace tout caractère autre que tiret par 1. Le sujet suppose que la représentation symbolique est valide.

def symb_to_oct(chaine):
    repr_bin = symb_to_bin(chaine)
    user = repr_bin[0] + repr_bin[1] + repr_bin[2]
    group = repr_bin[3] + repr_bin[4] + repr_bin[5]
    other = repr_bin[6] + repr_bin[7] + repr_bin[8]
    return str(bin_to_oct(user)) + str(bin_to_oct(group)) + str(bin_to_oct(other))

Chaque groupe est converti séparément, puis les trois chiffres sont concaténés. Les str sont nécessaires : additionner trois entiers donnerait une somme, pas le code de permissions. Conserver une chaîne garde aussi un éventuel zéro initial.

mon_fichier = Fichier('concat.pls', 1257, 'root', 'www-data', 'rw-r--r--')

On respecte l’ordre du constructeur : nom, poids, propriétaire, groupe, permissions. Le type initial du fichier, le tiret de ls-l, ne fait pas partie des neuf caractères stockés dans permission.

def chown(self, nouveau_proprietaire):
    self.proprietaire = nouveau_proprietaire

Cette méthode modifie le modèle Python. Elle n’exécute pas une commande système et ne change pas réellement les droits d’un fichier du disque.

def get_executable(fichiers, proprietaire):
    resultat = []
    for fichier in fichiers:
        if fichier.proprietaire == proprietaire and fichier.permission[2] == 'x':
            resultat.append(fichier)
    return resultat

Deux conditions doivent être vraies : le propriétaire correspond et le troisième caractère du bloc user est x. La chaîne compte neuf caractères, donc cet indice est 2. Tester un x n’importe où accepterait à tort un fichier exécutable seulement par le groupe ou les autres.

INSERT INTO Produits (id_produit, nom, categorie, prix, id_fournisseur)
VALUES (10, 'croissant', 'Alimentaire', 0.90, 4);

Le fournisseur Boulangerie du Coin a l’identifiant 4. La quantité en stock n’est pas fournie ; la liste de colonnes permet de ne pas inventer cette donnée. Cette insertion suppose que la colonne omise accepte sa valeur par défaut ou NULL, aucune contrainte contraire n’étant donnée. Si le schéma réel exige une quantité non nulle, il faut obtenir cette information avant d’insérer.

UPDATE Fournisseurs
SET adresse = '78 Rue des Jeux', ville = 'Elbeuf', pays = 'France'
WHERE id_fournisseur = 3;

Le même fournisseur conserve son identifiant. On ne crée pas une nouvelle ligne, car tous ses produits doivent continuer à le référencer.

La requête donne le nom de chaque produit de catégorie Alimentaire. Sur l’extrait initial : Yaourts blanc x4, Lait et Pain. Si l’insertion de Q1 a été exécutée auparavant, croissant apparaît aussi. Le résultat ne contient ni les prix ni les fournisseurs.

SELECT Details.*
FROM Details JOIN Commandes ON Details.id_commande = Commandes.id_commande
WHERE Commandes.total_commande >= 1000;

On filtre le montant total de la commande, pas la valeur d’une seule ligne. La commande 2 vaut 1150€ ; ses deux détails, identifiants 3 et 4, sont donc tous deux renvoyés.

SELECT nom FROM Fournisseurs
WHERE pays = 'Espagne' OR pays = 'Italie';

Une ligne doit satisfaire l’un des deux pays. AND demanderait deux valeurs différentes dans la même colonne, ce qui serait impossible ici. Le résultat contient Moda e stile et Estilo Español.

SELECT DISTINCT Fournisseurs.nom
FROM Fournisseurs
JOIN Produits ON Fournisseurs.id_fournisseur = Produits.id_fournisseur
JOIN Details ON Produits.id_produit = Details.id_produit
WHERE Produits.categorie = 'Alimentaire';

Le verbe « ont vendu » conduit à vérifier une ligne de commande dans Details. Laiteries Unies a des produits alimentaires effectivement commandés dans l’extrait. DISTINCT évite de répéter son nom pour les yaourts et le lait.

Si l’on cherchait seulement les fournisseurs de produits alimentaires référencés au catalogue, on omettrait la jointure Details et on obtiendrait aussi Boulangerie du Coin. Les deux questions ne sont pas identiques.

SELECT DISTINCT Commandes.id_commande, Commandes.date_commande, Fournisseurs.nom
FROM Commandes
JOIN Details ON Commandes.id_commande = Details.id_commande
JOIN Produits ON Details.id_produit = Produits.id_produit
JOIN Fournisseurs ON Produits.id_fournisseur = Fournisseurs.id_fournisseur
WHERE Produits.categorie = 'Vêtement';

Les quatre tables sont utiles : commande, date ; détail, produit commandé ; produit, catégorie et fournisseur ; fournisseur, nom. Dans l’extrait, la commande 2 du 08/12/2024 donne deux lignes, pour Moda e stile et Estilo Español. DISTINCT supprime seulement les triples identiques.

Toulouse → Bordeaux → Nantes → Calais, soit 250 + 340 + 550 = 1140 km. Une route via Lyon et Paris vaut 405+465+300=1170 km, donc est un peu plus longue.

Les distances sont positives : fixer le plus petit coût provisoire permet de certifier le résultat, contrairement à un simple choix de la route sortante la plus courte.

C, N, B, T, L, M, P, S, soit Calais, Nantes, Bordeaux, Toulouse, Lyon, Marseille, Paris, Strasbourg.

On descend autant que possible : depuis Nantes, Bordeaux est le premier voisin non visité ; depuis Toulouse, Lyon précède Marseille. À Lyon, Marseille est explorée avantParis. Quand une branche est épuisée, on revient au dernier sommet ayant encore un voisin non visité.

C, N, P, S, B, L, T, M. La première couche aprèsCalais estNantes, Paris, Strasbourg. En traitantNantes, on découvreBordeaux puisLyon. Bordeaux découvreToulouse avant queLyon ne découvreMarseille. Une ville déjà découverte n’est pas ajoutée une seconde fois.

graphe['Lyon']['Marseille'] = 315
graphe['Marseille']['Lyon'] = 315

Le réseau est non orienté et sa représentation stocke chaque arête dans les deux listes de voisinage. Modifier un seul sens ferait diverger le dictionnaire du graphe de la figure 2.

def distance(graphe, ville1, ville2):
    if ville1 in graphe and ville2 in graphe[ville1]:
        return graphe[ville1][ville2]
    return None

On consulte l’arête directe dans le dictionnaire interne. Cette fonction ne cherche pas un itinéraire passant par d’autres villes. Le premier test protège aussi le cas d’un nom de ville absent du graphe.

def distance_totale(graphe, ville_depart, ville_destination):
    chemin = trouver_chemin(graphe, ville_depart, ville_destination)
    if chemin is None or len(chemin) == 0:
        return None
    total = 0
    for i in range(len(chemin) - 1):
        total += graphe[chemin[i]][chemin[i + 1]]
    return total

On additionne les poids de chaque paire de villes consécutives, jusqu’à l’avant-dernier indice. Pour une origine égale à la destination, un chemin d’un seul sommet a une distance 0. Le code suppose que l’absence de chemin est signalée par None ou une liste vide ; cette convention doit correspondre à la fonction fournie.

La distance calculée est celle du chemin renvoyé. Le sujet ne dit pas que trouver_chemin optimise la distance : on ne peut pas conclure que le total est minimal.

3,47, de type float, soit 3,47 heures. L’indice 0 contient 385 km et l’indice 1 la durée. Une durée décimale 3,47 h ne signifie pas 3 h47 min.

def ratio_duree_distance(graphe):
    for ville, connexions in graphe.items():
        for destination, valeurs in connexions.items():
            distance, duree = valeurs
            ratio = round(duree / distance, 3)
            graphe[ville][destination].append(ratio)
    return graphe

La première boucle parcourt les villes et leurs dictionnaires, la seconde les voisins et leurs listes. Le ratio est exprimé en heures par kilomètre, l’inverse d’une vitesse moyenne. L’arrondi à trois décimales reproduit les valeurs montrées dans le sujet :3,47/385≈0,009.

La fonction modifie les listes en place et suppose deux éléments au départ. L’appeler une seconde fois sans adaptation ferait échouer le dépaquetage ou ajouterait des données en double dans une autre version. Les deux sens d’une arête doivent recevoir les mêmes informations.

Un algorithme glouton. Il choisit ce qui paraît le meilleur localement à chaque étape, sans examiner toutes les conséquences du choix. Ce principe ne garantit pas à lui seul un optimum global ni même l’arrivée à destination.

Si l’on interdit de revisiter les villes déjà parcourues, on obtient Toulouse → Bordeaux → Nantes → Paris → Calais. Les choix successifs de ratio sont 0,010 ;0,012 ;0,009 ;0,011. Le trajet mesure 1275 km et prend 13,35 h selon les données arrondies.

La consigne originale ne précise toutefois pas cette interdiction. Sans elle, Toulouse choisitBordeaux(ratio 0,010), puis Bordeaux choisitToulouse(0,010, inférieur aux 0,012 vers Nantes) : l’algorithme boucle entre ces deux villes et ne rejoint jamaisCalais. Il n’existe donc pas de trajet terminé déterminé par le seul prompt sans ajouter une règle contre les cycles.

Même avec cette règle, minimiser chaque ratio d’arête ne prouve pas que le ratio total somme(durées)/somme(distances) est minimal. Ce ratio global n’est pas la somme des ratios locaux.