Lisp liste itération

Question

J'ai une fonction qui récupère x(une valeur) et xs(une liste) et supprime toutes les valeurs qui sont plus grands que x à partir de la liste.Eh bien, il ne fonctionne pas, pouvez-vous me dire pourquoi?

(defun biggerElems(x xs) 
  (let ((xst))
    (dolist (elem xs)
      (if (> x elem)
          (setf xst (remove elem xs))))
    xst))

Answer 1

Je pense que c'est cette ligne qui n'est pas droit:

(setf xst (remove elem xs))))

Le premier argument de setf est le lieu, suivi par la valeur.Il semble que vous avez vers l'arrière (et xst est soit nil ou non initialisée).

Vous trouverez peut-être plus facile de faire ceci:

(defun biggerElems (x xs)
  (remove-if (lambda (item) (> item x)) xs))

Answer 2

Plus concis autant que je sache:

(defun bigger-elements (x xs) (remove x xs :test #'<))

de retour d'une nouvelle liste, il supprime tous les éléments y de xs pour lesquelles

(< y x)

ou à l'aide de la célèbre BOUCLE:

(defun bigger-elements-2 (x xs) 
  (loop for e in xs
        unless (< e x)
        collect e))

Answer 3

Il a travaillé comme ça:

(defun filterBig (x xs)
  (remove-if (lambda (item) (> item x)) xs))

Quel a été le '#' pour?Il n'a pas à compiler avec elle.

Answer 4

Si vous souhaitez faire le Lisp Façon, vous pouvez utiliser la récursivité pour revenir à la nouvelle liste:

(defun biggerElems (x xs)
  (cond ((null xs) NIL)
        ((< x (car xs))
         (biggerElems x (cdr xs)))
       (t
        (cons (car xs) (biggerElems x (cdr xs))))))

@Luis Oliveira

Cette solution est de le comparer avec celui affiché dans la question.Avions-nous besoin de faire quelque chose un peu plus compliqué, il est important d'être ancré dans l'approche récursive à la manipulation de listes.

Answer 5

@Ben:Ce n'est pas le setf appel c'est le mal ... le problème c'est qu'il n'est pas de mise à jour xs.

c'est à dire:xst est en cours de mise à xs avec l'élément supprimé, mais xs n'est pas mis à jour.Si un deuxième élément est d'être supprimé, xst sera le premier de retour dans ce.

vous devez lier xst pour xs, et de remplacer le xs dans la suppression de l'appel avec xst.Ce serait alors supprimer tous les éléments de x est plus grand que.c'est à dire:

(defun biggerElems(x xs)
  (let ((xst xs))
    (dolist (elem xs)
      (when (> x elem)
        (setf xst (remove elem xst))))
    xst))

Il pourrait être légèrement plus rapide pour définir xst pour (copie de la liste xs) et utilisez ensuite supprimer, au lieu de supprimer (delete est destructeur...en fonction de votre mise en œuvre, il peut être plus rapide que de le retirer.Puisque vous êtes l'appeler plusieurs fois, vous pouvez obtenir de meilleures performances de la copie de la liste une fois et de façon destructrice suppression de celle-ci).

Sinon:

(defun bigger-elems (x xs) ; I prefer hyphen separated to camelCase... to each his own
  (loop for elem in xs when (<= x elem) collect elem))

En regardant en arrière au-dessus de votre post original, c'est un peu déroutant...vous dites que vous supprimez tous les éléments plus grands que x, mais votre code ressemble, c'est de tenter de retirer tous les éléments de x est plus grand que.Les solutions que j'ai écrit au retour de tous les éléments plus grands que x (c'est à dire:supprimer tous les éléments de x est plus grand que).

Answer 6

Quel a été le '#' pour?Il n'a pas compiler avec elle.

Faute de frappe.Normalement, vous devez vous référer à fonctions #' (comme (remove-if #'oddp list)), mais quand je l'édition, j'ai oublié de supprimer le '#'.