Problème — cartes d'accès d'une médiathèque
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` (), 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 et `M` entier dans (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 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 »).
```
DEF FN Verifnum(ch:chaîne):booléen
1) k ← 0
Répéter
k ← k + 1
Jusqu'à (NON ch[k] dans ["0".."9"]) OU (k = Long(ch))
2) Verifnum ← ch[k] dans ["0".."9"]
3) Fin Verifnum
```
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
Valeur(Sous-chaine(nbch,1,4), nb1)
Valeur(Sous-chaine(nbch,5,Long(nbch)-4), nb2)
Convch(nb1+nb2, C[i])
FinSi
FinPour
2) Fin Coder
```
TDOL : `i`, `r`, `x`, `e`, `nb`, `nb1`, `nb2` entiers ; `ch`, `nbch` chaînes.
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
```