BronKClojure

(defn empty-graph [n]
 (vec (repeat n #{})))

(defn add-directed-edge [g n1 n2]
 (let [n1-neighbors (g n1)]
   (assoc g n1 (conj n1-neighbors n2))))

(defn add-edge [g [n1 n2]]
 (-> g
     (add-directed-edge n1 n2)
     (add-directed-edge n2 n1)))

(defn sanity1 []
  (let [edgelist '([0 1] [0 2] [1 2] [1 3])]
    (reduce add-edge (empty-graph 4) edgelist)))

(defn neighV [graph nodenum]
  (let [ret-list (for [i (range (count graph)) :when (contains? (graph i) nodenum)] i)]
    ret-list))

(defn BK-Call [graph]
  (Bron-Kerbosch '() '(range (count graph)) '() graph '()))

(defn Bron-Kerbosch [r p x graph cliques]
  (cond (and (empty? p) (empty? x)) (conj cliques r)
        :else
        (let [neigh (neighV graph (dec (count p)))]
          (loop [loop-clq '(cliques)
                 loop-cnt '(dec (count p))
                 loop-p '(p)
                 loop-x '(x)]
            (cond (= -1 loop-cnt) loop-clq
                  :else
                  (recur (conj loop-clq (Bron-Kerbosch (conj r loop-cnt) (conj p neigh) (disj x neigh)))
                         (dec loop-cnt)
                         (disj p loop-cnt)
                         (conj x loop-cnt)))))))