#lang racket
(require racket/trace)

(module+ test
  (require rackunit))

(define (my-reverse lst)
  (cond
    [(null? lst) '()]
    [else
     (append (my-reverse (cdr lst)) (list (car lst)))]))

(define (my-reverse-2 lst [acc '()])
  (cond
    [(null? lst) acc]
    [else
     (my-reverse-2
      (cdr lst)
      (cons (car lst)
            acc))]))

(define (group-lengths lst [acc '()])
  (cond
    [(null? lst) acc]
    [(null? acc)
     ; (list (cons (car lst) 1))
     ; => `((,(car lst) . 1))
     (group-lengths (cdr lst) `((,(car lst) . 1)))]
    [else (let* [(elt (car lst))
                 (cur-acc (car acc))
                 (last-elt (car cur-acc))
                 (last-count (cdr cur-acc))
                 (new-acc (if (eqv? elt last-elt)
                              (cons (cons elt (add1 last-count))
                                    (cdr acc))
                              (cons (cons elt 1)
                                    acc)))]
            (group-lengths (cdr lst) new-acc))]))

(define (letter-frequencies str)
  (let* [(lowercase (string-downcase str))
         (listified (string->list lowercase))
         (alphabetic (filter char-alphabetic? listified))
         (sorted-chars (sort alphabetic char<?))
         (lengths (group-lengths sorted-chars))
         (sorted-occurs (sort lengths (lambda (a b) (> (cdr a) (cdr b)))))]
    sorted-occurs))