;; Гласные буквы русского языка
(defun vowel-p (char)
  (member char '(#\а #\е #\ё #\и #\о #\у #\ы #\э #\ю #\я
                 #\А #\Е #\Ё #\И #\О #\У #\Ы #\Э #\Ю #\Я)
          :test #'char=))
 
;; Согласные буквы русского языка
(defun consonant-p (char)
  (not (vowel-p char)))
 
;; Функция для проверки наличия "й" после гласной
(defun yot-after-vowel-p (chars index)
  (and (< (1+ index) (length chars))
       (char= (elt chars (1+ index)) #\й)
       (vowel-p (elt chars index))))
 
 
;; Разбиение слова на слоги по правилам русского языка (рекурсивная версия без SETF)
(defun split-word (word)
  (labels ((split-word-recursive (chars syllables current i)
             (cond
               ((>= i (length chars)) ; Базовый случай: конец слова
                (if current
                    (reverse (cons (coerce (reverse current) 'string) syllables))
                    (reverse syllables)))
               (t
                (let ((ch (elt chars i)))
                  (cond
                    ((vowel-p ch)
                     (if (yot-after-vowel-p chars i)
                         (split-word-recursive chars
                                               (cons (coerce (reverse (cons (elt chars (1+ i)) current)) 'string) syllables)
                                               nil
                                               (+ i 2))
                         (split-word-recursive chars
                                               (cons (coerce (reverse (cons ch current)) 'string) syllables)
                                               nil
                                               (1+ i))))
                    (t
                     (split-word-recursive chars
                                           syllables
                                           (cons ch current)
                                           (1+ i)))))))))  ; Закрывающая скобка для let
    (split-word-recursive (coerce word 'list) nil nil 0)))
 
;; Разбиение строки на слова (рекурсивная версия без SETF)
(defun split-string (str)
  (labels ((split-string-recursive (str current-word words)
             (cond
               ((null str)  ; Базовый случай: достигли конца строки
                (if current-word
                    (reverse (cons (coerce (reverse current-word) 'string) words)) ; Добавляем последнее слово и возвращаем
                    (reverse words))) ; Возвращаем накопленные слова
               ((char= (car str) #\Space)  ; Разделитель - пробел
                (if current-word
                    (split-string-recursive (cdr str) nil (cons (coerce (reverse current-word) 'string) words)) ; Добавляем слово, начинаем новое
                    (split-string-recursive (cdr str) nil words))) ; Пропускаем пробел
               (t  ; Добавляем символ к текущему слову
                (split-string-recursive (cdr str) (cons (car str) current-word) words))))) ; Рекурсивный вызов
    (split-string-recursive (coerce str 'list) nil nil))) ; Запускаем рекурсию
 
 
;; Главная функция с использованием MAPCAR
(defun split-phrase (phrase)
  (mapcar #'split-word (split-string phrase)))  ; Using MAPCAR
 
;; Тест
(print (split-phrase "написать программу"))
(print (split-phrase "дана фраза на русском языке"))
(print (split-phrase "война, мир, эвакуатор"))
(print (split-phrase "скамейка"))
(print (split-phrase "ванна"))
(print (split-phrase "коллекция"))
(print (split-phrase "чай"))

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