14rec, Common Lisp

Language: Layout:

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

;Конкатенация двух упорядоченных по возрастанию списков так, чтоб
(defun concat (l1 l2)
    (let (i)) (setf i 0)
    (let (j)) (setf j 0)
    (let (k)) (setf k 0)
    (let (len1)) (setf len1 (length l1))
    (let (len2)) (setf len2 (length l2))
    (let (len)) (setf len (+  len1 len2))
    (let (conl)) (setf conl (list))
    (let (el1)) (let (el2))
    (let (complexity)) (setf complexity 0)
    (loop while (< k len)
          when (>= i len1)
               do (setf conl (nconc conl (subseq l2 j) )) and do (return  (list conl complexity))
          when (>= j len2)
               do (setf conl (nconc conl (subseq l1 i) )) and do (return  (list conl complexity))
          do (setf el1 (nth i l1))
          do (setf el2 (nth j l2))
          if (< el1 el2)
              do (setf conl (nconc conl (list el1) )) and
              do (incf i)
          else 
              do (setf conl (nconc conl (list el2) )) and
              do (incf j)
          do (incf k)
          do (setf complexity (+ complexity 11))
          )
    )

;Инверсия списка.
(defun inverse (list)
    (let (len)) (setf len (- (length list) 1))
    (loop for i from len downto 0
          collect (nth i list) into inv
          finally (return (list inv (+ len 1)))
          )
    )

;Вывод на экран элементов списка.
(defun print-list (list)
    (loop for x in list 
          do (princ x)
          do (princ " ")
          )
    (* 2 (length list))
    )

;Сформировать для заданного списка список, элементами которого являются числа, задающие число вхождений каждого элемента исходного списка в этот список.
(defun counts (list)
    (let ())
    )

;Проверка, является ли один список подсписком другого списка, причем таким, что все его элементы являются последними элементами исходного списка.
(defun is-sublist (l1 l2)
    (let (len1)) (setf len1 (length l1))
    (let (len2)) (setf len2 (length l2))
    (when (> len2 len2) (return-from sublist (list nil 1)))
    (let (is-sublist)) (setf is-sublist t)
    (let (i)) (setf i (- len1 1))
    (let (j)) (setf j (- len2 1))
     (let (complexity)) (setf complexity 0)
    (loop while (>= j 0)
          if (not (eql (nth i l1) (nth j l2)))
              return (list nil complexity)
          do (decf i)
          do (decf j)
          do (setf complexity (+ complexity 7))
          finally (return (list t complexity))
     )
    )

;Выделение подсписка, первым элементом которого будет заданный элемент
(defun sublist (list el)
    (let(pos)) (setf pos 0)
    (let (complexity)) (setf complexity 0)
    (loop for x in list
          if (eql x el)
              return pos
          else 
              do (incf pos)
          do (setf complexity (+ 2 complexity))
          )
    (let (len)) (setf len (length list))
    (when (eql pos len) (return-from sublist (list nil (+ complexity 2)))) 
    (decf len)
    (loop for i from pos to len
          collect (nth i list) into sublist
          do (incf complexity)
          finally (return (list sublist complexity))
          )
    )

;Удаление повторяющихся элементов списка с сохренением порядка
(defun remove-repeats (list)
    (let (complexity)) (setf complexity 0)
    (loop while (not (null list))
          collecting (first list) into l
          do (setf list (remove (first list) list))
          do (setf complexity (+ 6 complexity))
          finally (return (list l complexity))
          )
    )

(let (l1)) (setf l1 (list 0 2 2 4 4 4 6 6  7 7 8 8 9))
(let (l2)) (setf l2 (list 5 6 7 7 8 8 9 ))
(print "Список 1")
(print l1)
(print "_____________________________________")
(print "Список 2")
(print l2)
(print "_____________________________________")
(print "Конкатенация двух упорядоченных по возрастанию списков так, чтобы полученный список также был упорядочен по возрастанию.")
(print (concat l1 l2))
(print "_____________________________________")
(print "Инверсия списка 1")
(print (inverse l2))
(print "_____________________________________")
(print "Сформировать для списка 1 список, элементами которого являются числа, задающие число вхождений каждого элемента исходного списка в этот список.")
(print (counts l1))
(print "_____________________________________")
(print "Проверка, является ли один список подсписком другого списка, причем таким, что все его элементы являются последними элементами исходного списка.")
(print (is-sublist l1 l2))

(let (num)) (setf num 7)
(print "Выделение подсписка списка 1, первым элементом которого будет заданный элемент")
(princ "Заданный элемент: ") (print num)
(print (sublist l1 num))
(print "_____________________________________")
(print "Удаление повторяющихся элементов списка 1 с сохренением порядка")
(print (remove-repeats  l1 ))

[ + ] Show input
Absolute running time: 0.19 sec, cpu time: 0.03 sec, memory peak: 9 Mb, absolute service time: 0,32 sec