;(display (cons 2 (cons 1 '())))
;(newline)
(define TworzListe
       (lambda (n)
       (if (<= n 1)
       (cons 1 '())
       (cons n (TworzListe (- n 1)))
       )
   )
)

(define DlugoscListy
      (lambda (x)
        (if (pair? x)
        (+ 1 (DlugoscListy (cdr x)))
        0
        )
    )
)

(define SumaListy
      (lambda (x)
        (if (pair? x)
            (+ (car x) (SumaListy (cdr x)))
            0
        )
       )
)

(define SredniaAryt
     (lambda (x)
        (/ (SumaListy x) (DlugoscListy x))
       )
)

;(display (TworzListe (read)))
;(newline)
;(display (Dlugosc (TworzListe (read))))
(define n (read))
(define lista (TworzListe n))
(display "Lista: ")
(display lista)
(newline)
(display "Suma listy: ")
(display (SumaListy lista))
(newline)
(display "Dlugosc listy: ")
(display (DlugoscListy lista))
(newline)
(display "Srednia aryt: ")
(display (SredniaAryt lista))
(newline)

; ************* Odwracanie Listy ******************

(define Reverse-help
    (lambda (s r)
      (if (pair? s)
         (Reverse-help (cdr s) (cons (car s) r))
         r
       )   
     )
)      


(define reversidlo
    (lambda (x)
      (Reverse-help x '())
     )
)

(display "Odwrocona lista: ")
(display (reversidlo lista))
(newline)

; *************************************************

(define DodajListy
   (lambda (a b)
     (if (pair? a)
         (cons (+ (car a) (car b)) (DodajListy (cdr a) (cdr b) ))
         '()
       )
    )
)
;*************************
(define DodajListyProsciej
      (lambda (a b)
        (map + a b)
       )
)
;*************************
(define a (list 1 2 3 4))
(define b (list 1 0 1 -4))
(define m (list a b))
(define x (list 2 1 -1 1))

(define DodajMacierze
    (lambda (a  b)
      (map DodajListyProsciej a b)
     )
)

(display (DodajMacierze m m))
(newline)

;*********** Transpozycja Macierzy ******
(define Transp
   (lambda (m)
      (if (pair? (car m))
          (cons
            (map car m)
            (Transp (map cdr m))
           )
          '()
       )
    )
)
; ***************** ILOCZYN SKALARNY *************
(define iloczyn-skalarny
     (lambda (a b)
      (SumaListy (map * a b))
      )
)
;************* Mnozenie macierzy przez skalar? ***
(define iloczyn-skalarny-przez
   (lambda (x)
     (lambda (a) (iloczyn-skalarny a x))
    )
)

(define macierz-przez-wektor
    (lambda (A x)
      (map (iloczyn-skalarny-przez x) A)
     )
)
;**** Mnozenie macierzy przez macierz ******
(define mac-przez-mac-help
  (lambda (A)
    (lambda (x) (macierz-przez-wektor A x))
   )
)

(define macierz-przez-macierz
   (lambda (A B)
     (map (mac-przez-mac-help A) (Transp B))
    )
)
;********* >  MAIN  < *************

;(display (DodajListy a b))
;(newline)
;(display (DodajListyProsciej a b))
(display m)
(newline)
(display (Transp m))
(newline)
;(display (iloczyn-skalarny a b))
(display (macierz-przez-wektor m x))
(newline)
(display (macierz-przez-macierz m (Transp m)))