¿Puedo hacer esto en Lisp?

Question

He estado buscando por todas partes para las siguientes funciones en Lisp, y han llegado a ninguna parte:

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

   (index-of item InThisList) 
   

2. reemplaza 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 solo estoy creando más trabajo para mí.

Ésta es la forma en que he estado fingiendo 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

soy un novato a mí mismo, pero se puede utilizar setf y nth hacer número 2 y 3.

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

(1 2 3 4 101 6) 

Ninguna pista sobre el número uno.

EDIT: Para el número uno puede usar the position function. Decir ah.

(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 in this index.

Answer 2

Las respuestas de Jeremy deberían funcionar; Pero dicho esto, si usted se encuentra escribiendo código como

(setf (i enésimo mi lista) nueva-ELT)

es probable que estés utilizando la estructura de datos incorrecto. Las listas son simplemente listas vinculadas, por lo que son O (N) para acceder por índice. Es posible que sea mejor usar matrices.

O tal vez está usando listas como tuplas. En ese caso, deberían estar bien. Pero es probable que desee nombrar accesadores para que alguien que lea su código no tenga que recordar lo que se supone que significa "enésimo 4". Algo así como

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

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

Answer 3

Tengo que estar de acuerdo con Thomas. Si usa listas como matrices, entonces eso será lento (y posiblemente incómodo). Por lo tanto, debe usar matrices o apegarse a las funciones que ha escrito, pero muévalas "hacia arriba" de forma que pueda reemplazar fácilmente las listas lentas con matrices más adelante.

Answer 4

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

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

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

En el esquema, aquí hay una cola implementación recursiva del documento DrScheme 's:

(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á utilizando una lista como una colección de máquinas tragamonedas para almacenar datos estructurados, tal vez debería echarle un vistazo al defstruct o incluso algún tipo de Lisp O bject System como CLOS.

Si está aprendiendo Lisp, asegúrese de echar un vistazo a Practical Common Lisp y/o The Little Schemer.

¡Salud!

Answer 5

Respuestas:

1. (secuencia elemento posición & llave de extremo (inicio 0) final prueba clave de prueba-no)
   http://lispdoc.com/?q=position&search=Basic+search

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

3. (índice de secuencia elt)
   http://lispdoc.com/?q=elt&search=Basic+search
   NOTA: elt es preferible porque enésimo elt funciona en cualquier secuencia, no sólo enumera

Answer 6

+2 para "Práctico Common Lisp". Es una mezcla de un libro de recetas de Common Lisp y un libro Teach Yourself Lisp de calidad.

También hay "Lisp común exitoso" (http://www.psg.com/~dlamkins/sl/cover.html y http://www.psg.com/~dlamkins/sl/contents.html) que parece llenar algunos vacíos/extender cosas en "Practical Common Lisp".

También he leído de Paul Graham "ANSI Common Lisp", que es más acerca de los fundamentos de la lengua, pero un poco más de un manual de referencia.