#lang racket ;

#| power, ki sprejme število x in potenco n, ter vrne n-to potenco
števila x (0 je veljavna potenca). |#
(define (power x n)
  (if (= n 0)
      1
      (* x (power x (- n 1)))))

#| gcd, ki sprejme dve števili, in vrne njun največji skupni delitelj. |#
(define (gcd a b)
  (if (= b 0) a (gcd b (modulo a b))))

#|fib, ki sprejme število n in vrne n-to fibonaccijevo število.
(fibonacccijeva števila so 1 1 2 3 5 ..., za n=3 naj funkcija vrne 2. |#
(define (fib n)
  (if(or (= n 0) (= n 1)) n  (+ (fib(- n 1)) (fib(- n 2)) )))

#|reverse, ki sprejme seznam in vrne obrnjen seznam
(za dodajanje na konec seznama lahko uporabite vgrajeno funkcijo append) |#
(define (reverse xs)
  (if(null? xs) null (append(reverse(cdr xs)) (list (car xs)))))

#|remove, ki sprejme element x in seznam, ter vrne nov seznam,
ki je enak kot vhodni, le da so v njem odstranjene vse pojavitve elementa x. |#
(define (remove x xs)
  (if(null? xs) null (if(= x (car xs)) (remove (cdr xs) x) (append (list (car xs)) (remove (cdr xs) x)))))


#| map, ki sprejme funkcijo in seznam ter vrne seznam rezultatov,
ki jih vrne podana funkcija, če jo zapovrstjo kličemo na elementih vhodnega seznama. |#
(define (map f xs)
  (if(null? xs) null (append (list(f(car xs))) (map f (cdr xs)))))

#|filter, ki sprejme funkcijo in seznam ter vrne seznam, ki vsebuje vse elemente vhodnega seznama,
za katere podana funkcija vrne resnično vrednost.|#
(define (filter f xs)
  (if(null? xs) null (if(equal? #t (f(car xs))) (append (list (car xs)) (filter f (cdr xs))) (filter f (cdr xs)))))


#|zip, ki sprejme dva seznama, vrne pa seznam parov, ki je tako dolg, kot krajši izmed vhodnih seznamov.
Prvi element izhodnega seznama vsebuje par prvih števil vhodnih seznamov, drugi element par drugih števil, ... |#
(define (zip xs1 xs2)
  (if(or (null? xs1) (null? xs2)) null  (append (list(append (list(car xs1)) (list(car xs2))))  (zip (cdr xs1) (cdr xs2) ))))


#| range, ki sprejme tri števila, začetek, konec in korak.
Vrne seznam števil, ki se začne s številom začetek, vsako naslednje število pa je za korak večje od prejšnjega.
Največje število v seznamu je manjše ali enako od števila konec. Korak bo vedno pozitiven, konec pa vedno večji od začetka. |#
(define (range zac kon kor)
  (if(<= zac kon) (append (list zac) (range (+ zac kor) kon kor))    null))

#| everynth, ki sprejme število n in seznam, ter vrne nov seznam, ki vsebuje samo vsak n-ti element v podanem seznamu.|#
(define (everynth n xs)
  (let ([x n])
    (define (calc x xs)
      (if(null? xs) null   (if(= x 1)  (append (list(car xs)) (everynth n (cdr xs))) (calc (- x 1) (cdr xs)))))
    (calc x xs)))