• Seznámení s prostředím PLT DrRacket
• Syntax jazyka, základní funkce, atomy, seznamy, quote, akumulátor, komentáře (“;”, “#;”, “#|” “|#”)

(define (sudy? as)
  (if (null? as)
      #t
      (if (null? (cdr as))
          #f
          (sudy? (cddr as))
)))
 
(define (delka as)
  (if (null? as) 0 (+ 1 (delka (cdr as))))
)
 
(define (odeber as)
  (if (null? (cdr as))
      '()
      (cons (car as) (odeber (cdr as)))
))
 
(define (spoj as bs)
  (if (null? as)
      bs
      (cons (car as) (spoj (cdr as) bs))
))
 
(define (pridej as a)
  (spoj as (list a))
)
 
(define (otoc as)
  (if (null? as)
      '()
      (pridej (otoc (cdr as)) (car as))
))
 
; verze otoc s akumulatorem
(define (otoc-akum as akum)
  (if (null? as)
      akum
      (otoc-akum (cdr as) (cons (car as) akum))
))
 
(define (otoc-rychle as)
  (otoc-akum as '())
)

• list, equal?
• zadání 1. domácí úlohy

(define (rozdel ls pivot)
  (if (null? ls)
      (cons '() '())
      (let* ((x (car ls))
             (res (rozdel (cdr ls) pivot))
             (fst (car res))
             (snd (cdr res)))
        (if (< x pivot)
            (cons (cons x fst) snd)
            (cons fst (cons x snd))
))))
 
(define (quicksort ls)
  (if (null? ls)
      '()
      (let* ((pivot (car ls))
             (roz (rozdel (cdr ls) pivot))
             (mensi (car roz))
             (vetsi (cdr roz)))
        (append (quicksort mensi)
                (cons pivot (quicksort vetsi)))
)))
 
 
(define left-turns '(north west south east north))
 
(define (next a as)
  (if (equal? a (car as))
      (cadr as)
      (next a (cdr as))
))
 
(define (turn-left orientace)
  (next orientace left-turns)
)

• map

(define (get-nth as n)
  (if (= n 0) (car as) (get-nth (cdr as) (- n 1)))
)
 
(define (set-nth as n a)
  (if (= n 0)
      (cons a (cdr as))
      (cons (car as) (set-nth (cdr as) (- n 1) a))
))
 
(define (maze-update maze coord a)
  (let* ((x (car coord))
         (y (cadr coord))
         (row (get-nth maze x))
         (new (set-nth row y a)))
    (set-nth maze x new)
))
 
(define (map1 f as)
  (if (null? as) '() (cons (f (car as)) (map1 f (cdr as))))
)
 
(define (map-many f as . ass)
  (if (null? as) '()
      (cons
       (apply f (map1 car (cons as ass)))
       (apply map-many f (map1 cdr (cons as ass)))
)))
 
(define (transpose matrix)
  (apply map list matrix)
)
 

• call-with-current-continuation
• fold-right, fold-left
• zadání 2. domácí úlohy

(define (nasob . args)
  (if (null? args) 1
      (* (car args) (apply nasob (cdr args)))))
 
(define (rychle-nasob . args)
  (if (null? args) 1
      (if (= (car args) 0) 0
          (* (car args) (apply rychle-nasob (cdr args))))))
 
(define (super-rychle-nasob . args)
  (define (nasob exit)
    (define (n ls)
      (if (null? ls) 1
          (if (= (car ls) 0) (exit 0)
              (* (car ls) (n (cdr ls))))))
    (n args)
    )
  (call-with-current-continuation nasob)

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

• generátor permutací
• zadání 3. domácí úlohy

(define (perm ls)
  (if (null? (cdr ls)) (list ls)
      (spoj-seznamy (map (lambda (p)
                           (vloz-prvek-do-seznamu (car ls) p))
                         (perm (cdr ls))))
      ))
 
(define (vloz-prvek-do-seznamu e ls)
  (if (null? ls) (list (list e))
      (cons (cons e ls)
            (map (lambda (as) (cons (car ls) as))
                 (vloz-prvek-do-seznamu e (cdr ls))
                 )
            )))
 
(define (spoj-seznamy lss)
  (cond ((null? lss) '())
        ((null? (cdr lss)) (car lss))
        (else (spoj-seznamy (cons
                             (append (car lss) (cadr lss))
                             (cddr lss))))
        ))
 
; alternativa
 
(define (vloz-vsude e ls)
  (define (cons-car-ls xs) (cons (car ls) xs))
  (if (null? ls) 
      (list (list e))
      (let ((rec (vloz-vsude e (cdr ls))))
        (cons (cons e ls) (map cons-car-ls rec))
)))
 
(define (permutace ls)
  (define (vloz-car-vsude xs) (vloz-vsude (car ls) xs))
  (if (null? (cdr ls)) 
      (list ls)
      (let ((rec (permutace (cdr ls))))
        (apply append (map vloz-car-vsude rec))
)))
 

(define (power-set ls)
  (if (null? ls) (list ls)
      (let* (
             (mezivysledek (power-set (cdr ls)))
             (pridavek (map (lambda (xs) (cons (car ls) xs)) mezivysledek))
             )
        (append mezivysledek pridavek)
        )))
 
; alternativa
 
(define (podmnoziny ls)
  (define (cons-car-ls xs) (cons (car ls) xs))
  (if (null? ls) 
      (list ls)
      (let ((rec (podmnoziny (cdr ls))))
        (append rec (map cons-car-ls rec))
)))