filtrer une fonction en lisp

bonjour

je bloque sur un exo est ce que il ya qlq qui pourra m'iader

Généralisez une fonction pour fabriquer une fonction qui trie n'importe quel élément, pas seulement des gouttes d'eau (des o), d'après les spécifications suivantes :
> (garde 'o '(o o o & o o o ! o o $ o o o o))
(o o o o o o o o o o o o)
> (garde 'a '(a a a b a b a d c e a a))
(a a a a a a a)

ce que j'ai pu faire c'est

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

(defun garde (x) ( seau) (setq bassine nil) (loop (cond ((not seau) (return bassine)) ((equal (car seau) 'x) (push (pop seau) bassine)) (( pop seau)) ) ) )   mais quand je tapppe (garde 'o '(o o o & o o o ! o o $ o o o o))   *** - EVAL/APPLY: too many arguments given to GARDE The following restarts are available: ABORT :R1 Abort main loop

---

:?

Salut !

Tout d'abord, il faut indiquer tous les arguments après le nom de la fonction. Tu ecris: « garde (x) », c'est-à-dire la fonction n'accepte qu'un seul argument X. L'expression suivante, « (seau) », c'est l'invocation d'une fonction SEAU, qui, je suppose, n'existe pas. Ce que tu voulais écrire, c'est « garde (x seau) » - une fonction avec deux arguments.

En lisp, on déclare des variables. La méthode courante de déclarer une variable locale c'est employer LET:

Code:

---

1 2	(let ((bassine nil)) (loop ...))

---

ou tout simplement

Code:

---

1 2	(let (bassine) (loop ...))

---

LET permet d'indiquer la valeur de la variable; NIL est la valeur par défaut.

S'il s'agit seulement des listes de symboles, il vaut mieux employer EQ au lieu de EQUAL.

Alors, la solution qui fonctionne:

Code:

---

1 2 3 4 5 6 7

(defun garde (x seau) (let (bassine) (loop (cond ((not seau) (return bassine)) ((eq (car seau) x) (push (pop seau) bassine)) (t (pop seau))))))

---

En plus, tu pourrais essayer d'écrire la même fonction d'une façon beaucoup plus brève et idiomatique à l'aide de REMOVE-IF-NOT (c'est exactement le filtre général en lisp) ou bien de COUNT et LIST.

Ah, encore : la clause par défaut de COND est introduite par T.

salut


En lisp, on déclare des variables. La méthode courante de déclarer une variable locale c'est employer LET:
est ce que let c'est comme setq ??

Alors, la solution qui fonctionne:

Code:

---

1 2 3 4 5 6 7

(defun garde (x seau) (let (bassine) (loop (cond ((not seau) (return bassine)) ((eq (car seau) x) (push (pop seau) bassine)) (t (pop seau))))))

---

et t veut dire quoi ?
donc faut jamais mettre deux parenthèse pour déclarer un argument c'est-à-dire pas de (x) (seau) ?

merci beaucoup pour la réponse

SETQ est un operateur d'affectation (dont on n'a pas besoin car il y a un operateur beaucoup plus général, SETF). On assume que la variable déjà existe, c'est-à-dire, a été déjà déclaré, et on change sa valeur (ce qui arrive assez rarement en lisp par rapport à d'autres langages). Un bon compilateur se plaindrait qu'il ne connaît pas qu'est-ce que c'est que BASSINE.

En lisp, on peut associer une valeur à un symbole. Ça ce dit to bind, attacher et ça correspond aux variables locales d'autres langages. Ainsi écrit-on

Code:

---

1 2 3 4 5

(let ((a 1) (b 2)) forme1 forme2 ...)

---

Ici nous avons introduit deux notations, A et B, qui sont valides dans les formes forme1, forme2, etc., qui constituent le « corps » du LET mais pas ailleurs. Ces formes peuvent même changer les valeurs de l'A et du B à l'aide de SETF ou SETQ, c'est-à-dire, les affectionner de nouvelles valeurs.

Je souligne que les variables introduits par LET sont locales. Il ne sont visibles que dans le corps du LET. C'est très bien.

T c'est « true ». Comment est-ce que COND fonctionne? Il a des clauses:

Code:

---

1 2 3 4 5

(cond (condition1 forme1) (condition2 forme2) ... (condition_n forme_n))

---

Tout d'abord COND vérifie la valeur de condition1. Si elle est vraie (tous les valeurs sont vraies sauf NIL), COND évalue et renvoie FORME1. Si elle est faux, COND vérifie la valeur de condition2, etc. Il est habituel de fournir la dernière clause avec la condition T, qui est notoirement vraie, alors si aucune des clauses précédentes n'a été évalué, la dernière T-clause devient le défaut.

En effect, les clauses peuvent contenir plusieures formes...

Quant'aux arguments des fonctions - oui, il sont tous déclarés dans la même liste.

Est-ce que ça a du sens pour toi ? :)

merci pour les explication c'est très claire :)