Série N°6 : Modularité 2 — Les Procédures

Cochez la bonne réponse pour chacune des 10 questions suivantes :

Analysez rigoureusement les algorithmes et traces d'exécution suivants :

Procédure Test(a : Entier, @b : Entier)
Début
  a ← a + 10
  b ← b + 10
Fin

// Dans le programme principal :
x ← 5
y ← 5
Test(x, y)

Procédure Permuter(x : Entier, y : Entier)
Début
  aux ← x
  x ← y
  y ← aux
Fin

Procédure Saisie(@n : Entier)
Début
  Répéter
    Ecrire("Donner N (N > 0) : ")
    Lire(n)
  Jusqu'à n > 0
Fin

compteur = 0

def incrementer():
    global compteur
    compteur += 1

incrementer()
incrementer()
print(compteur)

Procédure Division_Euclidienne(a : Entier, b : Entier, @q : Entier, @r : Entier)
Début
  q ← a Div b
  r ← a Mod b
Fin

En sécurité routière et en physique appliquée, la distance totale d'arrêt d'un véhicule $D_a$ face à un obstacle imprévu se compose de deux phases successives :

1. La distance de réaction ($D_r$) : parcourue à vitesse constante pendant le temps de réflexe du conducteur ($t_r$, estimé à $1.0\text{ s}$ pour un conducteur vigilant). En convertissant la vitesse de km/h en m/s ($v_{ms} = \frac{v}{3.6}$), on a : $D_r = v_{ms} \times t_r$.
2. La distance de freinage ($D_f$) : décélération active des freins jusqu'à l'arrêt complet selon la pesanteur ($g = 9.81\text{ m/s}^2$) et l'adhérence $\mu$ : $$D_f = \frac{v_{ms}^2}{2 \times g \times \mu}$$ $\mu = 0.8$ sur route sèche ("Sec"), $\mu = 0.4$ sur route mouillée ("Mouille"), et $\mu = 0.1$ sur route verglacée ("Verglace").

La distance totale d'arrêt vaut la somme des deux distances : $D_a = D_r + D_f$. On souhaite concevoir un module embarqué combinant fonctions et procédures :

• Une fonction Adherence_Route(etat : Chaîne) : Réel qui reçoit l'état textuel de la route et renvoie le coefficient de frottement $\mu$ correspondant ($0.8$, $0.4$, ou $0.1$ ; $0.5$ par défaut si non reconnu).
• Une fonction Distance_Freinage(vitesse_kmh : Réel, coef_mu : Réel) : Réel qui calcule et retourne la distance de freinage physique $D_f$ en mètres.
• Une procédure Calculer_Securite_Arret(vitesse_kmh : Réel, etat_route : Chaîne, temps_reac : Réel, @dist_reac : Réel, @dist_frein : Réel, @dist_arret : Réel) qui calcule simultanément les trois distances ($D_r$, $D_f$ et $D_a = D_r + D_f$) et les restitue via trois paramètres de sortie passés par variable (@).
• Une fonction Tester_Collision(dist_arret : Réel, dist_obstacle : Réel) : Booléen qui renvoie Vrai si $dist\_arret > dist\_obstacle$ (choc inévitable), et Faux si le véhicule parvient à s'arrêter avant l'obstacle.
• Une procédure Afficher_Diagnostic_Routier(vitesse_kmh : Réel, etat_route : Chaîne, dist_obstacle : Réel) qui coordonne l'appel aux sous-programmes (en fixant le temps de réaction à $1.0\text{ s}$), puis affiche un compte-rendu clair : distances décomposées, verdict de collision ou d'arrêt sécurisé, et marge restante ou distance manquante.

Dans les formulaires d'inscription en ligne, les utilisateurs saisissent souvent des identités avec des espacements multiples anarchiques et une alternance désordonnée de majuscules et de minuscules (par exemple : ch = " mOhaMed aLi bEn sALEM ").
Avant archivage, le système doit normaliser cette chaîne sur place (sans utiliser de tableau) : éliminer les espaces superflus, compter le nombre effectif de mots et capitaliser chaque composante (première lettre en majuscule, les autres en minuscule : "Mohamed Ali Ben Salem").

