(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))
(foldl + 0 (list 1 2 3))
(foldr append '() (list (list 1 2 3) (list 4 5 6) (list 7 8 9)))



;;;;;;;; 1
(define (favg f g)
  (lambda (x)
    (/ (+ (f x) (g x)) 2)
   )
 )

((favg sqr sqrt) 9)

;;;;;;;; 2
(define (flist fs)
  (lambda (x)
    (foldl (lambda (f x) (f x)) x fs)
   )
 )

((flist (list sqrt (lambda (x) (+ x x)) sqr)) 4)



;;;;;;;; 3

(define (sieve-of-eratosthenes n)
  (define (helper remaining-numbers)
    (if (null? remaining-numbers)
        '()
        (cons (first remaining-numbers)
              (helper (filter (lambda (k) (> (remainder k (first remaining-numbers)) 0))
                              (rest remaining-numbers))))))
  (helper (range 2 (+ n 1))))

(define (sieve n)
  (define (sieve-helper remaining)
    (if (null? remaining)
        remaining
        (let* (
              (first (car remaining))
              (dividedBy (lambda (i)
                           (< 0 (remainder i first))))
              )
          (cons first (sieve-helper (filter dividedBy (cdr remaining))))
        )
    )
    )
  (sieve-helper (range 2 n))
 )
(sieve-of-eratosthenes 50)
(sieve 50)

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


; Зад. 3 Да се дефинира функция (insert-sorted x xs),
; която вмъква число x в сортиран в нарастващ ред списък xs.
; (insert-sorted 5 '()) == '(5)
; (insert-sorted 5 '(4 6)) == '(4 5 6)

; Зад. 4 Използвайки insert-sorted и foldl, да се дефинира
; функция my-sort, която сортира списък.
; (my-sort '(3 5 0 1)) == '(0 1 3 5)


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

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