Entonces, me gustaría tomar una lista de números, atomizarla (para eliminar enteros anidados), luego encontrar el valor máximo. Tengo dos funciones escritas que logran esto individualmente, pero no puedo encontrar la forma de combinarlas en LISP para poder hacer una llamada y ejecutar ambas. Cualquier ayuda sería apreciada.

:Atomize function to remove nests 
:(atomify ‘( a (b c) (e (f (g h) i)) j)->(a b c e f g h i j)

(defun atomify (numbers)
  (cond ((null numbers) nil)
        ((atom (car numbers))
         (cons (car numbers)
               (atomify (cdr numbers))))
        (t
         (append (atomify (car numbers))
                 (atomify (cdr numbers))))))



:Max value of a list of integers function

(defun large_atom (numbers) 
  (if (null numbers)
      0 
      (max (first numbers)
           (large_atom (rest numbers)))))
0
Jamie Jackson 14 nov. 2017 a las 10:14

2 respuestas

La mejor respuesta

Jamie. Tu camino tiene dos pasos: 1. Aplanar lista 2. Encuentre el valor máximo a partir del resultado del primer paso En este caso es la verdadera forma. Pero debes hacerlo con una llamada de función. Es fácil. Simplemente use etiquetas, aplicar y, por supuesto, max

(defun foo (lst)
  (labels ((flatten (lst acc)
             (cond
               ((null lst)
                acc)
               ((consp (car lst))
                (flatten (cdr lst) (flatten (car lst) acc)))
               (t
                (flatten (cdr lst) (cons (car lst) acc))))))
    (apply #'max (flatten lst nil))))

Otra forma es no aplanar la lista de fuentes. Pero en este caso, necesita encontrar el primer valor para compararlo con otros valores. Inténtalo tú mismo.

2
Hurry Blob 14 nov. 2017 a las 12:53

Aquí hay otra forma de resolver el problema: en lugar de aplanar la lista, la recorre de forma recursiva. Esto es muy explícito acerca de cuál debe ser la estructura de la lista: una buena lista es una lista propia no nula, cada uno de cuyos elementos es un número entero o una buena lista.

El problema con este enfoque es que no es recursivo de cola, por lo que necesariamente fallará en estructuras muy grandes (e incluso si fuera recursivo de cola, CL no promete lidiar con la recursión de cola.

(defun greatest-integer (good-list)
  ;; a good list is one of:
  ;; - a cons of a good list and either a good list or ()
  ;; - a cons of an integer and either a good list or ()
  ;; In particular it can't be () and it can't be an improper list
  ;;
  (destructuring-bind (a . b) good-list
    ;; a can be an integer or a good list, b can be null or a good list
    (etypecase b
      (null
       (etypecase a
         (integer a)
         (cons (greatest-integer a))))
      (cons
       (max (etypecase a
              (integer a)
              (cons (greatest-integer a)))
            (greatest-integer b))))))
2
tfb 14 nov. 2017 a las 14:34