\devoirsynthese{Baccalauréat Blanc}{Baccalauréat blanc}

\vspace*{-1cm}
\textit{Voir nos conseils de méthode \og Spécial Bac \fg dans la partie  \og Méthodes de travail \fg en début d'ouvrage.}

\Par

La durée de l'épreuve est de 3 h 30 min. Le sujet comporte trois exercices.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{exobb}{Environnement Linux}{D'après bac 2024 Étranger J2}{2}{60}
\textit{Cet exercice, noté sur 6 points, porte sur la programmation objet, la récursivité, les arbres et les systèmes d'exploitation.}

Dans cet exercice, on travaille dans un environnement Linux. On considère l'arborescence de fichiers de la figure \ref{bb-ex1fig1}.
\begin{figure}
\centering
\includegraphics{321_bb-ex1-fig1}
\label{bb-ex1fig1}\figcaption{Arborescence de fichiers}
\end{figure}

\subsectionnn{Partie A : arborescence de fichiers}
\begin{questions}\enlargethispage*{2em}
\item Le répertoire courant est \texttt{home}. Donner une commande permettant de connaître le contenu du dossier \texttt{documents}.

On suppose que l'on se trouve dans le dossier \texttt{cours} et que l'on exécute la commande \texttt{mv ../../multimedia /home/documents}

\item Indiquer la modification que cela apporte dans l'arborescence de la figure \ref{bb-ex1fig1}.

On considère le code suivant :

\begin{listing}{}{bb-new-ex1-1.py}\end{listing}

\item Donner une raison qui justifie que le code précédent ne permet pas de modéliser l'arborescence de fichiers de la figure \ref{bb-ex1fig1}.

\item Donner le nom du parcours réalisé par le code précédent.

\item Donner la liste des dossiers dans l'ordre d'un parcours en largeur de l'arborescence. On ne demande pas d'écrire ce parcours en Python.

\end{questions}

\subsectionnn{Partie B : implémentation de la classe Dossier}

\begin{questions}
\item Pour pouvoir modéliser l'arborescence de fichiers de la figure \ref{bb-ex1fig1}, on propose l'implémentation suivante. L'attribut \texttt{fils} est une variable de type \texttt{list} contenant tous les dossiers fils. Cette liste est vide dans le cas où le dossier est vide.

\begin{listing}{}{bb-new-ex1-2.py}\end{listing}

\item Écrire le code Python d'une méthode \texttt{est\_vide} qui renvoie \texttt{True} lorsque le dossier est vide et \texttt{False} sinon.

\item Écrire le code Python permettant d'instancier la variable \linebreak \texttt{var\_multimedia} de la classe \texttt{Dossier} représentant le dossier \linebreak \texttt{multimedia} de la figure \ref{bb-ex1fig1}. Attention : cela nécessite d'instancier tous les nœuds du sous-arbre de racine \texttt{multimedia}.

\item Recopier et compléter sur votre copie le code Python de la méthode \texttt{parcours} suivante qui affiche les noms de tous les descendants d'un dossier en utilisant l'ordre préfixe.

\begin{listing}{}{bb-new-ex1-3.py}\end{listing}

\item Justifier que cette méthode \texttt{parcours} termine toujours sur une arborescence de fichiers.

\item Proposer une modification de la méthode \texttt{parcours} pour que celle-ci effectue plutôt un parcours suffixe (ou postfixe).

\item Expliquer la différence de comportement entre un appel à la méthode \texttt{parcours} de la classe \texttt{Dossier} et une exécution de la commande UNIX \texttt{ls}.

On considère la variable \texttt{var\_videos} de type \texttt{Dossier} représentant le dossier \texttt{videos} de la figure \ref{bb-ex1fig1}.
On souhaite que le code Python \linebreak \texttt{var\_videos.mkdir("documentaires")} crée un dossier \linebreak \texttt{documentaires} vide dans le dossier \texttt{var\_videos}.

\item Écrire le code Python de la méthode \texttt{mkdir}.

\item Écrire en Python une méthode \texttt{contient(self, nom\_dossier)} qui renvoie \texttt{True} si l'arborescence de racine \texttt{self} contient au moins un dossier de nom \texttt{nom\_dossier} et \texttt{False} sinon.

\item Avec l'implémentation de la classe \texttt{Dossier} de cette partie, expliquer comment il serait possible de déterminer le dossier parent d'un dossier donné dans une arborescence donnée. On attend ici l'idée principale de l'algorithme décrite en français. On ne demande pas d'implémenter cet algorithme en Python.

\item Proposer une modification dans la méthode \texttt{\_\_init\_\_} de la classe\linebreak \texttt{Dossier} qui permettrait de répondre à la question précédente beaucoup plus efficacement et expliquer votre choix.
\end{questions}
\end{exobb}


\begin{corrigebb}
\subsectionnn{Partie A : arborescence de fichiers}

\begin{questions}
\item La commande \texttt{ls} permet de lister le contenu d'un répertoire. Le répertoire \texttt{documents} est un répertoire fils du répertoire courant. Une commande possible est donc :
\begin{verbatim}
ls documents
\end{verbatim}
\item La commande \texttt{mv} effectue le déplacement (\textit{move}) de l'origine (en chemin relatif) \texttt{../../multimedia} (on remonte donc de deux répertoires parents et on redescend vers \texttt{multimedia}) vers la destination (en chemin absolu) \texttt{/home/documents}. L'ensemble du répertoire multimedia et ses fils se retrouvent donc comme fils du répertoire \texttt{documents}.
%% @TODO retracer figure ?
\item La classe \texttt{Arbre} présentée ici permet de décrire un arbre binaire, chaque nœud ne pouvant posséder qu'au plus deux sous-arbres (droite et gauche). Or l'arborescence de fichiers présente des répertoires qui peuvent contenir plus de deux répertoires fils (tel \texttt{documents} qui en possède initialement 3). Donc la classe présentée ne convient pas pour cette modélisation.
\item Il s'agit d'un parcours en profondeur car la méthode \texttt{parcours} affiche le nœud rencontré puis s'appelle récursivement sur ses sous-arbres gauche, puis droit. Cet ordre correspond à un parcours préfixe.
\item Un parcours en largeur affiche les nœuds, en commençant par la racine, puis niveau par niveau, par distance croissante à la racine : \texttt{home}, \texttt{documents}, \texttt{multimedia}, \texttt{cours}, \texttt{administratif}, \texttt{personnel}, \linebreak \texttt{images}, \texttt{videos}, \texttt{films} (pour l'arborescence initiale, figure \ref{bb-ex1fig1}).
\end{questions}

\subsectionnn{Partie B : implémentation de la classe Dossier}
\enlargethispage*{5em}

\begin{questions}
\item ~\par\vspace*{-2.5em}

\begin{listing}{}{bb-new-ex1-4.py}\end{listing}

\Par

\item ~\par\vspace*{-2.5em}

\begin{listing}{}{bb-new-ex1-5.py}\end{listing}
ou
\begin{listing}{}{bb-new-ex1-5b.py}\end{listing}

\item  ~\par\vspace*{-2.5em}

\begin{listing}{}{bb-new-ex1-3c.py}\end{listing}

\item Chaque répertoire dispose toujours d'un nombre fini de répertoires fils. De plus, il existe toujours, dans un répertoire vide (feuille de l'arbre). Donc le parcours termine toujours (arrêt des appels récursifs).

\item ~\par\vspace*{-2.2em}

\begin{listing}{}{bb-new-ex1-3d.py}\end{listing}

\item La commande \texttt{ls} n'affiche que les répertoires fils et les fichiers contenus dans le répertoire courant. La méthode \texttt{parcours} affiche récursivement le contenu de tous les répertoires fils. En cela, elle se rapproche de la commande \texttt{ls -R}.

\item ~\par\vspace*{-2.2em}

\begin{listing}{}{bb-new-ex1-6.py}\end{listing}


\item ~\par\vspace*{-2.2em}

\begin{listing}{}{bb-new-ex1-7.py}\end{listing}

\enlargethispage*{5em}
\item Il s'agit ici de définir une méthode récursive prenant en argument le nom du dossier (\texttt{nom\_dossier}) dont on cherche le répertoire parent. On parcourt tous les éléments \texttt{fils} de la liste \texttt{self.fils}. \begin{itemize}
	\item Si l'on trouve \texttt{nom\_dossier} parmi cette liste, alors on retourne \texttt{self.nom} (ou \texttt{self} si c'est l'instance qui doit être retournée plutôt que son nom).
	\item Sinon, on appelle récursivement la méthode sur l'instance \texttt{fils}.
\end{itemize}
Une implémentation possible (non demandée) est la suivante :
\begin{listing}{}{bb-new-ex1-9.py}\end{listing}
\item On peut stocker, dans chaque instance de \texttt{Dossier}, l'instance du répertoire parent (\texttt{None} si racine). Cela occupe plus de place en mémoire mais permet une recherche plus efficace.
\begin{listing}{}{bb-new-ex1-8.py}\end{listing}
\end{questions}
\end{corrigebb}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{exobb}{Groupe de personnes}{D'après bac 2024 Amérique Nord J1}{2}{60}
\textit{Cet exercice, noté sur 6 points, porte sur les graphes.}

Dans cet exercice, on modélise un groupe de personnes à l'aide d'un graphe.

Le groupe est constitué de huit personnes (Anas, Emma, Gabriel, Jade, Lou, Milo, Nina et Yanis) qui possèdent entre elles les relations suivantes :
\begin{itemize}
\item Gabriel est ami avec Jade, Yanis, Nina et Milo ;
\item Jade est amie avec Gabriel, Yanis, Emma et Lou ;
\item Yanis est ami avec Gabriel, Jade, Emma, Nina, Milo et Anas ;
\item Emma est amie avec Jade, Yanis et Nina ;
\item Nina est amie avec Gabriel, Yanis et Emma ;
\item Milo est ami avec Gabriel, Yanis et Anas ;
\item Anas est ami avec Yanis et Milo ;
\item Lou est amie avec Jade.
\end{itemize}

\subsectionnn{Partie A : matrice d'adjacence} %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%\enlargethispage*{3em}

On choisit de représenter cette situation par un graphe dont les sommets sont les personnes et les arêtes représentent les liens d'amitié.

\begin{questions}
\item Dessiner sur votre copie ce graphe en représentant chaque personne par la première lettre de son prénom entourée d'un cercle et où un lien d'amitié est représenté par un trait entre deux personnes.

Une matrice d'adjacence est un tableau à deux entrées dans lequel on trouve en lignes et en colonnes les sommets du graphe.

Un lien d'amitié sera représenté par la valeur \texttt{1} à l'intersection de la ligne et de la colonne qui représentent les deux amis alors que l'absence de lien d'amitié sera représentée par un \texttt{0}.

\item Recopier et compléter l'implémentation de la déclaration de la matrice d'adjacence du graphe.

\begin{listing}{}{bb-new-ex2-1.py}\end{listing}

On dispose de la liste suivante qui identifie les sommets du graphe :

{
\ttfamily
sommets = ['G', 'J', 'Y', 'E', 'N', 'M', 'A', 'L']
}

On dispose d'une fonction \texttt{indice(l, s)} qui prend en paramètres une liste de sommets \texttt{l} et un nom de sommet \texttt{s} et qui renvoie l'indice du sommet \texttt{s} dans la liste \texttt{l} s'il est présent et \texttt{None} sinon.

\item Indiquer quel seront les retours de l'exécution des instructions suivantes :

\begin{verbatim}
>>> indice(sommets, 'G')
>>> indice(sommets, 'Z')
\end{verbatim}

\item Recopier et compléter le code de la fonction \texttt{nb\_amis(L, m, s)} qui prend en paramètres une liste de noms de sommets \texttt{L}, une matrice d'adjacence \texttt{m} d'un graphe et un nom de sommet \texttt{s} et qui renvoie le nombre d'amis du sommet \texttt{s} s'il est présent dans \texttt{L} et \texttt{None} sinon.

\begin{listing}{}{bb-new-ex2-2.py}\end{listing}

\item Indiquer quel est le retour de l'exécution de la commande suivante :

\begin{verbatim}
>>> nb_amis(sommets, matrice_adj, 'G')}
\end{verbatim}
\end{questions}

\subsectionnn{Partie B : dictionnaire de listes d'adjacence}
\begin{questions}
\item Dans un dictionnaire Python \texttt{\{c : v\}}, indiquer ce que représentent\linebreak \texttt{c} et \texttt{v}.

On appelle \texttt{graphe} le dictionnaire de listes d'adjacence associé au graphe des amis. On rappelle que Gabriel est ami avec Jade, Yanis, Nina et Milo.

\begin{verbatim}
graphe = {'G' : ['J', 'Y', 'N', 'M'],
			'J' : ...
			...
		  }
\end{verbatim}

\item Recopier et compléter le dictionnaire de listes d'adjacence \texttt{graphe} sur votre copie pour qu'il modélise complètement le groupe d'amis.

\item Écrire le code de la fonction \texttt{nb\_amis(d, s)} qui prend en paramètres un dictionnaire d'adjacence \texttt{d} et un nom de sommet \texttt{s} et qui renvoie le nombre d'amis du nom de sommet \texttt{s}. On suppose que \texttt{s} est bien dans \texttt{d}.

Par exemple :
\begin{verbatim}
>>> nb_amis(graphe, 'L')
1
\end{verbatim}

Milo s'est fâché avec Gabriel et Yanis tandis qu'Anas s'est fâché avec Yanis. Le dictionnaire d'adjacence du graphe qui modélise cette nouvelle situation est donné ci-dessous :

\begin{verbatim}
graphe = {'G' : ['J', 'N'],
		  'J' : ['G', 'Y', 'E', 'L'],
		  'Y' : ['J', 'E', 'N'],
		  'E' : ['J', 'Y', 'N'],
		  'N' : ['G', 'Y', 'E'],
		  'M' : ['A'],
		  'A' : ['M'],
		  'L' : ['J']
		 }
\end{verbatim}

Pour établir la liste du cercle d'amis d'un sommet, on utilise un parcours en profondeur du graphe à partir de ce sommet. On appelle cercle d'amis de \texttt{Nom} toute personne atteignable dans le graphe à partir de \texttt{Nom}.

\item Donner la liste du cercle d'amis de Lou.

Un algorithme possible de parcours en profondeur de graphe est donné ci-dessous :

\begin{algorithme}{}
visités = liste vide des sommets déjà visités

fonction parcours\_en\_profondeur(d, s)
\quad ajouter s à la liste visités
\quad pour tous les sommets voisins v de s :
\quad \quad si v n'est pas dans la liste visités :
\quad \quad \quad parcours\_en\_profondeur(d, v)
\quad retourner la liste visités
\end{algorithme}

\item Recopier et compléter le code de la fonction \linebreak \texttt{parcours\_en\_profondeur(d, s)} qui prend en paramètres un dictionnaire d'adjacence \texttt{d} et un sommet \texttt{s} et qui renvoie la liste des sommets issue du parcours en profondeur du graphe modélisé par \texttt{d} à partir du sommet \texttt{s}.

\begin{listing}{}{bb-new-ex2-3.py}\end{listing}

\end{questions}
\end{exobb}

\begin{corrigebb}
\subsectionnn{Partie A : matrice d'adjacence}
\begin{questions}
\item ~\par\vspace*{-1em}
\begin{center}
\includegraphics[scale=0.85]{335_bb-ex2-fig1}
\end{center}

\item ~\par\vspace*{-2.2em}

\begin{listing}{}{bb-new-ex2-1c.py}\end{listing}


\item \begin{verbatim}
>>> indice(sommets, 'G')
0
>>> indice(sommets, 'Z')
None
\end{verbatim}

\item ~\par\vspace*{-2.2em}

\begin{listing}{}{bb-new-ex2-2c.py}\end{listing}


\item Gabriel a 4 amis, ce qui se représente dans la matrice d'adjacence par une liste \texttt{[0, 1, 1, 0, 1, 1, 0, 0]} (soit 4 occurrences de \texttt{'1'}) :
\begin{verbatim}
>>> nb_amis(sommets, matrice_adj, 'G')}
4
\end{verbatim}
\end{questions}
\subsectionnn{Partie B : dictionnaire de listes d'adjacence}
\begin{questions}
\item Dans \texttt{\{c : v\}}, \texttt{c} est la clé et \texttt{v} la valeur qui lui est associée.
\item Le dictionnaire de listes d'adjacence est :
\begin{verbatim}
graphe = {'G' : ['J', 'Y', 'N', 'M'],
		  'J' : ['G', 'Y', 'E', 'L'],
		  'Y' : ['G', 'J', 'E', 'N', 'M', 'A'],
		  'E' : ['J', 'Y', 'N'],
		  'N' : ['G', 'Y', 'E'],
		  'M' : ['G', 'Y', 'A'],
		  'A' : ['Y', 'M'],
		  'L' : ['J']}
\end{verbatim}
\item Avec un dictionnaire de liste d'adjacence, dès lors que \texttt{s} est dans \texttt{d}, permet de trouver le nombre d'amis de \texttt{s} en renvoyant la longueur de la liste associée à la clé \texttt{s} :
\begin{listing}{}{bb-new-ex2-4.py}\end{listing}
\item Désormais, les sommets \texttt{'M'} et \texttt{'A'} ne sont plus liés qu'entre eux et ne sont plus atteignables par les autres (\textit{cf}. nouveau graphe ci-dessous).
 
\begin{center}
\includegraphics[scale=0.85]{336_bb-ex2-fig1-mod-Qb4}
\end{center}

Ainsi, le cercle d'amis de Lou est constitué de Jade, Yanis, Emma, Gabriel et Nina.
\item \begin{listing}{}{bb-new-ex2-3c.py}\end{listing}
\end{questions}
\end{corrigebb}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{exobb}{Gestion d'un hôpital}{D'après bac 2024 Polynésie J2}{2}{80}

\textit{Cet exercice, noté sur 8 points, porte sur les protocoles réseau, les bases de données relationnelles et
les requêtes SQL, l'algorithmique et la programmation en Python.}

Cet exercice est composé de trois parties indépendantes.

\subsectionnn{Partie A : le réseau informatique d'un hôpital} %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

Dans un hôpital, le service informatique a créé le réseau ci-dessous :

\begin{figure}
\centering
\includegraphics{327_bb-ex3-fig1}
\label{bb-ex3fig1}\figcaption{Réseau informatique de l'hôpital}
\end{figure}

Dans un premier temps, on s'intéresse au protocole RIP, qui minimise le nombre de sauts entre routeurs.

\begin{questions}

\item Donner les chemins possibles d'un paquet de données partant du service de neurologie à destination du service d'imagerie en utilisant le protocole RIP.

\item Recopier et compléter la table des coûts du nœud R2 selon le protocole RIP.
\begin{center}
\begin{tabular}{|c|c|}
\hline\tabulartitle
\multicolumn{2}{|c|}{Nœud R2} \\
\hline
Destination & Coût \\
\hline
R1 & 1 \\
\hline
... & ... \\
\hline
\end{tabular}
\end{center}

\newpage


On s'intéresse maintenant au protocole de routage OSPF. Ce dernier cherche à minimiser la somme des coûts des liaisons entre les routeurs empruntés par un paquet. Le coût \texttt{c} d'une liaison est donné par :
$$c=\frac{10^8}{d}$$

où \texttt{d} est la bande passante en bit/s de la liaison.

La bande passante des liaisons FTTH (fibre optique : Fiber To The Home) est de 10~Gbit/s et celle des liaisons FastEthernet est de 100~Mbit/s.

\item Calculer le coût d'une liaison de communication par la technologie FTTH.

Sur la figure \ref{bb-ex3fig1}, les liaisons sont représentées par un style de trait différents en fonction de leur débit. La légende y est indiquée en bas à gauche.

\item Avec le protocole OSPF, donner le chemin pris par un paquet partant du service de neurologie à destination du service d'imagerie.

\end{questions}

\subsectionnn{Partie B : le dossier médical d'un patient} %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

Lorsqu'un patient se présente dans un hôpital, on lui demande sa carte de sécurité sociale (carte Vitale) ainsi qu'une pièce d'identité. En effet, les secrétaires des différents services doivent mettre à jour les données du dossier médical du patient. Ainsi le dossier permet aux médecins de l'hôpital d'avoir accès aux fichiers contenant les divers examens effectués par le patient (les clichés des IRM ou radios, les résultats de ses prises de sang, etc.).

Pour gérer et partager toutes ces données, le service informatique de l'hôpital a créé une base de données dont le modèle relationnel est donné par le schéma présenté sur la figure \ref{bb-ex3fig2}. Sur ce schéma, un attribut souligné indique qu'il s'agit d'une clé primaire et un dièse \texttt{\#} avant un attribut indique qu'il s'agit d'une clé étrangère.


\begin{figure}
\includegraphics{328_bb-ex3-fig2}
\label{bb-ex3fig2}\figcaption{Base de données de l'hôpital}
\end{figure}

Toutes les clés primaires de cette base de données sont de type \texttt{INT} (sauf \texttt{num\_SS} qui
est de type \texttt{TEXT}), les dates sont de type \texttt{DATE} (\texttt{JJ/MM/AAAA}) et tous les autres attributs sont de type \texttt{TEXT}.

L'énoncé de cet exercice utilise tout ou une partie des mots clefs du langage SQL suivants : \texttt{SELECT}, \texttt{DISTINCT}, \texttt{FROM}, \texttt{WHERE}, \texttt{JOIN ... ON}, \texttt{UPDATE ... SET}, \texttt{DELETE},
\texttt{INSERT INTO ... VALUES}, \texttt{LIKE}, \texttt{BETWEEN}.

La commande \texttt{LIKE 'a\%'} permet de rechercher toutes les chaînes de caractères qui commencent par un \og a \fg et \texttt{LIKE '\%a'} celles qui se terminent par un \og a \fg.

\hspace*{-1cm}
\begin{tabular}{|c|c|c|c|c|}
\hline\tabulartitle
\multicolumn{5}{|c|}{\texttt{Patient}} \\
\hline
\texttt{num\_SS} & \texttt{Nom} & \texttt{prenom} & \texttt{date\_naissance} & \texttt{lieu\_naissance} \\
\hline
2~95~07~75~019~089~45 & Baujean & Emma & 03/07/1995 & Paris \\
\hline
1~01~12~14~118~326~20 & Tardus & Kylian & 16/12/2001 & Caen \\
\hline
2~12~10~31~555~673~33 & Delpuis & Sarah & 23/10/2012 & Toulouse \\
\hline
1~90~03~49~007~512~42 & Montpart & Vincent & 30/03/1990 & Angers \\
\hline
\end{tabular}

\begin{questions}

\item Décrire simplement le résultat obtenu avec la requête SQL ci-dessous :

\begin{verbatim}
SELECT nom,prenom FROM patient WHERE num_SS LIKE '1%';
\end{verbatim}

\item \'Ecrire une requête SQL permettant d'afficher le numéro de Sécurité Sociale des patients hospitalisés dans le service intitulé orthopédique durant l'année 2023.

\item \'Ecrire une requête SQL permettant d'afficher le type et la date de chaque examen de la patiente Mme Baujean Emma.

\item \'Ecrire une requête SQL permettant d'afficher le nom et le prénom de tous les patients du médecin M. ARNOS Pierre.
\end{questions}

\subsectionnn{Partie C : la sécurité des mots de passe d'un médecin} %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

Pour utiliser les ordinateurs de cet hôpital, tout le personnel doit saisir son identifiant puis son mot de passe. Pour davantage de sécurité, ce dernier doit être fort et changé régulièrement.

On appelle \og mot de passe fort \fg une chaîne de caractères composée :
\begin{itemize}
\item d'au minimum 12 caractères ;
\item d'au moins 2 majuscules ;
\item d'au moins 2 chiffres ;
\item d'au moins 2 symboles parmi \#@!?\%<>=€\$+-*/\&.
\end{itemize}

Par exemple, un médecin utilise le mot de passe fort : \texttt{@20!HôPiTaL\&24\#}.

On dispose des méthodes :
\begin{itemize}
\item \texttt{isalpha} qui permet de tester si un caractère est une lettre ;
\item \texttt{isupper} qui permet de tester si un caractère est une majuscule ;
\item \texttt{isdigit} qui permet de tester si un caractère est un chiffre.
\end{itemize}


\begin{listing}{}{bb-new-ex3-console1.py}\end{listing}

De plus, on affecte tous les symboles dans une variable globale \linebreak \texttt{liste\_symboles} de type \texttt{str}:

\begin{verbatim}
liste_symboles = '#@!?%<>=€$+-*/&'
\end{verbatim}

\begin{questions}

\item On considère une fonction \texttt{mdp\_fort} qui prend en paramètre une chaîne de caractères \texttt{mdp} et qui renvoie \texttt{True} si \texttt{mdp} est un mot de passe fort et \texttt{False} sinon.
Compléter le script de cette fonction \texttt{mdp\_fort} en recopiant les lignes 2, 10, 12 et 14 sur votre copie :

\begin{listing}[language=Python,numbers=left,numberstyle=\small]{}{bb-new-ex3-1.py}
\end{listing}

Pour aider le personnel, le service informatique a mis en place une fonction \texttt{creation\_mdp} permettant de générer aléatoirement un mot de passe. Elle prend en paramètres quatre entiers de type \texttt{int} :
\begin{itemize}
\item la longueur \texttt{n} du mot de passe ;
\item le nombre \texttt{nbr\_m} de majuscules qu'il doit contenir au minimum ;
\item le nombre \texttt{nbr\_c} de chiffres qu'il doit contenir au minimum ;
\item le nombre \texttt{nbr\_s} de symboles qu'il doit contenir au minimum.
\end{itemize}

Cette fonction renvoie une chaîne de caractères respectant les conditions précédentes.

\item Compléter le script de cette fonction \texttt{creation\_mdp} en recopiant les lignes 9 et de 14 à 20 sur votre copie.

\begin{listing}[language=Python,numbers=left,numberstyle=\small]{}{bb-new-ex3-2.py}
\end{listing}

Si un personnel n'utilise pas le générateur de mot de passe, il a tendance à y insérer des mots de la langue française.
Par exemple, le mot de passe \texttt{@20!HôPiTaL\&24\#} est fort mais on y trouve le mot \og hôpital \fg.
Si un mot de passe ne contient pas de mots de 4 lettres ou plus de la langue française ou étrangère, on dit que c'est un \og mot de passe extra fort \fg.
On dispose de la variable \texttt{dicoFR} (de type \texttt{list}) qui contient tous les mots de la langue
française en minuscules.

On dispose également de la fonction \texttt{transforme} qui prend en paramètre une chaîne de caractères et qui renvoie une nouvelle chaîne de caractère en transformant toutes les lettres majuscules en minuscules. Par exemple :

\begin{listing}{}{bb-new-ex3-console2.py}\end{listing}

\enlargethispage*{\baselineskip}
Pour simplifier, on suppose que les mots présents dans un mot de passe sont entiers (pas d'abréviation) et sont séparés par des chiffres ou des symboles.
On considère une fonction \texttt{recherche\_mot} qui prend en paramètre un mot de passe \texttt{mdp} (de type \texttt{str}) et qui renvoie des mots présents (de type \texttt{str}) dans \texttt{mdp}. 

Exemple :

\begin{listing}{}{bb-new-ex3-console3.py}\end{listing}

\item Compléter le script de cette fonction \texttt{recherche\_mot} en recopiant les lignes 5, 6, 15, 16, 18 sur votre copie.

\begin{listing}[language=Python,numbers=left,numberstyle=\small]{}{bb-new-ex3-3.py}
\end{listing}

\item \'Ecrire une fonction \texttt{mdp\_extra\_fort} qui prend en paramètre une chaîne de caractères \texttt{mdp} et qui renvoie \texttt{True} si \texttt{mdp} est un mot de passe extra fort et \texttt{False} sinon.

\end{questions}
\end{exobb}

\begin{corrigebb}
\subsectionnn{Partie A : le réseau informatique d'un hôpital}
\begin{questions}
\item En utilisant le protocole RIP, le chemin entre R4 et R2 minimise le nombre d'intermédiaires. 

On a donc : 
\begin{center}
R4 -- R8 -- R1 -- R2 ou R4 -- R8 -- R7 -- R2.
\end{center}

\item On remplit la table des coûts du nœud R2 en comptant le nombres de routeurs à joindre pour que le paquet chemine jusqu'à chaque routeur.

\begin{center}
\begin{tabular}{|c|c|}
\hline\tabulartitle
\multicolumn{2}{|c|}{Nœud R2} \\
\hline
Destination & Coût \\
\hline
R1 & 1 \\
\hline
R3 & 3 \\
\hline
R4 & 3 \\
\hline
R5 & 2 \\
\hline
R6 & 3 \\
\hline
R7 & 1 \\
\hline
R8 & 2 \\
\hline
R9 & 2 \\
\hline
\end{tabular}
\end{center}

\item Le débit d'une liaison FTTH est : $d = 10\times 10^9$, d'où:
$$c = \frac{10^8}{10\times 10^9} = 10^{-2} = 0,01.$$

Or, les coûts inférieurs à 1 dans OSPF sont arrondis à 1.

La réponse est donc $c = 1$.

\newpage

\item Les liaisons FTTH ont un coût de 0,01. Les liaisons FastEthernet ont un coût de 1. Les autres ont un coût de 1. Le protocole OSPF minimise le coût total du chemin. On trouve alors R8 -- R9 -- R1 -- R2 avec un coût total de $4$.
\end{questions}


\subsectionnn{Partie B : le dossier médical d'un patient}

\begin{questions}
\item Le résultat de la requête contient les noms et prénoms de tous les patients dont le numéro de Sécurité Sociale commence par un 1 (hommes).
\item On réalise une jointure (interne) entre les tables \texttt{patient} et \linebreak \texttt{hospitalisation}. Les doublons éventuels (un même patient hospitalisé plusieurs fois durant l'année dans ce service) avec \texttt{DISTINCT}. Les dates n'étant pas stockées au format \texttt{TEXT}, il ne semble pas adapté d'utilier \texttt{LIKE} mais plutôt des tests sur \texttt{hospitalisation.date} avec l'opérateur \texttt{BETWEEN}.

\begin{listing}[language=SQL]{}{bb-new-ex3-5.sql}\end{listing}
\item Là aussi, on utilise une jointure interne. Les doublons ne sont pas éliminés.

\begin{listing}[language=SQL]{}{bb-new-ex3-6.sql}\end{listing}
\item La jointure interne est réalisée entre les trois tables, avec élimination des doublons.
\enlargethispage*{3em}
\begin{listing}[language=SQL]{}{bb-new-ex3-7.sql}\end{listing}
\end{questions}

\newpage

\subsectionnn{Partie C : la sécurité des mots de passe d'un médecin}


\begin{questions}
\item La fonction renvoie \texttt{False} dès qu'une des conditions n'est pas remplie, \texttt{True} sinon. Pour cela, elle teste la longueur de la chaîne \texttt{mdp} puis utilise 3 variables pour compter les caractères (lettres, chiffres et symboles).
\begin{listing}{}{bb-new-ex3-1c.py}\end{listing}

\enlargethispage*{5em}
\item On reprend le même principe que précédemment, avec l'utilisation de compteurs. La chaîne retournée est le résultat d'une concaténation caractère par caractère, qui s'arrête lorsque toutes les conditions sont réunies.

\begin{listing}{}{bb-new-ex3-2c.py}\end{listing}

\newpage

\item La chaîne \texttt{mdp} est parcourue caractère par caractère : si le caractère est un chiffre ou symbole, on passe au caractère suivant. Sinon, on constitue une chaîne par concaténation, tant que le caractère est une lettre. La fin de la chaîne ou l'apparition d'un chiffre ou d'un symbole arrête la concaténation et la chaîne construite est ajoutée dans la liste à retourner.
\begin{listing}[language=Python]{}{bb-new-ex3-3c.py}
\end{listing}

\item À l'aide de la fonction \texttt{recherche\_mot}, les mots à tester sont extraits de la chaîne \texttt{mdp}. Si au moins un de ces mots extraits est de taille supérieure ou égale à 4 et qu'il est présent dans le dictionnaire, alors on retourne \texttt{False}. Après avoir testé tous les mots, on retourne \texttt{True} car aucun mot de 4 lettres au moins n'a été trouvé dans le dictionnaire utilisé.

\begin{listing}[language=Python]{}{bb-new-ex3-4.py}
\end{listing}
\end{questions}
\end{corrigebb}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%


\onglet 
\AfficheCorrigeBB
