#lang racket

; TODO 1
(define (pair-to-index L)
  (map cons L (range (length L))))

; TODO 2
(define (split-cipher L)
  (define aux (pair-to-index L))
  (map car
       (append (filter (compose even? cdr) aux)
               (filter (compose odd? cdr) aux))))

; TODO 3
(define (scytale-cipher L n)
  (define aux (pair-to-index L))
  (map car
       (apply append
              (map (λ (pos) (filter (λ (p) (= pos (modulo (cdr p) n))) aux))
                   (range n)))))

; TODO 4
(define (most-frequent L)
  (define (freq x) (length (filter (curry equal? x) L)))
  (let loop ((L (cdr L)) (best (car L)) (f (freq (car L))))
    (if (null? L)
        best
        (let ((f* (freq (car L))))
          (if (> f* f)
              (loop (cdr L) (car L) f*)
              (loop (cdr L) best f))))))

; TODO 5
(define (key-stream alphabet text)
  (define aux (pair-to-index alphabet))
  (let loop ((t text))
    (if (null? t)
        (loop text)
        (stream-cons (cdar (filter (λ (p) (equal? (car p) (car t))) aux))
                     (loop (cdr t))))))

; TODO 6
(define (make-infinite-stream s)
  (let loop ((curr s) (dx 0))
    (if (stream-empty? curr)
        (loop s (- 1 dx))
        (stream-cons (+ dx (stream-first curr))
                     (loop (stream-rest curr) dx)))))