[CLisp] - Fonction Position

Bonjour, je voudrais faire une fonction comme la fonction prédéfinie position.
J'ai fais une fonction itérative :

Code:

---

1 2 3 4

(defun position (x lst) (when (consp lst) (loop for c in lst for i from 0 when (equal c x) return i)))

---

Maintenant j'essaye de refaire cette fonction de façon a ce qu'elle soit récursive, mais je ne vois pas trop comment.

J'ai tenté avec ceci :

Code:

---

1 2 3 4 5 6

(defun position (x lst) (cond ((atom lst) nil) ((equal (car lst) x) 0) ((null (car lst)) (posi x)) (t (1+ (posi x (cdr lst)))) ) )

---

Elle fonctionne tant que la fonction ne tombe pas sur un nil

Code:

---

1 2 3 4

(posit 'd '(a b c d e f) 3 (posi 'y '(a b c d e f) nil is not a number

---

Sauf que je ne peux pas changer le nil de (atom list) sinon le nil est compter.

D'abord, dans ta fonction position il est fait appel à la fonction "posi": est-ce volontaire, une erreur de frappe?

Ensuite, il faut que tu partes de la spécification de la fonction: qu'est ce que ta fonction est censée faire si on lui fournit des arguments corrects, et que doit elle faire si on lui fournit des arguments incorrects?

Pour la première partie, quand les arguments sont corrects, la fonction doit retourner nil si l'élément n'est pas présent, et l'index de l'élément s'il est présent. L'élément est absent si on est arrivé à la fin de la liste, c'est-à-dire que la liste est vide = Nil

Donc:

Code:

---

1 2 3 4 5

(defun pos (x lst) (cond ((null lst) nil) ;; on est arrivé à la fin de la liste ((equal (car lst) x) 0) ;; on est arrivé à l'élément recherché (T (1+ (pos x (cdr lst)))))) ;; sinon on va un élément plus loin

---

Pour la gestion d'erreur, à toi de jouer.

Bonjour et merci pour la réponse :D

En effet pour posi et position, c'est des erreurs de frappes j’étais sur mon téléphone :oops:

Ma fonction :

Code:

---

1 2 3 4 5 6

(defun position (x lst) (cond ((atom lst) nil) ((equal (car lst) x) 0) ((null (car lst)) (posi x)) (t (1+ (position x (cdr lst)))) ) )

---

et ta fonction :

Code:

---

1 2 3 4 5

(defun pos (x lst) (cond ((null lst) nil) ((equal (car lst) x) 0) (T (1+ (pos x (cdr lst))))))

---

fonctionnent toutes les deux et donnent le même résultat sauf pour les erreurs comme :

Code:

---

1 2	(pos 'x '(c d e f a b)) - 1+: NIL is not a number

---

Moi je cherche a savoir comment faire pour éviter cette erreur :/ :calim2:

Exact!

Il faut modifier la fonction de la façon suivante, pour éviter (1+ Nil):

Code:

---

1 2 3 4 5 6

(defun pos (x lst) (cond ((null lst) nil) ((equal (car lst) x) 0) (T (let ((nxt (pos x (cdr lst)))) (when nxt (1+ nxt)))))

---

Merci stendhal666 ;) :lol: !

Bonjour, est ce qu'il serait possible de refaire cette même fonction mais sans When ou let ?

Oui mais pourquoi?

Pour when, c'est facile, tu peux le remplacer par if. On utilise when quand on ne met pas d'expression à exécuter si la condition est fausse (if then else / when then). when X Z est équivalent à if X Z nil.

Pour let, il est possible de répéter l'expression qui y est définie mais c'est moins élégant et moins efficace (elle sera évaluée deux fois).

Parce j'aime me casser la tête :mrgreen::mrgreen::mrgreen:

Ainsi la fonction deviendrait :

Code:

---

1 2 3 4 5 6 7

(defun pos (x lst) (cond ((null lst) nil) ((equal (car lst) x) 0) (T (let ((nxt (pos x (cdr lst)))) (if (nxt t) : (1+ nxt)))))

---

Et pour le let je vois pas trop tu pourrais m'expliquer ? :oops:

Merci!

Personne ? :/

Quelle est donc ta question ?

L'algorithme est suivant:
1) si la laste est vide, renvoyer NIL (l'objet n'est pas été trouvé);
2) si la liste n'est pas vide et en le premier élément équivaut à l'objet donné, renvoyer 1;
3) si la liste n'est pas vide et en le primier élément n'équivaut pas à l'objet donné, trouver la position de l'object dans le reste de la liste;
4) si l'objet n'est pas été trouvé, renvoyer NIL;
5) autrement renvoyer sa position dans le reste de la liste plus 1.

Ainsi, ayant trouvé la position de l'élément dans le reste de la liste, faut-il la garder pour la tester et pour l'augmenter ensuite.

De toute façon, tu as des erreurs syntaxiques. Tout d'abord, qu'est-ce que sont que ces deux-points ? Ensuite, en écrivant (nxt t) tu veux appliquer la fonction nxt à la valeur t, ce qui n'a pas de sens. La forme (if <expr1> <expr2> <expr3>) teste si <expr1> est NIL ou pas et évalue l'une des expressions suivantes, alors dans ce cas il suffit écrire simplement (if nxt ...).

Bonjour et merci d'avance,

Ma question est que je voudrais re-ecrire cette fonction

Code:

---

1 2 3 4 5 6

(defun pos (x lst) (cond ((null lst) nil) ((equal (car lst) x) 0) (T (let ((nxt (pos x (cdr lst)))) (when nxt (1+ nxt)))))

---

Mais sans When et let...Mais je n'y arrive pas :weird:

Bien, est-ce que tu peux formuler un algorithme sans branchement ? Moi, je ne le peux pas, mais on peut masquer WHEN/IF comme une branche du COND. Quant'à LET, on peut l'éliminer en le remplacant avec l'expression même (alors que la complexité devient exponentielle au lieu de lineaire). Alors, on obtient ce code affreux:

Code:

---

1 2 3 4 5

(defun pos (x list) (cond ((null list) nil) ((equal (first list) x) 0) ((pos x (rest list)) (1+ (pos x (rest list)))) (t nil)))

---

Bonjour LittleGeeky,

Remplace ton let par la fonction anonyme lambda, et ton when par un if

Code:

---

1 2 3 4 5

(defun pos (x lst) (cond ((null lst) nil) ((equal (car lst) x) 0) (T ((lambda (i) (if i (1+ i))) (pos x (cdr lst))))))

---

A+