Common Lisp: conversión entre listas y matrices

Question

¿Cómo se convierte elegantemente entre listas y matrices anidadas arbitrariamente?

p. Ej.

((1 2 3) (4 5 6)) 

convierte

#2A((1 2 3) (4 5 6)) 

y viceversa

Answer 1

Lista de matriz 2D:

(defun list-to-2d-array (list) 
    (make-array (list (length list) 
        (length (first list))) 
       :initial-contents list)) 

matriz 2D a la lista:

(defun 2d-array-to-list (array) 
    (loop for i below (array-dimension array 0) 
     collect (loop for j below (array-dimension array 1) 
         collect (aref array i j)))) 

La forma multidimensional para list to 2d es fácil.

(defun list-dimensions (list depth) 
    (loop repeat depth 
     collect (length list) 
     do (setf list (car list)))) 

(defun list-to-array (list depth) 
    (make-array (list-dimensions list depth) 
       :initial-contents list)) 

La matriz de la lista es más complicada.

Tal vez algo como esto:

(defun array-to-list (array) 
    (let* ((dimensions (array-dimensions array)) 
     (depth  (1- (length dimensions))) 
     (indices (make-list (1+ depth) :initial-element 0))) 
    (labels ((recurse (n) 
       (loop for j below (nth n dimensions) 
        do (setf (nth n indices) j) 
        collect (if (= n depth) 
           (apply #'aref array indices) 
           (recurse (1+ n)))))) 
     (recurse 0)))) 

Answer 2

Otra matriz 2D para el listado de soluciones:

(defun 2d-array-to-list (array) 
    (map 'list #'identity array)) 

Y la lista de matriz 2D (Pero tal vez no es tan eficiente como la solución de la última respuesta):

(defun list-to-2d-array (list) 
    (map 'array #'identity list))