SD-FStructures de données et modularité

Problème modulaire — cartes d'accès (IDENT / DATE / CODE)

Idée directrice

Forme calquée sur le problème 2019 (session principale) : automatisation d'accès par cartes, trois tableaux de chaînes parallèles (identifiants, dates, codes), contrôles de saisie stricts, module de codage dépendant des dates, affichage final. L'entrée attendue est encore l'analyse modulaire puis les algorithmes (TDNT/TDOG/TDOL).

Ce qui aide à reconnaître la démarche

« Analyser le problème en le décomposant en modules » ; « tableaux IDENT, DATE, CODE » ; « contrôles de saisie » ; « TDNT / TDOG / TDOL »

Besoin d’un point de départ ? Voir la méthode

Dégager d'abord le résultat final (affichage des trois champs) puis remonter aux modules qui produisent chaque tableau.
Un seul module Remplir pour IDENT+DATE évite la redondance ; Coder ne lit que DATE.
Les contrôles (longueur 8, chiffres seuls, J/M bornés) sont une constante du problème 2019.
Traiter les trois cas de formation du code (4 chiffres / < 1000 / > 9999) séparément.

Les pièges à vérifier dans ta démarche

Oublier le contrôle « 8 chiffres » ; construire DATE sans convertir J et M en chaînes ; coder avant d'avoir rempli DATE ; n'afficher qu'un seul tableau.

Sujet principal

Problème — cartes d'accès d'une médiathèque

6 questionsCorrigé masqué

Une médiathèque automatise l'accès à ses services via des cartes. Chaque carte est caractérisée par un identifiant unique, une date de création et un code d'accès. On propose d'écrire un programme permettant de :

Stocker les identifiants de n cartes dans un tableau IDENT ( $3 \le n \le 50$ ), chaque identifiant étant une chaîne formée de 8 chiffres.
Stocker les dates de création dans un tableau DATE : chaîne J/M avec J entier dans $[1..31]$ et M entier dans $[1..12]$ (contrôles de saisie obligatoires).
Déterminer dans un tableau CODE les n codes (chaînes de 4 chiffres) à partir de DATE selon le principe suivant : concaténer J et M pour former un nombre ; le multiplier par un entier aléatoire X dans $[5..64]$ pour obtenir Y ; former le code de 4 chiffres — si Y a 4 chiffres, déplacer le chiffre des milliers à droite ; si Y < 1000, compléter par des 0 à droite ; si Y > 9999, additionner le bloc des 4 chiffres de gauche au reste jusqu'à obtenir 4 chiffres.
Afficher pour chaque carte : identifiant : date : code.

Exemple. Pour n = 3, IDENT = ["12345678", "23456789", "34567891"], DATE = ["8/11", "2/1", "24/12"] et en supposant les aléas X ∈ {10, 32, 53}, on obtient CODE = ["1108", "6720", "1314"] et l'affichage :

12345678 : 8/11 : 1108
23456789 : 2/1 : 6720
34567891 : 24/12 : 1314

NB : on ne demande pas de vérifier l'unicité des identifiants dans IDENT.

Travail demandé :

Analyser le problème en le décomposant en modules (procédure de remplissage de IDENT et DATE, module de vérification qu'une chaîne est numérique, procédure de formation de CODE, procédure d'affichage).
Écrire les algorithmes et les tableaux de déclaration des objets relatifs aux modules (TDNT, TDOG, TDOL).

Voir la correction commentéeAprès avoir posé votre démarche

1. Analyse du programme principal

Nom : Mediatheque
  (IDENT, DATE, n) = PROC Remplir(IDENT, DATE, n)
  PROC Coder(CODE, DATE, n)
  PROC Afficher(IDENT, DATE, CODE, n)
Fin Mediatheque

TDNT — tab = tableau de 50 chaînes

TDOG

IDENT : tab — identifiants des cartes
DATE : tab — dates de création
CODE : tab — codes d'accès
n : entier — nombre de cartes
Remplir, Coder, Afficher : procédures ; Verifnum : module booléen de contrôle numérique

2. Algorithmes

Remplir — saisie de n, de chaque identifiant et de chaque date avec contrôles.

DEF PROC Remplir(var Id,D:tab ; var n:entier)
1) Répéter
     Écrire("Donner le nombre de cartes :")
     Lire(n)
   Jusqu'à (n dans [3..50])
2) Pour i de 1 à n faire
     Répéter
       Écrire("Identifiant de la carte n°", i, " : ")
       Lire(Id[i])
     Jusqu'à (Long(Id[i])=8) ET Verifnum(Id[i])
     Répéter
       Écrire("Donner J :") ; Lire(j)
     Jusqu'à (j dans [1..31])
     Répéter
       Écrire("Donner M :") ; Lire(m)
     Jusqu'à (m dans [1..12])
     Convch(j, jch) ; Convch(m, mch)
     D[i] ← jch + "/" + mch
   FinPour
3) Fin Remplir

TDOL : i, j, m entiers ; jch, mch chaînes ; Verifnum (contrôle « chaîne formée de chiffres »).

0) DEF FN Verifnum(ch:chaîne):booléen
1) k ← 1 ; valide ← (Long(ch) > 0)
2) TantQue (k ≤ Long(ch)) ET valide faire
     Si NON (ch[k] dans ["0".."9"]) alors valide ← Faux FinSi
     k ← k+1
   FinTantQue
3) Verifnum ← valide
4) Fin Verifnum

