(defun memoize (fn)
   (let ((cache (make-hash-table :test #'equal)))
      #'(lambda (&rest args)
         (multiple-value-bind (val win) (gethash args cache)
            (if win
               val
               (setf (gethash args cache)
                      (apply fn args)))))))

(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)))