Do you understand apply? apply + gives you the first element of the
result you want.

(let ((lst '(0 1 1 1)))
  (apply + lst))
   => 3

Do you understand map? map lets you transform your original list. You
might want a transformation like:
(0 1 1 1) => (1 0 0 0)

(map (lambda (n) (- 1 n)) '(0 1 1 1))
  => (1 0 0 0)

Now you can get the second element of your desired result:
(let ((lst '(0 1 1 1))
       (flip (lambda (n) (- 1 n))))
  (apply + (map flip lst)))
   => 1

thus,
(define (num_right&wrong lst)
  (let ((flip (lambda (n) (- 1 n))))
   (list
    (apply + lst)
    (apply + (map flip lst))))

(num_right&wrong '(0 1 1 1))
   => (3 1)

demonstrates what you want.

There are many other ways to do it. The "schemish" way is to iterate
through a list using a tail recursive function:

(define (num_right&wrong lst)
   (letrec
    ((sum_them
      (lambda (lst right wrong)
        (cond
         ((null? lst)
          (list right wrong))
         ((zero? (car lst))
          (sum_them (cdr lst) right (+ wrong 1)))
         (else
          (sum_them (cdr lst) (+ right 1) wrong))))))
    (sum_them lst 0 0)))

(num_right&wrong '(0 1 1 1))
  => (3 1)