Ivelin Pavlov

Функция за деструктивно обръщане на списък.
От (1 2 3 4 5) => (5 4 3 2 1).

(define (reverse1 l)
  (if (null? l) '()
     (append (reverse1 (cdr l)) (list (car l)))
))
(define (reverse! l)
   (let ((l1 (reverse1 l)))
     (begin
     (set-cdr! l (cdr l1))
     (set-car! l (car l1))
     )
))
(define l (list 1 2 3))
(reverse! l)
l

Тази функция взима число и връща друго създадено от нечетните цифри на 1-то. Или по-скоро преобразува число, като маха неговите четни цифри.
На  123456 връща 135

(define (make_number n)
  (define (get-num num)
    (if (odd? num)
        num
        0))
  (cond ((= n 0) 0)
        (else (+ (get-num (remainder n 10))
              (if (odd? (quotient (remainder n 100) 10)) (* 10 (make_number (quotient n 10)))
                  (make_number (quotient n 10)))))))
(make_number 123456789)

Ето и една функция на Lisp, за намиране на сумата от четните цифри на едно число.
Или на 2245533, ще върне 2+2+4=8

(define (even-digits n)
  (define (get-num num)
    (if (even? num)
        num
        0))
  (cond
    ((= n 0) 0)
    (else (+
           (get-num (remainder n 10))
           (even-digits (quotient n 10))))))
(even-digits 2222333)

remove_deep премахва елемент от списък, които може да има като елемент други списъци.
Или от L = {1, 2, {3}, {4, 5, {6}}, 7}, може да премахнем всяко число с „remove_deep L x“.

(define (remove_deep l x)
  (define (cons_helper a b)
    (if (= x a)
        b
        (cons a b)))
  (cond 
    ((null? l) l)
    ((list? (car l))
     (cons (remove_deep (car l) x)
             (remove_deep (cdr l) x)))
    (else (cons_helper (car l)
                       (remove_deep (cdr l) x)))))
(remove_deep (list 2 5 3 (list 2 6 (list 2 3))) 3)

Реда на Фибоначи написан на Лисп

(define (fib n)
	(cond ((= n 0) 0)
              ((= n 1) 1)
              (else (+ (fib (- n 1))
                       (fib (- n 2))))))
;izpolzvane
(fib 6)
;otgovor 8