; ----------------------------------------------------- ;
   ; Функция, возвращающая список из 3-х элементов,        ;
   ; a именно: квадрата, куба, и четвертой степени числа N ;
   ; ----------------------------------------------------- ;
   (DEFUN SP (LAMBDA (N)
      (LIST (* N N)
            (* (* N N) N)
            (* (* (* N N) N) N))
   ))

   ; -------------------------------------------- ;
   ; Определить операции сложения и умножения над ;
   ;               кватернионами                  ;
   ; -------------------------------------------- ;
   (DEFUN KVA (LAMBDA (L M)
   ; L и M - списки вида (X Y Z K) ;
   ; Сложение кватернионов         ;
      (LIST (+ (CAR L) (CAR M))
            (+ (CADR L) (CADR M))
            (+ (CADDR L) (CADDR M))
            (+ (CAR (CDDDR L))(CAR (CDDDR M)))
      )
   ))
   ; -------------------- ;
   (DEFUN TIM (LAMBDA (L M)
   ; Умножение кватернионов ;
      (SETQ A (CAR L))
      (SETQ B (CADR L))
      (SETQ C (CADDR L))
      (SETQ D (CAR (CDDDR L)))
      (SETQ A1 (CAR M))
      (SETQ B1 (CADR M))
      (SETQ C1 (CADDR M))
      (SETQ D1 (CAR (CDDDR M)))
      (LIST (- (- (* A A1) (* B B1))
            (+ (* C C1) (* D D1)))
            (+ (+ (* A B1)(* B A1))
            (- (* C D1)(* D C1)))
            (+ (+ (* A C1)(* C A1))
            (- (* D B1)(* B D1)))
            (+ (+ (* A D1)(* D A1))
            (- (* B C1)(* C B1))))
   ))

   ;------------------------------------------------- ;
   ; Напишите функцию, возвращающую последний элемент ;
   ;   списка. Если же список пуст, то вернуть NIL    ;
   ;------------------------------------------------- ;
   (DEFUN POSL (LAMBDA (L)
      (COND ( (NULL L) NIL )
            (  T  (CAR (REVERSE L)) )
      )
   ))

   ; -------------------------------------------- ;
   ; Для числового списка А, определить, является ;
   ;     ли сумма его элементов четным числом     ;
   ;--------------------------------------------- ;
   (DEFUN OTV (LAMBDA (LST)
      (COND ( (EQ (MOD (SUM LST) 2) 0) T )
            (  T  NIL  )
      )
   ))
   ; -------------------- ;
   (DEFUN SUM (LAMBDA (LST)
   ; Находит сумму элементов числового списка ;
      (COND ( (NULL LST) 0 )
            (  T  (+ (CAR LST) (SUM (CDR LST))) ))
   ))

   ; --------------------------------------------- ;
   ; Реализуйте на языке  LISP следующий алгоритм, ;
   ; записанный на языке APL                       ;
   ;                    X <- 1 2 3                 ;
   ;                    +/X                        ;
   ; --------------------------------------------- ;
   (DEFUN SUM (LAMBDA(LST)
      (COND
         ( (NULL LST) 0 )
         (  T  (+ (CAR LST)
                  (SUM (CDR LST))) )
      )
   ))

   ; -------------------------------------------- ;
   ; Найти элемент числового списка, равный сумме ;
   ; первого и последнего элемента того же списка ;
   ; -------------------------------------------- ;
   (DEFUN MAIN (LAMBDA (LST)
      (COND ( (NULL LST) NIL )
            (  T  (MEMBER (+ (CAR LST)
                          (CAR (REVERSE LST))) LST) )
      )
   ))

   ; -------------------------------------------------- ;
   ; Построить список, содержащий только отрицательные  ;
   ;      элементы данного числового списка LST         ;
   ; -------------------------------------------------- ;
   (DEFUN NEGATIV (LAMBDA (LST)
      (COND ( (NULL LST) NIL)
            ( (MINUSP (CAR LST))
                   (CONS (CAR LST) (NEGATIV (CDR LST))) )
            (  T  (NEGATIV (CDR LST)) )
      )
   ))

   ; --------------------------------------------------- ;
   ; Определите функцию, строящую N-уровневый вложенный  ;
   ; список, элементом которого на самом глубоком уровне ;
   ;                  является число N                   ;
   ; --------------------------------------------------- ;
   (DEFUN LUC (LAMBDA (N X)
      (COND ( (ZEROP N) X )
            (  T  (LIST (LUC (- N 1) X)) )
      )
   ))

   ; ----------------------------------------------------- ;
   ; Замените отрицательные элементы числового списка на 0 ;
   ; ----------------------------------------------------- ;
   (DEFUN ZAM (LAMBDA (LST)
      (COND ( (NULL LST) NIL )
            ( (MINUSP (CAR LST))
                        (CONS 0 (ZAM (CDR LST))) )
            (  T  (CONS (CAR LST) (ZAM (CDR LST))) )
      )
   ))

   ; ---------------------------------------- ;
   ; Напишите функцию, "обрывающую" список,   ;
   ; если он состоит более чем из N элементов ;
   ; ---------------------------------------- ;
   (DEFUN FIRSTN (LAMBDA (LST N)
      (COND ( (EQ N 1) (LIST (CAR LST)) )
            ( (< (LENGTH LST) N) LST )
            (   T   (CONS (CAR LST)
                          (FIRSTN (CDR LST)
                                  (- N 1))) )
      )
   ))

   ; -------------------------------------------------- ;
   ; Выясните, есть ли в списке два одинаковых элемента ;
   ; -------------------------------------------------- ;
   (DEFUN POISK (LAMBDA (LST)
      (COND  ( (NULL LST) NIL )
             ( (MEMBER (CAR LST) (CDR LST))  T )
             (     T       (POISK (CDR LST))   )
      )
   ))

   ; ---------------------------------------------- ;
   ; Определите  функцию  (CDNR N L), эквивалентную ;
   ; функции (CDDD...DR L), в имени которой имеется ;
   ;                     N букв D                   ;
   ; ---------------------------------------------- ;
   (DEFUN CDNR (LAMBDA (N LST)
      (COND ( (EQ N 0) LST )
            ( (EQ N 1) (CDR LST) )
            (  T  (CDNR (- N 1) (CDR LST)) )
      )
   ))

   ; --------------------------------------- ;
   ; Определить функцию, удаляющую из списка ;
   ;        каждый третий его элемент        ;
   ; --------------------------------------- ;
   (DEFUN FO (LAMBDA (L)
      (COND ( (NULL L) NIL )
            ( (<   (LENGTH L) 3) L )
            (  T   (CONS (CAR L)
                         (CONS (CADR L)
                                   (FO (CDR (CDDR L)))))
            )
      )
   ))

   ; ----------------------------------------------- ;
   ; Найти максимальный элемент среди отрицательных  ;
   ;           элементов числового списка            ;
   ; ----------------------------------------------- ;
   (DEFUN MAIN (LAMBDA (LST)
      (MAXIM (NEGATIV LST))
   ))
   ; ------------------------ ;
   (DEFUN NEGATIV (LAMBDA (LST)
   ; Построение списка, составленного из отрицательных ;
   ;               элементов списка LST                ;
      (COND ( (NULL LST) NIL )
            ( (MINUSP (CAR LST))
                      (CONS (CAR LST)
                            (NEGATIV (CDR LST))) )
            (  T  (NEGATIV (CDR LST)) )
      )
   ))
   ; ---------------------- ;
   (DEFUN MAXIM (LAMBDA (LST)
   ; Определение наибольшего элемента одноуровневого ;
   ;            числового списка LST                 ;
      (COND ( (NULL LST) NIL )
            ( (EQ (LENGTH LST) 1) (CAR LST) )
            (  T  (MAX2 (CAR LST) (MAXIM (CDR LST))) )
      )
   ))
   ; --------------------- ;
   (DEFUN MAX2 (LAMBDA (X Y)
      (( (> X Y) X ) Y )
   ))

   ; ------------------------------------------------- ;
   ; Напишите функцию REVERS, которая должна соединить ;
   ; списка, причем оба списка должны быть обращены    ;
   ; ------------------------------------------------- ;
   (DEFUN REVERS (LAMBDA (L1 L2)
      (APPEND (REVERSE L1) (REVERSE L2))
   ))
   ; ----------------------- ;
   (DEFUN APPEND (LAMBDA (X Y)
   ; Составляет список из элементов списков X и Y ;
      (COND ( (NULL X) Y )
            (  T  (CONS (CAR X) (APPEND (CDR X) Y)) ))
   ))

   ; -------------------------------------------------- ;
   ; Определить функцию  EQUALL  такую, что  (EQUALL L) ;
   ; возвращает T, если  L - список, чьи  элементы  (на ;
   ; самом верхнем уровне) все равны друг другу и NIL - ;
   ;                в противном случае                  ;
   ; -------------------------------------------------- ;
   (DEFUN EQUALL (LAMBDA (LST)
      (COND ( (EQ (LENGTH LST) 1) T )
            (   T   (AND (EQ (CAR LST) (CADR LST))
                             (EQUALL (CDR LST))
                    )
            )
      )
   ))

   ; -------------------------------------------------- ;
   ; Определить функцию DOMINATE с двумя числовыми спи- ;
   ; сками в качестве аргументов, такую, что  она  воз- ;
   ; вращает Т, если каждый атом из L больше, чем соот- ;
   ;     ветствующий из М и NIL - в противном случае    ;
   ; -------------------------------------------------- ;
   (DEFUN DOMINATE (LAMBDA (L M)
      (COND ( (NULL L) T )
            (    T   (AND (  >      (CAR L) (CAR M))
                          (DOMINATE (CDR L) (CDR M)) ) )
      )
   ))

   ; ----------------------------------------------------- ;
   ; Напишите функцию INDEXMAX, которая возвращает индекс  ;
   ; максимального числа в списке числовых атомов, не име- ;
   ;                   ющего подсписков                    ;
   ; ----------------------------------------------------- ;
   (DEFUN INDEXMAX (LAMBDA (LST)
      (INDEX (MAXIM LST) LST)
   ))
   ; ------------------------ ;
   (DEFUN INDEX (LAMBDA (X LST)
   ; Поиск "места" элемента X в списке LST ;
      (COND ( (NULL LST) 0)
            ( (EQ (CAR LST) X) 1 )
            (   T  (+ 1 (INDEX X (CDR LST))) )
      )
   ))
   ; ---------------------- ;
   (DEFUN MAXIM (LAMBDA (LST)
   ; Определение наибольшего элемента числового списка LST ;
      (COND ( (NULL LST) NIL )
            ( (EQ (LENGTH LST) 1)  (CAR LST) )
            (   T  (MAX2 (CAR LST) (MAXIM (CDR LST))) )
      )
   ))
   ; --------------------- ;
   (DEFUN MAX2 (LAMBDA (X Y)
      (COND ( (> X Y) X )
            (  T   Y )
      )
   ))

   ; ------------------------------------------------------ ;
   ; Напишите функцию (INRANGE V LST), возвращающую T, если ;
   ; V лежит между MAXIMUM  и  MINIMUM, включая  границы, и ;
   ; NIL - в противном случае. Предполагается, что V - чис- ;
   ; ловой атом. MAXIMUM и MINIMUM - наибольший  и наимень- ;
   ;                ший элементы данного списка             ;
   ; ------------------------------------------------------ ;
   (DEFUN INRANGE (LAMBDA (V LST)
      (COND ( (AND ( <  V (MAXIMUM LST))
                   ( >  V (MINIMUM LST)))  T )
            ( T  NIL )
      )
   ))
   ; ------------------------ ;
   (DEFUN MAXIMUM (LAMBDA (LST)
      (COND ( (NULL LST) NIL )
            ( (EQ (LENGTH LST) 1)  (CAR LST) )
            (   T  (MAX2 (CAR LST) (MAXIMUM (CDR LST))) )
      )
   ))
   ; --------------------- ;
   (DEFUN MAX2 (LAMBDA (X Y)
      (COND ( (> X Y) X )
            (  T  Y )
      )
   ))
   ; -------------------------- ;
   (DEFUN MINIMUM (LAMBDA (LST)
      (COND ( (NULL LST) NIL )
            ( (EQ (LENGTH LST) 1) (CAR LST) )
            (  T  (MIN2 (CAR LST) (MINIMUM (CDR LST))) )
      )
   ))
   ; --------------------- ;
   (DEFUN MIN2 (LAMBDA (X Y)
      (COND ( (< X Y) X )
            ( T  Y )
      )
   ))

   ; ------------------------------------------------------ ;
   ; Построить функцию, которая удаляет из числового списка ;
   ; все совпадающие  с заданным  числом элементы и возвра- ;
   ;      щает список из квадратов оставшихся элементов     ;
   ; ------------------------------------------------------ ;
   (DEFUN MAN (LAMBDA (X LST)
      (COPY (REMBER X LST))
   ))
   ; ------------------------- ;
   (DEFUN REMBER (LAMBDA (X LST)
      (COND ( (NULL LST) NIL )
            ( (EQ X (CAR LST)) (REMBER X (CDR LST)) )
            (  T  (CONS (CAR LST) (REMBER X (CDR LST))) )
      )
    ))
   ; ------------------- ;
   (DEFUN COPY (LAMBDA (L)
   ; Функция возвращает список, состоящий из квадратов ;
      (COND ( (NULL L) NIL )
            (  T  (CONS (* (CAR L) (CAR L))
                                     (COPY (CDR L)) ) )
      )
   ))

   ; -------------------------------------------- ;
   ; Определить, имеются ли в числовом списке два ;
   ;        подряд идущих нулевых элемента        ;
   ; -------------------------------------------- ;
   (DEFUN POISK (LAMBDA (LST)
      (COND ( (NULL LST) NIL )
            ( (AND (EQ (CAR LST) (CAR (CDR LST)))
                   (EQ (CAR LST) 0)) T )
            (  T   (POISK (CDR LST)) )
      )
   ))