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

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

(define (spoj as bs)
  (if (null? as) bs
      (cons (car as) (spoj (cdr as) bs))))

(define (bez-posledniho ls)
  (if (null? (cdr ls)) '()
      (cons (car ls) (bez-posledniho (cdr ls)))))
 
(define (pomaly-rev ls)
  (if (null? ls) '()
      (cons (posledni ls) (pomaly-rev (bez-posledniho ls)))))

(define (gen2 acc n)
  (if (= n 0) acc
      (gen2 (cons n acc) (- n 1)))) 
 
(define (generuj n) (gen2 '() n)) 

(define (rev2 acc ls)
  (if (null? ls) acc
      (rev2 (cons (car ls) acc) (cdr ls))))
 
(define (rev ls) (rev2 '() ls))

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

(define (quick-sort ls)
  (cond ((null? ls) ls)
        ((null? (cdr ls)) ls)
        (else
         (let* ((pivot (car ls))
                (r (rozdel pivot (cdr ls)))
                (as (quick-sort (car r)))
                (bs (quick-sort (cdr r)))
                )
           (append as (cons pivot bs)))
         )
        ))
 
(define (rozdel pivot ls)
  (if (null? ls) '(().())
      (let* (
             (prvni (car ls))
             (r (rozdel pivot (cdr ls)))
             (as (car r))
             (bs (cdr r))
             )
        (if (<= prvni pivot)
            (cons (cons prvni as) bs)
            (cons as (cons prvni bs))
            ))))

(define (bubble-sort ls)
  (bubble-sort2 ls ls))
 
(define (bubble-sort2 cs ls)
  (if (null? cs) ls
      (bubble-sort2 (cdr cs) (bubble ls))
      ))
 
(define (bubble ls)
  (cond ((null? ls) ls)
        ((null? (cdr ls)) ls)
        (else (let (
                    (a (car ls))
                    (b (cadr ls))                
                    )
                (if (<= a b)
                    (cons a (bubble (cdr ls)))
                    (cons b (bubble (cons a (cddr ls))))
                    )))))

(define (list-update ls nth element)
  (if (= nth 0) (cons element (cdr ls))
      (cons (car ls) (list-update (cdr ls) (- nth 1) element))))

;implementace vestavěné funkce (list-ref)
(define (list-nth ls nth)
  (if (= nth 0) (car ls)
      (list-nth (cdr ls) (- nth 1))))

(define (maze-update maze coords element)
  (let* (
         (x (car coords))
         (y (cadr coords))
         (row (list-nth maze x))
         (updated-row (list-update row y element))
         )
    (list-update maze x updated-row)))

;zjednodušená implementace vestavěné funkce (map)
(define (my-map f ls)
  (if (null? ls) '()
      (cons (f (car ls)) (my-map f (cdr ls)))))

;plná implementace vestavěné funkce (map)
(define (full-map f ls . rest-lists)
  (if (null? ls) '()
      (cons (apply f (my-map car (cons ls rest-lists)))
            (apply full-map f (my-map cdr (cons ls rest-lists))))))

;transpozice matice reprezentované seznamem seznamů:
;zde předpokládáme nejmenší matici ()
(define (transpose0 m)
  (if (null? m) '()
        (cons (map car m) (transpose1 (map cdr m)))))
 
;transpozice matice reprezentované seznamem seznamů:
;zde předpokládáme nejmenší matici (())
(define (transpose1 m)
  (cond ((equal? m '(())) '(()))
        ((null? (cdar m)) (list (map car m)))
        (else (cons (map car m) (transpose1 (map cdr m))))))
 
;transpozice matice reprezentované seznamem seznamů:
;zde předpokládáme nejmenší matici ((x))
;(pro vstup (()) vrátí transpose2 ())
(define (transpose2 m)
  (apply full-map list m))

zadání 2. domácí úlohy, fold-left, filter, generování všech permutací?

(define (detekuj-cyklus ls)
  (define (loop xs)
    (cond
      ((null? xs) #f)
      ((eq? ls xs) #t)
      (else (loop (cdr xs)))
      ))
  (if (null? ls) #f (loop (cdr ls)))
  )

(define (fold-left f p ls)
  (if (null? ls) p
      (fold-left f (f p (car ls)) (cdr ls))))

(define (filter check? ls)
  (reverse 
   (fold-left (lambda (r e) (if (check? e) (cons e r) r)) '() ls))
  )

(define (vloz-prvek e ls)
  (if (null? ls) `((,e))
      (let* (
             (mezivysledek (vloz-prvek e (cdr ls)))
             (s-prefixem (map (lambda (x) (cons (car ls) x)) mezivysledek))
             (prvni-prvek (cons e ls))
             )
        (cons prvni-prvek s-prefixem)
        )))

(define (vloz-prvek1 e ls)
  (define (vp pr ls result e)
    (let* (
           (mezivysledek (cons (append pr (list e) ls) result))
           )
      (if (null? ls) mezivysledek
          (vp (append pr (list (car ls))) 
              (cdr ls) 
              mezivysledek 
              e)
          )))
  (vp '() ls '() e)
  )

(define (permutuj ls)
  (if (null? (cdr ls)) (list ls)
      (apply append 
             (map (lambda (xs) (vloz-prvek (car ls) xs)) (permutuj (cdr ls)))
             )))

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