Список целых чисел A1, A2, ..., AN оставить без изменений, если он упорядочен по возрастанию или убыванию.

(defun foo (lst)
  (cond ((and lst
          (or (apply #'<= lst) (apply #'>= lst))) lst)
    (t (labels ((change-list (lst n)
              (if lst
              (let ((head (car lst))
                (tail (cdr lst))
                (n-plus1 (1+ n)))
                (if (oddp n)
                (if (zerop (mod head 4))
                    (change-list tail n-plus1)
                    (cons head (change-list tail n-plus1)))
                (cons (* 3 head) (change-list tail n-plus1)))))))
         (change-list lst 1)))))
 
CL-USER> (foo '(1 2 3 4 5 6 7 8 9 10))
(1 2 3 4 5 6 7 8 9 10)
CL-USER> (foo '(1 7 3 4 5 6 7 8 9 10))
(1 21 3 12 5 18 7 24 9 30)
CL-USER> (foo '(1 7 3 4 8 6 12 8))
(1 21 3 12 18 24)

(defun f (l)
           (if (or (eval (cons '< l))
                   (eval (cons '> l))) l
                (loop for a in l and b from 1
                     if (evenp b) collect (* a 3)
                     else if (not (zerop (mod a 4)))
                     collect a)))

(defun f (l)
           (if (or (eval (cons '< l)) (eval (cons '> l))) l
               (labels 
                   ((fun (l test)
                      (if l (if test
                                (if (zerop (mod (car l) 4))
                                    (fun (cdr l) ())
                                    (cons (car l) (fun (cdr l) ())))
                                (cons (* (car l) 3)
                                      (fun (cdr l) t))) ())))
                 (fun l t))))

(defun task (lst)
  (cond ((apply '<= lst) lst)
        ((apply '>= lst) lst)
        (t (let ((r nil) (p 0))
                (dolist (i lst r)
                  (setq p (+ 1 p))
                  (if (and (oddp p) (= 0 (% i 4))) nil
                      (progn (when (evenp i) (setq i (+ i i i)))
                             (setq r (append r (list i)))))))))) 
 
==> task
 
(task '(1 7 3 4 5 6 7 8 9 10))
 
==> (1 7 3 12 5 18 7 24 9 30)

(defun chaos (w &aux (a (car w)) (d (cdr w)))
  (cond ((null w) nil)
        ((zerop (mod a 4)) (cons (* (car d) 3) (chaos (cdr d))))
        ((cons a (cons (* (car d) 3) (chaos (cdr d)))))))
 
(defun ordered (w)
  (or (null w) (apply #'<= w) (apply #'>= w)))
 
(defun ordered-chaos (w)
  (if (ordered w) w (chaos w)))
 
> (ordered-chaos '(1 7 3 4 8 6 12 8))
(1 21 3 12 18 24)