Bac NSI 2025 Asie jour 2

self.jour = jour
self.mois = mois
self.annee = annee

À gauche, self désigne l’objet que l’on initialise ; à droite, on utilise les arguments reçus. Le paramètre et l’attribut peuvent avoir le même nom sans être la même variable.

Au 1 er mai 2000. L’ordre des arguments est jour, mois, année ; 5 désigne mai, pas le jour du mois.

d = Date(19, 6, 2024)

Le mois est passé comme entier 6 ; on ne passe pas le texte « juin » au constructeur défini.

def get_annee(self):
    return self.annee

Un accesseur retourne la donnée sans modifier l’objet. Écrire print(self.annee) afficherait une valeur mais ne la renverrait pas au programme appelant.

def set_mois(self, mois):
    self.mois = mois

Il s’agit d’une modification de l’objet. Le sujet suppose des données valides ; cette méthode seule ne vérifie pas que le jour existe dans le nouveau mois.

if self.est_bissextile():
    self.nb_jours_par_mois[1] = 29

Février est le deuxième mois, donc l’élément d’indice 1. On appelle la méthode sur l’instance déjà initialisée, afin qu’elle lise sa valeur d’année.

La liste étant créée dans chaque constructeur, chaque objet possède ses propres longueurs de mois. En revanche, le set_annee imprimé ne les recalcule pas : après un changement d’année, une implémentation complète devrait remettre février à 28 ou 29 selon la nouvelle valeur.

def est_bissextile(self):
    return (self.annee % 4 == 0 and self.annee % 100 != 0) or self.annee % 400 == 0

Les parenthèses rendent les deux possibilités visibles. 2024 est divisible par 4 et pas par 100 : vrai. 1900 est divisible par 100 mais pas par 400 : faux. 2000 satisfait le second cas : vrai. Ces trois tests évitent la règle incomplète « divisible par 4 ».

79 : 20 jours de mars + 28 de février + 31 de janvier. 2001 n’est pas bissextile. La méthode inclut le jour courant : le 1 er janvier renverrait 1, pas 0.

def nb_jours_restants(self):
    j = 365
    if self.est_bissextile():
        j = 366
    return j - self.nb_jours_passes()

Le nombre total dépend de l’année bissextile. Comme les jours passés incluent aujourd’hui, les jours restants commencent demain : le 31 décembre donne 0. Ces deux méthodes utilisent donc des conventions complémentaires.

Attention au code réellement imprimé : la quatrième instruction appelle date(1, 1, annee) alors que la classe définie est Date. Sans autre définition, elle produit donc une NameError. Le résultat 731 correspond à la correction de cette majuscule ; les trois premiers retours arrivent avant cette ligne.

Une autre limite apparaît pour deux dates différentes d’une même année, si other est antérieure : le code additionne à tort le début et la fin de l’année. Pour un objet pleinement fonctionnel, voici la méthode corrigée, distincte du programme fourni :

def nb_jours_depuis(self, other):
    if other.get_annee() > self.get_annee():
        return -1
    if other.get_annee() == self.get_annee():
        difference = self.nb_jours_passes() - other.nb_jours_passes()
        return difference if difference >= 0 else -1
    nb_jours = self.nb_jours_passes() + other.nb_jours_restants()
    for annee in range(other.get_annee() + 1, self.get_annee()):
        d_suivant = Date(1, 1, annee)
        nb_jours += 366 if d_suivant.est_bissextile() else 365
    return nb_jours

Dans le cas d’années différentes, on additionne la fin de la première année, les années complètes intermédiaires et le début de la dernière. Dans la même année, une simple différence de numéros de jour suffit.

def timestamp(self):
    d = Date(1, 1, 1970)
    return self.nb_jours_depuis(d) * 24 * 3600

La référence est une autre instance de Date. On convertit les jours en secondes avec 24 × 3600 = 86400. Il faut la méthode nb_jours_depuis corrigée ci-dessus pour un fonctionnement général.

Le 1 er janvier 1970 est une origine conventionnelle de temps Unix, pas la date de démarrage de tous les systèmes Unix. La classe ne gère ni fuseau ni heure d’été. Pour le 1 er janvier 2024 à minuit UTC, ce calcul donne 1704067200. Le nombre 1704063600 imprimé dans le sujet correspond à une heure plus tôt en UTC, donc à minuit dans un fuseau UTC+1 ; sans précision de fuseau, les deux notions ne doivent pas être confondues.

Il s’agit de l’ordonnanceur, composant du système d’exploitation chargé de choisir quel processus prêt obtient le processeur.

Les états centraux sont prêt (il peut s’exécuter mais attend le CPU), élu ou en exécution (il utilise le CPU), et bloqué ou en attente (il attend un événement, par exemple une entrée-sortie). Selon le diagramme de cycle de vie utilisé, on ajoute nouveau et terminé.

