In [7]:

    

#!/usr/bin/env python
# coding=utf-8

import re, os, sys

def SudokuInit():
    sudoku = {"(1, 1)": " ", "(1, 2)": "4", "(1, 3)": "3", "(1, 4)": " ", "(1, 5)": "5",
                             "(1, 6)": " ", "(1, 7)": "6", "(1, 8)": " ", "(1, 9)": " ",
              "(2, 1)": " ", "(2, 2)": " ", "(2, 3)": " ", "(2, 4)": "9", "(2, 5)": " ",
                             "(2, 6)": " ", "(2, 7)": " ", "(2, 8)": " ", "(2, 9)": " ",
              "(3, 1)": "8", "(3, 2)": "6", "(3, 3)": " ", "(3, 4)": " ", "(3, 5)": " ",
                             "(3, 6)": " ", "(3, 7)": " ", "(3, 8)": " ", "(3, 9)": " ",
              "(4, 1)": " ", "(4, 2)": " ", "(4, 3)": " ", "(4, 4)": " ", "(4, 5)": "6",
                             "(4, 6)": " ", "(4, 7)": "1", "(4, 8)": "2", "(4, 9)": " ",
              "(5, 1)": " ", "(5, 2)": "5", "(5, 3)": "2", "(5, 4)": " ", "(5, 5)": "3",
                             "(5, 6)": " ", "(5, 7)": " ", "(5, 8)": " ", "(5, 9)": " ",
              "(6, 1)": " ", "(6, 2)": " ", "(6, 3)": "9", "(6, 4)": " ", "(6, 5)": " ",
                             "(6, 6)": " ", "(6, 7)": " ", "(6, 8)": " ", "(6, 9)": "5",
              "(7, 1)": "2", "(7, 2)": " ", "(7, 3)": " ", "(7, 4)": " ", "(7, 5)": " ",
                             "(7, 6)": " ", "(7, 7)": " ", "(7, 8)": " ", "(7, 9)": " ",
              "(8, 1)": " ", "(8, 2)": " ", "(8, 3)": " ", "(8, 4)": "5", "(8, 5)": "7",
                             "(8, 6)": " ", "(8, 7)": "9", "(8, 8)": " ", "(8, 9)": " ",
              "(9, 1)": " ", "(9, 2)": " ", "(9, 3)": "1", "(9, 4)": " ", "(9, 5)": "8",
                             "(9, 6)": " ", "(9, 7)": "4", "(9, 8)": " ", "(9, 9)": "6"
             }
    return sudoku

def SquareDict(row_args, col_args):
    row_modrlt = int(row_args) % 3
    col_modrlt = int(col_args) % 3
    row_modict = {"1": [int(row_args) + 1, int(row_args) + 2],
                    "2": [int(row_args) - 1, int(row_args) + 1],
                    "0": [int(row_args) - 2, int(row_args) - 1]
                    }
    col_modict = {"1": [int(col_args) + 1, int(col_args) + 2],
                    "2": [int(col_args) - 1, int(col_args) + 1],
                    "0": [int(col_args) - 2, int(col_args) - 1]
                    }
    square_dict = {"row": row_modict["%s" %row_modrlt], "col": col_modict["%s" %col_modrlt]}
    return square_dict

def SudokuSolver(sudoku):    #TODO:sudokusolver
    pri_subdict = {}
    sec_subdict = {}
    for i in range(1, 10):
        for j in range(1, 10):
            if sudoku["(%s, %s)" %(i, j)] == " ":
                sec_subdict.update({"(%s, %s)" %(i, j): " "})
                del sudoku["(%s, %s)" %(i, j)]
    pri_subdict = sudoku          #TODO:solve in sec_subdict
    sudoku.update(dict(pri_subdict, **sec_subdict))
    while " " in sudoku:
        for i in range(1, 10):
            for j in range(1, 10):
                for k in range(1, 10):
                    if sudoku["(%s, %s)" %(i, j)] == k:
                        #match_dict = {"row": str(i), "col": str(j), "num": str(k)}
                        for m in range(1, 10):
                            rcs_dict = {}
                            rcs_dict.update(sudoku["(%s, %s)" %(i, m)])
                            rcs_dict.update(sudoku["(%s, %s)" %(m, j)])
                        square_dict = SquareDict(i, j)
                        for l in square_dict["row"]:
                            for n in square_dict["col"]:
                                rcs_dict.update(sudoku["(%s, %s)" %(l, n)])
    
    
    sudoku.update(dict(pri_subdict, **sec_subdict))
    return sudoku

def SudokuPrint(sudoku):
    for i in range(3):
        print("+-------+-------+-------+")
        for j in range(3):
            print("| " + sudoku["(%s, %s)" %(3*i+j+1, 1)] + " "
                    + sudoku["(%s, %s)" %(3*i+j+1, 2)] + " "
                    + sudoku["(%s, %s)" %(3*i+j+1, 3)] + " | "
                    + sudoku["(%s, %s)" %(3*i+j+1, 4)] + " "
                    + sudoku["(%s, %s)" %(3*i+j+1, 5)] + " "
                    + sudoku["(%s, %s)" %(3*i+j+1, 6)] + " | "
                    + sudoku["(%s, %s)" %(3*i+j+1, 7)] + " "
                    + sudoku["(%s, %s)" %(3*i+j+1, 8)] + " "
                    + sudoku["(%s, %s)" %(3*i+j+1, 9)] + " |")
    print("+-------+-------+-------+")


if sys.hexversion < 0x20700F0:
    print("a higher python version is required")
    sys.exit()

sudoku = SudokuInit()
SudokuPrint(sudoku)
print
print("==========================")
print
SudokuSolver(sudoku)
SudokuPrint(sudoku)


    

    




+-------+-------+-------+
|   4 3 |   5   | 6     |
|       | 9     |       |
| 8 6   |       |       |
+-------+-------+-------+
|       |   6   | 1 2   |
|   5 2 |   3   |       |
|     9 |       |     5 |
+-------+-------+-------+
| 2     |       |       |
|       | 5 7   | 9     |
|     1 |   8   | 4   6 |
+-------+-------+-------+

==========================

+-------+-------+-------+
|   4 3 |   5   | 6     |
|       | 9     |       |
| 8 6   |       |       |
+-------+-------+-------+
|       |   6   | 1 2   |
|   5 2 |   3   |       |
|     9 |       |     5 |
+-------+-------+-------+
| 2     |       |       |
|       | 5 7   | 9     |
|     1 |   8   | 4   6 |
+-------+-------+-------+

In [ ]: