(format t "Task 1")
(terpri)
;Task 1
;min-ітеративна функція
(defun FIND_MIN (lst)
(setq curr-min (car lst))
(loop for x in (cdr lst) do
(if (< x curr-min)
(setq curr-min x)))
curr-min)
;max-рекурсивна функція
(defun FUNC_FIND_MAX (lst max-elem)
(setq head (car lst))
(cond
((identity lst) (cond
((> head max-elem) (FUNC_FIND_MAX (cdr lst) head))
(t (FUNC_FIND_MAX (cdr lst) max-elem))))
(t max-elem)))
(defun FIND_MAX (lst)
(FUNC_FIND_MAX (cdr lst) (car lst)))
; incr ітеративна функція
; істина, якщо lst в порядку зростання, в іншому разі nil
(defun INCR (lst)
(setq prev (car lst))
(setq is-incr t)
(loop for x in (cdr lst) do
(if (< x prev)
(return (setq is-incr nil))))
is-incr)
; decr рекурсивна функція
; істина, якщо lst в порядку спадання, в іншому разі nil
(defun FUNC_DECR (prev lst)
(cond
((not lst)
t)
((> (car lst) prev)
nil)
(t (FUNC_DECR (car lst) (cdr lst)))))
; викликає FUNC_DECR з lst head і tail
(defun DECR (lst)
(FUNC_DECR (car lst) (cdr lst)))
(format t "(FIND_MIN '(10 2 4 6 1 5)) = ~a~%" (FIND_MIN '(10 2 4 6 1 5)))
(format t "(FIND_MAX '(10 2 4 6 1 5)) = ~a~%" (FIND_MAX '(10 2 4 6 1 5)))
(terpri)
(format t "(INCR '(-1 0 1 2 3 4)) = ~a~%" (INCR '(-1 0 1 2 3 4 )))
(format t "(INCR '(4 3 2 )) = ~a~%" (INCR '(4 3 2 )))
(terpri)
(format t "(DECR '(4 3 2 1 0 -1)) = ~a~%" (DECR '(4 3 2 1 0 -1)))
(format t "(DECR '(-1 0 1 )) = ~a~%" (DECR '(-1 0 1)))
(terpri)
(format t "Task 3а)")
(terpri)
;Task 3a) рекурсивна функція
; ділить додатній x на додатній y, а коли викликається chc повинно бути 0
; повертає cons quotient remainder
(defun FUNC_DIVIS (x y q)
(cond
((< x y) (cons q x))
(t (FUNC_DIVIS (- x y) y (+ 1 q)))))
;; використовує FUNC_DIVIS і виправляє результати для недодатніх x та y
;; повертає cons quotient remainder
(defun RECURSIVE_DIVIS (x y)
(setq abs-x (abs x))
(setq abs-y (abs y))
(setq result (FUNC_DIVIS abs-x abs-y 0))
(cond
((and (minusp x) (minusp y))
(setq result (cons (+ 1 (car result)) (- (- (cdr result) abs-y)))))
((minusp x)
(setq result (cons (- (+ 1 (car result))) (- (- (cdr result) abs-y)))))
((minusp y)
(setq result (cons (- (car result)) (cdr result)))))
result)
(format t "(RECURSIVE_DIVIS 5 2) = ~a~%" (RECURSIVE_DIVIS 5 2))
(format t "(RECURSIVE_DIVIS -5 2) = ~a~%" (RECURSIVE_DIVIS -5 2))
(format t "(RECURSIVE_DIVIS 5 -2) = ~a~%" (RECURSIVE_DIVIS 5 -2))
(format t "(RECURSIVE_DIVIS -5 -2) = ~a~%" (RECURSIVE_DIVIS -5 -2))
(terpri)
; 3a) ітеративна функція
; ділить x на y
; повертає cons quotient remainder
(defun ITERATIVE_DIVIS (x y)
(setq q 0)
(setq abs-x (abs x))
(setq abs-y (abs y))
(loop while (>= abs-x abs-y) do
(setq abs-x (- abs-x abs-y))
(incf q))
(cond
((and (minusp x) (minusp y))
(setq result (cons (+ 1 q) (- (- abs-x abs-y)))))
((minusp x)
(setq result (cons (- (+ 1 q)) (- (- abs-x abs-y)))))
((minusp y)
(setq result (cons (- q) abs-x)))
(t
(setq result (cons q abs-x))))
result)
(format t "(ITERATIVE_DIVIS 5 2) = ~a~%" (ITERATIVE_DIVIS 5 2))
(format t "(ITERATIVE_DIVIS -5 2) = ~a~%" (ITERATIVE_DIVIS -5 2))
(format t "(ITERATIVE_DIVIS 5 -2) = ~a~%" (ITERATIVE_DIVIS 5 -2))
(format t "(ITERATIVE_DIVIS -5 -2) = ~a~%" (ITERATIVE_DIVIS -5 -2))
(terpri)
(format t "Task 4a)")
(terpri)
; Task 4a) рекурсивна функція
; шукає кількість знаків у двійковому представленні числа n.
(defun FUNC_BINARY (n)
(cond
((zerop n) 0)
(t (+ 1 (FUNC_BINARY (ash n -1))))))
; викликає FUNC_BINARY і обробляє особливий випадок коли n рівне 0
(defun RECURSIVE_BINARY (n)
(cond
((zerop n) 1)
(t (FUNC_BINARY n))))
(format t "(RECURSIVE_BINARY 1) = ~a~%" (RECURSIVE_BINARY 1))
(format t "(RECURSIVE_BINARY 2) = ~a~%" (RECURSIVE_BINARY 2))
(format t "(RECURSIVE_BINARY 4) = ~a~%" (RECURSIVE_BINARY 4))
(format t "(RECURSIVE_BINARY 10) = ~a~%" (RECURSIVE_BINARY 10))
(terpri)
; 4a) ітераційна функція
; шукає кількість знаків у двійковому представленні числа n.
(defun ITERATIVE_BINARY (n)
(setq len 0)
(if (zerop n)
(setq len 1)
(loop while (not (zerop n)) do
(setq n (ash n -1))
(setq len (+ 1 len))))
len)
(format t "(ITERATIVE_BINARY 1) = ~a~%" (ITERATIVE_BINARY 1))
(format t "(ITERATIVE_BINARY 2) = ~a~%" (ITERATIVE_BINARY 2))
(format t "(ITERATIVE_BINARY 4) = ~a~%" (ITERATIVE_BINARY 4))
(format t "(ITERATIVE_BINARY 0) = ~a~%" (ITERATIVE_BINARY 10))
(terpri)
(format t "Task 5в)")
(terpri)
; 5в) рекурсивна функція
(defun FUNC_SCALAR (lst1 lst2 res)
(cond
((and lst1 lst2)
(setq product (* (car lst1) (car lst2)))
(FUNC_SCALAR (cdr lst1) (cdr lst2) (+ res product)))
((or lst1 lst2)
nil)
(t
res)))
(defun RECURSIVE_SCALAR (lst1 lst2)
(FUNC_SCALAR lst1 lst2 0))
(format t "(RECURSIVE_SCALAR '(1 2 3) '(3 2 1)) = ~a~%" (RECURSIVE_SCALAR '(0 2 5) '(1 2 1)))
(format t "(RECURSIVE_SCALAR '(1 2 3) '(3 2)) = ~a~%" (RECURSIVE_SCALAR '(1 1 1) '(2 2)))
(terpri)
;; 5в) ітераційна функція
(defun ITERATIVE_SCALAR (lst1 lst2)
(setq res 0)
(loop while (and lst1 lst2) do
(setq product (* (car lst1) (car lst2)))
(setq res (+ res product))
(setq lst1 (cdr lst1) lst2 (cdr lst2)))
(if (or lst1 lst2)
nil
res))
(format t "(ITERATIVE_SCALAR '(1 2 3) '(3 2 1)) = ~a~%" (ITERATIVE_SCALAR '(0 2 5) '(1 2 1)))
(format t "(ITERATIVE_SCALAR '(1 2 3) '(3 2)) = ~a~%" (ITERATIVE_SCALAR '(1 1 1) '(2 2)))
(terpri)
; your code goes here; your code goes here