Attendre son tour dans une file de l’ordonnanceur correspond à prêt, pas à bloqué : le processus ne manque alors que du processeur.

La file (proposition 2) assure le premier arrivé, premier servi. Une pile favoriserait le dernier arrivé et pourrait faire attendre indéfiniment les plus anciens. Une liste Python peut implémenter cette file, mais le comportement abstrait recherché est FIFO.

class Processus:
    def __init__(self, PID, priorite, temps_CPU):
        self.priorite = priorite
        self.PID = PID
        self.temps_utilisation = 0
        self.temps_CPU = temps_CPU

temps_utilisation commence à 0 tandis que temps_CPU désigne la quantité totale de CPU nécessaire. La priorité reçue est stockée telle quelle ; le programme d’arrivée lui passe 0.

Les listes du sujet sont écrites avec la tête de file à droite, comme le montre le retrait de P1 au cycle 1. Le test des attentes compare à la priorité de p avant de la diminuer. Au cycle 4, la troisième file demeure vide : les points de suspension du modèle n’imposent pas qu’elle contienne un processus.

À mesure qu’il consomme du CPU, le processus long voit sa valeur numérique de priorité augmenter : il devient de moins en moins prioritaire. Les nouveaux processus courts arrivent toujours avec la valeur 0. S’ils alimentent continuellement les files prioritaires, le processus long peut rester dans une file de faible priorité sans être réélu.

C’est une famine : le système continue à travailler, mais un processus ne reçoit pas assez de CPU pour terminer. Il ne faut pas confondre ce phénomène avec un interblocage, où plusieurs processus s’attendent mutuellement.

Le vieillissement rétablit progressivement la priorité d’un processus qui attend. Sa valeur numérique diminue jusqu’à rejoindre les files servies ; dans une même priorité, l’ordre FIFO empêche les nouveaux arrivants de passer systématiquement devant lui. Il reçoit de nouvelles tranches de CPU et peut accumuler les 1000 unités nécessaires.

Cette conclusion suppose que la remontée déplace effectivement le processus dans la bonne file et que le compteur est géré de manière cohérente. Un simple attribut qui augmente sans modifier l’ordonnancement ne suffit pas.

def meilleur_priorite(liste_files):
    for priorite in range(len(liste_files)):
        if len(liste_files[priorite]) > 0:
            return priorite
    return None

On explore les indices dans l’ordre croissant : le premier indice non vide est la plus petite valeur, donc la meilleure priorité. Le retour None vient après la boucle pour ne pas s’arrêter dès la première file vide. Une liste de files vide est traitée naturellement.

def prioritaire(liste_files):
    priorite = meilleur_priorite(liste_files)
    if priorite is None:
        return None
    return liste_files[priorite].pop()

La fonction précédente donne la file à utiliser. La tête est à droite dans la représentation de la simulation : pop(), équivalent à pop(-1), enlève donc le bon processus. Le cas None doit être testé avant d’indexer la liste.

def gerer(p, liste_files):
    if p is None:
        return prioritaire(liste_files)
    if p.temps_utilisation >= p.temps_CPU:
        return None
    p.temps_utilisation += 1
    attente = meilleur_priorite(liste_files)
    doit_ceder = attente is not None and attente <= p.priorite
    p.priorite += 1
    if doit_ceder:
        while len(liste_files) <= p.priorite:
            liste_files.append([])
        liste_files[p.priorite].insert(0, p)
        return prioritaire(liste_files)
    return p

La fonction renvoie le nouveau processus élu, ou None si le CPU devient libre. Elle respecte la succession du texte : un cycle qui constate la fin retire le processus ; l’élection suivante interviendra au prochain appel. Lors d’un travail réel, elle mémorise la nécessité de céder avant d’augmenter la valeur de priorité.

L’insertion à gauche, insert(0, p), place le nouvel arrivant derrière les éléments qui sortiront à droite. Si la priorité atteint un indice encore absent, on ajoute des files vides : sans cela, un processus long finirait par provoquer une erreur d’indice. Le vieillissement de Q7 n’est pas demandé dans cette fonction et n’est pas ajouté implicitement.

SELECT nom_patient, prenom
FROM Patient
WHERE age > 60;

Le filtre exclut une personne de 60 ans exactement. Dans l’extrait, la seule ligne renvoyée est Woods, Caroll, âgée de 65 ans.

UPDATE Symptome
SET toux = 'Non'
WHERE nom_patient = 'Heartman';

Le symptôme est stocké dans Symptome et non dans Patient. La colonne contient les chaînes Oui et Non ; on conserve ce codage au lieu d’y introduire le booléen Python False.

SELECT COUNT(*)
FROM Diagnostic JOIN Symptome
ON Diagnostic.nom_patient = Symptome.nom_patient
WHERE Diagnostic.nom_maladie = 'Covid-19'
AND Symptome.toux = 'Oui';

