Sudoku OK ?!

src/sudoku.clj

@@ -2,57 +2,95 @@
   (:require [clojure.set :as set]))
 
 (def board identity)
+(def all-values #{1 2 3 4 5 6 7 8 9})
 
 (defn value-at [board coord]
-  nil)
+  (get-in board coord))
 
 (defn has-value? [board coord]
-  nil)
+  (not= 0 (value-at board coord)))
 
 (defn row-values [board coord]
-  nil)
+  (let [[row col] coord]
+    (set (nth board row))))
 
 (defn col-values [board coord]
-  nil)
+  (let [[row col] coord]
+    (set (map #(nth % col) board))))
 
 (defn coord-pairs [coords]
-  nil)
+  (for [row coords, col coords]
+    [row col]))
 
 (defn block-values [board coord]
-  nil)
+  (let [[row col] coord
+        top (* 3 (quot row 3))
+        left (* 3 (quot col 3))]
+    (set (for [r (range top (+ top 3))
+              c (range left (+ left 3))]
+          (value-at board [r c])))))
 
 (defn valid-values-for [board coord]
-  nil)
+  (if (has-value? board coord)
+    #{}
+    (set/difference all-values
+                    (row-values board coord)
+                    (col-values board coord)
+                    (block-values board coord))))
 
 (defn filled? [board]
-  nil)
+  (-> (mapcat identity board)
+      set
+      (contains? 0)
+      not
+      ))
 
 (defn rows [board]
-  nil)
+  (map set board))
 
 (defn valid-rows? [board]
-  nil)
+  (every? #(= % all-values) (rows board)))
 
 (defn cols [board]
-  nil)
+  (->> (apply map vector board)
+       (map set)))
 
 (defn valid-cols? [board]
-  nil)
+  (every? #(= % all-values) (cols board)))
 
 (defn blocks [board]
-  nil)
+  (->> (map #(partition 3 %) board)
+       (partition 3)
+       (mapcat #(apply map concat %))
+       (map set)))
 
 (defn valid-blocks? [board]
-  nil)
+  (every? #(= % all-values) (blocks board)))
 
 (defn valid-solution? [board]
-  nil)
+  (and (valid-rows? board)
+       (valid-cols? board)
+       (valid-blocks? board)))
 
 (defn set-value-at [board coord new-value]
-  nil)
+  (assoc-in board coord new-value))
 
 (defn find-empty-point [board]
-  nil)
+  (->> (for [r (range 9)
+             c (range 9)]
+         [r c])
+       (filter #(not (has-value? board %)))
+       first
+       ))
+
+(defn solve-helper [board]
+  (if-let [ep (find-empty-point board)]
+    (->> (valid-values-for board ep)
+         (mapcat #(solve-helper (set-value-at board ep %))))
+    (if (valid-solution? board)
+      [board]
+      nil
+      )))
 
 (defn solve [board]
-  nil)
+  (first (solve-helper board)))