Scheme code snippets

Перевіряє чи елемент є у списку
(define (is-in-list element list)(cond
                                   ((eq? list `()) #f)
                                   ((eq? element (car list)) #t)
                                   (#t (is-in-list element (cdr list)))))

З'єднює два списки
(define (concat-lists list1 list2)(cond
                                    ((eq? list1 `()) list2)
                                    (#t (cons (car list1) (concat-lists (cdr list1) list2)))
                                    ))

Видаляє елементи з першого списку, які є у другому списку
(define (subtract-similar list1 list2) (cond
                       ((eq? list1 `()) `())
                       ((is-in-list (car list1) list2) (subtract-similar (cdr list1) list2))
                       (#t (cons (car list1) (subtract-similar (cdr list1) list2)))))

Видаляє елементи з другого списку, які є у першому списку
(define (subtract-similar-2 a b) (subtract-lists b a))

Добавляє рівні вкладеності
(define (make-nested list) (cond
                              ((eq? list '()) '())
                              ((eq? (cdr list) '()) list)
                              (#t (cons (car list) (cons (deepen-list (cdr list)) '())))))

Перетворює складну спискову структуру в однорівневий список
(define (revoke-nested l) (cond
                           ((eq? l '()) '())
                           ((pair? (car l)) (concat-lists (revoke-nested (car l)) (revoke-nested (cdr l))))
                           (#t (cons (car l) (revoke-nested (cdr l))))))

Перевіряє чи є спільні елементи у списках
(define (intersect? l1 l2) (cond
                             ((eq? l1 '()) #f)
                             ((in-list (car l1) l2) #t)
                             (#t (intersect? (cdr l1) l2))))

Перевіряє чи елементи входять тільки один раз
(define (is-unique? l) (cond
                      ((eq? l '()) #t)
                      ((is-in-list (car l) (cdr l)) #f)
                      (#t (is-unique? (cdr l)))))

Визначає загальну к-сть атомів у списковій структурі та к-сть елементів на верхньому рівні
(define (count-upper l) (cond
                          ((eq? l '()) 0)
                          (#t (+ 1 (count-upper (cdr l))))))
(define (count-atoms l) (cond
                          ((eq? l '()) 0)
                          ((pair? (car l)) (+ (count-atoms (cdr l)) (count-atoms (car l))))
                          (#t (+ 1 (count-atoms (cdr l))))))
(define (count-all l) (cons (count-atoms l) (count-upper l)))

На основі двох вхідних списків утворює новий список з таких елементів, що входять у ці списки, але не входять в обидва одночасно
(define (xor-lists a b) (concat-lists (subtract-similar a b) (subtract-similar b a)))

Видаляє нульові елементи зі списку
(define (non-zero list) (cond
                          ((eq? list `()) `())
                          ((eq? (car list) `0) (non-zero (cdr list)))
                          (#t (cons (car list) (non-zero (cdr list))))
                          ))

Повертає перший елемент, який входить в обидва списки, у протилежному випадку - no.
(define (is-in-list element list)(cond
                                   ((eq? list `()) `no)
                                   ((eq? element (car list)) #t)
                                   (#t (is-in-list element (cdr list)))))

(define (check-similar l1 l2) (cond
                             ((eq? l1 '()) `no)
                             ((in-list (car l1) l2) (car l1))
                             (#t (intersect? (cdr l1) l2))))

Визначає чи два s-вирази еквівалентні
(define Equals? (lambda(x y) (cond
                               ((AND1 (eq? x '()) (eq? y '())) '#t)
                               ((OR1 (eq? x '()) (eq? y '())) '#f)
                               ((AND1 (LIST? x) (LIST? y)) (AND1 (Equals? (CAR x) (CAR y)) (Equals? (CDR x) (CDR y) )))
                               ((AND1 (PAIR? x) (PAIR? y)) (AND1 (Equals? (CAR x) (CAR y)) (Equals? (CDR x) (CDR y) )))
                               (#t (eq? x y))
                               )))

(define AND1 (lambda(x y) (cond ((eq? x '#f) '#f)
                                ((eq? y '#f) '#f)
                                (#t '#t)
                                )))

(define OR1 (lambda(x y) (cond ((eq? x '#t) '#t)
                               ((eq? y '#t) '#t)
                               (#t '#f)
                               )))