#lang racket

;;; Exercise 01

(define (list-len a)
  (if (null? a)
    0
    (add1 (list-len (cdr a)))))

;;; Exercise 02

(define (list-contains lst elem)
  (cond [(null? lst) #f]
        [(= (car lst) elem) #t]
        [else (list-contains (cdr lst) elem)]))

;;; Exercise 03

(define (list-insert lst elem ind)
  (if (= ind 0)
    (list* elem lst)
    (list* (car lst) (list-insert (cdr lst) elem (sub1 ind)))))

;;; Exercise 04

(define (list-min lst)
  (define (calc-iter lst minel)
    (cond [(null? lst) minel]
          [(< (car lst) minel) (calc-iter (cdr lst) (car lst))]
          [else (calc-iter (cdr lst) minel)]))
  (calc-iter lst (car lst)))

;;; Exercise 05

(define (remove-first lst elem)
  (if (= (car lst) elem)
    (cdr lst)
    (if (null? (cdr lst))
      lst
      (list* (car lst) (remove-first (cdr lst) elem)))))

;;; Exercise 06

(define (remove-elem lst elem)
  (if (null? lst)
    lst
    (if (= (car lst) elem)
      (remove-elem (cdr lst) elem)
      (list* (car lst) (remove-elem (cdr lst) elem)))))

;;; Exercise 07

(define (list-concat lst1 lst2)
  (if (null? lst1)
    lst2
    (if (null? (cdr lst1))
      (list* (car lst1) lst2)
      (list* (car lst1) (list-concat (cdr lst1) lst2)))))

;;; Exercise 08

(define (list-rev lst)
  (define (calc-iter toret lst)
    (if (null? lst)
      toret
      (calc-iter (list-insert toret (car lst) 0) (cdr lst))))
  (calc-iter '() lst))

;;; Exercise 09

(define (remove-duplicates subxs xs)
  (if (= (car xs) subxs)
    (list* (car xs) (remove-elem (cdr xs) subxs))
    (list* (car xs) (remove-duplicates subxs (cdr xs)))))

;;; Exercise 10

(define (sublist-between start end xs)
  (cond [(> start 0) (sublist-between (sub1 start) (sub1 end) (cdr xs))]
        [(> end 1) (list* (car xs) (sublist-between 0 (sub1 end) (cdr xs)))]
        [else (list (car xs))]))

;;; Exercise 11

(define (count-occurrences subxs xs)
  (define (calc-iter occs lst)
    (if (null? lst)
      occs
      (calc-iter (if (= (car lst) subxs) (add1 occs) occs)
                 (cdr lst))))
  (calc-iter 0 xs))