Listas


Las listas son los objetos que caracterizan a Lisp. Se escriben con paréntesis, con sus elementos separados por espacios.

append, nconc

; une listas
(append '(1 2 4 5) '(a b c d))
(1 2 4 5 A B C D)
; une listas
(nconc '(1 2 4 5) '(a b c d))
(1 2 4 5 A B C D)
; append no modifica argumentos
(let (l1 l2 tot)
  (setf l1 '(1 2 3)
        l2 '(a b c))
  (setf tot (append l1 l2))
  (list l1 l2 tot) )
((1 2 3) (A B C) (1 2 3 A B C))
; nconc almacena resultado en el primer argumento
(let (l1 l2 tot)
  (setf l1 '(1 2 3)
        l2 '(a b c))
  (setf tot (nconc l1 l2))
  (list l1 l2 tot) )
((1 2 3 A B C) (A B C) (1 2 3 A B C))

butlast, nbutlast

; devuelve la lista, excepto el último elemento
(butlast '(1 2 3 4))
(1 2 3)
; devuelve la lista, excepto los dos últimos elementos
(butlast '(1 2 3 4) 2)
(1 2)
; butlast no modifica su argumento
(let (l1 tot)
  (setf l1 '(1 2 3))
  (setf tot (butlast l1))
  (list l1 tot) )
((1 2 3) (1 2))
; nbutlast hace lo mismo que butlast pero 
; guarda el resultado en su argumento
(let (l1 tot)
  (setf l1 '(1 2 3))
  (setf tot (nbutlast l1))
  (list l1 tot) )
((1 2) (1 2))

car

; devuelve el primer elemento de la lista
(car '(1 2 3 4 5))
1
(car '(1))
NIL

cdr

(cdr '(1 2 3 4 5))
(2 3 4 5)
(cdr '())
NIL
(cdr '(1))
NIL

c...r

(caddr '(1 2 3 4 5))
3
(cdar '((1 2) (3 4) 5))
(2)

cons

(cons 5 '(a 2 c 3 e 4))
(5 A 2 C 3 E 4)

copy-list

(let (a b c)
  ; asignamos una lista a la variable a
  (setf a '(1 2 3))
  (setf b a)             ; b apunta a a
  (setf c (copy-list a)) ; nueva copia

  ; cambio en b
  (setf (nth 1 b) 77)

  (list a b c) )
((1 77 3) (1 77 3) (1 2 3))

find, find-if

; devuelve posición contando a partir de 1
(find 4 '(1 2 3 4 5))
4
; busca impar hasta la posición 3
(find-if #'oddp '(2 4 6 4 5) :end 3)
NIL

first, second, third, ..., ninth, tenth

(first '(a b c d e))
A
(eighth '(a b c d e f g h j k l))
H

last

(last '(a b c d e))
(2 3 4 5)
(E)

length, list-length

(length '(a 2 c 3 e 4))
6
; específico para listas
(list-length '(a 2 c 3 e 4))
6

list, list*

; la comilla simple evita la evaluación de los 
; símbolos y el consiguiente error
(list 'a 'b (* 7 7) '(d e f))
(A B 49 (D E F))
; la diferencia entre list y list* se reduce
; al tratamiento del último elemento
(list* 'a 'b (* 7 7) '(d e f))
(A B 49 D E F)

make-list

; crea lista de 5 elementos iguales a NIL
(make-list 5)
(NIL NIL NIL NIL NIL)
; crea lista de 5 elementos iguales a 7
(make-list 5 :initial-element 7)
(7 7 7 7 7)

member, member-if

(member 3 '(a 2 c 3 e 4))
(3 E 4)
(member-if #'evenp '(-1 1 2 3 4))
(2 3 4)
(member-if-not #'evenp '(8 10 2 3 4))
(3 4)
; transforma a minúsculas los caracteres de la
; lista antes de hacer la prueba
(member
  #\s
  '(#\T #\e #\C #\o #\S #\t #\a #\t #\s)
  :key #'char-downcase)
(#\S #\t #\a #\t #\s)
; la función de predicado puede ser una función lambda,
; aquí busca el primer múltiplo de 4
(member-if
  #'(lambda (z) (integerp (/ z 4)))
  '(1 2 3 5 6 7 8 9 10))
(8 9 10)

nth

(nth 3 '(a b c d e))
D

nthcdr

(nthcdr 2 '(a b c d e))
(C D E)

position, position-if

; devuelve posición contando a partir de 0
(position 4 '(1 2 3 4 5))
3
; lugar del elemento 3,
; primera posición es cero
(position 3 '(a 2 c 7 e 3 b))
5
; lugar del elemento 3,
; empezando a buscar por el final
(position 3 '(a 2 c 7 e 3 b) :from-end t)
5
; falta elemento
(position 2 '(6 7 8))
NIL
; busca la posición de la primera lista cuyo primer
; elemento sea par a partir de la segunda posición,
; pero antes extrae el primer elemento de cada lista
(position-if
  #'evenp
  '((8 2 3) (5 6 8) (3 3 9) (4 90))
  :start 1 :key #'car)
3
; busca posición del primer entero
(position-if #'integerp '(1/3 2 #c(1 5) 4 5.0))
1

remove, remove-if

; elimina todos los cuatros de la lista
(remove 4 '(1 2 4 1 3 4 5))
(1 2 1 3 5)
; elimina los dos primeros cuatros comenzando por la izquierda
(remove 4 '(1 2 4 1 3 4 5 8 4 6) :count 2)
(1 2 1 3 5 8 4 6)
; elimina los dos primeros cuatros comenzando por la derecha
(remove 4 '(1 2 4 1 3 4 5 8 4 6) :count 2 :from-end t)
(1 2 4 1 3 5 8 6)
; elimina los valores x que cumplen la condición 3>x,
; test debe ser una función de predicado de dos argumentos.
(remove 3 '(1 2 4 1 3 4 5) :test #'>)
(4 3 4 5)
; elimina impares, la condición debe ser una función de
; predicado de un solo argumento.
(remove-if #'oddp '(1 2 4 1 3 4 5))
(2 4 4)
; elimina dos impares empezando por la derecha
(remove-if #'oddp '(1 2 4 1 3 4 5) :count 2 :from-end t)
(1 2 4 1 4)

rest

(rest '(1 2 3 4 5))
(2 3 4 5)
(rest '())
NIL
(rest '(1))
NIL

reverse

(reverse '(1 2 4 5))
(5 4 2 1)

subst, subst-if

; busca y sustituye el 5 en toda la estructura de la lista
(subst "cinco" 5 '(5 (s 5) ((3 5) p)))
("cinco" (S "cinco") ((3 "cinco") P))
; sustituye decimales por ceros
(subst-if 0 #'floatp '(8 (4 0.5) ((3 5.8 9) 5)))
(8 (4 0) ((3 0 9) 5))

substitute, substitute-if

; busca y sustituye el 5 solo en el nivel superior de la lista
(substitute "cinco" 5 '(5 (s 5) ((3 5) p)))
("cinco" (S 5) ((3 5) P))
; sustituye decimales en el primer nivel de la lista por ceros
(substitute-if 0 #'floatp '(0.5 (4 0.5) ((3 5.8 9) 5)))
(0 (4 0.5) ((3 5.8 9) 5))

© 2016, TecnoStats