Рекурсивный проход по списку. Вложенность

'(a b c (d e (f g (O U Y))) j x y)

'("abc" ("de" ("fg" ("YUO"))) "yxj")

(define (lst? lst)
  (if (empty? lst)
      #f
      (if (list? (car lst))
          #t
          (lst? (rest lst)))))
 
 
(lst? '(a b c (d e (f g (O U Y))) j x y))
 
=> #t
 
(define (revstr str)
  (let ([st (string->list str)])
    (let loop ([st st])
    (if (empty? st)
        ""
    (string-append  (string (last st)) (loop (remove (last st) st)))))))
 
(revstr "psiL")
 
=> "Lisp"
 
(define (str lst [acc ""])
  (cond ((empty? lst) (cons acc lst))
        ((list? (car lst))
          (cons (revstr acc) (list (str (if (lst? (car lst)) (append (car lst) (rest lst))  (car lst)) ""))))
          (#t (str (rest lst) (string-append (symbol->string (car lst)) acc)))))
 
(str '(a b c (d c a (f z (w w))) z x e))
 
=> ("abc" ("dca" ("fz" ("ww"))))
 
 
 
(define (fun lst [acc ""])
  (if (empty? lst)
      (cons acc lst)
      (if (symbol? (car lst))
          (fun (rest lst) (string-append (symbol->string (car lst)) acc))
          (append  (if (list? (car lst)) (list (revstr acc) (str (car lst))) acc) (fun (rest lst) "")))))
 
 
(fun '(a b c (d e (f g (O U Y))) j x y))
 
=>'("abc" ("de" ("fg" ("YUO"))) "yxj")

'("abc" ("de" ("fg" ("YUO"))) "yxj")

(fun '(a b c (d e (f g (O U Y) M I L K)) j x y))

(define (fun lst [acc ""])
  (if (empty? lst)
      (cons (revstr acc) lst)
      (if (symbol? (car lst))
          (fun (rest lst) (string-append (symbol->string (car lst)) acc))
          (append  (if (list? (car lst)) (list (revstr acc) (str (car lst))) acc) (fun (rest lst) "")))))
 
 
(fun '(a b c (d e (f g (O U Y) M I L K)) j x y))
=> '("abc" ("de" ("fg" ("OUY"))) "jxy")

(defun task (list &optional (acc ""))
  (cond ((null list) (if (eq "" acc) nil (list acc)))
        ((atom (car list)) (task (cdr list) (strCat acc (implode (append (list '&dq) (explode (car list)) (list '&dq))  ))))
        (t (cons acc (cons (task (car list) "") (task (cdr list) ""))))))
 
==> TASK
 
(task '(a b c (d e (f g (O U Y))) j x y))
==> ("ABC" ("DE" ("Fg" ("OUY"))) "jXY")
 
(task '(a b c (d e (f g (O U Y) M I L K)) j x y))
==> ("ABC" ("DE" ("Fg" ("OUY") "MILK")) "jXY")

(explode 'qwerty)
==> (Q W E R T Y)
 
(implode  '(q w e r t y))
==> QWERTY

(implode  '(&DQ q w e r t y &DQ))
==> "QWERTY"

#lang racket
 
(define (strings xs)
  (define (cons-str s list)
    (match s
      (""  list)
      (_  (cons s list))))
  (for/fold ((result '())
             (buffer "")
             #:result (reverse (cons-str buffer result)))
            ((x xs))
    (match x
      ((? symbol?)
       (values result
               (string-append buffer (symbol->string x))))
      ((? list?)
       (values (cons (strings x) (cons-str buffer result))
               ""))
      (_ (error 'strings "expected symbol? or list?, given: ~s" x)))))
 
(define (main)
  (printf "~s~n" (strings '(a b c (d e (f g (O U Y))) j x y))))