IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Algorithmes et structures de données Discussion :

exercice bts algo


Sujet :

Algorithmes et structures de données

  1. #1
    Candidat au Club
    Profil pro
    Inscrit en
    janvier 2008
    Messages
    5
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : janvier 2008
    Messages : 5
    Points : 2
    Points
    2
    Par défaut exercice bts algo
    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

  2. #2
    Modérateur
    Avatar de ToTo13
    Homme Profil pro
    Chercheur en informatique
    Inscrit en
    janvier 2006
    Messages
    5 791
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 42
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : Chercheur en informatique
    Secteur : Santé

    Informations forums :
    Inscription : janvier 2006
    Messages : 5 791
    Points : 9 857
    Points
    9 857
    Par défaut
    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.
    Consignes aux jeunes padawans : une image vaut 1000 mots !
    - Dans ton message respecter tu dois : les règles de rédaction et du forum, prévisualiser, relire et corriger TOUTES les FAUTES (frappes, sms, d'aurteaugrafe, mettre les ACCENTS et les BALISES) => ECRIRE clairement et en Français tu DOIS.
    - Le côté obscur je sens dans le MP => Tous tes MPs je détruirai et la réponse tu n'auras si en privé tu veux que je t'enseigne.(Lis donc ceci)
    - ton poste tu dois marquer quand la bonne réponse tu as obtenu.

  3. #3
    Invité
    Invité(e)
    Par défaut 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 : 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.

  4. #4
    Expert éminent
    Avatar de PRomu@ld
    Homme Profil pro
    Ingénieur de Recherche
    Inscrit en
    avril 2005
    Messages
    4 155
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 36
    Localisation : France, Vienne (Poitou Charente)

    Informations professionnelles :
    Activité : Ingénieur de Recherche
    Secteur : Enseignement

    Informations forums :
    Inscription : avril 2005
    Messages : 4 155
    Points : 6 486
    Points
    6 486
    Par défaut
    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.

  5. #5
    Invité
    Invité(e)
    Par défaut A chacun sa vérité
    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...
    Dernière modification par Invité ; 09/02/2008 à 19h46.

  6. #6
    Rédacteur
    Avatar de Zavonen
    Profil pro
    Inscrit en
    novembre 2006
    Messages
    1 772
    Détails du profil
    Informations personnelles :
    Âge : 74
    Localisation : France

    Informations forums :
    Inscription : novembre 2006
    Messages : 1 772
    Points : 1 913
    Points
    1 913
    Par défaut
    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()
    Ce qu'on trouve est plus important que ce qu'on cherche.
    Maths de base pour les nuls (et les autres...)

Discussions similaires

  1. Exercice d'algo !
    Par Bil'0x dans le forum Algorithmes et structures de données
    Réponses: 4
    Dernier message: 21/05/2009, 22h15
  2. Exercice d'algo que je n'arrive pas a resoudre
    Par bansan dans le forum Mathématiques
    Réponses: 7
    Dernier message: 10/03/2008, 08h15
  3. Aide pour exercices d'algo
    Par couls dans le forum Algorithmes et structures de données
    Réponses: 4
    Dernier message: 27/08/2007, 15h05
  4. probleme avec les exercices d'algo
    Par djsito1 dans le forum Windows
    Réponses: 1
    Dernier message: 20/10/2006, 15h20
  5. exercice d'algo
    Par rimbaut dans le forum Algorithmes et structures de données
    Réponses: 1
    Dernier message: 11/12/2005, 08h33

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo