LCP : Structure itérative et structure alternative
Bonjour,
"pour tout caractère de la chaîne", ça s'appelle une structure itérative. A l'intérieur de cette structure itérative, soit tu traites un caractère qui doit devenir une majuscule, soit tu traites un caractère qui reste ce qu'il est et qui doit éventuellement être suivi d'un espace. Ça s'appelle une structure alternative et cette alternative est conditionnée par la valeur d'une variable (un aiguillage).
Je ne devrais pas faire ton boulot mais si tu poses ce genre de question, c'est que tu es vraiment mal parti ! Maintenant, l'algorithme que je te propose s'appuie sur la méthode LCP (Loi de Construction de Programme). LCP raisonne par traitement et non par conditionnement. Avec ton : "je voudrais donc utiliser la formule SI", déjà, je le sens mal. Je doute fort que l'on enseigne encore LCP en BTS ou ailleurs. Cette méthode a au moins 35 ans. Elle a été créée par Warnier, un ingénieur de la Bull.
Je commence donc par une approche pédagogique du problème via ce que l'on appelle la décomposition en parenthèses suivie de l'organigramme qui résulte de cette approche sachant que tout ce qui n'est pas décomposé (Traitement <> (n)) fait l'objet d'un pavé. Le niveau de décomposition n'est pas forcément celui qui est attendu. Ainsi, j'occulte la transformation d'un caractère minuscule en majuscule qui peut faire l'objet d'une décomposition plus fine. Tout dépend de ses capacités d'abstraction.
La décomposition en parenthèses n'est qu'une approche pédagogique pour apprendre à maîtriser le raisonnement par traitement. Dès que l'on maîtrise, on oublie. De même, pour l'organigramme. L'expérience aidant, on décompose de moins en moins finement, jusqu'à ne plus y avoir recours.
D = Début
F = Fin
T = Traitement
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
+- +-
|D_PROG (1) |D_READ(1)
| |
| |
| |T_MAJ(0,1)
< T_READ(n) <
| |T_MIN(0,1)
| |
| |
|F_PROG(1) |F_READ(1)
+- +-
+-----------+
| D_PROG |
+-----------+
|
+<-----------------------+
| |
+-----------+ |
| D_READ | |
+-----------+ |
+------------< >------------+ |
+-----------+ +-----------+ |
| T-MAJ | | T-MIN | |
+-----------+ +-----------+ |
+-------+-----------+-------+ |
| |
+-----------+ |
| F_READ | |
+-----------+ |
< >-----------------------+
|
+-----------+
| F_PROG |
+-----------+ |
Il ne te reste plus qu'à écrire le programme.
Ça peut commencer comme ça :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
| T_READ : Table contenant la saisie (n items d'un caractère)
I_READ : Indice courant
J_READ : Indice borne dernier item renseigné
K_READ : Indice borne de la table T_READ
T_WRITE : Table contenant les caractères à afficher (n items d'un caractère)
I_WRITE : Indice courant
J_WRITE : Indice borne dernier item renseigné
K_WRITE : Indice borne de la table T_WRITE
AIG_MAJ = 0 => Traitement minuscule ou point
= 1 => Traitement MAJUSCULE
D_PROG(1) : I_READ = 1
I_WRITE = 1
AIG_MAJ = 1
D_READ(1) : si AIG_MAJ = 1
alors T_MAJ
sinon T_MIN
T_MAJ(0,1) : etc.
T_MIN(0,1) : ...
F_READ(1) : ...
F_PROG(1) : affichage de la table T_WRITE |
Tous les indices ne sont pas forcément utilisés (K) mais devraient cependant l'être pour ne pas risquer un débordement de table.
Davantage qu'une solution, c'est une véritable leçon particulière que je t'offre car tu sembles en avoir bien besoin. Tu as également besoin de cours de français.
Ce serait bien que tu complètes T_MAJ, T_MIN et F_READ
Pour une approche PS (Programmation Structurée), je laisse les spécialistes se manifester.
