;; Гласные буквы русского языка (без изменений)
(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))))
 
;; Разбиение слова на слоги (рекурсивная версия)
(defun split-word (word)
  (labels ((split-word-recursive (chars syllables current index)
             (cond
               ((>= index (length chars)) ; Базовый случай: конец слова
                (if current
                    (if syllables
                        (list
                         (concatenate 'string (car syllables) (coerce (reverse current) 'string))
                         (cdr syllables))
                        (list (coerce (reverse current) 'string)))
                    syllables)) ; return result
 
               (t (let* ((ch (elt chars index))
                         (new-current (cons ch current))) ; Добавляем текущий символ к текущему слогу
                    (cond
                      ((vowel-p ch)
                       (if (yot-after-vowel-p chars index)
                           (let* ((next-index (+ index 2))
                                  (yot-char (elt chars (1+ index)))
                                  (new-current-with-yot (cons yot-char new-current))
                                  (new-syllable (coerce (reverse new-current-with-yot) 'string))
                                  (new-syllables (cons new-syllable syllables)))
                               (split-word-recursive chars new-syllables nil next-index)) ; start new
                           (let* ((new-syllable (coerce (reverse new-current) 'string))
                                  (new-syllables (cons new-syllable syllables))
                                  (next-index (1+ index)))
                               (split-word-recursive chars new-syllables nil next-index)))) ; start new
                      (t (split-word-recursive chars syllables new-current (+ index 1))))))))) ; next char
     (reverse (split-word-recursive (coerce word 'list) nil nil 0)))) ; Start
 
 
;; Разбиение строки на слова (рекурсивная версия)
(defun split-string (str)
  (labels ((split-string-recursive (str words current index)
             (cond
               ((>= index (length str))
                (if current
                    (reverse (cons (coerce (reverse current) 'string) words))
                    (reverse words))) ; return result
               (t (let ((ch (char str index)))
                    (if (char= ch #\Space)
                        (if current
                            (split-string-recursive str (cons (coerce (reverse current) 'string) words) nil (+ index 1))
                            (split-string-recursive str words nil (+ index 1))) ; space
                        (split-string-recursive str words (cons ch current) (+ index 1)))))))) ;next char
     (split-string-recursive str nil nil 0))) ; Start
 
 
;; Главная функция с использованием 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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