; ---------------------------------------------------- ;
   ; Запишите алгоритм вычеркивания из слова X всех букв, ;
   ;     стоящих на нечетных местах после буквы "A"       ;
   ; ---------------------------------------------------- ;
   (DEFUN PACDEL (LAMBDA NIL
      (SETQ LST (UNPACK (READ)))
      (COND ( (< (LENGTH LST) 2) (PACK LST) )
            (  T  (PACK (CONS (CAR LST)
                              (DELAP_A (CDR LST))))
            )
      )
   ))
   ; ------------------------ ;
   (DEFUN DELAP_A (LAMBDA (LST)
      (COND ( (< (LENGTH LST) 2) LST )
            ( (EQ (CAR LST) A)
                     (CONS (CAR LST)
                           (DELAP_A (CDDR LST))) )
            (   T    (CONS (CAR LST)
                           (CONS (CADR LST)
                                 (DELAP_A (CDDR X))))
            )
      )
   ))

   ; --------------------------------------------------- ;
   ; Cоставьте алгоритм, выделяющий в слове Х все буквы  ;
   ; "О" символами "#", например, слово "SOSNA" должно   ;
   ; быть преобразовано в слово S#O#SNA"                 ;
   ; --------------------------------------------------- ;
   (DEFUN ILLUS (LAMBDA NIL
      (PACK (PRIMER (UNPACK (READ))))
   ))
   ; ----------------------- ;
   (DEFUN PRIMER (LAMBDA (LST)
      (COND ( (NULL LST) NIL )
            ( (EQ (CAR LST) O)
                    (CONS # (CONS O (CONS #
                                     (PRIMER (CDR LST)))))
            )
            (  T  (CONS (CAR LST) (PRIMER (CDR LST))) )
      )
   ))

   ; ------------------------------------------------- ;
   ; В заданном предложении найти слова заданной длины ;
   ; ------------------------------------------------- ;
   (DEFUN MAXIM (LAMBDA (N LST)
      (COND ( (NULL LST) NIL )
            ( (MAX2 (CAR LST))
                  (CONS (CAR LST) (MAXIM N (CDR LST))) )
            (  T  (MAXIM N (CDR LST)) )
      )
   ))
   ; ------------------- ;
   (DEFUN MAX2 (LAMBDA (Y)
      (COND ( (EQ (LENGTH (UNPACK Y)) N ) T )
            (  T  NIL )
      )
   ))

   ; ------------------------------------------------ ;
   ; Запишите алгоритм, выясняющий, есть ли в слове Х ;
   ;   буква "R", и если есть, то заменить ее на "C"  ;
   ; ------------------------------------------------ ;
   (DEFUN A (LAMBDA NIL
      (PACK (AF (UNPACK (READ))))
   ))
   ; ------------------- ;
   (DEFUN AF (LAMBDA (LST)
      (COND ( (NULL LST) NIL )
            ( (EQ (CAR LST) R)
                    (CONS C (AF (CDR LST))) )
            (   T   (CONS (CAR LST) (AF (CDR LST))) )
      )
   ))

   ; -------------------------------------------------- ;
   ; Запишите алгоритм подсчета числа букв "O", стоящих ;
   ;      в слове на местах, номер которых кратен 4     ;
   ; -------------------------------------------------- ;
   (DEFUN MAIN (LAMBDA ()
      (PLL (UNPACK (READ)))
   ))
   ; -------------------- ;
   (DEFUN PLL (LAMBDA (LST)
      (COND  ( (< (LENGTH LST) 4) 0 )
             ( (EQ (CAR (CDDDR LST)) O)
                       (+ 1 (PLL (CDR (CDDDR LST))) )
             )
             (   T    (PLL (CDR (CDDDR LST))) )
      )
   ))

   ;--------------------------------------------------- ;
   ; Запишите алгоритм, выясняющий, есть ли в слове  Х  ;
   ; буква "A", стоящая на четном месте после буквы "K" ;
   ;--------------------------------------------------- ;
   (DEFUN A (LAMBDA NIL
      (RR (UNPACK (READ)))
   ))
   ; ------------------- ;
   (DEFUN RR (LAMBDA (LST)
      (COND ( (< (LENGTH LST) 2) NIL )
            ( (AND (EQ (CAR LST) K) (EQ (CADR LST) A)) T )
            (  T  (RR (CDDR LST)) )
      )
   ))

   ; -------------------------------------------------;
   ; Запишите алгоритм, проверяющий есть ли в слове X ;
   ;               две одинаковые буквы               ;
   ; ------------------------------------------------ ;
   (DEFUN MAIN (LAMBDA ()
      (TWOEQ (UNPACK (READ)))
   ))
   ; ---------------------- ;
   (DEFUN TWOEQ (LAMBDA (LST)
      (COND
         ( (NULL LST)                    NIL              )
         ( (MEMBER (CAR LST) (CDR LST))  T                )
         (  T                           (TWOEQ (CDR LST)) )
      )
   ))

   ; -------------------------------------------------- ;
   ; Вычеркнуть из данного слова все буквы, номер кото- ;
   ;                рых в слове кратен 4                ;
   ; -------------------------------------------------- ;
    (DEFUN F (LAMBDA (L)
      (FO (UNPACK L))
    ))
    ; ----------------- ;
    (DEFUN FO (LAMBDA (L)
      (COND ( (NULL L) NIL )
            ( (< (LENGTH L) 4 )  L )
            (  T   (CONS (CAR L)
                         (CONS (CADR L)
                             (CONS (CADDR L)
                                   (FO (CDDR (CDDR L))))))
            )
      )
   ))

   ; ----------------------------------------------- ;
   ; Написать программу для подсчета числа сочетаний ;
   ;               "MU" в заданном слове             ;
   ; ----------------------------------------------- ;
   (DEFUN UU (LAMBDA NIL
      (MU (UNPACK (READ)))
   ))
   ; ------------------- ;
   (DEFUN MU (LAMBDA (LST)
      (COND ( (< (LENGTH LST) 2) 0 )
            ( (AND (EQ (CAR LST) M) (EQ (CADR LST) U))
                  (+ 1 (MU (CDR LST))) )
            (  T  (MU (CDR LST)) )
      )
   ))

   ; -------------------------------------------- ;
   ; Заменить в слове букву "A" на сочетание "KU" ;
   ; -------------------------------------------- ;
   (DEFUN MAIN (LAMBDA ()
      (PACK (INSDEL (UNPACK (READ))))
   ))
   ; ----------------------- ;
   (DEFUN INSDEL (LAMBDA (LST)
      (COND ( (NULL LST) NIL )
            ( (EQ (CAR LST) A)
                   (CONS K (CONS U (INSDEL (CDR LST)))) )
            (   T  (CONS (CAR LST) (INSDEL (CDR LST)))  )
      )
   ))

   ; ------------------------------------------------ ;
   ; Запишите алгоритм проверки, совпадает ли первая  ;
   ;     буква слова Х и последняя буква слова Y      ;
   ; ------------------------------------------------ ;
   (DEFUN PROVFL (LAMBDA (X Y)
      (COND ( (EQ (CAR (UNPACK X))
                  (CAR (REVERSE (UNPACK Y)))) T )
            (  T  NIL  )
      )
   ))

   ; ------------------------------------------------- ;
   ; Выяснить, является ли заданное слово перевертышем ;
   ; ------------------------------------------------- ;
   (DEFUN PER (LAMBDA (W)
      (COND ( (EQUAL (UNPACK W) (REVERSE (UNPACK W))) T )
            (   T   NIL  )
      )
   ))

   ; ------------------------------------------- ;
   ; Составить алгоритм, проверяющий сколько раз ;
   ; первая  буква слова X встречается в слове Y ;
   ; ------------------------------------------- ;
   (DEFUN MAIN (LAMBDA (X Y)
      (RR (CAR (UNPACK X)) (UNPACK Y))
   ))
   ; --------------------- ;
   (DEFUN RR (LAMBDA (Z LST)
      (COND ( (NULL LST) 0 )
            ( (EQ (CAR LST) Z) (+ 1 (RR Z (CDR LST))) )
            (   T  (RR Z (CDR LST)) )
      )
   ))

   ; ------------------------------------------------- ;
   ; Составить алгоритм подсчета суммарного количества ;
   ;            букв "M" и "N" в слове Y               ;
   ; ------------------------------------------------- ;
   (DEFUN MAIN (LAMBDA (Y)
      (+ (BUK M (UNPACK Y))
         (BUK N (UNPACK Y)))
   ))
   ; ---------------------- ;
   (DEFUN BUK (LAMBDA (X LST)
      (COND ( (NULL LST) 0                             )
            ( (EQ (CAR LST) X) (+ 1 (BUK X (CDR LST))) )
            (        T         (BUK X (CDR LST))       )
      )
   ))

   ; ---------------------------------------------------- ;
   ; Напишите программу, позволяющую вычеркнуть букву "B" ;
   ;     (и прописную, и строчную) из заданного слова     ;
   ; ---------------------------------------------------- ;
   (DEFUN V (LAMBDA NIL
      (PACK (REMOVE B (REMOVE b (UNPACK (READ)))))
   ))
   ; --------------------------- ;
   (DEFUN REMOVE (LAMBDA (ATM LST)
   ; Возвращает список, в котором удалены все вхождения ;
   ;                ATM в список LST                    ;
      (COND ( (NULL LST) NIL )
            ( (EQ ATM (CAR LST))
                        (REMOVE ATM (CDR LST)) )
            (   T   (CONS (CAR LST) (REMOVE ATM (CDR LST))) )
      )
   ))

   ; ------------------------------------------------------ ;
   ; Запишите алгоритм, выясняющий сколько раз вторая буква ;
   ; слова LST1 встречается в слове LST2 на четных  местах  ;
   ; ------------------------------------------------------ ;
   (DEFUN KOL (LAMBDA (LST1 LST2)
      (COND ( (NULL LST2) 0 )
            ( (EQ (CADR LST1) (CADR LST2))
                    (+ 1 (KOL LST1 (CDDR LST2))) )
            (   T   (KOL LST1 (CDDR LST2)))
      )
   ))

   ; ------------------------------------------------- ;
   ; Записaть алгоритм проверки, есть ли в слове буква ;
   ; "P". Если есть, то найти номер последней из них   ;
   ;-------------------------------------------------- ;
   (DEFUN MAIN (LAMBDA NIL
      (SETQ LST (UNPACK (READ)))
      (COND ( (MEMBER P LST)
                  (+ 1 (-
                         (LENGTH LST)
                         (POSITION P (REVERSE LST)))) )
            (   T   NIL  )
      )
   ))
   ; --------------------------- ;
   (DEFUN POSITION (LAMBDA (X LST)
      (COND  ( (NULL LST)       0)
             ( (EQ X (CAR LST)) 1)
             ( (MEMBER X LST)
                  (+ 1 (POSITION X (CDR LST))) )
             (  T   0  )
      )
   ))

   ; ----------------------------------------------------- ;
   ; Найти в заданном предложении слово максимальной длины ;
   ; ----------------------------------------------------- ;
   (DEFUN MAXIM (LAMBDA (LST)
      (COND ( (NULL LST) NIL )
            ( (EQ (LENGTH LST) 1) (CAR LST) )
            (   T   (MAX2 (CAR LST) (MAXIM (CDR LST)))  )
      )
   ))
   ; --------------------- ;
   (DEFUN MAX2 (LAMBDA (X Y)
      (COND ( (> (LENGTH (UNPACK X))
                 (LENGTH (UNPACK Y)))  X )
            (  T   Y  )
      )
   ))

   ; --------------------------------------------------- ;
   ; Написать программу, позволяющую определить, сколько ;
   ; различных символов слова A употребляются  в написа- ;
   ;              нии A более одного раза                ;
   ; --------------------------------------------------- ;
   (DEFUN KOLAM (LAMBDA (A)
      (OTO (LIST-SET (TH (UNPACK A) (UNPACK A))))
   ))
   ; ------------------------ ;
   (DEFUN TH (LAMBDA (LST LST0)
   ; Построение нового списка, содержащего элементы вида     ;
   ; (Элемент Количество_повторений_этого_элемента_в_списке) ;
      (COND ( (NULL LST) NIL)
            (  T  (CONS (LIST (CAR LST)
                              (KOL (CAR LST) LST0))
                        (TH (CDR LST) LST0)) ))
   ))
   ; ---------------------- ;
   (DEFUN KOL (LAMBDA (M LST)
   ; Подсчет количества повторений элемента M в списке LST ;
      (COND ( (NULL LST) 0 )
            ( (EQ (CAR LST) M)
                 (+ (KOL M (CDR LST)) 1) )
            (  T  (KOL M (CDR LST)) ))
   ))
   ; ------------------------- ;
   (DEFUN LIST-SET (LAMBDA (LST)
   ; Функция преобразует список LST в множество ;
      (COND ( (NULL LST) NIL )
            ( (MEMBER (CAR LST) (CDR LST))
                (LIST-SET (CDR LST)) )
            (   T   (CONS (CAR LST) (LIST-SET (CDR LST))) )
      )
   ))
   ; -------------------- ;
   (DEFUN OTO (LAMBDA (LST)
      (COND ( (NULL LST) 0 )
            ( (> (CADAR LST) 1)
                    (+ 1 (OTO (CDR LST))) )
            (  T    (OTO (CDR LST)) )
      )
   ))

   ; --------------------------------------------- ;
   ; Из данного предложения выбрать слова, имеющие ;
   ; заданное количество букв (слова в предложении ;
   ;            разделены символом "_")            ;
   ; --------------------------------------------- ;
   (DEFUN W (LAMBDA (N WORD)
      (KUKU (MM N (UNPACK WORD)))
   ))
   ; --------------------- ;
   (DEFUN MM (LAMBDA (N LST)
      (COND ( (NULL LST) NIL )
            ( (EQ (- (POSITION _ LST) 1) N)
                  (APPEND
                       (LIST (NTN N LST))
                       (MM N (MEM _ LST))) )
            (  T  (MM N (MEM _ LST)) )
      )
   ))
   ; ---------------------- ;
   (DEFUN NTN (LAMBDA (N LST)
   ; Функция возвращает первых N элементов списка LST ;
       (COND ( (EQ (LENGTH LST) N)
                   LST)
             (  T  (NTN N (DR LST)) )
       )
   ))
   ; ------------------- ;
   (DEFUN DR (LAMBDA (LST)
   ; Функция удаляет из списка LST последний элемент ;
      (REVERSE (CDR (REVERSE LST)))
   ))
   ; --------------------------- ;
   (DEFUN POSITION (LAMBDA (X LST)
   ; Возвращает положение атома Х в списке LST ;
      (COND ( (NULL LST)       0)
            ( (EQ X (CAR LST)) 1)
            ( (MEMBER X LST)
                 (+ 1 (POSITION X (CDR LST)))  )
            ( T  0 )
      )
   ))
   ; ---------------------- ;
   (DEFUN MEM (LAMBDA (A LST)
   ; Возвращает часть списка LST после вхождения элемента A ;
      (COND ( (NULL LST) NIL )
            ( (EQ (CAR LST) A) (CDR LST) )
            ( T (MEM A (CDR LST)) )
      )
   ))
   ; ----------------------- ;
   (DEFUN APPEND (LAMBDA (X Y)
      (COND ( (NULL X) Y )
            ( T (CONS (CAR X) (APPEND (CDR X) Y)) )
      )
   ))
   ; --------------------- ;
   (DEFUN KUKU (LAMBDA (LST)
      (COND ( (NULL LST) NIL )
            (  T  (CONS (PACK (CAR LST))
                        (KUKU (CDR LST))) )
      )
   ))