Bac NSI 2026 Asie jour 2

5 : le numéro 2 est le sixième élément de la liste. Il faut distinguer la valeur de la tuile, 2, de l’indice où elle se trouve, 5.

La tuile 1 passe dans l’ancien vide d’indice 3 et le vide se retrouve à l’indice 4. Le tableau est [5,3,8,1,0,2,7,6,4]. Le numéro de cette question est absent de l’impression du PDF, mais cette consigne correspond au deuxième item entre les questions 1 et 3.

tab == [0,1,2,3,4,5,6,7,8]

L’égalité des listes compare longueur et valeurs dans l’ordre. Tester seulement si tous les numéros sont présents ne suffit pas, car toute grille mélangée valide possède les mêmes numéros.

def est_gagnant(self):
    return self.tab == [0,1,2,3,4,5,6,7,8]

La méthode teste la grille de l’instance courante via self.tab. Elle ne modifie aucun état et renvoie directement le booléen de comparaison.

assert 0 <= numero <= 8, "numero de case non valide"
# Condition de la boucle :
while self.tab[i] != numero:

0 doit être autorisé car jouer cherche aussi l’indice du vide. Le tableau reste une permutation de 0 à 8 : un numéro valide est donc forcément trouvé avant de sortir de la liste. Cette garantie vient de l’invariant du jeu, pas du while seul. Si le tableau pouvait être corrompu, il faudrait borner la recherche et signaler l’absence.

def jouer(self, numero):
    if self.est_possible(numero):
        i = self.indice(numero)
        j = self.indice(0)
        self.tab[j] = numero
        self.tab[i] = 0

i est la position de la tuile et j celle du vide. La tuile va à j ; sa case initiale i devient vide. Les deux indices sont calculés avant les modifications. Un coup illégal ne change rien. Chaque coup est sa propre opération inverse : rejouer immédiatement le même numéro remet la grille dans l’état précédent.

def melanger(self, n):
    precedent = None
    i = 0
    while i < n:
        possibilites = self.coups_possibles()
        choix = random.choice(possibilites)
        if choix != precedent:
            self.jouer(choix)
            precedent = choix
            i += 1

La liste des coups possibles doit être recalculée après chaque déplacement. Le compteur n’augmente qu’après un coup effectivement joué, pas après un tirage rejeté. Rejouer la même tuile annulerait simplement le dernier coup ; l’exclusion évite ces retours immédiats. Le tirage peut théoriquement répéter plusieurs fois le même numéro avant d’en choisir un autre ; filtrer la liste avant random.choice serait une variante plus directe.

L’ordre est 2,5,4,1. Une pile LIFO retrouve d’abord le dernier changement. Chaque numéro rejoué annule exactement l’échange qu’il avait produit. L’ordre inverse est essentiel : rejouer les numéros dans l’ordre initial ne garantit pas de revenir à la solution.

def resoudre(self):
    self.mode_resolution = True
    while not self.est_gagnant():
        numero = self.pile.depiler()
        self.jouer(numero)
        print(numero)

Le mode est activé avant le premier appel à jouer pour éviter de réempiler l’annulation. Sous l’invariant annoncé (tous les coups enregistrés depuis une grille gagnante), une grille non gagnante possède un historique suffisant pour revenir à la solution. Une application acceptant des états chargés de l’extérieur devrait aussi détecter une pile vide incohérente. On peut rétablir mode_resolution=False après la boucle si l’on souhaite reprendre une session de jeu avec enregistrement des nouveaux coups.

Le coup dépilé est rejoué puis immédiatement réempilé par jouer. Le sommet ne disparaît donc pas de l’historique. À l’itération suivante, on joue de nouveau ce même numéro, ce qui annule l’annulation : la grille oscille entre deux états. Dans l’exemple à quatre coups, aucun de ces deux états n’est la solution, donc la boucle ne termine pas.

La formulation ne doit pas être prise comme une impossibilité absolue de terminaison : si un seul coup sépare la grille de la solution, la première annulation peut déjà gagner et la boucle s’arrête. Le bug est que le mécanisme de progression n’est plus garanti, pas que toute entrée boucle forcément.

if not self.mode_resolution:
    if not self.pile.est_vide():
        precedent = self.pile.depiler()
        if precedent != numero:
            self.pile.empiler(precedent)
            self.pile.empiler(numero)
    else:
        self.pile.empiler(numero)

On retire temporairement le sommet. S’il est égal au nouveau coup, les deux mouvements se compensent : on ne remet rien. Sinon on restaure l’ancien sommet avant d’empiler le nouveau, pour conserver l’ordre chronologique. Cette logique reste à l’intérieur de la branche d’un coup légal ; un clic impossible ne doit jamais polluer l’historique.

participation, où elle référence personne.id_pers. La même personne peut apparaître sur plusieurs participations, mais son identifiant est unique dans la table personne.

Plusieurs joueurs participent à la même partie, donc plusieurs lignes partagent id_partie. Une clé primaire doit être unique. Le couple (id_partie,id_pers) conviendrait si un joueur possède une unique ligne de score par partie, convention naturelle de cette modélisation.

INSERT INTO personne (id_pers, pseudo_pers, date_pers)
VALUES (42, 'theorie', '2022-12-14');

Le format ISO place l’année avant le mois et le jour. L’identifiant 42 est fourni par la consigne ; il doit être libre pour cette insertion.

SELECT DISTINCT pa.id_partie
FROM participation AS pa
JOIN personne AS p ON pa.id_pers = p.id_pers
WHERE p.pseudo_pers = 'test';

Le pseudonyme est dans personne ; les identifiants de parties sont dans participation. La jointure retrouve les participations de ce compte. DISTINCT protège contre des répétitions éventuelles de projection ; si le couple partie/personne est effectivement unique, il est ici redondant mais correct.

DELETE FROM participation WHERE id_pers = 8;
DELETE FROM personne WHERE id_pers = 8;

On supprime d’abord les lignes qui référencent le compte, puis la personne elle-même. L’ordre inverse serait refusé par l’intégrité référentielle en l’absence de cascade. Les autres joueurs des mêmes parties doivent rester dans participation.

if ordre[i] == lettre:
    return i

L’indice exprime la priorité de la lettre dans l’alphabet secret. La précondition garantit que lettre est une des six voyelles et apparaît dans ordre, donc un return est rencontré. Sans cette garantie, la fonction renverrait implicitement None.

def comparer(mot1, mot2, ordre):
    i = 0
    while i < len(mot1) and i < len(mot2):
        i1 = indice(mot1[i], ordre)
        i2 = indice(mot2[i], ordre)
        if i1 < i2:
            return True
        elif i1 > i2:
            return False
        i += 1
    return len(mot1) < len(mot2)

Les lettres communes sont ignorées jusqu’à la première différence. Les rangs dans ordre décident immédiatement : les lettres suivantes ne comptent plus. Si la boucle finit sans différence, un mot est préfixe de l’autre, donc sa longueur décide. Comparer directement les chaînes Python utiliserait l’ordre Unicode, pas l’ordre secret.

def premiere_diff(mot1, mot2):
    i = 0
    while i < len(mot1) and i < len(mot2) and mot1[i] == mot2[i]:
        i += 1
    return i

Les deux tests de longueur précèdent les accès aux caractères, ce qui évite un dépassement sur un préfixe. À la sortie, soit un mot est terminé, soit les deux lettres diffèrent. On obtient 2 pour oou/ooai et 3 pour aio/aioiee. La fonction n’établit pas encore quel mot est plus petit : elle localise seulement la décision.

{'u': ['a', 'y'], 'y': ['i', 'a'], 'a': ['i'],
 'o': ['u'], 'e': ['a']}

Les lettres sans arc sortant, ici i, ne sont pas nécessairement des clés du dictionnaire, même si elles restent des sommets. L’ordre des valeurs suit celui des couples lus. Le code fourni ajoute des doublons si une même contrainte apparaît plusieurs fois, contrairement à la description d’un arc unique ; l’exemple ne contient pas cette répétition. Un test d’appartenance avant append pourrait éviter ces doublons sans changer l’ordre possible.

