Discussion :

[Jéjé34]

Bonjour,

Je souhaite faire une fonction (tree-leaves a) qui retourne les feuilles de l'arbre a.
Par exemple,
(tree-leaves '(1)) => (1)
(tree-leaves '(1 2)) => (1 2) ou (2 1)
(tree-leaves '(1 (2 3) 4)) => (1 2 3 4) ou (4 3 2 1) etc.

J'ai essayé comme ceci :

Code Lisp :

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

1
2
3
4
5
6
(defun tree-leaves (a)
	(if (atom a)
		a
		(if (null (cdr a))
			(cons (tree-leaves (car a)) NIL)
			(cons (tree-leaves (car a)) (tree-leaves (cdr a))))))

Pour les deux premiers exemples, le résultat renvoyé est le bon.
Mais j'ai des problemes de paranthèses quand j'ai une liste dans ma liste...
En effet, (tree-leaves '(1 (2 3) 4)) => (1 (2 3) 4)
Ma fonction ne fait rien d'autre qu'une copie au final.

Comment je peux m'en sortir pour me débarasser de ces parantheses ? Merci.

[stendhal666]

Code :

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

(cons (tree-leaves (car a)) (tree-leaves (cdr a))))))

tu prends comme premier membre du 'cons' la liste des feuilles, c'est donc normal que les parenthèses subsistent...

Tu peux essayer d'utiliser 'append' à la place de 'cons' mais tu devras modifier une autre partie de ton code (indice: les arguments de append sont tous des listes)

[Jéjé34]

Raaaa, et dire que j'ai passé le début de l'aprem a m'abstiner avec cons...

Code :

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

1
2
3
4
5
6
(defun tree-leaves (a)
	(if (atom a)
		(cons a NIL)
		(if (null (cdr a))
			(tree-leaves (car a))
			(append (tree-leaves (car a)) (tree-leaves (cdr a))))))

Ca semble fonctionner.
Merci stendhal.

[Bruno-Vdh]

Bonjour,

Jette également un œil à la discussion suivante:
http://www.developpez.net/forums/d14...e/#post7942977

Il y a un exemple avec cond à la place de if, cela permet une écriture un peu plus concise.
A+

[stendhal666]

En effet, 'cond' est plus concis lorsqu'il y a plus de deux branches conditionnelles.
Néanmoins, 'cond' est en fait une macro qui se développe en 'if' imbriqués, qui pourrait s'écrire, par exemple:

Code :

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

1
2
3
4
5
6
7
 
(defmacro mycond (&rest clauses-consequences) 
  (if (not (null clauses-consequences))
      (let ((first-cc (first clauses-consequences)))
	`(if ,(car first-cc)
	     (progn ,@(cdr first-cc))
	     (mycond ,@(cdr clauses-consequences))))))

Donc c'est surtout une affaire de goût, il n'y a pas de gain "réel" dessous.
Mais c'est peut-être mieux d'éviter les idiomatismes Java/C/C++ et d'adopter ceux de LISP, je suis d'accord.

[jack-ft]

En effet, 'cond' est plus concis lorsqu'il y a plus de deux branches conditionnelles.
Néanmoins, 'cond' est en fait une macro qui se développe en 'if' imbriqués, qui pourrait s'écrire, par exemple:

Code :

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

1
2
3
4
5
6
7
 
(defmacro mycond (&rest clauses-consequences) 
  (if (not (null clauses-consequences))
      (let ((first-cc (first clauses-consequences)))
	`(if ,(car first-cc)
	     (progn ,@(cdr first-cc))
	     (mycond ,@(cdr clauses-consequences))))))

Presque...

Code :

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

1
2
3
4
ELISP> (mycond (3))
nil
ELISP> (cond (3))
3

Mais c'est peut-être du chipotage...

Donc c'est surtout une affaire de goût, il n'y a pas de gain "réel" dessous.
Mais c'est peut-être mieux d'éviter les idiomatismes Java/C/C++ et d'adopter ceux de LISP, je suis d'accord.

En Pascal, si mes souvenirs sont exacts, il n'y avait pas de "elsif", ce qui conduisait à un décalage progressif des clauses.
On a ce même décalage avec les "if" imbriqués de lisp.
Dans les langages qui ont le "elsif" (Java, shell, etc.), on peut avoir une suite de clauses avec la même indentation, ce qui est plus agréable pour l’œil humain (en tout cas, pour le mien!) que le décalage des clauses.
Du coup, lorsque le test est un vrai booléen (à 2 valeurs!) ou lorsque je suis sûr que je n'aurai que 2 clauses, j'utilise généralement "if", sinon j'utilise "cond".
Mais il m'arrive régulièrement de remplacer l'un par l'autre (et réciproquement) en fonction de l'évolution du code.
Un autre critère est le nombre d'arguments du "if".
Lorsque le "if" admet juste 3 arguments (CL, entre autres) et que j'ai besoin d'un "progn" dans le "else" du "if", je vais peut-être utiliser un "cond".
Dans un lisp où le "if" contient un "progn" implicite (comme emacs-lisp ou Le_Lisp), je ne me pose pas la question.

Du point de vue efficacité, je suis d'accord: il n'y a probablement aucune différence entre le cond et le if.
C'est juste du visuel! (ce qui est important pour les humains qui lisent le code!)

[stendhal666]

Mais c'est peut-être du chipotage...

Je pense plutôt que c'est bien vu!

D'ailleurs:

Code :

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

1
2
3
4
CL-USER> (macroexpand-1
	  '(cond (3)))
(VALUES 3)
T

ce qui suggère une macro nettement plus compliquée derrière, polie par une longue expérience...
Une preuve de plus assurément qu'il ne faut pas chercher à réinventer la roue.

Mais c'est peut-être du chipotage...

Je pense plutôt que c'est bien vu!

D'ailleurs:

Code :

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

1
2
3
4
CL-USER> (macroexpand-1
	  '(cond (3)))
(VALUES 3)
T

ce qui suggère une macro nettement plus compliquée derrière, polie par une longue expérience...
Une preuve de plus assurément qu'il ne faut pas chercher à réinventer la roue.