(print "Problema 1")

(defun my-first (lst)
    (print (CAR lst)))
(my-first'(A B C))

(defun my-last(lst)
    (print (CDR lst)))
(my-last'(A B C))

(defun my-third (lst)
    (print (CAR(CDR(CDR lst)))))
(my-third'(A B C D E F))

(defun construct (lst lst1)
    (print (CONS lst lst1)))
(construct 'A '(C D))

(print "Problema 2")

(defun rotate-left (lst)
    (print(APPEND (CDR lst) (list(CAR lst)))))
(rotate-left '(A B C))
(rotate-left (rotate-left'(A B C)))

(print "Problema 3")

(defun rotate-right (lst)
    (print(APPEND (LAST lst) (REVERSE(CDR(REVERSE lst))))))
(rotate-right '(A B C D))

(print "Problema 4")

(defun palindrom (lst)
    (print(APPEND lst (REVERSE lst))))
(palindrom'(A B C D))

(print "Problema 5")

(defun delta (a b c)
    (- (* b b) (* a c 4)))

(defun rez (a b c)
    (print (COND(( > (delta a b c) 0)
                 (LIST (/ (+ (- b) (sqrt (delta a b c))) (* 2 a)) (/ (- (- b) (sqrt (delta a b c))) (* 2 a))))
                (nil)
                ((= (delta a b c) 0)
                 (LIST (/ (- b) (* 2 a)))))))
(rez 1 -4 4)

(print "Problema 6")

(defun evenpp (a)
    (print(ZEROP (REM a 2))))
(evenpp 2)
(evenpp 3)

(print "Problema 7")

(defun palindromp (lst)
    (print (EQUAL lst (REVERSE lst))))
(palindromp '(A B A))
(palindromp '(A B A C))

(print "Problema 8")

(defun not-realp (a b c)
    (print(MINUSP (- (* b b) (* a c 4)))))
(not-realp 1 3 1)

(print "Problema 9")

(defun absp (x)
    (print(COND((MINUSP x) (* x -1))
               ((> x 0) x))))
(absp -4)

(defun minim (a b)
    (print(COND((< a b) a)
               ((> a b) b))))
(minim 1 5)

(defun maxim (a b)
    (print(COND((< a b) b)
               ((> a b) a))))
(maxim 1 5)

(print "Problema 10")

(defun notp (a)
    (print(COND((NULL a) 't)
               (a nil))))
(notp 2)
(notp nil)

(defun andp(a b c)
    (print(COND ((equal a nil) nil)
          ((equal b nil) nil)
          ((equal c nil) nil)
          (c))))

(defun orp(a b c)
    (print(COND ((NOT (equal a nil)) a)
          ((NOT (equal b nil)) b)
          ((NOT (equal c nil)) c)
          (nil))))

(print "Problema 11")

(print(CDR nil))
(print(CAR nil))
(print(cons nil nil))
(print(cons (car nil) (cdr nil)))

(print "Problema 12")

(defun med(a b c)
    (cond ((or (and (equal c (min a b c)) (equal a (max a b c))) (and (equal a (min a b c)) (equal c (max a b c)))) b)
          ((or (and (equal b (min a b c)) (equal c (max a b c))) (and (equal c (min a b c)) (equal b (max a b c)))) a)
          ((or (and (equal a (min a b c)) (equal b (max a b c))) (and (equal b (min a b c)) (equal a (max a b c)))) c)
    ))