Fonction Recursive en Clisp

Salut tout le monde :)

J'ai un petit probleme avec Clisp, je dois faire une fonction qui filtre une liste et garde seulement les éléments voulu. Une version de cette fonction doit n'avoir qu'un seul argument , la liste a trier et donc l’élément a trier est défini dans la fonction.

Ça j'y arrive mais des que je veux modifier cette même fonction pour qu'elle prenne en compte un deuxième argument qui serai l’élément a trier ça coince :/

Le truc est que quand je fais cette fonction avec une boucle iterative ca marche mais des que j'en fais une fonction recursive ca marche pas.

---Fonction avec boucle itérative--- Fonctionne

Code:

---

1 2 3 4 5 6 7 8 9 10 11

(defun garde (x liste &aux bassine) (setq bassine nil) (loop (cond ((not liste) (return bassine)) ((equal (car liste) x)(push (pop liste) bassine)) ((pop liste)) )))))   (garde 'o '(o o o & o &)) (O O O O)

---

---Fonction Récursive et élément connu (o)--- Fonctionne

Code:

---

1 2 3 4 5 6 7 8 9

(defun garde-o (liste) (cond ((not liste) nil) ((equal (car liste) 'o) (cons (car liste) (garde-o(cdr liste)) )) ((not (equal (car liste) 'o)) (garde-o(cdr liste)) )) )   (garde-o '(o o o & o &)) (O O O O)

---

---Fonction Récursive et élément inconnu (x)--- Fonctionne Pas

Code:

---

1 2 3 4 5 6 7 8 9 10 11

(defun garde (x liste) (cond ((not liste) nil) ((not (equal (car liste) x)) (garde(x (cdr liste)))) ((equal (car liste) x) (cons (car liste) (garde(x (cdr liste)))))))   (garde '(o o o)'o)     *** - EVAL: undefined function X

---

Citation:

---

Envoyé par Syriano56

Salut tout le monde :)

J'ai un petit probleme avec Clisp, je dois faire une fonction qui filtre une liste et garde seulement les éléments voulu. Une version de cette fonction doit n'avoir qu'un seul argument , la liste a trier et donc l’élément a trier est défini dans la fonction.

Ça j'y arrive mais des que je veux modifier cette même fonction pour qu'elle prenne en compte un deuxième argument qui serai l’élément a trier ça coince :/

Le truc est que quand je fais cette fonction avec une boucle iterative ca marche mais des que j'en fais une fonction recursive ca marche pas.

---Fonction avec boucle itérative--- Fonctionne

Code:

---

1 2 3 4 5 6 7 8 9 10 11

(defun garde (x liste &aux bassine) (setq bassine nil) (loop (cond ((not liste) (return bassine)) ((equal (car liste) x)(push (pop liste) bassine)) ((pop liste)) )))))   (garde 'o '(o o o & o &)) (O O O O)

---

---Fonction Récursive et élément connu (o)--- Fonctionne

Code:

---

1 2 3 4 5 6 7 8 9

