mulisp

;(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))))
    )
)