Discussion :

[tbc92]

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.

[Galet]

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...

[Flodelarab]

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.

[tbc92]

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é.

[Galet]

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,

[APL-AML]

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 "##&"

[valentin03]

L’algorigramme (logigramme, organigra.....

Merci pour ces explications.

[anapurna]

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