Un parcours en profondeur, avec ajout du sommet à tri après le traitement de ses successeurs. On obtient donc un ordre de fin de parcours, ou postordre. Cette position de append est essentielle : inverser ensuite ces fins permet un tri topologique d’un graphe orienté sans cycle.

def trier(mots):
    adj = dico_adj(mots)
    tri = []
    deja_vus = []
    for voyelle in "aeiouy":
        if voyelle not in deja_vus:
            deja_vus.append(voyelle)
            parcours(adj, voyelle, deja_vus, tri)
    tri.reverse()
    return tri

La boucle porte sur les six voyelles et pas seulement sur adj, afin d’inclure aussi les sommets sans arc sortant ou sans contrainte. reverse modifie la liste en place et renvoie None : return tri.reverse() serait faux. Avec l’ordre de départ aeiouy et les listes fournies, on obtient ["o","u","y","e","a","i"]. D’autres permutations peuvent satisfaire les mêmes contraintes.

La garantie vient du contexte : les couples sont issus d’un véritable ordre secret, donc les contraintes sont compatibles et le graphe sans cycle. Si des couples arbitraires étaient saisis, il faudrait vérifier les cycles et rejeter un préfixe placé après son extension (par exemple aa avant a), car le code dico_adj seul ignore ce dernier conflit. Sans ces validations, inverser un postordre ne certifie pas toujours un classement valide.

La chaîne développée est AGAGAGAG. Depuis une orientation vers la droite, le robot avance à droite, tourne vers le haut, avance, tourne vers la gauche, avance, tourne vers le bas, avance, puis se remet orienté vers la droite. Il trace un carré de côté un pas et retrouve sa position et son orientation initiales.

return intrus == []

La compréhension collecte tous les caractères hors de l’alphabet autorisé. Une liste vide signifie qu’aucun intrus n’a été trouvé. return len(intrus) == 0 ou return not intrus conviennent aussi. Cette étape ne vérifie ni les parenthèses ni la position des nombres.

def entiers_valides(chaine):
    chiffres = "0123456789"
    if chaine[len(chaine)-1] in chiffres:
        return False
    for indice in range(1, len(chaine)):
        if chaine[indice] == ")":
            if chaine[indice-1] in chiffres:
                return False
    return True

Un chiffre final annonce une répétition sans commande ; un chiffre devant ) annonce une répétition sans contenu dans ce bloc. Le return True se place après le parcours complet. Le squelette suppose une chaîne non vide : une extension robuste commence par if chaine == "": return True si l’on décide qu’une commande vide ne fait rien, ou par un refus explicite si elle n’est pas autorisée.

def parenthesage_correct(chaine):
    parenthese = 0
    for caractere in chaine:
        if caractere == "(":
            parenthese += 1
        elif caractere == ")":
            parenthese -= 1
        if parenthese < 0:
            return False
    return parenthese == 0

Le compteur donne le nombre de parenthèses ouvertes non encore fermées dans le préfixe lu. Il ne doit jamais devenir négatif : )( aurait un bilan final nul mais reste incorrect. À la fin, zéro garantit que toutes les ouvertures sont fermées. Le contrôle autorise naturellement une chaîne sans parenthèse et des blocs imbriqués.

L’indice 5 pointe sur A, premier caractère non numérique : la boucle s’arrête et renvoie (179,4). Le nombre est accumulé en texte puis converti en entier. La validité préalable garantit qu’un nombre n’arrive pas en fin de chaîne, sinon le while sans borne pourrait lire au-delà.

bloc = bloc + caractere
indice = indice + 1
caractere = chaine[indice]

Ces trois lignes complètent le squelette et donnent les résultats des exemples fournis. Le compteur distingue la parenthèse fermante du bloc des fermetures internes. Mais le squelette ne compte pas correctement un premier caractère de bloc qui serait lui-même une parenthèse, et échoue sur un bloc vide. Ces cas ne sont pas exclus par les trois validations précédentes. Pour une fonction correcte sur tout parenthésage validé, voici une version qui compte chaque caractère avant de conclure :

def lire_bloc(chaine, indice):
    debut = indice + 1
    compteur = 1
    while compteur > 0:
        indice += 1
        if chaine[indice] == '(':
            compteur += 1
        elif chaine[indice] == ')':
            compteur -= 1
    return chaine[debut:indice], indice

On conserve l’indice de début, avance depuis la parenthèse ouvrante et compte toutes les ouvertures/fermetures. Quand le compteur revient à 0, la tranche exclut les deux parenthèses extérieures et conserve les éventuelles parenthèses intérieures. Cette version traite aussi () et ((AD)). Elle suppose que l’indice reçu pointe bien sur une ouverture et que le parenthésage a déjà été validé.

t = lire_nombre(chaine, indice)  # ligne 12
t = lire_bloc(chaine, indice)    # ligne 16
lire_parcours(bloc)              # ligne 20

Le résultat de chaque lecteur contient un contenu et l’indice du dernier caractère consommé. La boucle principale ajoute ensuite 1 pour passer à la suite. Une commande simple est répétée nombre fois ; un bloc est interprété récursivement le même nombre de fois. Après consommation, nombre revient à 1 pour qu’une répétition ne s’applique pas aussi aux instructions suivantes.

Avec 2(3(AD)G)2A, on interprète deux fois un bloc contenant lui-même trois répétitions de AD puis G, avant d’avancer deux fois. La version robuste de lire_bloc précédente permet les imbrications générales. Le volume d’actions exécutées peut être bien plus grand que la longueur du texte ; un système réel devrait limiter les répétitions et vérifier l’environnement avant de déplacer un robot.

Seule la route vers 46 s’améliore : prochain robot 4, distance 2, par 91→4→46. Les routes vers 4 et 22 restent directes à distance 1 ; celle vers 57 reste via 22 à distance 2, car 91→4→46→57 demanderait trois transmissions.

Le contact direct ajoute 87 à distance 1. Les destinations annoncées 63 à distance 1 et 36 à distance 2 sont connues par 91 avec un saut supplémentaire. L’annonce de 91 lui-même ne doit pas créer une route de retour vers soi. Les anciennes routes restent inchangées puisqu’aucune amélioration vers elles n’est indiquée.

def ajouter_voisin(self, identifiant):
    self.table_routage[identifiant] = {
        "prochain": identifiant,
        "distance": 1
    }

Un voisin direct est sa propre prochaine étape et coûte une transmission. L’identifiant est la clé de la table ; prochain et distance sont les clés du sous-dictionnaire. On suppose que l’identifiant fourni n’est pas celui du robot lui-même.

return self.table_routage[identifiant]["distance"]

L’accès est sûr dans le else car la présence a été testée. La valeur 16 sert à représenter l’inaccessibilité dans ce modèle où les routes utilisables sont limitées à 15 sauts. Il faut renvoyer la distance, pas le prochain robot ni le sous-dictionnaire entier.

def voisins(self):
    resultat = []
    for identifiant in self.table_routage:
        if self.table_routage[identifiant]["distance"] == 1:
            resultat.append(identifiant)
    return resultat

Dans une table cohérente, la distance 1 caractérise un voisin direct. L’ordre de la liste n’est pas imposé. On ne renvoie pas tous les prochains robots sans déduplication : plusieurs routes distantes pourraient partager le même prochain voisin.

def communiquer_extrait_table(self, voisin):
    extrait = {}
    for destination, route in self.table_routage.items():
        if route["prochain"] != voisin:
            extrait[destination] = route.copy()
    return extrait

Le filtre porte sur prochain, pas seulement sur la destination. Par exemple, si 46 se rejoint via 22, la route de 46 ne doit pas être annoncée à 22, même si 46 ≠ 22. La copie du sous-dictionnaire préserve la table interne si le destinataire du résultat le modifie ensuite. L’extrait conserve la même structure que la table et n’incrémente pas les distances : le récepteur ajoutera son propre saut lors du traitement.