;Zaimplementować i przetestować funkcję:

;1. obliczającą długość listy
(define (dl list)
  (if (null? list) 
      0
      (+ 1 (dl (cdr list)))
      )
  )
(display "(dl '(1 2 4)) => 3,\n");
(dl '(1 2 3))

;2. obliczającą sumę elementów na liście 
(define (suma list)
  (if (null? list)
      0
      (+ (car list) (suma (cdr list)))
      ))
(display "\n(suma '(1 2 4)) => 7,\n")
(suma '(1 2 4))

;3. obliczającą iloczyn elementów na liście 

(define (iloczyn list)
  (if (null? list) 
      1
      (* (car list) (iloczyn (cdr list)))
      ))
(display "\n(iloczyn '(1 2 4)) => 8,\n")
(iloczyn '(1 2 4))

;4. obliczającą iloczyn skalarny dwóch list 
(define (il-skal list1 list2)
  (if (null? list1)
      0
      ( + (* (car list1) (car list2)) (il-skal (cdr list1) (cdr list2)))
      ))

(display "\n(il-skal '(1 2 3) '(1 2 3)) => 14\n")
(il-skal '(1 2 3) '(1 2 3))


;5. obliczającą liczbę elementów na liście spełniających predykat 

(define (count_if list pred)
  (cond 
    ((null? list) 0)
    ((pred (car list)) (+ 1 (count_if (cdr list) pred)))
    (else
     (count_if (cdr list) pred))
    ))

(display "\n(count_if '(3 5 2) odd?) => 2,\n")
(count_if '(3 5 2) odd?)


;6. obliczającą liczbę elementów o określonej wartości w liście

(define (count_elem list arg)
  (cond 
    ((null? list) 0)
    ((= (car list) arg) (+ 1 (count_elem (cdr list) arg)))
    (else
     (count_elem (cdr list) arg))
    ))
(display "\n(count_elem '(1 1 2 3 1) 1) => 3,\n")
(count_elem '(1 1 2 3 1) 1)

;7. przyjmującą listę i predykat, elementy, które spełniają ten predykat powinny być 
;przekopiowane do listy wynikowej

(define (copy_if list pred)
  (cond
    ((null? list) '())
    ((pred (car list)) (cons (car list) (copy_if (cdr list) pred)))
    (else
     (copy_if (cdr list) pred))))

(display "\n(copy_if '(1 2 3 4 5) odd?) => (1 3 5),\n")
(copy_if '(1 2 3 4 5) odd?)

;8. tworzącą listę, której elementy są kolejnymi sumami elementów dwóch list

(define (suma-list list1 list2)
  (if (null? list1) 
      '()
      (cons (+ (car list1) (car list2)) (suma-list (cdr list1) (cdr list2)))
      ))
     
(display "\n(suma-list '(1 2 3) '(1 2 3)) => (2 4 6),\n")
(suma-list '(1 2 3) '(1 2 3))


;9. tworzącą listę zawierającą n określonych parametrem liczb
(define (wypelnij czym ile)
  (if (= 0 ile)
      '()
      (cons czym (wypelnij czym (- ile 1)))
      ))
(display "\n(wypelnij 10 3) => (10 10 10),\n")
(wypelnij 10 3)

;10. znajdującą maksymalny element na liście
(define (maksymalna lista)
  (define (pomocnicza wstepny lista1)
    (cond 
      ((null? lista1) wstepny)
      ((> (car lista1) wstepny) (pomocnicza (car lista1) (cdr lista1)))
      (else
       (pomocnicza wstepny (cdr lista1))
       )))
  (pomocnicza (car lista) (cdr lista)))
(display "\n(maksymalna '(4 2 10 1)) => 10,\n")
(maksymalna '(4 2 10 10))

;11. znajdującą i zwracającą pierwszy element spełniający predykat
(define (pierwszy list pred)
  (cond
    ((null? list) '())
    ((pred (car list)) (car list))
    (else
     (pierwszy (cdr list) pred))
    ))
(display "\n(pierwszy '(4 6 8 3 3) odd?) => 3,\n")
(pierwszy '(4 6 8 3 3) odd?)

;12. tworzącą listę zawierającą elementy z listy docelowej zmodyfikowane przekazywaną jako 
;drugi parametr funkcją 

(define (mapa list pred)
  (if (null? list) '()
      (cons (pred (car list)) (mapa (cdr list) pred))
      ))
(display "\n(mapa '(4 16 36) sqrt) => (2 4 6)\n")
(mapa '(4 16 36) sqrt)