1)
(defun abss (x) (if (> 0 x) (- 0 x) x))
(defun nott (x) (if (equal x t) nil t))

2)
(defun orr (x y z) (cond (x x) (y y) (z z)))
(defun andd (x y z) (cond (x (cond (y (cond (z z)))))))

3)
(defun mij (a b c) (cond ((> a b c) b) ((> a c b) c) ((> b a c) a) ((> b c a) c) ((> c a b) a) ((> c b a)
b)))

4)
(defun my-third (l) (caddr l))
(defun my-last (l) (car (reverse l)))

5)
(defun my-append (l1 l2) (append l1 l2))
(defun palindrom (l) (equal l (reverse l)))

6)
(defun ec (a b c)
(let ((delta (- (* b b) (* 4 a c)) ))
(cond
    ((> delta 0) (list (/ (+ (- 0 b) (sqrt delta)) (* 2 a)) (/ (- (- 0 b) (sqrt delta)) (* 2 a))))
    ((equal delta 0) (/ (- 0 b) (* 2 a)))
    ((< delta 0) "Solutii complexe")
)
)
)

7)
(defun f (x)
    (cond
        ((>= -2 x) (* x x))
        ((and (< -2 x) (<= x 1)) (+ x 2))
        ((> x 1) (sqrt (+ (* x x) 1)))
    )
)

8)
(defun add (lst a)
    (if (not (member a lst))
        (append lst (list a))
        (member a lst)
    )
)

9)
(defun prg ()
    (format t "1-Adunare~%2-Scadere~%3-Inmultire~%4-Restul impartirii~%Alegeti optiunea urmata de cele
2 numere: ")
    (let ((opt (read)) (x (read)) (y (read)))
        (cond
            ((equal opt 1) (+ x y))
            ((equal opt 2) (- x y))
            ((equal opt 3) (* x y))
            ((equal opt 4) (rem x y))
        )
    ))
)