Eight queens problem

eight_queens.clj

(ns queens
  (:require [interfaces :refer [enumerate-interval]]))

;; Solution for Eight Queens Problem from SICP 2.42

(def empty-board [[[]]])

(def board-size 8)

(defn safe? [k positions]
  (let [s-k (- k 1)
        position (last positions)
        last-queen (last position)
        existing-queens (vec (take (- (count position) 1) position))
        filtered-queens
        (filter (fn [[col queen]]
                  (if (or
                       (= queen last-queen)
                       (= (+ (- queen s-k) col) last-queen)
                       (= (- (+ queen s-k) col) last-queen))
                    false
                    true))
                (map-indexed vector existing-queens))]

    (if (= (count existing-queens)
           (count filtered-queens))
      true
      false)))

(defn adjoin-position [new-row k rest-of-queens]
  (let [r (- new-row 1)]
    (vec (map (fn [position]
                (if (< (count position) board-size)
                  (conj position r)
                  position)) rest-of-queens))))

(defn queens* [board]
  (if (= board 0)
    empty-board
    (filter
     (fn [positions]
       (let [safe
             (safe? board positions)]
        ;(println "Safe: " positions safe board)
         safe))
     (mapcat
      (fn [rest-of-queens]
        (map
         (fn [new-row] (adjoin-position new-row board rest-of-queens))
         (enumerate-interval 1 board-size)))
      (queens* (- board 1))))))