Lisp Likvid

;problem 5 from bilet11
(defun sumHelper (l sum)
  (if (null l)
      sum
      (if (atom (car l))
          (if (numberp (car l))
              (sumHelper (cdr l) (+ sum (car l)))
              (sumHelper (cdr l) sum)
          )
          (sumHelper (cdr l) (sumHelper (car l) sum))
      )
  )
)

(defun findSum (l)
  (sumHelper l 0)
)

;(print (findSum '(4 (5 (2 3 (1 1))4) 3 5 4)))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

; program to print first element of the deepest level in the given list
(defun max_deepest_helper(lst deep)
   (if (null lst); if null return 0
       (cons deep 0)
       (if (atom (car lst)); else if first elem is atom
          (if (< deep (car (max_deepest_helper (cdr lst) deep))); if deep < mnacaci deep-ic
              (max_deepest_helper (cdr lst) deep); call it for rem list and deep
              (cons deep (car lst)); else (deep first elem)
          )
       (if (< (car (max_deepest_helper (car lst) (+ deep 1))) (car (max_deepest_helper (cdr lst) deep))); else if first it's not atom and deep of the first list, deep + 1 < deep of rem list, deep
          (max_deepest_helper (cdr lst) deep); call it for rem list, deep
       (max_deepest_helper (car lst) (+ deep 1)); else call it for rem list, deep+1
       )
       )
   )
)

(defun max_deepest(lst)
    (cdr (max_deepest_helper lst 0)))

;(print (max_deepest '(1 2 ( 3 (42 5) 8) (1 2 (4)))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;program to remove all prime elements of the list and print the result
(defun primep (n d)
  (if (= n 1); if n == 1
      t      ; return true
  (if (/= n (isqrt n)); else if (n != sqrt(n))
      (or (= d 1)  (and (/= (rem n d) 0) (primep  n (- d 1)))); returns true if(d == 1 || (n % d != 0 && isPrime(n, d-1)))
  )
  )
)


(defun remove-primes (lst)
  (if (null lst); if list is null
       nil ; retrun nil
  (if (atom (car lst));else if first elem of list is atom (1)
      (if (primep (car lst) (- (car lst) 1)); if that elem is prime
          (remove-primes (cdr lst)); call this function without this elem
      (cons (car lst)(remove-primes (cdr lst)))); else create list for this elem + call function without this part
  (cons (remove-primes (car lst)) (remove-primes(cdr lst)))))); else if that elem is not an atom, make new list from calling this function for first elem and calling this function whithout this elem

;(print (remove-primes '(1 2 ( 3 (42 5) 8) (1 2 (4)))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;problem4 from bilet5 and bilet11

(defun nod(a b)
   (and (null a) (null b) (numberp a) (numberp b))
   (if (= a b); if a == b
       a      ; return a
       (if (> a b); else if a > b
           (nod (- a b) b); return gcd(a-b,b)
       (nod a (- b a)); else return gcd(a,b-a)
       )
   )
)
;(print (gcd 36 60))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;problem 4 from bilet4

(defun factorial (n)
  (if (<= n 1)
      1
      (* n (factorial (- n 1)))))

(defun Func (x y)
  (if (or (< x 0) (< y 0))
      0
      (f x y 0)))

(defun f (x y sum)
  (if (> y -1)
      (f x (- y 1) (+ sum (factorial (* x y))))
      sum))

;(print (Func 2 2))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;problem 5 from bilet4

(defun isUnique(x lst)
    (if (null lst)
        t
        (if (= x (car lst))
            nil
            (isUnique x (cdr lst))))
)

(defun remove-non-unique-elements (lst)
  (if (null lst)
      nil
      (if (isUnique (car lst) (cdr lst))
          (cons (car lst) (remove-non-unique-elements (cdr lst)))
          (remove-non-unique-elements (remove (car lst) lst))
      )
  )
)

(defun remove-even(lst)
   (if (null lst)
       nil
       (if (evenp (car lst))
           (remove-even (cdr lst))
           (cons (car lst) (remove-even (cdr lst)))
       )
   )
)

(defun Func(L1 L2 L3)
    (if (or (null L1) (null L2) (null L3))
        nil
        (cons (cons (remove-even L1)  L2)  (remove-non-unique-elements L3))
        ;(append (remove-even L1)  L2  (remove-non-unique-elements L3))
    )
)
(print (Func '(1 2 3 4 2 5 6 5) '(1 2 3 4 2 5 6 5) '(1 2 3 4 2 5 6 5)))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;