===== Tutorial 1 =====

  * Introduction to IDE [[http://racket-lang.org/ | PLT DrRacket]]
  * Basic syntax, functions, atoms, lists, quote

<code scheme>
(define (is_even? ls)
  (if (null? ls)
      #t
      (is_odd? (cdr ls))
      ))
(define (is_odd? ls)
  (if (null? ls)
      #f
      (is_even? (cdr ls))
      ))
</code>

<code scheme>      
(define (is-even? ls)
  (if (null? ls)
      #t
      (if (null? (cdr ls))
          #f
          (is-even? (cddr ls))
          )))          
</code>

<code scheme>
(define (len ls)
  (if (null? ls)
      0
      (+ 1 (len (cdr ls))))
  )
</code>

<code scheme>
(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)))))

</code>

<code scheme>
(define (rev2 ls temp)
  (if (null? ls) temp
      (rev2 (cdr ls) (cons (car ls) temp))))
(define (efficient_rev ls)
  (rev2 ls '()))

</code>

<code scheme>
(define (mid ls)
  (mid2 ls ls))

(define (mid2 as bs)
  (if (null? (cdr as)) (car bs)
      (mid2 (cddr as) (cdr bs))))
</code>
===== Tutorial 2 =====

<code scheme>
(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)
       )
     )))  
</code>

===== Tutorial 3 =====

<code scheme>
(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))))
      </code>

===== Tutorial 4 =====

<code scheme>
(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))))</code>

===== Tutorial 5 =====

<code scheme>
</code>