Most completed.

src/sudoku.clj

@@ -3,56 +3,129 @@
 
 (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 [[y x] coord]
+ (set (get-in board [y]))))
 
 (defn col-values [board coord]
- nil)
+ (let [[y x] coord]
+ (loop [result #{} acc 0]
+ (cond
+ (== acc (count board))
+ result
+ :else (recur (conj result (value-at board [acc x])) (inc acc))))))
 
 (defn coord-pairs [coords]
- nil)
+ (let [result (for [a coords b coords]
+ [a b])]
+ (vec result)))
+
+(defn top-left-coord [coord]
+ (let [[y x] coord]
+ [(- y (rem y 3)) (- x (rem x 3))]))
 
 (defn block-values [board coord]
- nil)
+ (let [[y x] (top-left-coord coord)]
+ (loop [result #{} y-coord y x-coord x]
+ (cond
+ (== (+ y 3) y-coord)
+ result
+ (== (+ x 3) x-coord)
+ (recur result (inc y-coord) x)
+ :else (recur (conj result (value-at board [y-coord x-coord])) y-coord (inc x-coord))))))
 
 (defn valid-values-for [board coord]
- nil)
+ (if (has-value? board coord)
+ #{}
+ (let [taken-values (set/union (row-values board coord)
+ (col-values board coord)
+ (block-values board coord))]
+ (set/difference all-values taken-values))))
+
+(defn get-all-numbers [board]
+ (loop [result '() rows board]
+ (if (empty? rows)
+ result
+ (recur (concat result (first rows)) (rest rows)))))
 
 (defn filled? [board]
- nil)
+ (not (contains? (set (get-all-numbers board)) 0)))
 
 (defn rows [board]
- nil)
+ (loop [result [] rows board]
+ (if (empty? rows)
+ result
+ (recur (conj result (set (first rows))) (rest rows)))))
 
 (defn valid-rows? [board]
- nil)
+ (loop [all-rows (rows board)]
+ (cond
+ (empty? all-rows)
+ true
+ (= (first all-rows) all-values)
+ (recur (rest all-rows))
+ :else false)))
 
 (defn cols [board]
- nil)
+ (loop [result [] acc 0]
+ (cond
+ (== 9 acc)
+ result
+ :else (recur (conj result (col-values board [0 acc])) (inc acc)))))
 
 (defn valid-cols? [board]
- nil)
+ (loop [all-cols (cols board)]
+ (cond
+ (empty? all-cols)
+ true
+ (= (first all-cols) all-values)
+ (recur (rest all-cols))
+ :else false)))
 
 (defn blocks [board]
- nil)
+ (loop [result [] y 0 x 0]
+ (cond
+ (>= x 9)
+ result
+ (>= y 9)
+ (recur result 0 (+ x 3))
+ :else (recur (conj result (set (block-values board [x y]))) (+ y 3) x))))
 
 (defn valid-blocks? [board]
- nil)
+ (loop [all-blocks (blocks board)]
+ (cond
+ (empty? all-blocks)
+ true
+ (= (first all-blocks) all-values)
+ (recur (rest all-blocks))
+ :else false)))
 
 (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)
+ (loop [y 0 x 0]
+ (cond
+ (== 9 y)
+ nil
+ (== 0 (get-in board [y x]))
+ [y x]
+ (== 8 x)
+ (recur (inc y) 0)
+ :else (recur y (inc x)))))
 
 (defn solve [board]
  nil)