> Erik Naggum wrote:
>
> > (defun count-member (symbols tree)
> > (let* ((counts (loop for symbol in symbols collect (cons symbol 0)))
> > (lists (list tree))
> > (tail lists))
> > (dolist (list lists)
> > (dolist (element list)
> > (cond ((consp element)
> > (setf tail (setf (cdr tail) (list element))))
> > ((member element symbols :test #'eq)
> > (incf (cdr (assoc element counts :test #'eq)))))))
> > counts))
>

Testing:

* (count-member '(w x y z) '(a x (b y y (z) z)))

((W . 0) (X . 1) (Y . 0) (Z . 0))

It only counts the top-level symbols!

Gauche Scheme and Racket:

(require srfi/1) ;; iota for Racket

(define (countsyms syms tree)
(let ((index (map cons syms (iota (length syms))))
(counts (make-vector (length syms) 0)))
(define (count sym)
(let ((i (cond ((assoc sym index) => cdr) (else #f))))
(when i (vector-set! counts i (+ 1 (vector-ref counts i))))))
(let loop ((tree tree))
(unless (null? tree)
(if (symbol? (car tree))
(count (car tree))
(loop (car tree)))
(loop (cdr tree))))
(map cons (map car index) (vector->list counts))))

(countsyms '(w x y z) '(a x (b y y (z) z)))
===>
((w . 0) (x . 1) (y . 2) (z . 2))