#lang racket
;1)
(define (NWD a b) (if (= a b) a
             (if (< a b) (NWD a (- b a))
                 (NWD (- a b) b))))
;2)
(define (NWW a b) (/ (* a b) (NWD a b)))

;3)
(define (same-values? f1 f2 x y)(= (f1 x y) (f2 x y)))

;4)
(define (odd? n)(cond [(zero? n) #f]
                      [else (even? (- n 1))]))
;5)
(define (even? n) (cond [(zero? n) #t]
                       [else (odd? (- n 1))]))

;6)
(define (fib-recursive n)(if (<= n 2)
                             1
                             (+ (fib-recursive (- n 1)) (fib-recursive (- n 2)))))

(define (fib-iter n)(fib-iter-helper 1 0 n))
(define (fib-iter-helper a b counter)(cond ((= counter 0) b)
                                           (else (fib-iter-helper (+ a b) a (- counter 1)))))

;7)
(define (exp-recursive b e)(if (= e 0) 1
                                ( if (odd? e) (* b (* (exp-recursive b (/ (- e 1) 2)) (exp-recursive b (/ (- e 1) 2))))
                                (* (exp-recursive b (/ e 2)) (exp-recursive b (/ e 2))))))

(define (exp-iter b e)(exp-iter-helper b e 1))
(define (exp-iter-helper b e counter) (if (= e 0) counter
                                   (exp-iter-helper b (- e 1) (* counter b))))

;8)
(define (sum-of-squares-of-maxima a b c)(if (> a b)
                                            (if (> b c) (+ (* a a)(* b b))
                                                (+ (* a a)(* c c)))
                                            (if (> a c) (+ (* a a) (* b b))
                                                (+ (* b b)(* c c)))))

;9)
(define (call f x)(f x))

;13)
;(define (product term a next b)())

;17)
(define (iter f n)(exp-iter f n))

;19)
;a)
(define (append l m)(if (null? l) m
                        (cons (car l) (append (cdr l) m))))
;b)
(define (reverse l)(if (null? l) '()
                       (append (reverse (cdr l)) (list (car l)))))
;c)
(define (last l)(if (null? (cdr l)) (car l)
                    (last (cdr l))))
;d)
(define (delete l x)(if (null? l) '()
                        (if (equal? (car l) x) (delete (cdr l) x)
                        (cons (car l) (delete (cdr l) x)))))
;e)
(define (split l x)(split-helper l x '() '()))
(define (split-helper l x l1 l2)(if (null? l) (list l1 l2)
                                 (if (< (car l) x) (split-helper (cdr l) x (cons (car l) l1) l2)
                                     (split-helper (cdr l) x l1 (cons (car l) l2)))))

;20)
;b)
(define (mapf l f) (if (null? l) '()
                            (cons (f (car l)) (mapf (cdr l) f))))
;a)
(define (square-list l) (mapf l (lambda (x) (* x x))))

;c)
(define (filter l pred)(if (null? l) '()
                           (if (pred (car l)) (cons (car l) (filter (cdr l) pred))
                           (filter (cdr l) pred))))

;22)
(define (ewal l)(ewal-helper (car l) (cdr l))) ; ISSUE -> nie udaje sie zastosowac apply to funkcji
(define (ewal-helper exp l)(exp (ewal-resolver (car l)) (ewal-resolver (car (cdr l)))))
(define (ewal-resolver x) (if (list? x) (ewal-helper (car x) (cdr x)) x))

;23)
(define (member? x l)(if (null? l) #f
                         (if (equal? (car l) x) #t
                             (member? x (cdr l)))))

;24)
;INTERSECTION
(define (intersection l1 l2)(if (> (length l1) (length l2)) (intersection-helper l1 l2 '()) (intersection-helper l2 l1 '())))
(define (intersection-helper shorterList longerList output)(if (null? shorterList) output
                                                            (if (member? (car shorterList) longerList)
                                                               (intersection-helper (cdr shorterList) longerList (cons (car shorterList) output))
                                                               (intersection-helper (cdr shorterList) longerList output))))

(define (union l1 l2)(union-helper (append l1 l2) '()))
(define (union-helper l acc)(if (null? l) acc
                                (if (member? (car l) acc) (union-helper (cdr l) acc)
                                    (union-helper (cdr l) (cons (car l) acc)))))

;UNION
(define (length l)(length-acc l 0))
(define (length-acc l acc)(if (null? l) acc (length-acc (cdr l) (+ acc 1))))

;25)
(define (treeAdd x root)(if (null? root) (list '() x (list ))
                            (if (< (takeRoot root) x) (append  (takeRootAndLeft root) (list (treeAdd x (takeRightSubTree root))))
                               (cons (treeAdd x (takeLeftSubTree root)) (takeRootAndRight root)))))

(define (takeLeftSubTree l) (car l))
(define (takeRoot l) (car (cdr l)))
(define (takeRightSubTree l) (car (cdr (cdr l))))
(define (takeRootAndLeft l) (list (car l) (car (cdr l))))
(define (takeRootAndRight l) (cdr l))

(define (memberTree? x root) (if (null? root) #f
                                 (if (= (takeRoot root) x) #t
                                 (if (< (takeRoot root) x) (memberTree? x (takeRightSubTree root))
                                     (memberTree? x (takeLeftSubTree root))))))


(define (sumTree root) (sumTreeHelper root 0))
(define (sumTreeHelper root acc) (if (null? root) acc
                                     (+ (sumTreeHelper (takeLeftSubTree root) 0) (sumTreeHelper (takeRightSubTree root)  (+ acc (takeRoot root))))))

(define (member x root)(if (null? root) #f
                           (if (equal? x (car root)) #t
                               (member x (cdr root)))))

(define (numbers x) (numbersHelper x 0))
(define (numbersHelper x n) (if (equal? x n) (list n)
                                (cons n (numbersHelper x (+ n 1)))))

(define (flatten l) (if (null? l) '()
                        (if (list? (car l)) (append (flatten (car l)) (flatten (cdr l)))
                            (cons (car l) (flatten (cdr l))))))