Sujet bac NSI 2025 jour 1 (17 juin) | Correction

Exercice 1

Partie A

1. Expliquer pourquoi l'attrlbut num_ser ne peut pas etre une clé primaire de la relatlon inventaire.

   Une clé primaire doit respecter une contrainte d'unicité, num_ser est unique au sein d'une même marque (deux guitares de la marque \(Fender\) ne pourront pas avoir le même numéro de série), mais cet attribut n'est pas unique pour l'ensemble des guitares (on ne peut pas garantir que deux guitares de marques différentes n'ont pas le même numéro de série). Pour cette raison, num_ser ne peut pas être une clé primaire de la relation inventaire.

2. Donner sous forme de tableau le résultat‘de la requête suivante appliquée à l'extrait de table précédente

   SELECT marque, modele
   FROM inventaire
   WHERE annee = 1956
   

   Voici le résultat de la requête:

   marque	modele
   Gibson	Les Paul Goldtop
   Fender	Stratocaster

3. Écrire une requête SQL permettant d’obtenir toutes les années du modèle Les Paul Standard dans la collection.

   La clause DISTINCT permet d'éviter les répétitions des années de plusieurs exemplaires d'un même modèle de guitare, même si ce n'est pas le cas dans cet extrait.

   SELECT DISTINCT annee
   FROM inventaire
   WHERE modele = 'Les Paul Standard'
   

4. Écrire une requéte SQL permettant d’obtenir tous les modèles de guitares de la marque Gibson par ordre croissant de l'année dans la collection.

   SELECT modele
   FROM inventaire
   WHERE marque = 'Gibson'
   ORDER BY annee
   

   On utilise pas DISTINCT ici car on veut différencier les modèles produits a des années différentes. La clause SELECT serait plus explicite avec SELECT modele, annee mais ce n'est pas indiqué dans la question.

5. Maud a fait une erreur de saisie pour la guitare d'identifiant id=1. L'année est en realité 1957. Ecrire une requête SQL permettant de corrrger cette erreur de saisie.

   UPDATE inventaire
   SET annee = 1957
   WHERE id = 1
   

   Partie B

   La transformation de la relation inventaire en 3 relations marque, modele et guitare est utile pour éviter les redondances.

   Cependant le système clé primaire, clé étrangère demande de respecter les contraintes d'intégrité.

6. Expliquer briévement, en justifiant, dans quel ordre les trois tables doiventêtre créées.

   Pour respecter la contrainte de référencement, on crée les tables dans l'ordre suivant : - marque qui ne contient aucune clé étrangère. - modele, dont la clé étrangère id_marque référence la clé primaire de marque - guitare dont la clé étrangère id_modele correspond à la clé primaire de modele

7. Écrire une requête SQL permettant d’obtenir le numéro de série et l’année de toutes les guitares Les Paul Standard de la collection.

   SELECT guitare.num_ser, guitare.annee
   FROM guitare
   JOIN modele ON guitare.id_modele = modele.id
   WHERE nom = 'Les Paul Standard'
   

8. Ecrire une requête SQL permettant de retirer de la collection la guitare d’identifiant id=3.

   DELETE FROM guitare
   WHERE id = 3
   

9. Écrire l’ensemble des requêtes SQL permettant d’ajouter la guitare suivante :

   • marque : BC Rich
   • modèle : Mockingbird
   • année : 1992
   • numéro de série : 92R
   • prix : 5000.

   Comme indiqué à la question 6., on va écrire 3 requêtes a effectuer impérativement dans l'ordre suivant pour respecter les contraintes de référence.

   INSERT INTO marque (id, nom)
   VALUES (3, 'BC Rich')
   

   INSERT INTO modele (id, nom, id_marque)
   VALUES (5, 'Mockingbird', 3)
   

   INSERT INTO guitare (id, id_modele, annee, num_ser, prix)
   VALUES (9, 5, 1992, '92R', 5000)
   

10. Écrire une requête SQL permettant de calculer la valeur totale des modéles Stratocaster de la collection de Slash.

    SELECT SUM(prix)
    FROM guitare
    JOIN modele on guitare.id_modele = modele.id
    WHERE nom = 'Stratocaster'
    

Exercice 2

1. Donner |e code Python qui permet d’instancier deux variables tache1 et tache2 représentant les tâches :

   • tâche numéro 1 : Répondre aux e-mails. Durée estimée : 45 minutes.

   • tâche numéro 2 : Ranger ma chambre. Durée estimée : 6O minutes.

   Instancier, c'est créer un nouvel objet de la classe. Cela correspond à un appel de la méthode __init__ (constructeur) avec le nom de la classe et en précisant les paramètres.

   tache1 = Tache(1, "Répondre aux e-mails", 45)

   tache2 = Tache(2, "Ranger ma chambre", 60)

2. Recopier et compléter ie code de la méthode avancer de la classe Tache qui permet d’avancer la tâche self de n minutes.

   def avancer(self, n: int) -> None:
       self.duree restante -= n # décrémentation de n minutes
   

3. Recopier et compléter le code de la méthode est_terminee de la classe Tache qui renvoie True si la tache est terminée, ou False sinon.

   def est_terminee(self) -> bool:
       return self.duree restante <= 0
   

4. Représenter l’état de la file f lorsqu’on lui ajoute successivement la tâche numéro 6 avec la priorité 2, puis la tache numéro 7 avec la priorité 4 en respectant les conditions 1 et 2 décrites ci-dessus.

   [début] (<t3>, 4) (<t7>, 4) (<t1>, 3) (<t2>, 3) (<t6>, 2) (<t4>, 1) (<t5>, 1) [fin]

5. En repartant de la file f suivante :

   [début] (<t3>,4) (<t1>,3) (<t2>,3) (<t4>,1) (<t5>,1) [fin]

   donner la valeur de f.defiler()[0], et représenter le contenu de la file f après l’exécution de cette instruction.

   f.defiler()[0] retourne le premier tuple de la file, [0] retourne le premier élément de ce tuple.

   Avec la file f la valeur est donc : <t3>.

   Après cette instruction, la file sera alors :

   [début] (<t1>,3) (<t2>,3) (<t4>,1) (<t5>,1) [fin]

6. En repartant de la file f suivante :

   [début] (<t3>, 4) (<t1>, 3) (<t2>, 3) (<t4>, 1) (<t5>, 1) [fin]

   donner la valeur de f.examiner()[1], et représenter le contenu de la file f après l’exécution de cette instruction.

   f.examiner() renvoie le premier élément de la file : (\<t3\>, 4)

   f.examiner()[1] vaut le deuxième élément de ce tuple : 4

   la file n'est pas modifiée par la méthode examiner, elle vaut donc toujours :

   [début] (<t3>, 4) (<t1>, 3) (<t2>, 3) (<t4>, 1) (<t5>, 1) [fin]

7. Recopier et compléter le code de la fonction ajouter_fi1e_prio.

   def ajouter_file_prio(f, t, p):
       f_aux = File()
   
       # Transfert des éléments de priorité supérieures ou égales à p dans f_aux
       while not f.est_vide() and f.examiner()[1] >= p:
           f_aux.enfiler(f.defiler())
   
       # Ajout du nouvel élément (t, p) à la bonne position
       f_aux.enfiler((t, p))
   
       # Transfert le reste de f dans f_aux
       while not f.est_vide():
           f_aux.enfiler(f.defiler())
   
       # Transfert des éléments la file f_aux dans f
       while not f_aux.est_vide():
           f.enfiler(f_aux.defiler())
   

8. Donner le coût d’exécution temporel dens le pire des cas de la fonction ajouter_fi1e_prio, en fonction du nombre m d’éléments de la file f.

   La fonction ajouter_fi1e_prio est composée de plusieurs parties :

   • création en la file f_aux : \(O(1)\)
   • première et deuxième boucle while : transfert des m éléments de f vers f_aux: \(O(m)\)
   • ajout du nouvel élément (f_aux.enfiler((t, p))) : \(O(1)\)
   • transfert des éléments de f_aux vers f : \(O(m)\)

   Au total la complexité temporelle dans le pire des cas est donc linéaire en la taille de la file : \(O(m)\).

9. Indiquer pour chaque bloc de 25 minutes la tâche qui avance, en suivant le modèle proposé, jusqu’a la fin de toutes les tâches.

   la condition 2 indique qu'une tâche non terminée se ré insérée après les autres tâches de même priorité, il va donc y avoir un alternance de type tourniquet entre les tâches de même priorité ayant une durée restante supérieure à 25 minutes.

   numéro bloc 25 minutes	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17
   numéro de tâche avancée	3	7	3	3	3	1	2	1	2	2	6	6	6	4	5	4	5

10. Écrire Le code d’une fonction planning qui prend en paramÈtre une file de priorité f dont Ies éléments sont des tuples (tache, prio), et qui renvoie une liste de tâches, dans l’ordre dans lequel elles vont être effectuées par tranche de 25 minutes avec la méthode Pomodoro.

    def planning(f):
        execution = [] # liste qui contiendra les tâches à exécuter
    
        while not f.est_vide():
    
                tache, prio = f.defiler() # récupère la tâche de début de file
                execution.append(tache) # ajout à la file
                tache.avancer(25) # Avancer la tâche de 25 minutes
    
            # Si la tâche n'est pas terminée, la réinsérer dans la file avec même priorité
            if not tache.est_terminee():
                        ajouter_file_prio(f, tache, prio)
    
    
        return execution