Еще задача из раздела "С для начинающих" - кратчайший палиндром

(defun min-pal (lst)
  (labels ((is-pal (x) (equal x (reverse x))))
    (cond ((is-pal lst) lst)
          ((is-pal (cdr lst)) (append lst (list (car lst))))
          (t (append (list (car lst)) (min-pal (cdr lst)) (list (car lst)))))))
 
==> min-pal
 
(min-pal '(a b r b))
 
==> (a b r b a)
 
(min-pal '(a b a))
 
==> (a b a)
 
(min-pal '(a b r a))
 
==> (a b r a r b a)
 
(min-pal '(f l o l))
 
==> (f L o L f)

;;; double-linked-list
(defstruct dll val prev next)
 
(defstruct dll-links first last)
 
(defun dll-add-node (val prev next)
    (let ((nd (make-dll :val val :prev prev :next next)))
        (if next
            (setf (dll-prev next) nd))
        (if prev
            (setf (dll-next prev) nd))
        nd))
 
(defun push_back(store e)
    (if (dll-links-first store)
        (setf (dll-links-last store) (dll-add-node e (dll-links-last store) nil))
        (let ((nd (dll-add-node e nil nil)))
            (setf (dll-links-first store) nd)
            (setf (dll-links-last store) nd))))
 
(defun pop_forward(store)
    (let ((hd (dll-links-first store)))
        (cond
          ((not hd) nil)
          ((not (dll-next hd))
            (setf (dll-links-first store) nil)
            (setf (dll-links-last store) nil))
          (t
            (setf (dll-links-first store) (dll-next hd))
            (setf (dll-prev (dll-next hd)) nil)))))
 
(defun simple-linked-to-double-linked(lst)
    (let ((store (make-dll-links)))
      (map nil (lambda (e) (push_back store e)) lst)
      store))
 
(defun dll-empty(l) (not (and (dll-links-first l) (dll-links-last l))))
 
;;; task
 
(defun check-pol(store)
    (let ((flag t))
      (do   ((hd (dll-links-first store) (dll-next hd)) (tl (dll-links-last store) (dll-prev tl)))
            ((or (not flag) (not hd) (not tl) (eq hd tl) (eq (dll-prev hd) tl)) flag)
            (setf flag (and flag (eql (dll-val hd) (dll-val tl)))))))
 
(defun get-pol-pos(store)
    (do ((pos 0 (1+ pos)) (check-res (check-pol store) (check-pol store)))
        ((or check-res (dll-empty store)) pos)
        (pop_forward store)))
 
 
 
(defun task(l)
    (let* ((pos (get-pol-pos (simple-linked-to-double-linked l)))
           (lt (nreverse (subseq l 0 pos))))
      (nconc l lt)))