#lang racket

; TODO 1
(define (chunk L n)
    (cond ((null? L) '())
          ((<= (length L) n) (list L))
          (else (cons (take L n) (chunk (drop L n) n)))))

; TODO 2
(define (split2 L)
  (define len (length L))
  (define (sum L) (apply + L))
  (filter (λ (p) (< (sum (first p)) (sum (second p))))
          (let loop ((lenA 0))
            (if (> lenA len)
                '()
                (cons (list (take L lenA) (drop L lenA))
                      (loop (+ lenA 1)))))))

; TODO 3
(define (between-occurences L x)
  (define last-x (member x (reverse L)))
  (if last-x
      (member x (reverse last-x))
      '()))
        
; TODO 4
(define (pairs L s)
  (map (λ (x) (cons x (- s x)))
       (filter (λ (x) (and (< (* 2 x) s) (member (- s x) L)))
               L)))		

; TODO 5
(define (stream-group s)
  (if (stream-empty? s)
      s
      (let loop ((s (stream-rest s)) (group (list (stream-first s))))
        (cond
          ((stream-empty? s)
           (stream-cons group empty-stream))
          ((equal? (stream-first s) (car group))
           (loop (stream-rest s) (cons (car group) group)))
          (else
           (stream-cons group (loop (stream-rest s) (list (stream-first s)))))))))

; TODO 6
(define (stream-encode s)
  (stream-map (λ (group) (if (< (length group) 3) group (cons (car group) (length group))))
              s))