(define conta-letras
  (lambda (frase letra)
    (letrec((aux
             (lambda (i contador)
               (if(equal? i (string-length frase))
                   contador
                   (if(char-ci=? letra (string-ref frase i))
                      (aux (add1 i) (add1 contador))
                      (aux (add1 i) contador))))))
      (aux 0 0))))

(define nomes (vector "Aa" "a" "A"))

(define conta-vogais
  (lambda (v)
    (letrec((aux
             (lambda (v1 i j)
               (if(equal? j (vector-length v))
                  v1
                  (if(equal? i (string-length (vector-ref v j)))
                     (aux v1 0 (add1 j))
                     (begin
                       (cond
                         ((char-ci=? (string-ref (vector-ref v j) i) #\a) (vector-set! v1 0 (add1 (vector-ref v1 0))))
                         ((char-ci=? (string-ref (vector-ref v j) i) #\e) (vector-set! v1 1 (add1 (vector-ref v1 1))))
                         ((char-ci=? (string-ref (vector-ref v j) i) #\i) (vector-set! v1 2 (add1 (vector-ref v1 2))))
                         ((char-ci=? (string-ref (vector-ref v j) i) #\o) (vector-set! v1 3 (add1 (vector-ref v1 3))))
                         ((char-ci=? (string-ref (vector-ref v j) i) #\u) (vector-set! v1 4 (add1 (vector-ref v1 4)))))
                       (aux v1 (add1 i) j)))))))
      (aux (vector 0 0 0 0 0) 0 0))))

(define delete
  (lambda (item list)
    (cond
     ((equal? item (car list)) (cdr list))
     (else (cons (car list) (delete item (cdr list)))))))



(define acumula!
  (lambda (lista)
    (letrec((aux
             (lambda(i j)
               (if(not(equal? j (length lista)))
                  (if(equal? (+ i j) (length lista))
                     (aux 1 (add1 j))
                     (if(equal? (car (list-ref lista j)) (car (list-ref lista (+ i j))))
                        (begin
                          (set-cdr! (list-ref lista j) (+ (cdr (list-ref lista j)) (cdr (list-ref lista (+ i j)))))
                          (set-cdr! lista (delete (list-ref lista (+ i j)) (cdr lista)))
                          (aux i j))
                        (aux (add1 i) j)))))))
            (aux 1 0))))