Добавление элемента с максимальным значением после минимального элемента (Allegro Lisp)

(defun task-1 (lst)
 (let* ((max (apply 'max lst))
        (min (apply 'min lst))
        (pmi (position min lst)))
   (if (= pmi (1- (length lst)))
       (append lst (list max))
       (append (append (subseq lst 0 (1+ pmi)) (list max)) (subseq lst (1+ pmi)))))) 
 
==> task-1
 
(task-1 '(4 5 9 1 -5 7))
 
==> (4 5 9 1 -5 9 7)
 
(task-1 '(-14 5 9 1 -5 7))
 
==> (-14 9 5 9 1 -5 7)
 
(task-1 '(-14 5 9 1 -5 -77))
 
==> (-14 5 9 1 -5 -77 9)

(defun task-2 (lst)
  (let ((min (apply 'min (remove-if #'(lambda (x) (<= x 0)) lst)))
        (res nil))
   (dolist (i lst (reverse res))
      (if (evenp (length res)) (push min res) (push i res)))))
 
==> task-2
 
(task-2 '(-1 2 3 -8 12 -4))
 
==> (2 2 2 -8 2 -4)

(defun task-3 (lst &optional (n (length lst)) (l 0))
   (cond ((>= l n) lst)
         (t (task-3 (cdr lst) (1- n) (1+ l)))))
 
==> task-3
 
(task-3 '(a b c d e))
 
==> (d e)
 
(task-3 '(a b d e))
 
==> (d e)
 
(task-3 '(a b d e f g))
 
==> (e f g)

(defun task-1 (lst)
 (let* ((max (apply 'max lst))
        (min (apply 'min lst))
        (res nil)) 
    (dolist (i lst (reverse res))
        (push i res)
        (when (= i min) (push max res))))) 
 
 
==> task-1
 
(task-1 '(1 2 3 1 2 3 1 2 3))
 
==> (1 3 2 3 1 3 2 3 1 3 2 3)

;Вставить после ключа.
(defun insert-after (v k seq)
  (cond
    ((null seq) nil)
    ((equal (car seq) k) (cons k (cons v (insert-after v k (cdr seq)))))
    (t (cons (car seq) (insert-after v k (cdr seq))))))
 
> (insert-after 's 'b '(a b c b e))
 
==> (a b s c b s e)
 
;Решение.
(defun max-after-min (lst)
  (if lst
    (insert-after (apply #'max lst) (apply #'min lst) lst)))
 
> (max-after-min '(7 5 -9 2 4 8 -3 -6 -9 0))
 
==> (7 5 -9 8 2 4 8 -3 -6 -9 8 0)

(defun max-after-min (seq &optional (v (apply #'max seq)) (k (apply #'min seq)))
  (cond ((null seq) nil)
        ((equal (car seq) k) (cons k (cons v (max-after-min (cdr seq) v k))))
        (t (cons (car seq) (max-after-min (cdr seq) v k)))))
 
> (max-after-min '(0 1 2 5 1 2 3 0 1 2 3 0 4))
 
==> (0 5 1 2 5 1 2 3 0 5 1 2 3 0 5 4)

(defun nx-insert (w)
  (insert w (reduce #'min w) (reduce #'max w)))
 
(defun insert (w n x)
  (cond ((null w) nil)
        ((eq (car w) n) (cons n (cons x (insert (cdr w) n x))))
        ((cons (car w) (insert (cdr w) n x)))))
 
> (nx-insert '(0 1 2 5 1 2 3 0 1 2 3 0 4))
(0 5 1 2 5 1 2 3 0 5 1 2 3 0 5 4)

(defun nx-insert (w &optional (n (reduce #'min w)) (x (reduce #'max w)))
  (cond ((null w) nil)
        ((eq (car w) n) (cons n (cons x (nx-insert (cdr w) n x))))
        ((cons (car w) (nx-insert (cdr w) n x)))))
 
> (nx-insert '(0 1 2 5 1 2 3 0 1 2 3 0 4))
(0 5 1 2 5 1 2 3 0 5 1 2 3 0 5 4)