Le cahier des charges impose une décomposition modulaire mixte :

• Une fonction Est_Espace(c : Caractère) : Booléen qui renvoie Vrai si le caractère c est un espace, et Faux sinon.
• Une fonction En_Minuscule(c : Caractère) : Caractère qui convertit un caractère majuscule en minuscule en utilisant les codes ASCII (si "A" ≤ c ≤ "Z" renvoie Chr(Ord(c) + 32), sinon renvoie c).
• Une procédure Purger_Espaces(@texte : Chaîne) qui modifie la chaîne texte directement par variable (@) pour supprimer les espaces de tête, les espaces de queue, et réduire toute séquence d'espaces consécutifs à un seul espace.
• Une procédure Normaliser_Nom(@texte : Chaîne, @nb_mots : Entier) qui appelle Purger_Espaces(texte), puis parcourt la chaîne assainie pour mettre en majuscule la première lettre de chaque mot, convertir les autres lettres en minuscules, et compter le nombre total de mots (transmis par variable via @nb_mots).
• Une procédure Afficher_Fiche_Identite(nom_brut : Chaîne) qui prend une chaîne brute, appelle Normaliser_Nom, puis affiche le nom propre épuré ainsi que le nombre de mots identifiés.

La sécurité des accès informatiques repose sur la complexité des mots de passe. Un portail web souhaite intégrer un module autonome d'audit sans faire appel à des structures de tableaux :

• Attribuer un score pondéré selon 4 catégories (minuscules, majuscules, chiffres, caractères spéciaux).
• Examiner la chaîne en un seul parcours complet et renvoyer 5 indicateurs par variable (@).
• Classifier le niveau de robustesse ("Très Faible", "Moyen", "Robuste", "Excellent").
• Renforcer automatiquement le mot de passe sur place s'il est jugé vulnérable.

Le module se compose des sous-programmes suivants :

• Une fonction Poids_Caractere(c : Caractère) : Entier qui attribue un score pondéré selon la catégorie du caractère :
  • Lettre minuscule ($'a' \le c \le 'z'$) : 1 point
  • Lettre majuscule ($'A' \le c \le 'Z'$) : 2 points
  • Chiffre décimal ($'0' \le c \le '9'$) : 3 points
  • Caractère spécial (parmi # @ ! $ % & * ?) : 5 points
  • Tout autre caractère : 0 point
• Une procédure Evaluer_Mot_De_Passe(mdp : Chaîne, @score : Entier, @nb_maj : Entier, @nb_min : Entier, @nb_chiffres : Entier, @nb_speciaux : Entier) qui examine le mot de passe en un seul parcours complet de boucle, utilise Poids_Caractere pour cumuler le @score global et comptabilise simultanément les 4 catégories transmises par variable (@).
• Une fonction Determiner_Niveau(score : Entier, lg : Entier) : Chaîne qui retourne l'appréciation textuelle :
  • Si $lg < 8$ ou $score < 15$ : "Très Faible"
  • Sinon si $score < 25$ : "Moyen"
  • Sinon si $score < 40$ : "Robuste"
  • Sinon : "Excellent"
• Une procédure Renforcer_Mot_De_Passe(@mdp : Chaîne) qui modifie le mot de passe sur place par variable (@) pour corriger ses vulnérabilités :
  • S'il ne comporte aucune majuscule, convertit son premier caractère en majuscule.
  • S'il ne comporte aucun caractère spécial, lui ajoute le symbole "!" à la fin.
  • Si sa longueur finale reste strictement inférieure à 8 caractères, lui concatène le suffixe "2026".
• Une procédure Auditer_Securite(mdp : Chaîne) qui appelle Evaluer_Mot_De_Passe, affiche la grille des statistiques et le diagnostic de robustesse. Si le niveau est "Très Faible" ou "Moyen", elle appelle Renforcer_Mot_De_Passe et affiche la proposition de mot de passe sécurisé.