Listar operaciones en Lisp

Question

He estado buscando por todas partes la siguiente funcionalidad en Lisp y no he llegado a ninguna parte:

1. encontrar el índice de algo en una lista.ejemplo:

   (index-of item InThisList)
   

2. reemplazar algo en un lugar específico de una lista.ejemplo:

   (replace item InThisList AtThisIndex) ;i think this can be done with 'setf'?
   

3. devolver un artículo en un índice específico.ejemplo:

   (return InThisList ItemAtThisIndex)
   

Hasta este punto, he estado fingiendo con mis propias funciones.Me pregunto si estoy creando más trabajo para mí.

Así he estado fingiendo el número 1:

(defun my-index (findMe mylist)
  (let ((counter 0) (found 1))
    (dolist (item mylist)
      (cond
        ((eq item findMe) ;this works because 'eq' checks place in memory, 
                  ;and as long as 'findMe' was from the original list, this will work.
         (setq found nil)
        (found (incf counter))))
  counter))

Answer 1

Puedes usar setf y nth para reemplazar y recuperar valores por índice.

(let ((myList '(1 2 3 4 5 6)))
     (setf (nth 4 myList) 101); <----
     myList)

(1 2 3 4 101 6)

Para buscar por índice puedes usar el position función.

(let ((myList '(1 2 3 4 5 6)))
     (setf (nth 4 myList) 101)
     (list myList (position 101 myList)))

((1 2 3 4 101 6) 4)

Encontré estos todos en este índice de funciones.

Answer 2

1. encontrar el índice de algo en una lista.

En Emacs Lisp y Common Lisp, tienes la position función:

> (setq numbers (list 1 2 3 4))
(1 2 3 4)
> (position 3 numbers)
2

En Scheme, aquí hay una implementación recursiva de cola de DrSchemeEl documento de:

(define list-position 
  (lambda (o l)
    (let loop ((i 0) (l l))
      (if (null? l) #f
          (if (eqv? (car l) o) i
              (loop (+ i 1) (cdr l)))))))

----------------------------------------------------

> (define numbers (list 1 2 3 4))
> (list-position 3 numbers)
2
> 

Pero si estás usando una lista como una colección de espacios para almacenar datos estructurados, tal vez deberías echarle un vistazo a defstruct o incluso algún tipo de sistema de objetos Lisp como CLOS.

Si estás aprendiendo Lisp, asegúrate de echar un vistazo a Ceceo común práctico y/o El pequeño intrigante.

¡Salud!

Answer 3

Respuestas:

1. (posicionar secuencia de elementos y clave desde el final (inicio 0) finalizar la prueba de clave no prueba)
   http://lispdoc.com/?q=position&search=Búsqueda+básica

2. (valor setf (índice de secuencia elt))

3. (índice de secuencia elt)
   http://lispdoc.com/?q=elt&search=búsqueda+básica
   NOTA:elt es preferible a nth porque elt funciona en cualquier secuencia, no solo en listas

Answer 4

Las respuestas de Jeremy deberían funcionar;pero dicho esto, si te encuentras escribiendo código como

(setf (enésimo i mi-lista) nuevo-elt)

probablemente estés usando la estructura de datos incorrecta.Las listas son simplemente listas enlazadas, por lo que son O(N) para acceder por índice.Quizás sea mejor que uses matrices.

O tal vez estés usando listas como tuplas.En ese caso deberían estar bien.Pero probablemente quieras nombrar los accesores para que alguien que lea tu código no tenga que recordar lo que se supone que significa "nésimo 4".Algo como

(defun my-attr (list)
  (nth 4 list))

(defun (setf my-attr) (new list)
  (setf (nth 4 list) new))

Answer 5

+2 para "Ceceo común práctico".Es una mezcla de un libro de cocina Common Lisp y un libro Teach Yourself Lisp de calidad.

También está el "Lisp común exitoso" (http://www.psg.com/~dlamkins/sl/cover.html y http://www.psg.com/~dlamkins/sl/contents.html) que parecía llenar algunos vacíos/ampliar cosas en "Practical Common Lisp".

También leí "ANSI Common Lisp" de Paul Graham, que trata más sobre los conceptos básicos del lenguaje, pero es un poco más un manual de referencia.

Answer 6

Tengo que estar de acuerdo con Thomas.Si usa listas como matrices, será lento (y posiblemente incómodo).Por lo tanto, debería usar matrices o seguir con las funciones que ha escrito, pero moverlas "hacia arriba" de manera que pueda reemplazar fácilmente las listas lentas con matrices más adelante.