Le diagnostic et le symptôme appartiennent à deux tables : la jointure les associe par le patient. Puis les deux filtres doivent être vrais. Comme chaque table admet au plus une ligne par patient selon ses clés, la jointure ne multiplie pas ici les lignes d’un même patient.

On ne peut pas donner un résultat numérique à partir du document : la table Diagnostic n’y est pas remplie.

INSERT INTO Patients VALUES ('Douglas', 'Patrick', 168077230253829, 55);

Le problème de modèle visé est le doublon de clé primaire : Douglas existe déjà pour Bob, donc une seconde ligne de même nom_patient ne peut pas être insérée.

À la lettre, la requête emploie aussi Patients au pluriel, alors que la table du schéma est Patient. Sans table supplémentaire, cette différence produit d’abord une erreur de table inconnue. Corriger le nom en Patient laisse subsister le conflit de clé, qui motive la question suivante.

Ajouter un identifiant unique id_patient à Patient et en faire la clé primaire. Le nom devient un attribut ordinaire, autorisant les homonymes. Les tables Symptome et Diagnostic doivent alors remplacer leurs références par id_patient, vers la nouvelle clé.

Le numéro de sécurité sociale pourrait être envisagé si son unicité, sa présence et sa validité sont imposées. Un identifiant interne évite de dépendre de ces hypothèses externes.

Le résultat du modèle est positif (+). On suit oui à toux, oui à fièvre, non à nausée et non à anosmie. La feuille correspondante est étiquetée +.

assert not self.est_feuille() exige un nœud interne. Une feuille contient un diagnostic, pas un symptôme à consulter. Avec les assertions actives, appeler cette méthode sur une feuille lève une AssertionError au lieu d’interpréter le résultat comme une question.

valeur est un attribut. est_feuille est une méthode. Les attributs gauche et droit, ou les méthodes symptome et diagnostic, sont d’autres réponses possibles.

def applique(arbre, patient):
    if arbre.est_feuille():
        return arbre.diagnostic()
    else:
        if patient[arbre.symptome()]:
            return applique(arbre.droit, patient)
        else:
            return applique(arbre.gauche, patient)

Le cas d’arrêt est une feuille : son résultat est déjà disponible. Sinon, le dictionnaire dit si le symptôme du nœud est présent. La branche vraie descend à droit, la branche fausse à gauche, conformément à la convention du sujet. Chaque appel doit être retourné pour que le résultat remonte jusqu’au premier appel.

Il comporte 31 nœuds : 1 + 2 + 4 + 8 + 16, des niveaux de la racine aux feuilles. Les 16 résultats doivent être comptés ; ne donner que les 15 nœuds de symptômes oublierait les feuilles.

On commence par les nœuds anosmie dont les deux feuilles sont identiques. Six de ces huit nœuds disparaissent, chacun remplacé par une feuille, soit 12 nœuds retirés. Dans la branche toux oui et fièvre oui, les deux nouveaux résultats sont tous deux + : le nœud nausée disparaît à son tour avec deux nœuds supplémentaires.

La taille passe ainsi de 31 à 17, sans changer aucun des 16 résultats possibles. Il faut recommencer vers le haut après les premières réductions, car elles peuvent rendre un parent réductible.

def reduire(self):
    if self.est_feuille():
        return
    self.gauche.reduire()
    self.droit.reduire()
    if (self.gauche.est_feuille() and self.droit.est_feuille()
            and self.gauche.diagnostic() == self.droit.diagnostic()):
        self.valeur = self.gauche.diagnostic()
        self.gauche = None
        self.droit = None

On réduit d’abord les deux sous-arbres, puis on inspecte le nœud courant : c’est une logique de parcours postfixe. Tester les deux enfants avant de les avoir réduits manquerait des simplifications devenues possibles plus bas.

Le sujet imprime self.droite dans sa dernière ligne, mais le constructeur crée self.droit. Il faut conserver droit partout. Lors de la réduction, on copie la valeur avant de supprimer les références aux enfants, sinon on perdrait l’accès au diagnostic.

def verifie(num_secu):
    n = num_secu // 100
    k = num_secu % 100
    return (n + k) % 97 == 0

La division entière supprime les deux derniers chiffres ; le reste modulo 100 les extrait. Le test final porte ensuite sur la somme, pas sur le numéro complet. Il vérifie la relation arithmétique demandée, sans garantir qu’un numéro existe ou correspond à une personne.

def cle(n):
    return 97 - n % 97

Si n a pour reste r modulo 97, ajouter 97 - r atteint le multiple suivant. La clé est comprise entre 1 et 97 ; quand r vaut 0, elle vaut 97.

La seule équation énoncée admettrait aussi 0 lorsque n est déjà multiple de 97. La formule ci-dessus choisit la convention usuelle de clé 1 à 97. Ne pas confondre cette clé de contrôle, calculable par tous, avec une clé secrète de chiffrement.