VI_Lab_2

1. a)   (defun izmesaj (levo desno rel) (cond
                                         ((null levo) desno)
                                         ((null desno) levo)
                                         ((apply rel (list (car levo) (car desno))) (cons (car levo) (izmesaj (cdr levo) desno rel)))
                                         (t(cons (car desno) (izmesaj levo (cdr desno) rel)))
                                              ))

b.)     (defun ost (l1 l2) (cond
                                ((null l1) '())
                                ((null l2) (list l1))
                                ((atom l1) (if (equal l1 (car l2)) '() (ost l1 (cdr l2))))
                                (t(append (ost (car l1) l2) (ost (cdr l1) l2)))

                                     ))

2. a)   (defun list+ (l1 l2) (cond
                                  ((null l1) l2)
                                  ((null l2) l1)
                                  (t(append (list (+ (car l1) (car l2))) (list+ (cdr l1) (cdr l2))))
                                  ))

  b)    (defun broj_pojavljivanja (el l) (cond
                                               ((null l) '0)
                                               ((equal el (car l)) (+ 1 (broj_pojavljivanja el (cdr l))))
                                               ((listp (car l)) (+ (broj_pojavljivanja el (car l)) (broj_pojavljivanja el (cdr l))))
                                               (t(broj_pojavljivanja el (cdr l)))
                                                    ))

3. a)   (defun pribavi (n m lista) (cond
                                          ((= 0 (+ n m)) (cond
                                                          ((atom (car lista)) (car lista))
                                                          (t(car (car lista)))
                                                          ))
                                          ((= 0 n) (cond
                                                          ((atom (car lista)) (pribavi n (- m 1) (cdr lista)))
                                                          (t(pribavi n m (car lista)))
                                                          ))
                                          (t(pribavi (- n 1) m (cdr lista)))
                                          ))

b.)     (defun brdugih (br lista) (cond
                                       ((null lista) '0)
                                       ((atom (car lista)) (+ 0 (brdugih br (cdr lista))))
                                       ((> br (length (car lista))) (+ 0 (brdugih br (car lista)) (brdugih br (cdr lista))))
                                       (t(+ 1 (brdugih br (car lista)) (brdugih br (cdr lista)) ))
                                            ))

4. a)   (defun pronadji (kljuc alista) (cond
                                             ((null alista) '())
                                             ((equal kljuc (caar alista)) (cadr (car alista)))
                                             (t(pronadji kljuc (cdr alista)))
                                             ))

b)  (defun umetni (e1 e2 lista) (cond
                                         ((null lista) '())
                                         ((equal e2 (car lista)) (append (list e1) (list (car lista)) (umetni e1 e2 (cdr lista)) ))
                                         ((atom (car lista)) (append (list (car lista)) (umetni e1 e2 (cdr lista))))
                                         (t(append (list (umetni e1 e2 (car lista))) (umetni e1 e2 (cdr lista)) ))
                                              ))

5. a)   (defun kljucevi (alista) (cond
                                       ((null alista) '())
                                       (t(cons (caar alista) (kljucevi (cdr alista))))
                                       ))

b.) (defun clan-p (el lista) (cond
                                       ((null lista) '())
                                       ((equal el (car lista)) t)
                                       ((listp (car lista)) (or (clan-p el (car lista)) (clan-p el (cdr lista))))
                                       (t(clan-p el (cdr lista)))
                                       ))

6. a)   (defun brpon (pom lista) (cond
                                       ((null lista) '())
                                       ((equal (car lista) (cadr lista)) (brpon (1+ pom) (cdr lista)))
                                       (t(append (list (+ 1 pom)) (brpon 0 (cdr lista)) ))
                                            ))


b)  (defun gldiag (lista) (cond
                                    ((null lista) '())
                                    (t(append (list(nth (- (length lista) 1) (reverse (car lista)))) (gldiag (cdr lista))))
                                    ))

7. a)   (defun skupi (lista) (cond
                                   ((= 1 (length lista)) '())
                                   (t(append (list (+ (car lista) (cadr lista))) (skupi (cdr lista))))
                                   ))

b)  (defun skup-p (lista) (cond
                                    ((= (length lista) 1) t)
                                    ((> (length lista) 1) (if(equal (car lista) (cadr lista)) '() (skup-p (cons (car lista) (cddr lista)))))
                                    (t(and (skup-p (cdr lista)) t))
                                         ))


8. a)   (defun podeli (d deljenik) (cond
                                         ((= (length deljenik) 1) (list (/ (- (car deljenik) (mod (car deljenik) d)) d)))

                                         ((< (car deljenik) d) (cons '0 (podeli d (cons (+ (* (car deljenik) 10) (cadr deljenik)) (cddr deljenik)))))

                                         (t(cons (/ (- (car deljenik) (mod (car deljenik) d)) d) (podeli d (cons (+ (* (mod (car deljenik) d) 10)(cadr deljenik)) (cddr deljenik)))))

                                              ))

b. )    (defun unija (l1 l2) (cond
                                   ((null l1) l2)
                                   ((null l2) (list l1))
                                   ((atom l1) (if(equal l1 (car l2)) '() (unija l1 (cdr l2))))
                                   (t(append (unija (car l1) l2) (unija (cdr l1) l2)))
                                        ))

9. a)   (defun uporedi (alista) (cond
                                      ((null alista) '0)
                                      ((> (caar alista) (cadr (car alista))) (+ 1 (uporedi (cdr alista))))
                                      (t(+ 0 (uporedi (cdr alista))))
                                           ))



b)  (defun uvecaj (pom lista) (cond

                                        ((null lista) '())

                                        ((atom (car lista)) (append (list (+ (car lista) pom)) (uvecaj pom (cdr lista))))

                                        (t(cons (uvecaj (+ 1 pom) (car lista)) (uvecaj pom (cdr lista))))

                                        ))

10. a)  (defun napravi (lk lv) (cond
                                    ((null lk) '())
                                    ((null lv) (append (list (list (car lk))) (napravi (cdr lk) lv)))
                                    (t(append (list (append (list (car lk)) (list (car lv)))) (napravi (cdr lk) (cdr lv))))
                                    ))

b)  (defun maks (lista) (cond
                                  ((= (length lista) 1) (car lista))
                                  ((listp (car lista)) (maks (cons (maks (car lista)) (cdr lista))))
                                  ((> (car lista) (cadr lista)) (maks (cons (car lista) (cddr lista))))
                                  (t(maks (cdr lista)))))

11. a)  (defun palindrom (lista)  (cond
((null (cdr lista)) (list (car lista)))
                    (t (append (list (car lista)) (palindrom (cdr lista)) (list (car lista))))))

b)  (defun brojevip (lista) (cond
                                     ((null lista) t)
                                     ((numberp (car lista)) (and t (brojevip (cdr lista))))
                                     ((listp (car lista)) (and (brojevip (car lista)) (brojevip (cdr lista))))
                                     (t '())
                                     ))

12. a)  (defun razlika (v1 v2) (cond
                                     ((null v1) '())
                                     (t(append (list (- (car v1) (car v2))) (razlika (cdr v1) (cdr v2))))
                                     ))



b.) (defun obrisi (pom ind lista) (cond
                                        ((null lista) '())
                                        ((= pom ind) (obrisi (+ 1 pom) ind (cdr lista)))
                                        ((listp (car lista)) (append (list (obrisi '0 ind (car lista))) (obrisi (+ 1 pom) ind (cdr lista))))
                                            (t(append (list (car lista)) (obrisi (+ 1 pom) ind (cdr lista))))
                                             ))


13. a)  (defun polinom (x koef) (cond
                                      ((null koef) '0)
                                      (t(+ (car koef) (* (polinom x (cdr koef)) x)))
                                           ))

b)  (defun proizvod (lista) (cond
                                      ((null lista) '1)
                                      ((atom (car lista)) (* (car lista) (proizvod (cdr lista))))
                                      (t(* (proizvod (car lista)) (proizvod (cdr lista))))
                                      ))


14.
a)  (defun intenzitet (lista) (cond
((null lista) '0)
 (t(+ (expt (car lista) 2) (intenzitet (cdr lista))))))
b)  (defun postavi (el n m mat) (cond
                                         ((and (= (+ n m) 0) (listp (car mat))) (append (list (cons el (cdr (car mat)))) (cdr mat)))
                                         ((and (= (+ n m) 0) (atom (car mat))) (cons el (cdr mat)))
                                         ((and (= n 0) (listp (car mat))) (append (list (postavi el n m (car mat))) (cdr mat)))
                                         ((and (= n 0) (atom (car mat))) (cons (car mat) (postavi el n (- m 1) (cdr mat))))
                                         (t(cons (car mat) (postavi el (- n 1) m (cdr mat))))
                                              ))






15. a)  (defun simetrican (levo desno) (cond
                                           ((and (= (mod (+ (length levo) (length desno)) 2) 1) (> (length levo) (length desno)))  (equal (cdr levo) desno))
 ((and (= (mod (+ (length levo) (length desno)) 2) 0) (= (length levo) (length desno)))  (equal levo desno))
                                           (t(simetrican (cons (car desno) levo) (cdr desno)))
                                           ))


 (defun postavi (br n m mat) (cond
                                          ((and (= (+ n m) 0) (atom (car mat))) (append (list br) (cdr mat)))
                                          ((and (= (+ n m) 0) (listp (car mat))) (append (list (append (list br) (cdr (car mat)))) (cdr mat)))
                                          ((= n 0) (append () (postavi br n (- m 1) (append (list (cdr (car mat))) (cdr mat))) ))
                                          (t(append (car mat) (postavi br (- n 1) m (cdr mat))))))






 (defun podeli (deli delj) (cond
                                        ((null lista) '())
                                         ((> deli (car delj)) (append (list '0) (podeli deli (append (list (+ (* (car delj) 10) (cadr delj))) (caddr delj)))))
                                        (t(append (list ((x y) (/ (- x (mod x y)) y)))) ()))