8 ферзей

(defun nobeats ( Y lst X )
  (setq Y1 (car lst)) (not(eq(- Y1 Y) X)) (not(eq (- Y Y1 ) X)) (setq X1 (+ X 1)) (nobeats Y (cdr lst) X1) )
 
(defun safely ( lst ) 
  (cond ( (null lst) nil)
  ( t (safely (cdr lst)) (nobeats (car lst) (cdr lst) 1)) ))
 
(defun permut (list)
  (cond ((null list) nil)
        ((null (cdr list)) (list list))
        (t (loop for element in list
             append (mapcar (lambda (l) (cons element l))
                            (permut (remove element list)))))))
(defun queen ( lst )
  (cond ( (null lst) nil)
        ( t (safely (permut '(1 2 3 4 5 6 7 8))) ) ))

(defun equ ( lst x  )
  (cond ( (null lst) nil)
        ( (eq x (car lst))  (cons (car lst) (equ (cdr lst) x)) )
        ( t (equ (cdr lst) x) ) ))
 
(defun big ( lst x  )
  (cond ( (null lst) nil)
        ( (< x (car lst))  (cons (car lst) (big (cdr lst) x)) )
        ( t (big (cdr lst) x) ) ))
 
(defun less ( lst x  )
  (cond ( (null lst) nil)
        ( (> x (car lst))  (cons (car lst) (less (cdr lst) x)) )
        ( t (less (cdr lst) x) ) ))
 
(defun div ( lst x  )
  (cond ( (null lst) nil)
        ( t (list  (less lst x) (equ lst x) (big lst x) )) ))

(def solve (macro ()
    (def c-step-vars (macro (c) (cond (> c 8) "win" (
        (def rds nil)
        (def add-rds (macro (_c _r)
            (set! rds (cons (+ _r (- _c c)) (cons (+ _r (- c _c)) (cons _r rds))))))
        (def i 1) (while (< i c) (add-rds i (eval (++ "a" i))) (set! i (+ i 1)))
        (filter (lambda (e) (noelem e rds)) '(1 2 3 4 5 6 7 8))))))
 
    (def find-solution (macro (col) (
        (def step-vars (c-step-vars col))
        (cond (eq? "win" step-vars)
                  ((def col-names '("a" "b" "c" "d" "e" "f" "g" "h"))
                  (def i 1) (while (< i 9)
                      (print (car col-names)) (print (eval (++ "a" i))) (print " ")
                      (set! col-names (cdr col-names)) (set! i (+ i 1)))
                  (printLn ""))
            (map (lambda (v) (name-def (++ "a" col) v)
                             (find-solution (+ 1 col))) step-vars)))))
    (find-solution 1) ))
 
(printLn "Решения:") (solve) (printLn "Конец")

(def solve (macro ()
    (def map-m (macro (f _l) (cond (null? _l) nil (cons (f (car _l)) (map-m f (cdr _l))))))
    (def find-solution (macro (col)
        (cond (> col 8)
            ((map-m (macro (i)
                (print (list-ref (- i 1) '("a" "b" "c" "d" "e" "f" "g" "h")))
                (print (eval (++ "a" i))) (print " ")) '(1 2 3 4 5 6 7 8))
                (printLn ""))
 
            ((def add-rds (macro (_c _r)
                (cons (+ _r (- _c col)) (cons (+ _r (- col _c)) _r))))
            (def rds (concat (map-m (macro (i) (add-rds i (eval (++ "a" i))))
                (list-from-to 1 (- col 1)))))
            (map-m (lambda (v) (name-def (++ "a" col) v) (find-solution (+ 1 col)))
                (filter (lambda (e) (noelem e rds)) '(1 2 3 4 5 6 7 8))))
    )))
    (find-solution 1) ))