#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)))]))

(module+ test
  (check-equal? (my-reverse '(1 2 3 4)) '(4 3 2 1)))

(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)
     (group-lengths (cdr lst)
                    `((,(car lst) . 1)))]
    [else
     (let* [(last-char (caar acc))
            (last-count (cdar acc))
            (cur-char (car lst))
            (new-acc (if (eqv? cur-char last-char)
                         (cons (cons last-char
                                     (add1 last-count))
                               (cdr acc))
                         (cons (cons cur-char 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))
         (grouped (group-by identity alphabetic))
         (lengths (map (lambda (lst) (cons (car lst) (length lst))) grouped))
         (sorted-occurs (sort lengths > #:key cdr))]
    sorted-occurs))

(module+ test
  (check-equal? (letter-frequencies "good")
                '((#\o . 2) (#\g . 1) (#\d . 1))))