Discussion :

[PRomu@ld]

Nous avons un soucis dans les notations concernant l'algorithmique.

Ce que je propose, c'est que l'on discute des notations que nous allons tous utiliser dans les FAQ, les articles et les sources.

Ce qu'il faut absolument, c'est uniformiser les structures de contrôles, les affectations, les tests, les appels de fonctions, les élements de tableaux, les utilisations des pointeurs, ...

Merci à tous

[millie]

Pour la déclaration des fonctions, j'ai déjà vu en gros 2 manières :

Code :

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

1
2
 
fonction mafonction(element:Entier, truc:Reel):Entier

Ou :

Code :

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

1
2
 
fonction mafonction(Entier element, Reel truc) -> Entier

(ou des mélanges des deux).

Eventuellement, avec les fonctions ne renvoyant aucun paramètre (et donc avec effet de bord). Plutôt l'utilisation du terme "Procédure" que fonction.


Pour l'affectation :
Soit :
x <- 1
Soit
x:= 1 (utilisé dans plusieurs langage)
Peut être x=1, mais c'est moyen.


Pour la notation de pointeur, je ne sais pas si on utilise des réferences ou des pointeurs.



Il manque également la manière de noter les commentaires.

[PRomu@ld]

Eventuellement, avec les fonctions ne renvoyant aucun paramètre (et donc avec effet de bord).

Je suis pas certain que les procédures soient toutes des procédures qui modifient leur paramètres. Sauf si tu considères les sorties comme un effet de bord, je ne suis pas d'accord.

Pour les fonctions je fais ainsi :

Code :

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

1
2
 
fonction NomDeLaFonction ( X : type ; Y : type ; ... ) renvoie type.

Pour les procédures :

Code :

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

1
2
 
procedure NomDeLaProcedure( X : mode type ; Y : mode type)

On est donc très proche de ce qui est fait en ADA.

Pour l'affectation :
Soit :
x <- 1
Soit
x:= 1 (utilisé dans plusieurs langage)
Peut être x=1, mais c'est moyen.

Pour l'affectation surtout pas x=1. Comment fait tu la différence entre l'affectation et le test d'égalité (comme en C ?). C'est une mauvaise chose qui va entraîner des soucis.

Généralement je fais ceci :

Code :

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

X <- Valeur.

Pour la notation de pointeur, je ne sais pas si on utilise des réferences ou des pointeurs.

Une référence n'a de sens que dans un langage. En algo, seul le pointeur compte.

A la fac, j'ai l'habitude de voir deux choses :

Code :

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

X.all.valeur

ou alors ceci :

Code :

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

X->valeur

La première est la notation ADA, la deuxième est la notation C. La première interdit l'utilisation de champs nommé all (mais est-ce un problème ?), elle est généralement plus lourde mais est à mon sens assez efficace dans le sens où on ne se trompe assez rarement.

La deuxième est plus courte ( C oblige ). Je ne sais pas laquelle est la meilleure.

Il manque également la manière de noter les commentaires.

Pour les commentaires, j'aurai tendance à suivre les recommandations des créateurs de compilateurs : faire des commentaires à la C++ ou ADA. C'est à dire qui commence par un token et qui se termine avec la fin de ligne. Ca résoud quelques problèmes ou ambiguités.

[Jean-Marc.Bourguet]

L'intérêt d'une représentation informelle, c'est qu'elle est informelle. Si on veut une représentation fixée, autant utiliser un langage.

Ceci dit, j'écrivais pour commenter:

A la fac, j'ai l'habitude de voir deux choses :

Code :

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

X.all.valeur

...la notation ADA

