Laborator 6
Problema 1
Cod:
(defun impar(numar) ( do( (x '() ) (aux numar (floor (/ aux 10)) )
) ((zerop aux) x)
(cond( (not (= (mod aux 2) 0) )
(setq x (append x (list (mod aux 10)) ) )
)
)
)
)
Apelare: (impar '1234567)
Rezultat obtinut: (7 5 3 1)
Explicatii:
x-lista ca va fi returnata, la inceput este vida, ea se actualizeaza la sfarsit.
aux-pun numarul primit ca parametru in aceasta valoare auxiliara, cat timp aceasta este diferita de 0, bucla continua
Daca am intalnit o cifra impara, atasez acea cifra listei x
Problema 2
Cod:
(defun interclasare(lista1 lista2) ( if(null lista1) '()
(append (list (car lista1)) (list (car lista2)) (interclasare (cdr lista1) (cdr lista2))
)
)
)
Apelare: (interclasare '(1 3 5) '(2 4 6) )
Rezultat obtinut: (1 2 3 4 5 6)
Explicatii:
Ma folosesc de faptul ca listele au lungimi egale. Astfel creez o lista cu primul element din "lista1" urmat de primul element din "lista2". Continui la fel si cu restul listei, cat timp mai exista elemente.
Problema 3
Cod:
(defun lungimi(lista)( if(null lista) '()
( if (listp (car lista)) (append (list (length (car lista) )) (lungimi (cdr lista))
)
(lungimi (cdr lista))
)
)
)
Apelare: (lungimi '( 1 2 (3 4 5) (6 (7 (8 9 (10) ) ) ) 10 (13) ) )
Rezultat obtinut: (3 2 1)
Explicatii:
Daca primul element este o lista, atasez lungimea acestui la o noua lista care va fi returnata. La aceasta lista se ataseaza prin apel recursiv, parcurgand si restul listei. In caz contrar, continui cautarea in restul listei.
Problema 4
Cod:
(defun numere(lista n) ( do((aux 1) (x '() )) ((null lista) x)
(setq x (append x ( list (car lista) ) ) )
(cond( (= aux n) (setq x (append x ( list (car lista)) ) ) (setq aux 0) ) )
(setq aux (+ aux 1) )
(setq lista (cdr lista))
)
)
Apelare: (numere '(1 2 3 4 5) 2)
Rezultat obtinut: (1 2 2 3 4 4 5)
Explicatii:
Trebuie sa parcurgem lista si sa atasam unei noi liste primul element al listei curente. La fiecare iteratie lista se actualizeaza.(cdr)
Astfel, la fiecare al "n"-lea element, acesta trebuie atasat de doua ori.
Pentru a stii cand am ajuns la "n" folosesc o variabila "aux" care contorizeaza elementele parcurse. Acesta se incrementeaza la fiecare iteratie, iar cand am ajuns la "n", acesta se reintializeaza cu 0 deoarece la sfarsitul iteratiei acesta se incrementeaza si ajunge la valoarea 1, valoarea dorita si setata initial.
Problema 5
Cod:
(defun reuniune(lista1 lista2) ( do(x '()) ((and (null lista1) (null lista2)) x)
(cond( (and (not (member (car lista1) x :test 'equal )) (not (null lista1)) )
(setq x (append x (list(car lista1))))
)
)
(cond( (and (not (member (car lista2) x :test 'equal)) (not (null lista2)) )
(setq x (append x (list(car lista2))))
)
)
(setq lista1 (cdr lista1)) (setq lista2 (cdr lista2))
)
)
(defun intersectie(lista1 lista2) ( do(x '()) ((null lista1)x)
(cond( (and (not (member (car lista1) x :test 'equal ))
(member (car lista1) lista2 :test 'equal )
)
(setq x (append x (list(car lista1))))
)
)
(setq lista1 (cdr lista1))
)
)
(defun diferenta(lista1 lista2) ( do(x '()) ((null lista1)x)
(cond( (and (not (member (car lista1) x :test 'equal ))
(not (member (car lista1) lista2 :test 'equal ))
)
(setq x (append x (list(car lista1))))
)
)
(setq lista1 (cdr lista1))
)
)
(defun egalitate(lista1 lista2) (if(equal lista1 lista2) t nil) )
Metoda 2: (defun egalitate(lista1 lista2) (if (equal (or (diferenta lista1 lista2) (diferenta lista2 lista1)
)
nil
)
t nil
)
)
Apelare:
(reuniune '(1 2 3 4 3 3 (7 8 (9)) (7 8 9) ) '(4 4 3 (7 8 9) (7 8 9) (7 8 9)))
(intersectie '(1 2 3 3 4 4 4 (4 5 6) 8 9) '(3 4 4 4 (4 5 6) 9))
(diferenta '(1 2 3 3 4 4 4 (4 5 6) 8 9) '(3 4 4 4 (4 5 6) 9))
(egalitate '(1 2 (3) (4 5 (6) ) ) '(1 2 (3) (4 5 (6) ) ))
Rezultat obtinut:
(1 4 2 3 (7 8 9) (7 8 (9)))
(1 2 8)
(3 4 (4 5 6) 9)
T
Explicatii:
In varibila "x" imi formez lista pe care vreau sa o returnez.
Reuniune: Pur si simplu parcug ambele lista si adaug un element in "x" doar daca acest element nu este deja in "x", Cum listelor nu li se garanteaza lungime egala, verific ca nu cumva sa ajung la finalul unei liste, iar la cealalta nu, asta putand cauza adaugarea de "nil".
Obs: Nu adaug aceeasi lista de doua ori.
Intersectie: Parcurg doar prima lista. Daca elementul curent NU se afla in "x" si se afla si in a doua lista, il adaug in "x".
Diferenta: Parcurg doar prima lista. Daca elementul curent NU se afla in "x" si NU se afla si in a doua lista, il adaug in "x".
___________
Egalitate: Functia de biblioteca equal...
Metoda2(fara functia de biblioteca) : Daca diferenta dintre (lista1 - lista2) si (lista2 - lista1) sunt amandoua nil, inseamna ca listele sunt egale, adica au aceleasi elemente.
Observatie: Nu am considerat a fi multimi(fiecare element este unic intr-o multime). Am considerat ca elementele unei liste se pot repeta in acea lista. Am tinut cont de asta, de faptul ca o lista poate contine si alte liste, nu numai elemente de tip atom.