LAB 3

P1. Unii sunt deranja de numele primitivelor critice CAR, CDR i CONS. Definii noi
proceduri my-first, my-rest i construct care realizeaz acelai lucru. Putei defini i my-
second, my-third, etc.

(defun my-first (lista)

(car lista))
my-first
(my-first `(a b c d e))
a

(defun my-second (lista)

(car (cdr (lista)))
my-second
(my-second `(1 2 3 4))
2

(defun my-third (lista)

(caddr lista))
my-third
(my-third `(d e f g h i))
f

(defun my-rest (lista)

(cdr lista))
my-rest
(my-rest `(1 2 3 4))
(2 3 4)

(defun construct (a lista)

(cons a lista))
construct
(construct 'z '(a b c))
(z a b c)

P2. Definii rotate-left care primete o list ca argument i returneaz o nou list n
care primul element al listei de intrare este ultimul element al listei returnate.

(defun rot-left (lista)

(append (cdr lista) (cons (car lista) `())))
rot-left
(rot-left `(a b c d))
(b c d a)
(rot-left (rot-left `(a b c)))
(c d a)

P3. Definii rotate-right.

(defun rot-right (lista)
(append (last lista) (reverse (cdr (reverse lista)))))
rot-right
(rot-right `(a b c d e))
(e a b c d)

P4. Un palindrom este o list care conine aceeai secven de elemente atunci cnd este
citit att de la stnga la dreapta ct i de la dreapta la stnga. Definii palindrom care
primete o list ca argument i returneaz un palindrom de lungime dubl.

(defun palindrom (lista)

(append lista (reverse lista)))
palindrom
(palindrom `(x y z))
(x y z z y x)

P5. Definii ec2 care primete trei parametrii a, b si c i returneaz o list ce conine cele
dou rdcini ale ecuaiei de gradul doi a*x^2+b*x+c=0, folosind formula:

-b+-sqrt(b*b-4*a*c)
x= -----------------------------
2*a
(defun delta (a b c)
(- (* b b) (* 4 a c))
)
delta
(defun ec2 (a b c)
(cond ((<= 0 (delta a b c))
(append (cons (/ (- (- 0 b) (sqrt (delta a b c))) (* 2 a)) '())
(cons (/ (+ (- 0 b) (sqrt (delta a b c))) (* 2 a)) '())
)
)
((> 0 (delta a b c)) 'Ecuatia_nu_are_radacini_reale)
))
ec2
(ec2 2 1 -1)
(-1.0 0.5)
(ec2 4 2 9)
Ecuatia_nu_are_radacini_reale

P6. Definii propria versiune a predicatului EVENP. Putei folosi primitiva REM care
returneaz restul mparirii ntregi a dou numere.

(defun paritate (nr)

(= (rem nr 2) 0))
paritate
(paritate 3)
nil
(paritate 22)
t
P7. Definii predicatul PALINDROMP care testeaz dac argumentul este un
palindrom.

(defun palindrom (lista)

(equal lista (reverse lista)))
palindrom
(palindrom `(r a r))
t
(palindrom `(c o p a c))
nil

P8. Definii predicatul NOT-REALP care ia trei parametrii i returneaz t dac b*b-
4*a*c < 0.

(defun not-realp (a b c)
(< (- (* b b) (* 4 a c)) 0))
not-realp
(not-realp `(3 4 -10))
nil
(not-realp `(5 9 4))
nil
(not-realp `(5 2 7))
t

P9. Exprimai (abs X), (min A B) i (max A B) cu ajutorul lui COND.

(defun absolut (x)

(cond ((> x 0) x)
((= x 0) `0)
((< x 0) (- 0 x))))
absolut
(absolut -9)
9
(absolut 3)
3
(absolut 0)
0

(defun maxim (a b)
(cond ((<= a b) b)
((> a b) a)))
maxim
(maxim 4 5)
5
(maxim 9 0)
9
(maxim 5 5)
5
(maxim -7 7)
7
(defun minim (a b)
(cond ((<= a b) a)
((< b a) b)))
minim
(minim 10 2)
2
(minim -4 5)
-4
(minim 1 1)
1

P10. Exprimai (not U), (or X Y Z) i (and A B C) cu ajutorul lui COND.

(defun si (lista)
(cond ((< 0 (length (member nil lista))) nil)
((equal (member nil lista) nil) t)))
si
(si `(t t t))
t
(si `(nil t))
nil
(si `(t t t nil t))
nil

(defun notp (x)

(cond ((equal t x) nil)
((equal nil x) t)))
notp
(notp t)
nil
(notp nil)
t

(defun sau (lista)

(cond ((equal (member t lista) nil) nil)
((equal (car (member t lista)) t) t)))
sau
(sau `(t nil))
t
(sau `(nil nil nil))
nil
(sau `(nil t nil))
t

P11. Care este valoarea urmtoarei forme? Argumentai rspunsul.

(cons (car nil) (cdr nil))
nil
(car nil) returneaza nil deocarece lista vida (care este echivalentul lui nil) nu contine
elemente, deci primul element al acesteia este nil
(cdr nil) va returna de asemenea nil deoarece lista vida sau nil nu contine nici un
element deci excluzand primul element care este de asemenea nil vom ramane cu nil
(cons nil nil) va adauga la inceputul listei vide o lista vida rezultatul fiind tot o lista vida
(nil)
P12. Definii MEDIAN-OF-THREE, o procedur care primete trei argumente
numerice i returneaz pe cel din mijloc ca valoare (adic pe cel care nu e cel mai mic i
nu e cel mai mare).

(defun mijlociu (a b c)
(cond ((<= a b c) b)
((<= b c a) c)
((<= c a b) a)
((>= a b c) b)
((>= b c a) c)
((>= c a b) a)
))
mijlociu
(mijlociu 7 9 2)
7