• Introduction to IDE PLT DrRacket
• Basic syntax, functions, atoms, lists, quote

(define (is_even? ls)
  (if (null? ls)
      #t
      (is_odd? (cdr ls))
      ))
(define (is_odd? ls)
  (if (null? ls)
      #f
      (is_even? (cdr ls))
      ))

(define (is-even? ls)
  (if (null? ls)
      #t
      (if (null? (cdr ls))
          #f
          (is-even? (cddr ls))
          )))          

(define (len ls)
  (if (null? ls)
      0
      (+ 1 (len (cdr ls))))
  )

(define (last ls)
  (if (null? (cdr ls))
      (car ls)
      (last (cdr ls))))
 
(define (without_last ls)
  (if (null? (cdr ls)) '()
      (cons (car ls) (without_last (cdr ls)))))
 
(define (rev ls)
  (if (null? ls) '()
      (cons (last ls) (rev (without_last ls)))))

(define (rev2 ls temp)
  (if (null? ls) temp
      (rev2 (cdr ls) (cons (car ls) temp))))
(define (efficient_rev ls)
  (rev2 ls '()))

(define (mid ls)
  (mid2 ls ls))
 
(define (mid2 as bs)
  (if (null? (cdr as)) (car bs)
      (mid2 (cddr as) (cdr bs))))

(define (split ls)
  (cond
    ((null? ls) (cons '() '()))
    ((null? (cdr ls)) (cons ls '()))
    (else
     (let* ((a (car ls))
            (b (cadr ls))
            (rs (cddr ls))
            (p (split rs))
            )
       (cons (cons a (car p)) (cons b (cdr p)))
       ))))
 
(define (merge as bs)
  (cond
    ((null? as) bs)
    ((null? bs) as)
    ((<= (car as) (car bs))
     (cons (car as) (merge (cdr as) bs)))
    (else (merge bs as))
    )
  )
 
(define (merge-sort ls)
  (cond
    ((null? ls) ls)
    ((null? (cdr ls)) ls)
    (else
     (let* ( (p (split ls))
             (as (car p))
             (bs (cdr p))
             (sas (merge-sort as))
             (sbs (merge-sort bs))
             )  
       (merge sas sbs)
       )
     )))  

(define (my-map f ls)
  (if (null? ls) ls
      (cons (f (car ls)) (my-map f (cdr ls)))
      ))
 
(define (full-map f ls . args)
  (if (null? ls) ls
      (let* (
             (as (cons ls args))
             (fs (my-map car as))
             (fa (apply f fs))
             (gs (my-map cdr as))
             (rs (apply full-map f gs))
             )
        (cons fa rs)
        )))
 
(define (tr matrix) (apply map list matrix))
 
(define (list-update ls pos new)
  (if (= pos 0) (cons new (cdr ls))
      (cons (car ls) (list-update (cdr ls) (- pos 1) new))))
 
(define (matrix-update matrix row col new)
  (if (= row 0) (cons (list-update (car matrix) col new)
                      (cdr matrix))
      (cons (car matrix)
            (matrix-update (cdr matrix) (- row 1) col new))))
 

(define (multiply . args)
  (if (null? args) 1
      (* (car args) (apply multiply (cdr args)))))
 
(define (fast-multiply . args)
  (if (null? args) 1
      (if (= (car args) 0) 0
          (* (car args) (apply fast-multiply (cdr args))))))
 
(define (super-fast-multiply . args)
  (define (mult exit)
    (define (m ls)
      (if (null? ls) 1
          (if (= (car ls) 0) (exit 0)
              (* (car ls) (m (cdr ls))))))
    (m args)
    )
  (call-with-current-continuation mult)
  )
 
(define (fold-right f ls v)
  (if (null? ls) v
      (f (car ls) (fold-right f (cdr ls) v))))
 
(define (fold-left f v ls)
  (if (null? ls) v
      (fold-left f (f v (car ls)) (cdr ls))))