;(1 2 (3 (4 5) 6)) -> (1 2 3 4 5 6)
(defun flatten (lst)
 	(mapcan 
 		'(lambda (a) 
 			(cond 
 				((atom a) (list a))
 				(t (flatten a))
 			)
 		) lst
 	)
)


;(1 2 (3 4) 5) -> (1 1 2 2 (3 4) (3 4) 5 5)
(defun dblels (lst)
 	(mapcan '(lambda (x) (list x x)) lst)
)


;(1 2 3 4 5 6 8) -> ((2 4 6 8) (1 3 5))
(defun f1 (lst)
	(list
		(mapcan '(lambda (n) ((evenp n) (list n))) lst)
		(mapcan '(lambda (n) ((oddp n) (list n))) lst)
	)
)


;(1 2 3 4) -> ((4 3 2 1) (4 3 2) (4 3) (4))
(defun rev (lst)
	(maplist 'reverse lst)
)


;(1 2 (3 4) 5) -> (5 (4 3) 2 1)
(defun deep_reverse (lst)
	(cond
		((atom lst) lst)
		(t (reverse (mapcar 'deep_reverse lst)))
	)
)


;lst = (1 2 3 (1 3 (2 3) 2) 1) val = 2 whatever = 4 -> (1 4 3 (1 3 (4 3) 4 ) 1)
(defun replace_all_vals (lst val whatever)
	(mapcan
		'(lambda (a)
			(cond
				((atom a) (cond
					((eq a val) (list whatever))
					(t (list a))
				))
				(t (list (replace_all_vals a val whatever)))
			)
		) lst
	)
)


;lst = (1 2 (2 2 1 (2)) 2) val = 2 whatever = 0 -> (1 2 0 (2 0 2 0 1 (2 0)) 2 0)
(defun insert_after_vals (lst val whatever)
	(mapcan
		'(lambda (a)
			(cond
				((atom a)
					(cond 
						((eq a val) (list a whatever))
						(t (list a))
					)
				)
				(t (list (insert_after_vals a val whatever)))
			)
		) lst
	)
)


; (1 2 3 (1 2)) -> (1 2 2 3 (1 2 2))
(defun f2 (lst)
    (mapcan '(lambda (x)
				(cond	
					((atom x)
						(cond
							((evenp x) (list x x))	
							((oddp x) (list x))))
					(t (list(f2 x)))
				)
			)				
		lst
	)	
)


; (1 2 3 2 4)  2 -> (1 3 4)
(defun remove_vals (lst val)
	(mapcan '(lambda (n) ((not (eq n val)) (list n))) lst)
)


; (1 2 3) (4 5 6) -> (1 4 2 5 3 6)
(defun mergee (lst1 lst2)
	(mapcan 
		'(lambda (u v) (list u v)) lst1 lst2
	)
)


;(1 2 3 4) -> (1 (2 (3 (4))))
(defun bracketize (lst)
	(cond 
		((eq (length lst) 1) lst)
		((> (length lst) 1) 
			(append
				(list (car lst))
				(list (f (cdr lst))) 
			)
		)
	)
)


;(1 2 3 4) ->  (((((4) 3) 2) 1)
(defun reversed_bracketize (lst)
	(bracketize (reverse lst))
)


;(1 2 3 4) ->  (((((1) 2) 3) 4)
(defun reversed_bracketize2 (lst)
	(deep_reverse (bracketize (reverse lst)))
)


; (Horner '(1 2 3) 5) = 1*5^2 + 2*5^1 + 3*5^0 = 38 
; многочлен в точке
(defun Horner (lst x)
	(cond
		((null (cdr lst)) (car lst))
		(t 
			(Horner 
				(cons 
					(+ (* (car lst) x) (cadr lst)) 
					(cddr lst)
				) 
				x
			)
		)
	)
)


; наибольший общий делитель
(defun gcd (a b)
	(cond
		((eq a 0) b)
		((eq b 0) a)
		(t (gcd (mod b a) a))
	)
)


; наименьшее общее кратное
(defun lcm (a b)
	(/ (* a b) (gcd a b))
)


; t - в списке есть и парные и непарные, nil иначе
(defun isOddEven (lst)
	(cond
		(
			(and 
				(mapcan '(lambda (n) ((evenp n) (list n))) lst)
				(mapcan '(lambda (n) ((oddp n) (list n))) lst)
			)
			t
		)
		(t nil)
	)
)

; t - в списке есть и положительные и отрицательные числа, nil иначе
(defun isDiffSigns (lst)
	(cond
		(
			(and
				(mapcan '(lambda (n) ((>= n 0) (list n))) lst)
				(mapcan '(lambda (n) ((< n 0) (list n))) lst)
			)
			t
		)
		(t nil)
	)
)


; (removeEven '(1 2 3 4 5))
(defun removeEven (lst)
	(mapcan '(lambda (n) ((oddp n) (list n))) lst)
)


; (transpose '((1 2 3) (4 5 6) (7 8 9)))
(defun transpose (matrix)
	(defun cars (matrix)
	  	(if (null matrix)
	      	nil
	      	(cons (car (car matrix)) (cars (cdr matrix)))
	    )
	)

	(defun cdrs (matrix)
	  	(if (null matrix)
	    	nil
	    	(cons (cdr (car matrix)) (cdrs (cdr matrix)))
	    )
	)
	
	(cond 
		((null matrix) nil)
        ((null (car matrix)) nil)
        (t (cons (cars matrix) (transpose (cdrs matrix))))
    )
)