TDOL de Verifnum : k, entier (rang testé) ; valide, booléen (chaîne non vide et caractères déjà parcourus numériques). Pour une chaîne vide, aucune case n’est lue et la fonction renvoie Faux. Le contrôle ne dépend pas de l’évaluation court-circuit du test de longueur dans Remplir.

Coder — dépend entièrement de DATE déjà rempli.

DEF PROC Coder(var C:tab ; D:tab ; n:entier)
1) Pour i de 1 à n faire
     ch ← D[i]
     Effacer(ch, Pos("/", ch), 1)
     Valeur(ch, r, e)
     x ← 5 + Aléa(60)
     nb ← r * x
     Convch(nb, nbch)
     Si Long(nbch) = 4 alors
       C[i] ← Sous-chaine(nbch, 2, 3) + nbch[1]
     Sinon Si Long(nbch) < 4 alors
       Répéter nbch ← nbch + "0" Jusqu'à (Long(nbch) = 4)
       C[i] ← nbch
     Sinon
       Répéter
         Valeur(Sous-chaine(nbch,1,4), nb1, e)
         Valeur(Sous-chaine(nbch,5,Long(nbch)-4), nb2, e)
         Convch(nb1+nb2, nbch)
       Jusqu'à (Long(nbch) = 4)
       C[i] ← nbch
     FinSi
   FinPour
2) Fin Coder

TDOL : i, r, x, e, nb, nb1, nb2 entiers ; ch, nbch chaînes. Le repli est répété tant que la somme garde plus de quatre chiffres (par exemple 9 999 + 1 = 10 000 → 1 000 + 0 = 1 000), conformément à « jusqu'à obtenir 4 chiffres ».

Afficher — parcourt simultanément les trois tableaux.

DEF PROC Afficher(Id,D,C:tab ; n:entier)
1) Pour i de 1 à n faire
     Écrire(Id[i], " : ", D[i], " : ", C[i])
   FinPour
2) Fin Afficher

Changer d’énoncé, garder le raisonnement

Choisis un seul transfert après le sujet principal. Qu’est-ce qui change ? Quel résultat ou quelle méthode peux-tu réutiliser ? Les autres exercices restent disponibles pour une prochaine séance.

Exercices d'entraînement — une nuance à la fois

1 Un code reste une chaîne : conserver les zéros initiaux

Entraînement 01 / 01

Un code reste une chaîne : conserver les zéros initiaux

3 questionsCorrigé masquéEn cours de relecture

Une carte d’accès possède un code pédagogique obtenu à partir d’un entier positif Y ≤ 9999. Si Y a exactement quatre chiffres, on déplace son premier chiffre à la fin. S’il en a moins de quatre, on ajoute des caractères "0" à droite jusqu’à obtenir quatre caractères. Une seule branche est exécutée ; on ne recommence pas le traitement sur le résultat. Le code final est une chaîne, jamais un entier.

Écrire la fonction CodeCourt(Y), avec TDOL, qui retourne ce code. Les opérations Convch, Long, Sous-chaine utilisent des positions à partir de 1.
Donner les résultats pour Y = 1000, 37 et 9009. Un programme convertit le code obtenu en entier avant de l’enregistrer : montrer le défaut sur un de ces tests.
Écrire une fonction VerifChiffres(ch) qui accepte toute chaîne non vide composée uniquement de caractères "0" à "9". Elle doit refuser une chaîne vide sans lire une position inexistante ; fournir son TDOL et les verdicts pour "", "0073", "7A3".

Cet exercice et sa correction sont en cours de relecture. Tu peux les consulter ; l’exercice n’est pas encore proposé en séance.

Voir la correction commentéeAprès avoir posé votre démarche

CodeCourt. Y est un paramètre entier d’entrée dans [1..9999] ; le résultat est une chaîne de longueur quatre. TDOL : ch, chaîne contenant la représentation décimale puis le code.

0) DEF FN CodeCourt(Y:entier):chaîne
1) Convch(Y,ch)
2) Si Long(ch) = 4 alors
     ch ← Sous-chaine(ch,2,3) + ch[1]
   Sinon
     TantQue Long(ch) < 4 faire
       ch ← ch + "0"
     FinTantQue
   FinSi
3) CodeCourt ← ch
4) Fin CodeCourt

Tests. 1000 donne "0001" ; 37 donne "3700" ; 9009 donne "0099". Convertir "0001" en entier donne 1 : la longueur et les zéros initiaux sont perdus. De même, appliquer la rotation après le remplissage de "37" donnerait à tort "7003" ; les deux branches sont exclusives.

VerifChiffres. TDOL : i entier (rang courant), valide booléen (aucun caractère invalide vu). Le test de borne n’accède à aucune case : il ne dépend pas d’une évaluation court-circuit.

0) DEF FN VerifChiffres(ch:chaîne):booléen
1) valide ← (Long(ch) > 0) ; i ← 1
2) TantQue (i ≤ Long(ch)) ET valide faire
     Si NON (ch[i] dans ["0".."9"]) alors valide ← Faux FinSi
     i ← i+1
   FinTantQue
3) VerifChiffres ← valide
4) Fin VerifChiffres

La fonction retourne Faux pour "", Vrai pour "0073" et Faux pour "7A3". Une chaîne vide ne fait entrer dans aucune itération ; "0" est une chaîne valide. Ce contrôle ne transforme pas les caractères en nombre, donc préserve les zéros initiaux.

Relier ce raisonnement au bac

Choisis une filière pour voir les sujets qui étayent ce scénario.

Tu écris. Tu continues.