#lang racket

(define xs1 (list 1 2 3 4 5 6))
(println xs1)
(define xs2 (map (lambda (x) (* x x)) xs1))
(println xs2)
(define xs3 (filter even? xs2))
(println xs3)
(define x (apply + xs3))
(println x)

(map + (list 1 2 3) (list 4 5 6))
(map cons (list 1 2 3) (list 4 5 6))
(map (lambda (x) (+ (car x) (cdr x))) (map cons (list 1 2 3) (list 4 5 6)))

(define maximum
  (lambda (xs)
    (apply max xs)
   )
 )
(maximum (list 4 50 3))


;;;;;;;;;; 2
(define (sum-of-odd-squares xs)
  (define odd (filter odd? xs))
  (define squares (map (lambda (x) (* x x)) odd))
  (apply + squares)
 )
(println '(sum-of-odd-squares (list 3 5 8)))
(sum-of-odd-squares (list 3 5 8))
(println '(sum-of-odd-squares (list 2 4 6)))
(sum-of-odd-squares (list 2 4 6))

(define (sum-of-odd-squares2 xs)
  (define odd (filter odd? xs))
  (define squares (map (lambda (x) (* x x)) odd))
  (apply + squares)
 )


(define (my-foldl f x xs)
  (if (null? xs)
      x
      (my-foldl f (f (car xs) x) (cdr xs))
   )
 )



(foldl cons '() (list 1 2 3))
(my-foldl cons '() (list 1 2 3))


;;;;;;;;;; 3
(define (insert-sorted x xs)
   (if (null? xs)
       (list x)
       (if (<= x (car xs))
           (cons x xs)
           (cons (car xs) (insert-sorted x (cdr xs)))
         )
     )
 )
(insert-sorted 5 '())
(insert-sorted 5 (list 1 2))
(insert-sorted 5 (list 4 6))


;;;;;;;;;; 4
(define my-sort
  (lambda (xs)
    (foldl insert-sorted '() xs)
   )
 )
(my-sort (list 4 6 3 9 55 0))

(define my-sort2 (curry foldl insert-sorted '()))
(my-sort2 (list 4 6 3 9 55 0))


;;;;;;;;;; 5
(define (dedup xs)
  (define (insert-if-not-present x xs)
    (if (member x xs)
        xs
        (append xs (list x))
     )
    )
  (foldl insert-if-not-present '() (list 1 1 2 2 2 3))
 )
(dedup '(1 1 2 2 2 3))


(define (dedup2 xs)
  (if (null? xs)
      xs
      (let ((first (car xs)))
        (cons first (dedup2 (filter (lambda (x) (not (= x first))) (cdr xs))))
       )
    )
 )
(dedup2 '(1 1 2 2 2 3))


;;;;;;;;;; 1
(define (my-curry f x) (lambda (y) (f x y)))
(define plus2 (my-curry + 2))
(plus2 5)

(define my-identity (lambda (x) x))
(my-identity 10)

(define (my-compose f g)
  (lambda (x)
    (f (g x))
   )
 )
((my-compose (lambda (x) (* x x)) (lambda (x) (* x 2))) 2)


(define (my-negate p?) (compose not p?))

(define (repeatf f n)
  (if (= 0 n)
      my-identity
      (compose f (repeatf f (- n 1)))
   )
 )

(define sq-3 (repeatf (lambda (x) (* x x)) 3))
(sq-3 2)