Finish solver

Author: Raphael Sofaer

in.json

@@ -4,28 +4,98 @@
         clojure.contrib.combinatorics)
   (:gen-class))
 
-(def input-data
-  ((json/decode (slurp "in.json")) :rows))
 (def nums #{1 2 3 4 5 6 7 8 9})
 (def pairs (cartesian-product (range 1 10) (range 1 10)))
+(defn print-return [a] (println a) a)
 
-(defn get-row [mat i] (nth mat (- i 1)))
-(defn get-col [mat j] (map #(nth % (- j 1)) mat))
-(defn get-cell [mat i j] (nth (get-row mat i) (- j 1)))
-(defn get-zeros [mat] (map (filter #(= (first %) 0) (map (fn [[i j]] [(get-cell mat i j) [i j]]) pairs)))
+(defn get-row [mat i] (let [idx (* 9 (dec i))]
+  (take 9 (drop idx mat))))
+(defn get-col [mat j] (take-nth 9 (drop (dec j) mat)))
+(defn get-cell [mat i j] 
+  (nth (get-row mat i) (dec j)))
+(defn get-zeros [mat] (map (filter #(= (first %) 0) (map (fn [[i j]] [(get-cell mat i j) [i j]]) pairs))))
 
 
-(defn block-n [i-or-j] (nth [1,1,1,2,2,2,3,3,3] (- i-or-j 1)))
+(defn block-n[i-or-j] 
+  (quot (- i-or-j 1) 3))
+
 (defn get-box [mat i j]
   (let [i-block (block-n i)
-        j-block (block-n j)
-        rows (subvec mat (- (* i-block 3) 3) (* i-block 3))]
-    (flatten 
-      (map (fn [row] (subvec row (- (* j-block 3) 3) (* j-block 3)) ) rows))))
-(defn nums-remaining [mat i j] 
-  (if (= (get-cell mat i j) 0)
-      (difference nums (union (set (get-row mat i)) (set (get-col mat j)) (set (get-box mat i j))))
-      #{}))
+        j-block (block-n j)]
+    (vec (flatten (nth (partition 3 (take-nth 3 (nthnext (partition 3 mat) j-block))) i-block )))))
+
+(defn nums-remaining [mat idx] 
+  (let [i (inc (quot idx 9))
+        j (inc (rem idx 9))]
+    (if (= (get-cell mat i j) 0)
+        (difference nums (union (set (get-row mat i)) (set (get-col mat j)) (set (get-box mat i j))))
+        nil)
+    ))
+
+
+(defn consistent? [mat] 
+  (let [possibilities (map #(apply nums-remaining mat %) pairs)]
+    (every? (fn [set] (or (nil? set) (> (count set) 0))) possibilities)))
+
+(defn solved? [mat] (and (not (nil? mat)) (consistent? mat) (not-any? #(= % 0) mat)))
+
+(defn set-at-index [v e idx] 
+  (concat (take idx v) [e] (drop (+ idx 1) v)))
+(defn first-zero [mat]
+  (let [idx (.indexOf mat 0)]
+    [(inc (quot idx 9)) (inc (rem idx 9)) idx]))
+
+(defn solve [mat]
+  (println mat)
+  (let [idx (.indexOf mat 0)]
+    (if (= -1 idx)
+      mat
+      (let [nums (nums-remaining mat idx)]
+      (if (= 0 (count nums))
+        nil
+        (let [paths (filter #(not (nil? %)) 
+                      (map (fn [n] (solve (set-at-index mat n idx))) nums ))]
+          (if (empty? paths)
+            nil
+            (first paths))))))))
+
+(def easy-data
+   [0 0 0  0 0 0  0 0 7
+    7 0 4  0 0 0  8 9 3
+    0 0 6  8 0 2  0 0 0
+
+    0 0 7  5 2 8  6 0 0
+    0 8 0  0 0 6  7 0 1
+    9 0 3  4 0 0  0 8 0
+
+    0 0 0  7 0 4  9 0 0
+    6 0 0  0 9 0  0 0 0
+    4 5 9  0 0 0  1 0 8])
+
+(def hard-data
+  [0 3 0  0 0 0  0 4 0
+   0 1 0  0 9 7  0 5 0
+   0 0 2  5 0 8  6 0 0
+  
+   0 0 3  0 0 0  8 0 0
+   9 0 0  0 0 4  3 0 0
+   0 0 7  6 0 0  0 0 4
+  
+   0 0 9  8 0 5  4 0 0
+   0 7 0  0 0 0  0 2 0
+   0 5 0  0 7 1  0 8 0])
 
+(def ecco-data
+  [7 0 0  0 0 0  0 6 4
+   0 0 6  0 0 0  0 0 0
+   0 0 0  0 0 8  0 2 0
+  
+   5 6 3  0 0 0  0 0 0
+   0 0 0  0 7 0  2 0 9
+   0 0 0  0 0 0  0 0 0
+  
+   0 5 0  0 0 0  3 0 0
+   0 0 0  4 0 0  0 9 0
+   1 7 0  9 0 0  0 0 8])
 (defn -main []
-  (println (input-data)))
+  (println (partition 3 (solve hard-data))))

src/sudoku/core.clj

@@ -2,24 +2,31 @@
 require 'pp'
 require 'ruby-debug'
 require 'json'
+require 'perftools'
 class SudokuState
   def initialize rows
+    #@@stop_after_a_while ||= 0
+    @@failures ||= {}
+    @nums_remaining ||= {}
     @rows = rows
+    @cols = []
   end
 
   def row(i)
     @rows[i - 1]
   end
 
   def col(j)
-    @rows.map{|r| r[j-1]}
+    @cols[j] ||= @rows.map{|r| r[j-1]}
   end
 
   def cell(i, j)
     row(i)[j-1]
   end
 
   def set_cell(i, j, n)
+    @nums_remaining = {}
+    @cols[j] = nil
     i = i-1
     j = j-1
     @rows[i][j] = n
@@ -41,11 +48,13 @@ def box(i, j)
   end
 
   def nums_remaining(i, j)
-    possibilities = [1,2,3,4,5,6,7,8,9]
-    possibilities = possibilities - row(i)
-    possibilities = possibilities - col(j)
-    possibilities = possibilities - box(i,j)
-    possibilities
+    @nums_remaining[[i,j]] ||= lambda {
+      possibilities = [1,2,3,4,5,6,7,8,9]
+      possibilities = possibilities - row(i)
+      possibilities = possibilities - col(j)
+      possibilities = possibilities - box(i,j)
+      possibilities
+    }.call
   end
 
   def zeros
@@ -60,21 +69,29 @@ def zeros
     result
   end
 
+  def inconsistent?
+    return  "inconsistent state" if @@failures[@rows.hash]
+    if zeros.detect{|coords| nums_remaining(coords[0], coords[1]) == 0}
+      @@failures[@rows.hash] = true
+      return "inconsistent state"
+    end
+  end
   def basic_solve
     still_changing = true
     while still_changing
       still_changing = false
       zeros.each do |c|
         possibilities = nums_remaining(c[0],c[1])
         if possibilities.count == 0
+          @@failures[@rows.hash] = true
           return "inconsistent state"
         elsif possibilities.count == 1
           still_changing = true
           set_cell(c[0], c[1], possibilities.first)
         end
       end
     end
-    @rows
+    self
   end
 
   def solved?
@@ -85,13 +102,29 @@ def clone
     self.class.new JSON.parse(@rows.to_json)
   end
   def spec_solve
+    #@@stop_after_a_while += 1
+    #return if @@stop_after_a_while > 10000
     b_solved = self.clone.basic_solve
-    if b_solved == "inconsistent state"
+    if b_solved == "inconsistent state" || b_solved.inconsistent?
       return "inconsistent state"
     end
-    state = SudokuState.new(b_solved)
-    return state if state.solved?
-    /*
+    return b_solved if b_solved.solved?
+
+    stack = []
+    b_solved.zeros.each do |zero|
+      i = zero[0]
+      j = zero[1]
+
+      v = nums_remaining(i,j)
+      v.each do |num|
+        new_state = self.clone
+        new_state.set_cell(i, j, num)
+        next if new_state.inconsistent?
+        newer_state = new_state.spec_solve
+        return newer_state if newer_state.instance_of?(SudokuState) && newer_state.solved?
+      end
+    end
+=begin
       Let R be the entries in b_solved having two or more possible values
       for each entry e in R
         let V be the possible values for E
@@ -105,7 +138,7 @@ def spec_solve
           pop state
         end
       end
-      */
+=end
   end
 end
 basic_solvable = [[0,0,0, 0,0,0, 0,0,7],
@@ -119,5 +152,25 @@ def spec_solve
                   [0,0,0, 7,0,4, 9,0,0],
                   [6,0,0, 0,9,0, 0,0,0],
                   [4,5,9, 0,0,0, 1,0,8]]
+
+adv_solvable =  [[0,3,0, 0,0,0, 0,4,0],
+                 [0,1,0, 0,9,7, 0,5,0],
+                 [0,0,2, 5,0,8, 6,0,0],
+
+                 [0,0,3, 0,0,0, 8,0,0],
+                 [9,0,0, 0,0,4, 3,0,0],
+                 [0,0,7, 6,0,0, 0,0,4],
+
+                 [0,0,9, 8,0,5, 4,0,0],
+                 [0,7,0, 0,0,0, 0,2,0],
+                 [0,5,0, 0,7,1, 0,8,0]]
 s = SudokuState.new(basic_solvable)
 pp s.basic_solve
+
+s = SudokuState.new(adv_solvable)
+
+PerfTools::CpuProfiler.start("tmp/sudoku_profile") do
+  solved = s.spec_solve
+end
+
+pp solved

sudoku.rb

@@ -2,5 +2,40 @@
   (:use [sudoku.core])
   (:use [clojure.test]))
 
-(deftest replace-me ;; FIXME: write
-  (is false "No tests have been written."))
+(deftest rows
+  (is (= (get-row easy-data 1) [0 0 0  0 0 0  0 0 7]))
+  (is (= (get-row easy-data 4) [0 0 7  5 2 8  6 0 0])))
+
+(deftest columns
+  (is (= (get-col easy-data 1) [0 7 0  0 0 9  0 6 4]))
+  (is (= (get-col easy-data 4) [0 0 8  5 0 4  7 0 0])))
+
+(deftest cells
+  (is (= (get-cell easy-data 1 1) 0))
+  (is (= (get-cell easy-data 9 9) 8))
+  (is (= (get-cell easy-data 1 9) 7))
+  (is (= (get-cell easy-data 9 1) 4))
+  (is (= (get-cell easy-data 5 5) 0)))
+
+(deftest boxes
+  (is (= (get-box easy-data 1 1) [0 0 0  7 0 4  0 0 6]))
+  (is (= (get-box easy-data 6 1) [0 0 7  0 8 0  9 0 3]))
+  (is (= (get-box easy-data 7 7) [9 0 0  0 0 0  1 0 8]))
+  (is (= (get-box easy-data 4 8) [6 0 0  7 0 1  0 8 0])))
+
+(deftest zeros
+  (is (= (apply get-cell easy-data (take 2(first-zero easy-data))) 0)))
+
+(deftest solver
+  (is (= (solve easy-data)
+          [8 1 5  3 4 9  2 6 7
+           7 2 4  6 5 1  8 9 3
+           3 9 6  8 7 2  4 1 5
+
+           1 4 7  5 2 8  6 3 9
+           5 8 2  9 3 6  7 4 1
+           9 6 3  4 1 7  5 8 2
+
+           2 3 1  7 8 4  9 5 6
+           6 7 8  1 9 5  3 2 4
+           4 5 9  2 6 3  1 7 8])))