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 :

Logigramme et représentation


Sujet :

Algorithmes et structures de données

  1. #21
    Rédacteur/Modérateur

    Homme Profil pro
    Ingénieur qualité méthodes
    Inscrit en
    décembre 2013
    Messages
    3 274
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur qualité méthodes
    Secteur : Conseil

    Informations forums :
    Inscription : décembre 2013
    Messages : 3 274
    Points : 7 513
    Points
    7 513
    Par défaut
    Dans certains langages, il y a les boucles WHILE et les boucles UNTIL, et il y a même 2 formes possibles pour les boucles WHILE.
    J'ai découvert les 2 en même temps, dans la même page de cours ou à peu près. Et c'est certainement une très mauvaise idée sur un plan pédagogique.
    Très vite, j'ai fait mon choix : Pas de boucle UNTIL. Et je n'ai aucun problème avec les boucles WHILE. Plus précisément, je n'utilise les boucles While que sous la forme que j'appelle basique.
    A titre d'exercice, je saurais passer de l'un à l'autre, mais ça demande une gymnastique que je considère inutile.

    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
     
    ' Forme basique
    While condition Faire
       traitement 
    fin While
     
    ' Forme n°2
    Faire
       traitement
    while condition
     
    ' Exemple avec Until
    Faire 
       traitement
    Until condition
     
    ' La forme des années 1950, avec SI et GOTO.
    Début : 
    Traitement
    Si condition goto Début

    La forme basique peut aussi s'écrire comme ci-dessous, si on aime les GOTO :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    Début :
    si condition faire 
       Traitement
       Goto début.
    Fin si
    L'exemple classique, pour la lecture et le traitement d'un fichier :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    Lire PremièreLigne
    Tantque LectureRéussie
      Traiter Ligne
      Lire LigneSuivante
    Fin Tantque
    Je peux comprendre le traumatisme de Valentin03.
    On a 3 formes possibles avec WHILE au début, WHILE à la fin, ou UNTIL

    Si comme l'âne de Buridan, on n'arrive pas à choisir entre ces 3 organisations, on peut y perdre beaucoup de temps, et faire des trucs faux.

    Je pense que dans l'enseignement actuel, on ne parle plus que de la forme que j'appelle basique.
    N'oubliez pas le bouton Résolu si vous avez obtenu une réponse à votre question.

  2. #22
    Membre confirmé Avatar de Galet
    Homme Profil pro
    Consultant/Programmeur Robotique industrielle
    Inscrit en
    mars 2010
    Messages
    204
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Savoie (Rhône Alpes)

    Informations professionnelles :
    Activité : Consultant/Programmeur Robotique industrielle

    Informations forums :
    Inscription : mars 2010
    Messages : 204
    Points : 463
    Points
    463
    Par défaut
    Citation Envoyé par valentin03 Voir le message
    Pourquoi je n'aime pas les "Tant que"

    Méthode avec "Tant que":
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
     
    clic et re-clic
    Tant que flag=0
       Lire xa,ya
       Flag =1
       Lire xb, yb
       Suite du prog
    ...
    prog...
    Où tu place le Fin tant que ?
    Cet exemple n'a pas de sens puisque la valeur de flag ne dépend pas des valeurs qui sont lues... La sortie de boucle est connue et tout ce code ne sert à rien sauf dans le cas où flag est déjà différent de 0 avant le tant que. Un simple If Flag=0 alors lire xa,Ya suffit.

    A la différence d'une boucle For dont la variable de comptage est gérée par le langage, les boucles "jusqu'à" et "tant que" partent de l'apriori que l'on ne connait pas, à l'avance, le nombre de cycles. La variable de bouclage doit donc être modifiée par le programme (souvent par ce qui se trouve dans la boucle mais pas obligatoirement)

    Belle soirée...
    Windows 7 / Delphi Tokyo
    "Les choses ne changent pas. Change ta façon de les voir, cela suffit" Lao Tseu

  3. #23
    Expert éminent sénior Avatar de Flodelarab
    Homme Profil pro
    Inscrit en
    septembre 2005
    Messages
    4 774
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Charente (Poitou Charente)

    Informations forums :
    Inscription : septembre 2005
    Messages : 4 774
    Points : 11 995
    Points
    11 995
    Par défaut
    Citation Envoyé par tbc92 Voir le message
    On a 3 formes possibles avec WHILE au début, WHILE à la fin, ou UNTIL
    Même 4. Puisque de la même manière, UNTIL peut être au début ou à la fin.

    La différence entre WHILE et UNTIL est que la condition de sortie de la boucle doit être fausse pour l'un, et vraie pour l'autre. Il n'est donc pas utile de créer une instruction UNTIL puisqu'il suffit d'inverser la condition.

    Par contre, je regrette que trop de langages ne permettent pas de choisir la condition au début (sans tour de boucle), ou à la fin (après un premier tour de boucle). Ça, c'est une distinction utile. Plus utile que la différence entre WHILE et UNTIL.
    Cette réponse vous apporte quelque chose ? Cliquez sur en bas à droite du message.

  4. #24
    Rédacteur/Modérateur

    Homme Profil pro
    Ingénieur qualité méthodes
    Inscrit en
    décembre 2013
    Messages
    3 274
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur qualité méthodes
    Secteur : Conseil

    Informations forums :
    Inscription : décembre 2013
    Messages : 3 274
    Points : 7 513
    Points
    7 513
    Par défaut
    Une fois que l'on est programmeur chevronné, je suis d'accord avec toi, cette possibilité de mettre la condition en fin de bloc et non en début, c'est un plus.

    Mais j'ai vraiment ce souvenir, quand j'ai appris la programmation d'avoir galéré, à cause de ces 3 options pour le même besoin.
    En principe , un besoin = une réponse ( If pour un test, While pour une boucle, CALL pour un appel à un sous-programme ... ...)
    Et là, pour un seul besoin, on m'a enseigné d'un coup 3 solutions. Et pour la 1ère fois, je n'ai pas eu 20/20 à l'exercice, j'ai été traumatisé à vie (peut-être que j'exagère un peu). Donc, pédagogiquement, il faut enseigner une seule syntaxe ... TantQue Condition, faire Traitement.

    Quitte à proposer plus tard, quand les choses sont acquises, l'autre forme.

    Je différencie bien le côté apprentissage, initiation d'une part, et le côté professionnel d'autre part.

    La réaction de Valentin03 est typiquement liée à ce problème. Il a lu ou il a appris que dans une boucle TantQue, le test de sortie pouvait être fait avant ou après le traitement... A priori, c'est une option de plus, donc c'est une facilité. Mais à l'arrivée, c'est une option de plus, donc c'est une complexité.
    N'oubliez pas le bouton Résolu si vous avez obtenu une réponse à votre question.

  5. #25
    Membre confirmé Avatar de Galet
    Homme Profil pro
    Consultant/Programmeur Robotique industrielle
    Inscrit en
    mars 2010
    Messages
    204
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Savoie (Rhône Alpes)

    Informations professionnelles :
    Activité : Consultant/Programmeur Robotique industrielle

    Informations forums :
    Inscription : mars 2010
    Messages : 204
    Points : 463
    Points
    463
    Par défaut
    Bonsoir,
    la construction des boucles "a l'envers" n'existe pas dans tous les langages et elle est moins lisible que la lecture :
    1- tant que ça est vrai, on fait une action
    2- On fait une action jusqu'à ça devienne vrai
    Pour la formation, comme pour l'algo, c'est directement traçable et programmable. On voit aussi, facilement que la différence la plus importante est que l'action sera obligatoirement exécutée au moins 1 fois dans le cas 2, ce qui n'est pas vrai dans le cas 1.
    Il existe encore des langages qui ne proposent aucune de ces 2 boucles en utilisant force de Goto ou Jump...
    Mieux vaut avoir trop de choix (pour prendre celui qui convient au besoin et à sa logique)
    Cordialement,
    Windows 7 / Delphi Tokyo
    "Les choses ne changent pas. Change ta façon de les voir, cela suffit" Lao Tseu

  6. #26
    Membre éclairé
    Avatar de APL-AML
    Homme Profil pro
    Développeur Gestion (Retraité)
    Inscrit en
    juin 2020
    Messages
    13
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Côtes d'Armor (Bretagne)

    Informations professionnelles :
    Activité : Développeur Gestion (Retraité)
    Secteur : Administration - Collectivité locale

    Informations forums :
    Inscription : juin 2020
    Messages : 13
    Points : 691
    Points
    691
    Billets dans le blog
    63
    Par défaut Symbolique LCP (Logique de Construction des Programmes)
    L’algorigramme (logigramme, organigramme, ordinogramme) est sensé précéder le codage et non l’inverse. Cela dit, l’algorigramme construit à partir d’un programme déjà codé ne devrait pas être différent de l’algorigramme qui aurait dû précéder la programmation. Encore faut-il que la méthode de programmation ayant inspiré le codage corresponde à la réflexion qui inspire la construction à postériori de l’algorigramme.

    La représentation graphique du raisonnement doit être indépendante du langage, de ses spécificités, et doit permettre d’appréhender aisément les fonctionnalités du programme. Représenter graphiquement son raisonnement n’est pas la même chose que représenter graphiquement son codage.

    On ne construit pas un algorigramme en fonction des instructions du langage que l’on utilise. C’est à la programmation d’interpréter et de traduire l’algorigramme. L’algorigramme reste le même, quelque soient les instructions qu’offre le langage, « IF THEN ELSE », « FOR », « WHILE », « GO TO », etc.

    Le « logigramme », autre appellation de l’algorigramme dit bien ce qu’il veut dire, à savoir que c’est une représentation graphique de la logique, donc du raisonnement. Il appartient ensuite au codage de concrétiser cette logique à l’aide d’instructions. La décomposition de l’algorigramme devrait rester au niveau logique des traitements sans descendre jusqu’à l’instruction. Tout dépend de la capacité d’abstraction du programmeur.

    Réaliser un algorigramme suppose l’utilisation d’une symbolique qui dépend de la méthode de programmation utilisée, si tant est qu’il y en ait une :

    • Norme ISO 5807
    • Méthode CORIG (COnception et Réalisation de l'Informatique de Gestion – Robert Mallet, 1967-68)
    • Méthode PS (Arbre programmatique et Programmation Structurée – Marie-Thérèse Bertini et Yves Tallineau, 1978)
    • Méthode LCP (Logique de Construction de programmes – Jean-Dominique Warnier, 1970-71)

    La norme ISO 5807 n’est pas une méthode de programmation, c’est un ensemble de symboles de traitement et de condition de traitement représentant chacun une instruction ou un ensemble d’instructions :

    • Symbole général « traitement » : Opération ou groupe d’opérations sur de données, instructions, etc.
    • Fonction de sous-programme : Portion de programme considérée comme une simple opération.
    • Entrée - Sortie : Mise à disposition d’une information à traiter ou enregistrement d’une information traitée.
    • Préparation : Opération qui détermine partiellement ou complètement la voie à suivre dans un embranchement ou un sous-programme. Symbole également utilisé pour préparer une décision ou mettre un aiguillage en position.
    • Embranchement : Exploitation de conditions variables impliquant le choix d'une voie parmi plusieurs. Symbole couramment utilisé pour représenter une décision ou un aiguillage.

    Cette norme interprète le codage sans règle particulière de raisonnement, elle ne symbolise pas une réflexion indépendante du langage résultant d’un raisonnement méthodique. C’est comme s’exprimer en mode prose (forme ordinaire du discours qui n’est soumise à aucune règle) plutôt qu’en mode poésie (forme des mots disant plus qu'eux-mêmes par leur choix (sens et sonorités) et leur agencement (rythmes, métrique, figures de style).

    La méthodologie « LCP » structure le raisonnement selon une démarche par traitements, en analysant la problématique dans une approche top-down (du plus global vers le plus détaillé, par décompositions hiérarchiques successives). La représentation graphique de ce raisonnement adopte une symbolique à base de deux structures types, la structure itérative (répétitive) et la structure alternative. Lorsque les deux structures s’imbriquent, on appelle cet ensemble, une structure complexe.

    La construction d’algorigrammes LCP ne se fait qu’en phase d’apprentissage de la méthode, à savoir pendant quatre à six mois selon le degré de résistance à passer d’un mode de réflexion par conditionnements à un mode de réflexion par traitements. Une fois acquis les principes LCP, il n’est plus nécessaire de représenter graphiquement son raisonnement devenu un automatisme imprimé dans la mémoire procédurale.

    La séquence codée de Valentin03 que l’on devine se traduit en LCP ainsi :

                         ┌─────────────────────┐
                         │       D_PROG        │
                         └──────────┬──────────┘
                                    ├────────────────────────────────────┐
                         ┌──────────┴──────────┐                         │
                         │       D_TRAIT       │                         │
                         └──────────┬──────────┘                         │
               ┌────────────────────◊────────────────────┐               │
    ┌──────────┴──────────┐                   ┌──────────┴──────────┐    │
    │    TRAITEMENT_1     │                   │    TRAITEMENT_2     │    │
    └──────────┬──────────┘                   └──────────┬──────────┘    │
               └────────────────────┬────────────────────┘               │
                         ┌──────────┴──────────┐                         │
                         │       F_TRAIT       │                         │
                         └──────────┬──────────┘                         │
                                    ◊────────────────────────────────────┘
                         ┌──────────┴──────────┐
                         │       F_PROG        │
                         └─────────────────────┘
    
    D_POG et F_PROG peuvent se traduire par un « WHILE » ou un « FOR »

    D_TRAIT peut se traduire par un « IF THEN ELSE »



    Exercice

    Faire deviner un nombre (entre 1 et 100, choisi préalablement par vous) par votre programme, en moins de coups possible.

    Parmi les algorithmes imaginables, le plus simple consiste à procéder par dichotomie, c'est-à-dire que le programme va à chaque moment proposer comme nombre celui qui se trouve juste au milieu des deux extrêmes possibles.

    Par exemple, au tout début, les deux extrêmes étant 1 et 100, il proposera 50.

    [B]NB Une variante plus divertissante du programme consiste à lui faire choisir au début un nombre aléatoire entre 1 et 100, différent bien sûr du nombre choisi. Ainsi les séquences de recherche sont-elles plus variées qu’avec un départ systématique à 50…

    Imaginons que vous ayez pensé au nombre 23.

    Quand le programme demandera si c’est 50 (son tout premier choix), vous lui répondrez (honnêtement) « Non, 50 est trop grand. »

    À ce moment-là, le programme est assuré d’une chose : les extrêmes possibles sont dorénavant 1 et 49, au lieu de 1 et 100.

    Il proposera alors le nombre juste au milieu de 1 et 49 : 25.

    Et ainsi de suite.

    Source : Cet exercice est extrait d’un document « Bases de Programmation » (1998-1999) du Pr. Éric Kirsch.

    Dans ce document, l'exercice fait l'objet d’une analyse organique comparative :

    • En Pseudo-Code
    • En Arbre Programmatique,
    • En Algorigramme Norme ISO 5807,
    • En Langage Pascal.

    NB : J’ai pensé à télécharger ce document mais j’ai perdu le lien internet.
    Représentation en algorigramme LCP

                                 ┌─────────────────────┐
                          D_PROG │      CTR = 0        │
                                 │     MINI = 1        │
                                 │     MAXI = 100      │
                                 │     NBRE = 1<n>100  │
                                 │    CHOIX = n        │
                                 └──────────┬──────────┘
                                            ├────────────────────────────────────┐
                                 ┌──────────┴──────────┐                         │
                         D_TRAIT │    NBRE :: CHOIX    │                         │
                                 └──────────┬──────────┘                         │
                     < ┌────────────────────◊────────────────────┐ >             │
            ┌──────────┴──────────┐                   ┌──────────┴──────────┐    │
     T_MINI │     MINI = NBRE     │            T_MAXI │     MAXI = NBRE     │    │
            └──────────┬──────────┘                   └──────────┬──────────┘    │
                       └────────────────────┬────────────────────┘               │
                                 ┌──────────┴──────────┐                         │
                         F_TRAIT │      CTR = CTR + 1  │                         │
                                 │ «  CTR » = CTR      │                         │
                                 │ « MINI » = MINI     │                         │
                                 │ « MAXI » = MAXI     │                         │
                                 │NBRE = (MINI+MAXI)/2 │                         │
                                 │    NBRE :: CHOIX    │                         │
                                 └──────────┬──────────┘ <>                      │
                                            ◊────────────────────────────────────┘
                                 ┌──────────┴──────────┐
                          F_PROG │   « CTR » = CTR     │
                                 │ « CHOIX » = NBRE    │
                                 └─────────────────────┘
    
    Représentation en codage compréhensible

    { D_PROG   } CTR   = 0
                 MINI  = 1
                 MAXI  = 100
                 NBRE  = n
                 CHOIX = n
                 WHILE NBRE <> CHOIX
                 DO    BEGIN
    
    { D_TRAIT  }       IF NBRE   < CHOIX
    
    { T_MINI   }       THEN MINI = NBRE
    
    { T_MAXI   }       ELSE MAXI = NBRE
    
    { F_TRAIT  }       LET CTR   = CTR + 1
                       PRINT ″  CTR : ″, CTR  USING "##&"
                       PRINT ″ MINI : ″, MINI USING "##&"
                       PRINT ″ MAXI : ″, MAXI USING "##&"
                       SKIP 1 LINE
                       LET NBRE  = (MINI + MAXI) / 2
                       END
    
    { F_PROG   } PRINT ″───────────"
                 SKIP 1 LINE
                 PRINT ″  CTR : ″, CTR  USING "##&"
                 PRINT ″CHOIX : ″, NBRE USING "##&"
    
    La situation étant désespérée, tout est maintenant possible. John Cage

  7. #27
    Membre actif
    Homme Profil pro
    Développeur de jeux vidéo
    Inscrit en
    février 2013
    Messages
    285
    Détails du profil
    Informations personnelles :
    Sexe : Homme

    Informations professionnelles :
    Activité : Développeur de jeux vidéo

    Informations forums :
    Inscription : février 2013
    Messages : 285
    Points : 211
    Points
    211
    Par défaut
    Citation Envoyé par APL-AML Voir le message
    L’algorigramme (logigramme, organigra.....
    Nom : 20-12-16 11 38 44.JPG
Affichages : 65
Taille : 1,7 Ko
    Merci pour ces explications.
    Savoir pour comprendre et vice versa.

  8. #28
    Expert confirmé
    Avatar de anapurna
    Homme Profil pro
    Développeur informatique
    Inscrit en
    mai 2002
    Messages
    3 144
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Arts - Culture

    Informations forums :
    Inscription : mai 2002
    Messages : 3 144
    Points : 5 262
    Points
    5 262
    Par défaut
    salut

    la différence entre tansque(while) et repete-jusqua(repeat until)
    pour le premier nous ne somme pas obliger dans la boucle alors que dans l'autre cas tu fait au moins un tour

    dans ton exemple tu a oublier la boucle for qui n'est ni plus ni moins qu'une poucle while spécialisé

    après ce n'est qu'une question de grammaire ... le do while ou le while do pour moi est une hérésie mais le Ciste on le chique pour complexifié leur code
    Nous souhaitons la vérité et nous trouvons qu'incertitude. [...]
    Nous sommes incapables de ne pas souhaiter la vérité et le bonheur, et sommes incapables ni de certitude ni de bonheur.
    Blaise Pascal
    PS : n'oubliez pas le tag

Discussions similaires

  1. [debutant] représentation vector dans diagramme de class
    Par onap dans le forum Diagrammes de Classes
    Réponses: 5
    Dernier message: 23/12/2004, 22h01
  2. Représentation intervallaire des listes arborescentes
    Par PMAR dans le forum Décisions SGBD
    Réponses: 1
    Dernier message: 05/11/2004, 09h35
  3. [Normes] représentation des pourcentages
    Par Bowen dans le forum Décisions SGBD
    Réponses: 6
    Dernier message: 19/10/2004, 14h42
  4. [ASM370] Décimaux : représentation compacte et etendue
    Par grand's dans le forum Autres architectures
    Réponses: 6
    Dernier message: 25/01/2004, 17h47
  5. Logigramme du code
    Par David dans le forum Outils
    Réponses: 3
    Dernier message: 03/11/2003, 23h42

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