13, Common Lisp - rextester

Language: Layout:

#|
Используя стандартное представление списков, запрограммировать следующий предикаты для работы со списками. 
Каждый предикат должен вычислять сложность (число шагов, необходимых для вычисления) для  самого себя.
    1. Вычисление разности соседних четных элементов списка
    2. Проверка на принадлежность каждого элемента списка разностей исходному списку.
    3. Вычисление длины списка разностей.
    4. Вычисление минимальной разности.
    5. Вычисление произведений соседних элементов списка.
    6. Сортировка элементов списка произведений по убыванию.
    7. Сортировка элементов списка разностей по возрастанию
|#

;Вычисление разности соседних четных элементов списка
(defun sub (list)
    (let (len)) (setf len  (length list))
    (when (< len 3) (return-from sub (nil 1)))
    (let (i)) (setf i 0)
    (let (j)) (setf j 2)
    (let (complexity)) (setf complexity 0)
     (loop while (< j len)
           collecting (- (nth i list) (nth j list)) into subs
           do (setf i (+ i 2))
           do (setf j (+ j 2))
           do (setf complexity (+ complexity 7))
           finally (return (list subs complexity))
    ) 
)

;Проверка на принадлежность каждого элемента списка разностей исходному списку.
(defun sub-belong (list)
    (let (sub)) (setf sub (first (sub list)))
    (loop for x in sub
          collect (list x (if (find x list) t nil )) into belong
          finally (return (list belong (* 2 (length sub))))
          )
    )

;Вычисление длины списка разностей.
(defun sub-length (list)
    (list (length (first (sub list))) 1)
    )

;Вычисление минимальной разности.
(defun min-sub (list)
   (let (sub)) (setf sub (first (sub list)))
    (loop for x in sub
          minimizing x into min
          finally (return (list min (length sub)))
          )
    )

;Вычисление произведений соседних элементов списка.
(defun mult (list)
    (let (len)) (setf len  (length list))
    (let (i)) (setf i 0)
    (let (j)) (setf j 1)
    (let (complexity)) (setf complexity 0)
    (loop while (< j len)
          collecting (* (nth i list) (nth j list)) into mults
          do (incf i)
          do (incf j)
          do (setf complexity (+ complexity 6))
          finally (return (list mults complexity))
          )
    )

;Сортировка элементов списка произведений по убыванию.
(defun sort-mult (list)
    (let (mult)) (setf mult (first (mult list)))
 
    (let(count)) (let (max))
    (let (sorted)) (setf sorted (list))
    (let (complexity)) (setf complexity 0)
    (loop while (not (null mult))
          do (setf max (apply #'max mult))
       
          do (setf count (count max mult))
        
          (loop for i from 1 to count
                do (setf sorted (nconc sorted (list max)))
                )
          do (setf mult (remove max mult))
          do (setf complexity (+ complexity count 8))
          finally (return (list sorted complexity))
          )
    )

;Сортировка элементов списка разностей по возрастанию
(defun sort-sub (list)
    (let (sub)) (setf sub (first (sub list)))
 
    (let(count)) (let (min))
    (let (sorted)) (setf sorted (list))
    (let (complexity)) (setf complexity 0)
    (loop while (not (null sub))
          do (setf min (apply #'min sub))
       
          do (setf count (count min sub))
        
          (loop for i from 1 to count
                do (setf sorted (nconc sorted (list min)))
                )
          do (setf sub (remove min sub))
          do (setf complexity (+ complexity count 8))
          finally (return (list sorted complexity))
          )
    )

(let (list)) (setf list (list 10 1 10 1 5 1 12 6 5 18 20))
;(print list)
;(print (sub list))
;(print (sub-belong list))
;(print (sub-length list))
;(print (min-sub list))
;(print (mult list))
(print (sort-mult list))
(print (sort-sub list))
;(print (apply #'min (first (mult list))))

[ + ] Show input
Absolute running time: 0.15 sec, cpu time: 0.02 sec, memory peak: 9 Mb, absolute service time: 0,23 sec