(defun test-queen(place previous-lst)
  (let ((cur-row (+  1  (length previous-lst))) (counter  1 ))
       (dolist (i previous-lst)
         (if (or
                  (= place i)
                  (= place (+ i (- cur-row counter)))
                  (= place (- i (- cur-row counter))))
             (return)
             (setf counter (+  1  counter))))
       (if (= counter cur-row) t nil)))
(defun put-queen(start-pos max-place previous-list)
  (let ((finded)(num))
   (do ((i start-pos ( 1 + i)))
       ((> i max-place))
    (when (test-queen i previous-list)
        (setf finded t)
        (setf num i)
        (return)))
   (if finded (append previous-list (list num))  nil))))

(defun ncheck-remove(max lst)
  (let ((tmplst lst))
     (do ((i  0 ))
      ((>= max (get-last+ 1  tmplst)))
    (setf tmplst (butlast tmplst)))
  tmplst))

(defun get-last+ 1  (lst)
  (if (null lst)  0 
      (+  1  (car (last lst)))))

(defun put-queens (max-nums)
  (let ((cnt  0 ))
    (let (result-list temp-list)
      (do ((i  1 ))
          ((=  0  i))
        (setf temp-list (put-queen i max-nums result-list))
        (when (null (null temp-list))
          (setf i  1 )
          (setf result-list temp-list))
        (when (null temp-list)
          (setf result-list (ncheck-remove max-nums result-list))
          (setf i (get-last+ 1  result-list))
          (setf result-list (butlast result-list)))
        (when (= max-nums (length result-list))
          (print result-list)
          (incf cnt))))
    (print cnt)))

(define (queens columns)
  (define (check? n k s)
    (cond ((null? s) #t)
          (else (and (not (= k (car s)))
                     (not (= (abs (- k (car s))) n))
                     (check? (+ n  1 ) k (cdr s)))))
  )
  (define (iter r s k n)
    (cond ((=  0  n) (cons s r))
          (else (append (if (check?  1  (+ k  1 ) s) (iter r (cons (+ k  1 ) s)  0  (- n  1 )) '())
                        (if (< (+ k 1) columns) (iter r s (+ k 1) n) '()))))
  )        
  (iter '() '()  0  columns)
)

(define (queens columns)
  (define (check? n k s)
    (cond ((null? s) #t)
          (else (and (not (= k (car s)))
                     (not (= (abs (- k (car s))) n))
                     (check? (+ n  1 ) k (cdr s)))))
  )
  (define (iter r s k n)
    (cond ((=  0  n) (cons s r))
          (else (append (if (check?  1  (+ k  1 ) s) (iter r (cons (+ k  1 ) s)  0  (- n  1 )) '())
                        (if (< (+ k 1) columns) (iter r s (+ k 1) n) '()))))
  )        
  (iter '() '()  0  columns)
)