En Ada c'est X.valeur, le all est permit mais n'est obligatoire que quand on en fait pas référence à un champs (autrement dit, x.all c'est l'équivalent de *x en C, x.field l'équivalent de x->field).

[PRomu@ld]

Je suis tout à fait d'accord, il faut s'écrater des langages, c'est pourquoi j'ai crée ce topic.

Et toi, Jean Marc, quelles sont tes habitudes en matière de notation ?

[Jean-Marc.Bourguet]

Et toi, Jean Marc, quelles sont tes habitudes en matière de notation?

Pas tellement d'habitudes. J'utilise quelque chose de proche du langage qui sera utilisé par après, souvent même le langage utilisé en utilisant des commentaires pour ce qui n'est pas permis dans le langage. Pour une présentation, je vais me permettre des choses comme indices, exposants, lettres grecques... un peu dans l'esprit des différents niveaux de représentation d'Algol.

[titoumimi]

Je me permet de taper l'incrust dans ce sujet, veuillez m'excuser si c'est déplacé...

Pedant mon court séjour à EPITA, il existait un interpréteur d'algo, PowerAlgoPlus, qui était très proche du langage naturel. Je pense que c'est pas mal, ça permet à tout un chacun d'adapter ensuite dans son langage de prédilection.

Je n'ai pas réussi à remettre la main dessus, peut-être qu'un ancien epiteen aurait encore ça, mais en gros ça donnait :

i = 0
faire
i = i+1
tant que i < 20

j'avait beaucoup aimé à l'époque...

[PRomu@ld]

Je me permet de taper l'incrust dans ce sujet, veuillez m'excuser si c'est déplacé...

Le sujet est ouvert à tous (et surtout au plus grand nombre), histoire de confronter les différentes habitudes et de façon à ce que l'on puisse obtenir une notation uniformisée la plus adaptée possible.

Code :

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

1
2
3
4
 i = 0
faire
i = i+1
tant que i < 20

Effectivement, c'est sympa.

Par contre, pour les structures de contrôle, j'ai tendance à les mettre en majuscule pour bien les démarquer et aussi utiliser une indentation. Ainsi, ton code donne chez moi :

Code :

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

1
2
3
4
5
 
i <- 0
FAIRE
     i <- i + 1
TANT QUE i < 20

[Jean-Marc.Bourguet]

Pedant mon court séjour à EPITA, il existait un interpréteur d'algo, PowerAlgoPlus

S'il y a un interpréteur, c'est un langage. L'avantage de ne pas utiliser un langage formellement défini c'est de pouvoir être imprécis sur ce qui n'est pas significatif pour l'exposé en cours. Suivant ce qu'on veut faire, on utilise des choses différentes. Certains et non des moindres vont jusqu'à utiliser des langages machines...

Si on est en train de regarder les tris en place et l'occupation mémoire nécessaire, utiliser quelque chose de proche d'Haskell va poser des problèmes. Si on est en train d'exposer des algo sur des structures de données infinies, utiliser quelque chose de proche d'Haskell avec une évaluation paresseuse va au contraire aider à masquer toute une gestion qui n'a pas d'intérêt pour l'exposé. Si je fais des algo d'analyse numérique, utiliser quelque chose qui permet une notation infixe pour le calcul matriciel va être mieux.

D'autre part, si l'objectif est d'implémenter après, quelque chose de très proche du langage d'implémentation (ou même celui-ci avec des commentaires pour ce qui est informel) est mieux qu'une notation présentatant des similitudes syntaxiques mais des différences sémantiques.

Je ne crois pas à la solution universelle...

[titoumimi]

S'il y a un interpréteur, c'est un langage.

En fait, c'était un interpréteur qui avait été construit en interne sur la base des cours d'algo qu'on avait.

Mais effectivement, ce n'était que de l'initiation à la logique algorithmique, je n'ai jamais eu de gros algo de la mort à réaliser avec, ce n'était peut-être pas adapté.

[millie]

e suis pas certain que les procédures soient toutes des procédures qui modifient leur paramètres.

Effectivement, une procédure n'est pas obligée de modifer ses paramètres, mais en général, cela n'a pas trop d'utilité.

Par exemple :

Code :

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

1
2
3
 
Procédure carre(Entier i)
    j <- i *i

Une référence n'a de sens que dans un langage. En algo, seul le pointeur compte.

Personnellement, dans les cours d'algorithmique que j'ai eu et que j'ai vu, on a toujours parlé de reférence et non de pointeur.

[millie]

Il y a également la question de la déclaration des variables.

Déclare-t-on les variables ou non ? Et si oui, avec quel syntaxe ? Pour garder de la cohérence, cela devrait se faire de la même manière que dans la déclaration des fonctions

[zooro]

Bonjour,

Après avoir lu vos posts précédents, je vois qu'on a tous eu plus ou moins les mêmes cours d'algo

Alors, moi je vous propose (eh non, rien de neuf) :

Affectation :

Code :

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

x := 1

Pointeur :

Code :

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

x->valeur

Fonctions et procédures :

Code :

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

1
2
fonction mafonction(element:Entier, truc:Reel):Entier
procedure mafonction(element:Entier, truc:Reel)

me semble plus lisible que l'autre solution (avec -> pour le type de retour).

Structures :

Code :

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

1
2
3
4
5
i:Entier
i := 0
FAIRE
     i := i + 1
TANT QUE i < 20

en majuscules et indentées.

[PRomu@ld]

Fonctions et procédures :
...

Il faudrait pouvoir identifier dans tes procédures comment sont passés les paramètres (in, out ou in out).

Déclare-t-on les variables ou non ? Et si oui, avec quel syntaxe ?

Pour la déclaration, je pense à ça :

nom : type

[ner0lph]

Bonjour,
Pour ma part, je dirais :

pour une fonction :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
fonction maFonction(element : Entier, truc : Reel) : Entier
    i <- 0 // affectation
    tant que i < 20 faire
        i <- i + 1
    ftq // fin tant que
    retourne i
finfonc

lexique
    i : Entier, variable temporaire

Pour une procédure :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
procédure échangerVariables(inout x : Entier, inout y : Entier)
    tmp <- x
    x <- y
    y <- tmp
finproc

lexique
    tmp : Entier, variable temporaire pour permettre l'échange
    x : Entier, premier paramètre qui sera remplacé par y
    y : Entier, second paramètre qui sera remplacé par x

Pour une classe (par exemple) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
classe Arbre
    /* Un attribut */
    attribut : Entier
    /* Un nœud de l'arbre. Il est aussi un arbre. */
    nœud : Arbre

    constructeur(toto : Entier)
        ...
    finconst
finclasse

Les mots-clés étant soulignés. Indentations. Commentaires de type C, C++, Java, etc. On devrait permettre l'utilisation des accents (échangerVariables), ligatures (nœud) et autres symboles diacritiques (ç, etc.) ou lettres grecques.

Par exemple.

[reggae]

Bonjour,
Quant à moi, je privilégie un pseudo-langage proche du C, que je trouve presque plus lisible...

Les affectations:

Code :

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

1
2
type variable =x

Les fonctions:

Code :

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

1
2
fonction(type paramètre1, type paramètre2) : (type retour)

Les boucles et tests:

Code :

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

1
2
3
4
5
 
while (variable > y)
       //indentation //commentaires à la "C"
if (variable < z)
      //indentation

Quant aux classes, je ne les utilise que très rarement en algorithmique...

L'utilisation des lettres grecques me semble indispensable, contrairement aux accents qui me semblent superflus...

[PRomu@ld]

Je n'aime pas trop utiliser le signe égal pour les affectation, j'aime bien différencier l'égalité de l'affectation. De plus, le symbole <- semble admis de tous.

[ner0lph]

Oui, et c'est ce qu'on apprend en cours d'algo. en DUT info. (cf. aussi ma proposition).

[O( N )]

Bonjour a tous (ou bonne nuit vu l'heure)

La manière dont j'ai appris à concevoir les algorithmes ne dépend d'aucun langage informatique.

C'est un mélange entre les mathématiques et un algèbre de Boole sur des conditions.

Je n'y ai donc pas de notions sur les pointeurs (qui seraient vue comme une fonction),
les fonctions, les procédures et encore moins les classes...
(Bien qu'il semble faire moins de propositions,
il y aurait moins de vocabulaire à connaitre et il serait plus aisé d'écrire...)

Je ne crois pas qu'un algorithme est besoin de notion de classe ou faire la différence entre une fonction et une procédure.
Si je dois utiliser des classes alors j'utilise un langage de programmation.
( c'est mon opinion pas une vérité ! )

Voici quelques exemples des notions abordées :
// Je met des commentaires
// J'affecte une variable à un type. (avant l'écriture de l'algorithme.)
x : entier
// J'affecte une variable à la valeur 2 à l'initialisation de l'algorithme.
Init F(x) = F(2)
// J'affecte une variable à la valeur 5 à l'appel de l'algorithme.
(x > 0) => F(x) = F(5)
// Je fais un appel depuis un autre algorithme.
// F(x) est écrit et on connait son initialisation (2).
// le 'et' et le 'ou' logique.
(x > 0) & ((a = 0) || (a = x)) => G(x,a) = F(x)
// Les éléments d'une liste. ici L,l1,l2 une liste d'entier
// le . représente la concaténation
L,l1,l2 : Liste
c1,c2 : entier
(c1 <= c2) => F(c1.l1,c2.l2) = c1. F(l1,c2.l2)
// Les éléments d'un tableau.
// les [] permettent d'accèder à l'élément du tableau.
// le Swap (ou échange) est représenté ici par <->
T : Tableau
i,j : entier
(T[j] < T[i]) & (i < j) => Tri(i,j,T) = Tri(i+1, j, T[i]<->T[j])
...

Voici un exemple partiel d'algorithme :
// Tri Par Insertion
T : Tableau
i,j : Entier (des compteurs)
A : Entier valeur temporaire
N : indice maximum du tableau.

Init : TPI(i,j,A,T,N) = TPI(0,1, T[1], T,N)

(j <= N) & ((T[i] > A) || (i >= 0)) => TPI(i,j,A,T,N) = TPI(i-1, j, T[i], T[i]<->T[i+1], N)
...

//La trace pour voir le fonctionnement

...

//Le calcul des ressources utilisées par l'algorithme

//Complexité temporelle : (n * (n - 1)) / 2=> O(n²) => polynomiale.
// Complexité spatiale : O(1) (pas de besoin supplémentaire donc)
// Complexité dans les déplacements ...

voilà ...

[PRomu@ld]

C'est un mélange entre les mathématiques et un algèbre de Boole sur des conditions.

Je n'y ai donc pas de notions sur les pointeurs (qui seraient vue comme une fonction),
les fonctions, les procédures et encore moins les classes...
(Bien qu'il semble faire moins de propositions,
il y aurait moins de vocabulaire à connaitre et il serait plus aisé d'écrire...)

Je ne crois pas qu'un algorithme est besoin de notion de classe ou faire la différence entre une fonction et une procédure.
Si je dois utiliser des classes alors j'utilise un langage de programmation.
( c'est mon opinion pas une vérité ! )

J'ai des doutes sur ce que tu avances, en effet, il faudra bien à un moment ou à un autre que dans tes algorithmes tu puisses utiliser des types abtraits de données (on ne parle pas de classes, de surcharge de fonctions qui sont des domaines réservés aux langages), avec ta notation, j'aimerai bien savoir comment tu peux parler de graphes. De plus, la notation utilisée va dépendre très fortement du niveau d'abstraction auquel tu te places.

Code :

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

1
2
// J'affecte une variable à un type. (avant l'écriture de l'algorithme.)
x : entier

Jusqu'ici ça va à peut près (ton commentaire me semble faux, on affecte pas un type à une variable).

// J'affecte une variable à la valeur 2 à l'initialisation de l'algorithme.
Init F(x) = F(2)

Ici ça se gâte, a quoi correspond Init ? Doit on le rajouter à chacune des initialisations ? Ensuite, a quoi correspond le F ? c'est un mot clé (qui n'aurait pas de sens en algorithmique) de plus la notation est ambigüe en effet elle peut suggérer une égalité ou une affectation. Ensuite vouloir affecter 2 à x de cette façon laisse presque supposer que le paradigme de programmation que tu utilises est du lambda-calcul.

De plus, pourquoi distingues tu l'initialisation de l'affectation ?

Code :

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

1
2
// J'affecte une variable à la valeur 5 à l'appel de l'algorithme.
(x > 0) => F(x) = F(5)

Ici ta notation est ambiguë, le symbole => peut correspondre à un opérateur de comparaison, ça ne facilite pas la lecture. Même si ta notation est assez compacte, pour la même opération je préfèrerais écrire ceci :

[code]
SI x > 0 ALORS
x <- 5
FIN SI
[\code]

Code :

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

1
2
// le 'et' et le 'ou' logique.
(x > 0) & ((a = 0) || (a = x)) => G(x,a) = F(x)

Ici, tu te rapproches trop d'un langage de programation, pour un néophyte, savoir que || correspond au OU logique n'est pas chose aisée. De plus ici tu utilises un ET logique à un seul symbole lorsque le OU en possède deux, c'est une bizarrerie qui me semble renforcer la difficulté du "langage".

Ensuite, sur la fin de la notation :

Code :

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

G(x,a) = F(x)

Ici, j'ai du mal à te suivre, lors d'une initialisation F(x) = F(2) ça signifiait affecter 2 à x, or ici, tu as à gauche une fonction d'arrité 2 et à droite une fonction d'arrité un, alors je ne vois pas au premier abord ce qu'il faut affecter.

Tu dois me trouver sévère mais ce que j'avais proposé, c'est de trouver une notation qui puisse être adaptée à bon nombre d'utilisations et qui soit aussi facile d'accès pour quelqu'un qui ne fait pas d'algorithmique. Même si tout le monde semble d'accord sur le fait qu'une notation universelle n'existe pas.