add solver

sudoku/sudoku.lua

@@ -94,6 +94,15 @@ function showBoard(board)
     end
 end
 
+function checkBoardsEqual(b1, b2)
+    for i = 1, 9 do
+        for j = 1, 9 do
+            if b1[i][j] ~= b2[i][j] then return false end
+        end
+    end
+    return true
+end
+
 function iterZones(board)
     local row = 0
     local column = 0
@@ -433,129 +442,60 @@ function checkSearchSpace(board, searchSpace)
     return true
 end
 
-function backTrace2(board, s)
+function findFirstLeastOption(searchSpace)
-    local s = s or buildSearchSpace(board)
+    local min = 9
-    local x, y = findFirstEmptyCell(board)
+    local x, y
-    for _, v in ipairs(s[x][y]) do
+    for i = 1, 9 do
-        local b = cloneBoard(board)
+        for j = 1, 9 do
-        b[x][y] = v
+            local len = #searchSpace[i][j]
-        allPairs(b)
+            if len > 0 and len < min then
-        local ok, finished = checkBoard(b)
+                min = len
-        if finished then return b end
+                x = i
-        if ok and checkSearchSpace(b) then
+                y = j
-            local r = backTrace(b)
-            if r then return r end
             end
         end
+    end
+    return x, y, min
+end
+
+function backTrace(trace)
+    while true do
+        local currentStep = trace[#trace]
+        applyFillSinglesRepeatedly(currentStep.board)
+        local ok, finished = checkBoard(currentStep.board)
+        if not ok then rollBack(trace); goto endOfTheLoop end
+        if finished then return currentStep.board end
+        local s = buildSearchSpace(currentStep.board)
+        ok = checkSearchSpace(currentStep.board, s)
+        if not ok then rollBack(trace); goto endOfTheLoop end
+        if not currentStep.pointer then
+            local x, y = findFirstLeastOption(s)
+            currentStep.options = s[x][y]
+            currentStep.pointer = 0
+            currentStep.x = x
+            currentStep.y = y
+        end
+        currentStep.pointer = currentStep.pointer + 1
+        if currentStep.pointer > #currentStep.options then rollBack(trace); goto endOfTheLoop end
+        local nextStep = {}
+        nextStep.board = cloneBoard(currentStep.board)
+        nextStep.board[currentStep.x][currentStep.y] = currentStep.options[currentStep.pointer]
+        trace[#trace+1] = nextStep
+    ::endOfTheLoop::
+    end
 end
 
-function backTrace3(board, tried)
+function rollBack(trace)
-    -- dbg()
+    assert(#trace > 1, "Something is very wrong!")
-    local tried = tried or createEmptyBoard()
+    table.remove(trace)
-    for x = 1, 9 do
-        for y = 1, 9 do
-            if tried[x][y] == 0 and board[x][y] == 0 then
-                tried[x][y] = 1
-                print(x, y)
-                local s = buildSearchSpace(board)
-                for _, v in ipairs(s[x][y]) do
-                    local b = cloneBoard(board)
-                    b[x][y] = v
-                    allPairs(b)
-                    local ok, finished = checkBoard(b)
-                    if finished then return b end
-                    if ok and checkSearchSpace(b) then
-                        local r = backTrace(b, tried)
-                        if r then return r end
-                    end
-                end
-            end
-        end
-    end
-end
-
-function backTrace4(board, cx, cy)
-    local s = buildSearchSpace(board)
-    for x = 1, 9 do
-        for y = 1, 9 do
-            if x ~= cx and y ~=cy then
-                for _, v in ipairs(s[x][y]) do
-                    local b= cloneBoard(board)
-                    b[x][y] = v
-                    print(x, y, v)
-                    -- allPairs(b)
-                    applyFillSinglesRepeatedly(b)
-                    local ok, finished = checkBoard(b)
-                    if finished then return b end
-                    if ok and checkSearchSpace(b) then
-                        local r = backTrace(b, x, y)
-                        if r then return r end
-                    end
-                end
-            end
-        end
-    end
-end
-
-function backTrace(board)
-    local s = buildSearchSpace(board)
-    for x = 1, 9 do
-        for y = 1, 9 do
-            for _, v in ipairs(s[x][y]) do
-                local b= cloneBoard(board)
-                b[x][y] = v
-                -- allPairs(b)
-                applyFillSinglesRepeatedly(b)
-                local ok, finished = checkBoard(b)
-                print(x, y, v, ok, finished)
-                showBoard(b)
-                io.read(1)
-                if finished then return b end
-                if ok and checkSearchSpace(b) then
-                    local r = backTrace(b, x, y)
-                    if r then return r end
-                end
-            end
-            return
-        end
-    end
 end
 
 function solve(board)
-    -- allPairs(board)
+    local t = {}
-    applyFillSinglesRepeatedly(board)
+    t[1] = {board=cloneBoard(board),}
-    local ok, finished = checkBoard(board)
+    return backTrace(t)
-    if not ok then print("something's wrong!"); return end
-    if finished then showBoard(board); return end
-    local r = backTrace(board)
-    if r then
-        showBoard(r)
-    else
-        print "Could not solve!"
-    end
 end
 
-function sHelper(n)
-    local fn = string.format("/home/reza/p/lua/22.sudoku/boards/%03d.txt", n)
-    local board = loadBoard(fn)[1]
-    solve(board)
-end
-
-function checkBoardsEqual(b1, b2)
-    for i = 1, 9 do
-        for j = 1, 9 do
-            if b1[i][j] ~= b2[i][j] then return false end
-        end
-    end
-    return true
-end
-
--- b = loadBoard("b.txt")[1]
--- applyFillSinglesRepeatedly(b)
--- s = buildSearchSpace(b)
--- allPairs(b)
-
-
 return {
     loadBoard = loadBoard,
     cloneBoard = cloneBoard,
@@ -566,4 +506,5 @@ return {
     showBoard = showBoard,
     checkBoardsEqual = checkBoardsEqual, 
     saveBoard = saveBoard,
+    solve = solve,
 }

ui/sudokucanvas.lua

@@ -433,6 +433,9 @@ function SudokuCanvas:keypressed(key)
         undo(self)
     elseif key == "f" then
         sudoku.saveBoard("lastBoard.txt", self.board[1], self.board[2])
+    elseif key == "c" then
+        self.board[2] = sudoku.solve(self.board[1])
+        self:checkBoard()
     end
     self.cursor.x = x
     self.cursor.y = y