Определить рекурсивную функцию, собирающую числа и символы в отдельные списки

(defun cinderella (w &optional n s &aux (a (car w)))
  (cond ((null w) (list (reverse n) (reverse s)))
        ((numberp a) (cinderella (cdr w) (cons a n) s))
        ((cinderella (cdr w) n (cons a s)))))
 
> (cinderella '(v a 1 3 y 5 f y))
((1 3 5) (V A Y F Y))

(defun cinderella (w &optional n s &aux (a (car w)))
  (cond ((null w) (list (reverse n) (reverse s)))
        ((numberp a) (cinderella (cdr w) (cons a n) s))
        ((symbolp a) (cinderella (cdr w) n (cons a s)))
        ((cinderella (cdr w) n s))))
 
> (cinderella '(v a "ab" 1 3 y 5 f (6 7) y))
((1 3 5) (V A Y F Y))

(defun task (list)
  (let ((a nil)
        (b nil))
     (iter (for x in list) (if (numberp x) (collecting x into a) (collecting x into b)))
     (list a b))) 
 
==> TASK
 
(task '(1 q 2 w 3 4 c v))
==> ((1 2 3 4) (Q W C V))

(defun core (list num-list sym-list)
   (cond ((null list) (list num-list sym-list))
         ((numberp (car list))  (core (cdr list) (cons (car list) num-list) sym-list))
         (t (core (cdr list) num-list (cons (car list) sym-list)))))
 
==> CORE
 
(defun task (list)
  (core list nil nil))
 
==> TASK
 
(task '(1 q w 2 3 x 2))
 
==> ((2 3 2 1) (X W Q))
 
;; А если требуется сохранить порядок - то так:
 
(defun task (list)
  (core (reverse list) nil nil))   ;; reverse - стандартная функция CL, если что...
 
==> TASK
 
(task '(1 q w 2 3 x 2))
==> ((1 2 3 2) (Q W X))

(define (f fn lst)
    (let loop ([lst lst]
               [one empty]
               [two empty]
               [acc_one 0]
               [acc_two 0])
      (if (null? lst)
          (list acc_one one  acc_two two)
          (if (fn (car lst))
              (loop (cdr lst) (cons (car lst) one) two (add1 acc_one) acc_two)
              (loop (cdr lst) one (cons (car lst) two) acc_one (add1 acc_two))))))
 
 
  (f (lambda (x) (number? x)) '(1 a 2 b 3 c 4 d))
 
'(4 (4 3 2 1) 4 (d c b a))

(defn splitter [fn lst] [(filter #(fn %) lst) (filter #(not (fn %)) lst)])
(splitter number? '(1 a 2 b c 3))
=> [(1 2 3) (a b c)]