12, Common Lisp - rextester

Language: Layout:

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

(defun rearrangement (list)
    (let (new))
    (setf new (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)
          do (setf new (nconc new (list (nth j list) (nth i list))))
          do (setf i (+ i 2))
          do (setf j (+ j 2))
          do (setf complexity (+ complexity 6))
     )
    (when (eql j len) 
    (setf new (nconc new (last list)))
     (setf complexity (+ complexity 3))
          )
            (list new complexity)
)

(defun not-belong (list el) 
    (let (complexity)) (setf complexity 0)   
    (loop for x in list
            do (setf complexity (+ complexity 1)) 
          if (eql x el)
                 do (return-from not-belong (list nil complexity))
             )
    (list t complexity)
)

(defun no-repeat-list (list)
    (let (new)) (setf new (list))
    (let (complexity)) (setf complexity 0)
    (loop while (not (null list))
              do (setf new (nconc new (list (first list))))
              do (setf list (remove (first list) list))
              do (setf complexity (+ complexity 9))
    )
    (list new complexity)
)

(defun no-repeat-length (list)
    (let (no-repeat)) (setf no-repeat (no-repeat-list list))
    (let (new)) (setf new (first no-repeat))
    (let (complexity)) (setf complexity (second no-repeat)) ;??????
    (let (len)) (setf len 0)
    (loop for x in new
          do (incf len)
          do (incf complexity)
     
     )
    (list len complexity)
 )

(defun min-no-repeat (list)
    (let (no-repeat)) (setf no-repeat (no-repeat-list list))
    (let (new)) (setf new (first no-repeat))
    (let (complexity)) (setf complexity (second no-repeat)) ;??????
    (loop for x in new
          do (incf complexity)
          minimize x into min
          finally (return (list min complexity))
          )
    )

(defun sums (list)
     (let (no-repeat)) (setf no-repeat (no-repeat-list list))
    (let (new)) (setf new (first no-repeat))
    (let (complexity)) (setf complexity (second no-repeat)) ;??????
    (let (sum1))
    (setf sum1 (loop for x in list
                summing x into total
                finally (return total)
          ))
     (let (sum2))
    (setf sum2 (loop for x in new
                summing x into total
                finally (return total)
          ))
    
    (list sum1 sum2 (+ complexity (length list) (length new)))
)

(defun max-sum (list)
    (let (sums))
    (setf sums (sums list))
    (let (s1)) (setf s1 (first sums))
    (let (s2)) (setf s2 (second sums))
    (let (complexity)) (setf complexity ( + (third sums) 2))
    (if (> s1 s2)
        (list s1 complexity)
        (list s2 complexity)
        )
    
    )

(let (list))
(setf list (list 7 1 1 4 5 8 10 10))
(print list)
(print (no-repeat-list list))
(print (sums list))
(print (max-sum list))

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