SBCL 1.0.1

Версия компилятора Steel Bank Common Lisp.

Примеры:

Hello, World! - Lisp (38):

Результат выполнения этого кода в интерактивном режиме имеет следующий вид:

Hello, World!
NIL

Первая строка содержит стандартный поток вывода, вторая — значение, возвращаемое кодом (в данном случае — его отсутствие).

(format t "Hello, World!~%")

Факториал - Lisp (39):

Этот пример использует рекурсивное определение факториала, естественное для Lisp. Демонстрирует следующие особенности языка:

• математические операторы: (- n 1) — это префиксная запись, эквивалентная инфиксной записи n-1;
• операторы сравнения: (= n 0) возвращает T, если n равно нулю, и nil (используется как false) в противном случае;
• условный оператор if: выражения в Lisp определяются по скобкам и могут записыватся в несколько строк;
• определение функции с использованием defun;
• макрос Common Lisp loop;
• спецификации формата вывода в format: ~D соответствует целому числу, а ~% — концу строки.

(defun factorial (n)
    (if (= n 0)
        1
        (* n (factorial (- n 1))) ) )

(loop for i from 0 to 16
    do (format t "~D! = ~D~%" i (factorial i)) )

Числа Фибоначчи - Lisp (40):

Используется рекурсивное определение чисел Фибоначчи. Часть finally макроса loop выполняется после конца цикла.

(defun fibonacci (n)
    (if (< n 3)
        1
        (+ (fibonacci (- n 1)) (fibonacci (- n 2))) ))

(loop for i from 1 to 16
    do (format t "~D, " (fibonacci i))
    finally (format t "...~%"))

Факториал - Lisp (112):

Внутренний цикл с операцией collect создает список чисел от 1 до n, после чего к нему применяется операция *.

(loop for n from 0 to 16
   do (format t "~D! = ~D~%" n 
        (apply '* (loop for i from 1 to n 
                        collect i)) ) )

Квадратное уравнение - Lisp (138):

Common Lisp позволяет работать с комплексными числами и выводить их на печать в формате #C(real imag). Функция write-to-string преобразует число в строку.

(defun quadratic-roots-2 (A B C)
  (cond ((= A 0) (string "Not a quadratic equation."))
    (t
    (let ((D (- (* B B) (* 4 A C))))
      (cond ((= D 0) (concatenate 'string "x = " (write-to-string (/ (+ (- B) (sqrt D)) (* 2 A)))))
        (t
        (concatenate 'string (concatenate 'string "x1 = " (write-to-string (/ (+ (- B) (sqrt D)) (* 2 A))))
                             (concatenate 'string "~%x2 = " (write-to-string (/ (- (- B) (sqrt D)) (* 2 A)))))))))))

(let ((A (read))
     (B (read))
     (C (read)))
(format t (quadratic-roots-2 A B C)))

CamelCase - Lisp (268):

(defun camel-case (s)
  (remove #\Space 
          (string-capitalize
           (substitute #\Space nil s :key #'alpha-char-p))))

(princ (camel-case (read-line)))

Комментарии

blog comments powered by Disqus