#lang racket

(require racket/trace)

(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-counting lst [acc '()])
  (cond
    [(null? lst) acc]
    [(null? acc)
     (group-counting (cdr lst) (cons `(,(car lst) . 1) acc))]
    [else
     (let* [(last-acc (car acc))
            (last-elt (car last-acc))
            (cur-elt (car lst))
            (new-acc (if (eqv? cur-elt last-elt)
                         (cons (cons last-elt (add1 (cdr last-acc))) (cdr acc))
                         (cons `(,cur-elt . 1) acc)))]
       (group-counting (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<?))
         (grouped (group-counting sorted-chars))
         (sorted-occurs (sort grouped > #:key cdr))]
    sorted-occurs))

(define (average-list lst [acc '(0 . 0)])
  (cond
    [(null? lst) (/ (car acc) (cdr acc))]
    [else
     (average-list (cdr lst) (cons (+ (car acc) (car lst))
                                   (add1 (cdr acc))))]))

(define (split-list n lst)
  (define (iter lst k segment acc)
    (cond
      [(null? lst)
       (let [(final-acc (if (null? segment)
                            acc
                            (cons (reverse segment) acc)))]
         (reverse final-acc))]
      [(zero? k)
       (iter lst n '() (cons (reverse segment) acc))]
      [else
       (iter (cdr lst) (sub1 k) (cons (car lst) segment) acc)]))
  (iter lst n '() '()))

(define (n-block-average n lst)
  (map average-list (split-list n lst)))