Discussion :

[stèfv96]

Bonjour Tout le monde !

je suis élève de bts et j'ai un exercie d'algo qui est le suivant:

"l'utilisateur saisie un texte sans mettre de majuscule, et sans mettre d'éspace après le point se trouvant a la fin des phrase, puis il valide sa saisie.

le programme de mise en forme de texte réaffiche le texte saisi en ayant remplacé les minuscule par des majuscules azu début des phrase,et ayant ajouter un espace aprés chaque point"

je voudrais donc utiliser la formule SI(si tout caractère est aprés un point alors on remplace par une maj)

mais je ne sais pas comment dire "est precédé par" et "pour tout caractère de la chaîne" en algo

quelqu'un pourrais m'aider ?
merci

[ToTo13]

Bonjour,

tu peux toujours dire simplement "est précédé par ...", mais je ne pense pas que ce soit le but de l'exercice.
Je pense que le but c'est que construise un algorithme pour traduire "est précédé par...". Pour cela, je te conseille de rechercher les points et ensuite tu avances d'un cran pour ajouter la majuscule à la lettre suivante.

[Invité]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[PRomu@ld]

Cette méthode a au moins 35 ans.

Sans vouloir être médisant, qui utilise ceci à l'heure actuelle ? Quand je dis utiliser, c'est dans un contexte professionnel, pas pédagogique.

[Invité]

Bonjour,

Sans vouloir être médisant, qui utilise ceci à l'heure actuelle ? Quand je dis utiliser, c'est dans un contexte professionnel, pas pédagogique.

Je me doutais bien qu'il y aurait des réactions.

En observant la chute d'une pomme sous l'influence de son poids, Newton découvrit les lois de l'attraction universelle. Ces lois existaient avant et existent toujours, que je sache. Indépendamment du langage, une approche par traitement reste toujours vraie.

Je n'empêche personne de raisonner autrement. Il appartient à chacun de chercher et trouver sa vérité. Pour ce qui me concerne, durant toute ma carrière, j'ai eu le temps d'explorer pratiquement toutes les méthodes de programmation et d'analyse. Côté programmation, LCP m'a toujours donné satisfaction, je n'ai jamais rencontré de problèmes de logique. Mes premiers programmes ont tourné 14 ans et certains de mes derniers tournent depuis 17 ans. Durant ces 17 dernières années j'ai produit environ 3 millions de lignes à main levée sans qu'il m'ait été nécessaire de passer par un organigramme. 3 millions de lignes, à raison de 69 lignes par recto A4, ça représente 86 ramettes de 500 feuilles, soit 4m 30 de hauteur.

Face à une problématique, il y a lieu de se poser les vraies questions. En l'occurence ici :

1. Qu'est-ce que je traite : un caractère n fois (itérative)

2. Je le traite de quelle façon ? (alternative)
- soit en transformant le caractère en majuscule
- soit en recopiant le caractère tel qu'il est, en y ajoutant éventuellement un espace (incrémentation de la table T-WRITE)

C'est l'énoncé du problème qui détermine l'algorithme. Encore faut-il savoir le lire. Il n'est pas nécessaire d'être informaticien pour raisonner par traitement. La programmation qui consiste à mettre les instructions dans chaque pavé est tellement évidente qu'elle en perd même de son intérêt.

Certains compilateurs proposent des clauses "BEFORE GROUP" et "AFTER GROUP". Ce ne sont rien d'autre que les "Débuts de traitement" et "Fins de traitement" de structures itératives. La clause "EVERY ROW" constituant le traitement proprement dit. Je me situe là, dans un contexte de gestion. Comme en économie, il y aurait lieu d'ajouter un "toutes choses égales par ailleurs" pour relativiser mon discours.

J'invitais d'autres membres à proposer leur solution. Exprimez-vous...

[Zavonen]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
# -*- coding: cp1252 -*-
import string
 
# Juste pour la première lettre
def Traite(Saisie):
    if Saisie: # teste si vide (just in case)
        return string.upper(Saisie[0])+TraiteReste(Saisie[1:])
    else:
        return ""
 
#Pour le restant
def TraiteReste(Saisie):
    if Saisie=="": # chaîne vide rien à faire
        return ""
    else:
        if Saisie[0]!='.': #pas de point
            return Saisie[0]+TraiteReste(Saisie[1:]) # on prend le caractère et on traite le reste
        else:
            return ". "+string.upper(Saisie[1:2])+TraiteReste(Saisie[2:])#on remet le point on ajoute un espace et on transforme en majuscule
 
def main():
    print Traite("aa.bbb.cc.")
 
if __name__ == '__main__':
    main()