(defun garde-o (liste) (cond ((not liste) nil) ((equal (car liste) 'o) (cons (car liste) (garde-o(cdr liste)) )) ((not (equal (car liste) 'o)) (garde-o(cdr liste)) )) )   (garde-o '(o o o & o &)) (O O O O)

---

---Fonction Récursive et élément inconnu (x)--- Fonctionne Pas

Code:

---

1 2 3 4 5 6 7 8 9 10 11

(defun garde (x liste) (cond ((not liste) nil) ((not (equal (car liste) x)) (garde(x (cdr liste)))) ((equal (car liste) x) (cons (car liste) (garde(x (cdr liste)))))))   (garde '(o o o)'o)     *** - EVAL: undefined function X

---

---

Aye Resolu ! ^^

C'est la synthaxe des arguments de la fonction garde qui etaient faux. En effet c'est pas :

Code:

---

(garde(x (cdr liste)))

---

mais :

Code:

---

(garde x (cdr liste))

---

Je profite quand même de ton passage pour te proposer 2-3 petites améliorations

Code:

---

1 2 3 4 5

(defun garde (x liste) (cond ((null liste) nil) ;; (null liste) est plus idiomatique que (not liste) et probablement plus optimisé (car d'un usage plus restreint) ((equal (car liste) x) (cons (car liste) (garde x (cdr liste)))) ;; equal = 1 appel de fonction / not equal = 2 appels de fonctions => une petite optimisation pcq: (T (garde x (cdr liste)))) ;; pas la peine de formuler la dernière condition, puisque c'est la seule qui reste! un simple T suffit

---

plutôt que:

Citation:

---

(defun garde (x liste)
(cond
((not liste) nil)
((not (equal (car liste) x)) (garde(x (cdr liste))))
((equal (car liste) x) (cons (car liste) (garde(x (cdr liste)))))))

---

Merci ! En effet ça simplifie le code comme ça :) Mais je maitrise pas assez t pour y penser tout le temps ^^

Mnt j'ai une autre fonction qui construit, à partir d'une liste incluant des sous-listes, la liste des sous-listes commençant par un nombre :

Code:

---

1 2 3 4 5 6 7 8

(defun nombres (liste) (cond ((not liste) nil) ((and (listp (car liste)) (numberp (car(car liste)))) (cons (car liste) (nombres (cdr liste))) ) ((nombres (cdr liste))) ) )   (nombres '((2 d b) c (d) (4 f) (e g x) f)) ((2 D B) (4 F))

---

celle-ci marche mais je voudrais la modifier pour quelle compte au lieu de construire une liste donc j'ai fait ca :

Code:

---

1 2 3 4 5

(defun nombres (liste) (cond ((not liste) 0) ((and (listp (car liste)) (numberp (car(car liste)))) (+1 (nombres (cdr liste)))) ((nombres (cdr liste)))))

---

Mais a chaque fois j'ai cette erreur que je ne comprend pas :

Code:

---

1 2 3

*** - SYSTEM::%EXPAND-FORM: invalid form (1 (NOMBRES (CDR LISTE))) The following restarts are available: ABORT :R1 Abort main loop

---

Citation:

---

(defun nombres (liste)
(cond
((not liste) 0)
((and (listp (car liste)) (numberp (car(car liste)))) (+1 (nombres (cdr liste))))
((nombres (cdr liste)))))

---

En effet, cond prend comme arguments un nombre variable de listes, dont le premier élément est une condition, le deuxième l'expression à évaluer si la condition est vraie.
Or la dernière liste en argument de cond dans ton programme n'est constituée que de l'expression à évaluer. Il aurait fallu rajouter une condition au début, comme cela:

Code:

---

1 2 3 4 5

(defun nombres (liste) (cond ((not liste) 0) ((and (listp (car liste)) (numberp (car(car liste)))) (+1 (nombres (cdr liste)))) (T (nombres (cdr liste))))) ;; T est la condition toujours vraie. Si tu veux un truc qui te parle plus, tu peux aussi utiliser :else à la place, par ex: (:else (nombres (cdr liste))

---

Par ailleurs tes fonctions utilisent toujours le même pattern de récursion, capturé par la fonction reduce:

Code:

---

1 2 3 4 5

(defun filtre-liste-nombres (lst) (reduce (lambda (x y) (if (numberp (car x)) (cons x y) y)) lst :from-end T :initial-value Nil))

---

Code:

---

1 2 3 4 5

(defun compte-liste-nombres (lst) (reduce (lambda (x y) (if (numberp (car x)) (+ 1 y) y)) lst :from-end T :initial-value 0))

---

Ce pattern (qui s'appelle fold = plier dans d'autres langages) est l'objet d'un billet de mon blog que je te recommande modestement :) :
http://www.developpez.net/forums/blo.../b405/origami/

Merci pour la réponse rapide !

Mais quand je compile ton code cad avec le T cela ne change rien, toujours la même erreurs :( :?

Je finis mes DM en Clisp après je verrais le lien :D Merci !

Citation:

---

Mais quand je compile ton code cad avec le T cela ne change rien, toujours la même erreurs

---

Je l'ai mis dans ma boucle REPL, en effet il y avait un autre problème, tu as oublié l'espace entre + et 1

Citation:

---

((and (listp (car liste)) (numberp (car(car liste)))) (+1 (nombres (cdr liste))))

---

Et +1 n'est pas un symbole!

Merci !

Au fait j'ai pas résister je suis aller voir le lien et la je suis remonter jusqu'a (Poker time!) pour comprendre :mouarf: 8-)

Bonjour,

Un post en passant et pour me joindre au jeu de l'optimisation de la fonction garde, en signalant qu'il y en a une petite qui a été oublié...

Code:

---

1 2 3 4 5

(defun garde (x liste) (cond ((null liste) nil) ((equal (car liste) x) (cons x (garde x (cdr liste)))) ;; si (equal (car liste) x) vrai alors "conser" x et plus économe que (car liste) (T (garde x (cdr liste)))))

---

A+

+1 est le nombre « un ».
1+ est le nom de la fonction « ajouter un »
Common Lisp est le nom du language.
CL est en une abréviation.
(GNU) Clisp est une réalisation obsolète du langage.