Algorithm to Solve Sudoku Using Python

A Sudoku is a type of puzzle with number placement. The objective of this game is to complete a square grid of n size with numbers from 0 - 9 or 1 - n. The number in the Sudoku must be placed in each column, each row, and each sub-grid consists of the number from 1 - 'n'. Most sudoku puzzles contain a 9 x 9 grid, and the grids are not fully or partially filled with hints to confirm the solution can be reached.

This type of problem is mostly asked in technical round of the big tech companies such as Amazon, Google, Microsoft.

The company gives the problem description as follows. You have a sudoku puzzle in the 2D matrix form, and you must complete the cells without breaking any rules. The rules for the sudoku puzzle are given below.

Each digit from 1-9 must be present in each row.
Each digit from 1-9 must be present in each column.
Each digit from 1-9 must be present in each of the 3x3 subgrids.

A board is given that contains digits 1-9 and the character '.'. There should be a unique solution to the puzzle and the size of given board is always 9x9. The character '.' represents an empty cell.

The example shows the given sudoku puzzle.

The above image shows a sudoku puzzle of 9x9. The puzzle contains 3x3 sub-grids with some digits that are partially filled. The aim of this game is to fill the box with values from 1-9, and each row, each column and each grid should have unique values.

The solution to the above puzzle is:

The red numbers show the solution to the puzzle.

Let's see how, in Programming, the input is given as:

Input: Puzzle

{ {3, 0, 6, 5, 0, 8, 4, 0, 0},
{5, 2, 0, 0, 0, 0, 0, 0, 0},
{0, 8, 7, 0, 0, 0, 0, 3, 1},
{0, 0, 3, 0, 1, 0, 0, 8, 0},
{9, 0, 0, 8, 6, 3, 0, 0, 5},
{0, 5, 0, 0, 9, 0, 6, 0, 0}, 
{1, 3, 0, 0, 0, 0, 2, 5, 0},
{0, 0, 0, 0, 0, 0, 0, 7, 4},
{0, 0, 5, 2, 0, 6, 3, 0, 0} }

In the above input, there is a 9x9 2D matrix that is sparse, which means it contains more zeros. The goal is to replace the 0 with the digit from 1-9, and each row and column should contain unique digits.

Output:

3 1 6 5 7 8 4 9 2
5 2 9 1 3 4 7 6 8
4 8 7 6 2 9 5 3 1
2 6 3 4 1 5 9 8 7
9 7 4 8 6 3 1 2 5
8 5 1 7 9 2 6 4 3
1 3 8 9 4 7 2 5 6
6 9 2 3 5 1 8 7 4
7 4 5 2 8 6 3 1 9

In the output, we can see that 0 is replaced with the digits from 1-9, and each row, column, and 3x3 grid of the output contains unique values.

There are many approaches to solving the sudoku puzzle. The approaches are:

Naïve Approach: In this approach, all the possible solutions are generated for numbers from 1 to 9 to complete the empty cells. Every configuration is checked one by one until the correct puzzle is formed. For each position that is unassigned, fill the position with a digit from 1 - 9. After the unassigned position is filled, check if the matrix is saved or not. If the puzzle matrix is safe, it recurs for another case.

Here are some steps to solve the problem using Naïve Approach.

First, a function is created to check if the matrix that is given is a valid sudoku or not. A hashmap is made for each row, column and box. If a number has an occurrence greater than 1 in the hashmap, return false; else, return true.
A recursive function is created that takes a grid and the current row and column index.
Some base cases have been checked.
1. If the index present at the end of the matrix means i = N-1 and j = N, then the condition check for the grid is safe or not; if the grid is safe, then the grid is printed, and the true is returned by the function. Else, the value is returned as false.
2. The second base case is when the column value is N, which means the value of j = N, then the index value is moved to the next row, i.e., the value of i is updated to i++ and j = 0.
If the value is not assigned to the current index, then the index is filled with the value 1 to 9, and all the 9 cases are recured with the index of the next element, that is, i, j + 1. If the value is returned true by the recursive call then the loop is break and the true value is returned.
If the current index is assigned then the recursive function is called with the index of the next element that is I, j + 1.

The implementation of the above algorithm is:

Code:

# defining the size of the matrix that is N*N
N = 9 

# Printing the matrix
def display(mat):
    for i in range(N):
        for j in range(N):
            print(mat[i][j], end = " ")
        print()

def isSafe(grid, row, col, num):
    for x in range(9):
        if grid[row][x] == num:
            return False

    for x in range(9):
        if grid[x][col] == num:
            return False

    startRow = row - row%3
    startCol = col - col%3
    for i in range(3):
        for j in range(3):
            if grid[i + startRow][j + startCol] == num:
                return False
    return True

def solveSudoku(grid, row, col):
    if(row == N - 1 and col == N):
        return True

    if col == N:
        row = row + 1
        col = 0

    if grid[row][col] > 0:
        return solveSudoku(grid, row, col + 1)

    for num in range(1, N + 1, 1):
        if isSafe(grid, row, col, num):
            grid[row][col] = num

            if solveSudoku(grid, row, col + 1):
                return True
        grid[row][col] = 0
    return False


grid = [[3, 0, 6, 5, 0, 8, 4, 0, 0],
        [5, 2, 0, 0, 0, 0, 0, 0, 0],
        [0, 8, 7, 0, 0, 0, 0, 3, 1],
        [0, 0, 3, 0, 1, 0, 0, 8, 0],
        [9, 0, 0, 8, 6, 3, 0, 0, 5],
        [0, 5, 0, 0, 9, 0, 6, 0, 0],
        [1, 3, 0, 0, 0, 0, 2, 5, 0],
        [0, 0, 0, 0, 0, 0, 0, 7, 4],
        [0, 0, 5, 2, 0, 6, 3, 0, 0]]

if(solveSudoku(grid, 0, 0)):
    display(grid)
else:
    print("There is no solution to the problem")

Output:

3 1 6 5 7 8 4 9 2 
5 2 9 1 3 4 7 6 8 
4 8 7 6 2 9 5 3 1 
2 6 3 4 1 5 9 8 7 
9 7 4 8 6 3 1 2 5 
8 5 1 7 9 2 6 4 3 
1 3 8 9 4 7 2 5 6 
6 9 2 3 5 1 8 7 4 
7 4 5 2 8 6 3 1 9

Explanation:

In the above code, the size of the puzzle is defined as 9, which is a 3x3, 2D matrix. A function is defined to be used to print the 2D puzzle, and another function is made to check whether the index and cell are safe or not. The function accepts the parameters of grid, row, column, and number. In the function, for all the values from 1 to 9, the condition is checked, and if the same number is found in a similar row, then it is returned false. Otherwise, if the same number is found in the column, then also return false. If these same numbers are found in the 3x3 matrix, they also return false. Another function is the solve sudoku function, which accepts the parameters of the grid, row, and column. In the function, first, it is checked that if we have reached the 8^th row and 9^th column, and if it is true, then return True to avoid further Backtracking, and it is the based condition of the function. Next, the condition is checked that if column values become 9, then move to the next row, and the column starts from 0. If the current position of the grid is already filled, then move to the next column. Then check the safe place.

The numbers 1 to 9 in the given row and column move to the next column. Assign the number in the current row and column of the grid and assume that the number that is assigned in the position is correct. After assigning the number, check for the next possibility in the next column. Remove the assigned number since the assumption that was made was wrong, and go for the next assumption with a different number value.

Time Complexity: The time complexity of the above approach is O(9^(N*N)); for each unassigned index, there are 9 possible options. So, the time complexity is O(9^(N*N)).

Space Complexity: The space complexity of the above approach is O(N*N). A 2D matrix is needed to store the output.

Algorithm to Solve Sudoku using Backtracking:

Sudoku can be solved by assigning the numbers one by one to the cells that are empty. First, check whether the given cell is safe or not for assigning the number, then assign the number. A condition is checked to see whether the same number is present in the current row, current column, and current 3x3 subgrid or not. If it is saved, then the number is assigned, and recursively check whether the number that is assigned leads to a solution or not. If there is no solution after assigning the number, then the next number is tried for the current empty cell. If there is a number 1 to 9, give a solution for the puzzle, then return false and print that no solution exists.

Here are the steps to solve the sudoku puzzle problem with the help of Backtracking.

A function is created that checks whether the given grid is safe or not after the current index value is assigned to the number. A hashmap is maintained for a row, column and boxes. If the occurrence of any number is greater than 1 in the hashMap the false is returned else true is returned. Hashmap can be avoided with the help of loops.
A recursive function that takes a grid is created.
A statement checks if there is any unassigned location or not.
1. If the location is present, then the number assigned is from 1 to 9.
2. A statement checks the number assigned to the current index to make the grid safe or not.
3. If the current index is safe, then call the function recursively for all safe cases from 0 to 9.
4. If true is returned by any recursive call, end the loop and return true. If no true returned by any recursive call then return false.
If there is no unassigned location left, then return true.

Code:

def display(mat):
    for i in range(9):
        for j in range(9):
            print(mat[i][j], end = " ")
        print()

def findEmptyLocation(arr, l):
    for row in range(9):
        for col in range(9):
            if(arr[row][col] == 0):
                l[0] = row
                l[1] = col
                return True

    return False

def usedInRow(arr, row, num):
    for i in range(9):
        if(arr[row][i] == num):
            return True
    return False
    
def usedInCol(arr, col, num):
    for i in range(9):
        if(arr[i][col] == num):
            return True
    return False


def usedInBox(arr, row, col, num):
    for i in range(3):
        for j in range(3):
            if(arr[i + row][j + col] == num):
                return True

    return False


def checkLocationIsSafe(arr, row, col, num):
    return (not usedInRow(arr, row, num) and
           (not usedInCol(arr, col, num) and
           (not usedInBox(arr, row - row % 3, 
                           col - col % 3, num))))

def solveSudoku(arr):
    l =[0, 0] 
    if(not findEmptyLocation(arr, l)):
        return True
    row = l[0]
    col = l[1]
     
    # consider digits 1 to 9
    for num in range(1, 10):
        if(checkLocationIsSafe(arr, 
                          row, col, num)):
            arr[row][col]= num
            if(solveSudoku(arr)):
                return True
            arr[row][col] = 0      
    return False
grid =[[0 for x in range(9)]for y in range(9)]
grid =[[3, 0, 6, 5, 0, 8, 4, 0, 0],
          [5, 2, 0, 0, 0, 0, 0, 0, 0],
          [0, 8, 7, 0, 0, 0, 0, 3, 1],
          [0, 0, 3, 0, 1, 0, 0, 8, 0],
          [9, 0, 0, 8, 6, 3, 0, 0, 5],
          [0, 5, 0, 0, 9, 0, 6, 0, 0],
          [1, 3, 0, 0, 0, 0, 2, 5, 0],
          [0, 0, 0, 0, 0, 0, 0, 7, 4],
          [0, 0, 5, 2, 0, 6, 3, 0, 0]]
     
    # if success, print the grid
if(solveSudoku(grid)):
    display(grid)
else:
    print ("No solution exists")

Output:

3 1 6 5 7 8 4 9 2 
5 2 9 1 3 4 7 6 8 
4 8 7 6 2 9 5 3 1 
2 6 3 4 1 5 9 8 7 
9 7 4 8 6 3 1 2 5 
8 5 1 7 9 2 6 4 3 
1 3 8 9 4 7 2 5 6 
6 9 2 3 5 1 8 7 4 
7 4 5 2 8 6 3 1 9

Explanation:

In the above code, Backtracking is used to solve the sudoku puzzle. In the code, the display function is used to print the puzzle when it is complete. A function that finds the entry in the grid that is still not used. The grid is searched to find an entry that has not yet been assigned. If the entry is found, the reference row, col, will be set for the location that is unassigned, and true is returned. If there are no unassigned entries left, false is returned by the function. In the code, l is the list variable that has been passed from the solve sudoku function to keep the record for the incrementation of rows and columns. A Boolean value is returned, which shows whether any assigned entry in the specified row matches the given number or not. A state is checked to see whether the number assigned is legal or not to the given row, col, and grid. A Boolean value is returned, which shows whether it will be legal to assign num to the given row, col location. The last function, the solveSudoku function, completes the whole grid that takes the input of a partially filled-in grid and tries to assign values to all unassigned locations in such a way as to meet the requirements for a sudoku solution.

Time complexity: The time complexity of the above algorithm is O(9^(N*N)), and each unassigned index has 9 possibilities, so the time complexity is O(9^(N*N)). The time complexity remains the same as the naïve approach, but the difference is that there will be some early pruning, so the time taken will be less than the naïve approach.
Space Complexity: The space complexity of the algorithm is O(N*N) because a matrix needs to be maintained for output.

Sudoku using Bit Masks:

The bit mask method is another optimized solution for solving the sudoku problem. In this method for every row, column and 3x3 grid, a bitmask is created and for each element in the grid, the position value is set to 1 for O(1) check.

Algorithm for the Bit Masks:

Three arrays are created of size N (one for row, one for column and one for 3x3 boxes).
The index values for the boxes are set to 0 to 8.
The initial values are mapped to the first grid.
Each time an element is added or removed from the grid set the bit to 1 or 0 for the corresponding bitmasks.

Code:

N = 9


def print_grid(grid):
    for i in range(N):
        for j in range(N):
            print(grid[i][j], end=" ")
        print()


def is_safe(grid, row, col, num):
    
    for x in range(N):
        if grid[row][x] == num:
            return False

    
    for x in range(N):
        if grid[x][col] == num:
            return False

    
    start_row = row - row % 3
    start_col = col - col % 3
    for i in range(3):
        for j in range(3):
            if grid[i + start_row][j + start_col] == num:
                return False
    return True


def solve_sudoku(grid, row, col):
    
    if row == N - 1 and col == N:
        return True


    if col == N:
        row += 1
        col = 0

    if grid[row][col] > 0:
        return solve_sudoku(grid, row, col + 1)
    for num in range(1, N + 1, 1):
        if is_safe(grid, row, col, num):
            grid[row][col] = num
            if solve_sudoku(grid, row, col + 1):
                return True

        grid[row][col] = 0

    return False


sudoku_grid = [
    [3, 0, 6, 5, 0, 8, 4, 0, 0],
    [5, 2, 0, 0, 0, 0, 0, 0, 0],
    [0, 8, 7, 0, 0, 0, 0, 3, 1],
    [0, 0, 3, 0, 1, 0, 0, 8, 0],
    [9, 0, 0, 8, 6, 3, 0, 0, 5],
    [0, 5, 0, 0, 9, 0, 6, 0, 0],
    [1, 3, 0, 0, 0, 0, 2, 5, 0],
    [0, 0, 0, 0, 0, 0, 0, 7, 4],
    [0, 0, 5, 2, 0, 6, 3, 0, 0]
]

if solve_sudoku(sudoku_grid, 0, 0):
    print_grid(sudoku_grid)
else:
    print("No solution exists.")

Output:

3 1 6 5 7 8 4 9 2 
5 2 9 1 3 4 7 6 8 
4 8 7 6 2 9 5 3 1 
2 6 3 4 1 5 9 8 7 
9 7 4 8 6 3 1 2 5 
8 5 1 7 9 2 6 4 3 
1 3 8 9 4 7 2 5 6 
6 9 2 3 5 1 8 7 4 
7 4 5 2 8 6 3 1 9

Explanation:

In the above code for the sudoku problem, the print_grid function is used to print the full sudoku grid, a function that checks the safe condition of the row, column and the 3x3 grid. Another function that is used to solve the sudoku puzzle is That if the index reaches the 8^th row and 9^th column, true is returned to avoid further Backtracking. A condition is checked to determine if the column value becomes 9 or not. If the column becomes 9, the index is moved to the next row, and the column starts from 0. If the current position of the grid has values greater than 0, then iterate for the next column. If the index position is safe, place the number (1-9) in the given row and move to the next column. Assing the number in the current row or column position of the grid and assume that our assigned number in the position is correct. Check for the next possibility in the next column.

Time Complexity: The complexity of the above algorithm is O(9^(N*N)) for each index that is not assigned having 9 possibilities. So, the time complexity is O(9^(N*N)).
Space Complexity: The space complexity of the algorithm is O(N*N) because an output array is needed to store the output, and 3 extra arrays having size n are also needed for the bitmasks.

Solving Sudoku Using Cross-Hatching with Backtracking:

This is an optimized method for the bit mask method. It is 5 times faster than the bit mask method. In the bit-wise method, Sudoku is filled out by first finding the element that is almost filled. In this method, the row and column are identified where the element should be placed.

Here's the algorithm to solve the sudoku puzzle:

A graph is made with the elements that are left and mapped to row, and column coordinates where they can be placed in the original matrix.
An element is picked from the graph and sorted by fewer remaining elements to be filled.
Fill the elements recursively with the help of a graph into the matrix. Backtrack once an unsafe position is found.

Code:

# Sudoku Solver using Backtracking with Optimization

# Input matrix
sudoku_board = [
    [3, 0, 6, 5, 0, 8, 4, 0, 0],
    [5, 2, 0, 0, 0, 0, 0, 0, 0],
    [0, 8, 7, 0, 0, 0, 0, 3, 1],
    [0, 0, 3, 0, 1, 0, 0, 8, 0],
    [9, 0, 0, 8, 6, 3, 0, 0, 5],
    [0, 5, 0, 0, 9, 0, 6, 0, 0],
    [1, 3, 0, 0, 0, 0, 2, 5, 0],
    [0, 0, 0, 0, 0, 0, 0, 7, 4],
    [0, 0, 5, 2, 0, 6, 3, 0, 0]
]

# Position of the input elements in the sudoku_board
positions = {}

# Count of the remaining number of the elements
remaining = {}

# Graph defining tentative positions of the elements to be filled
graph = {}


# Print the sudoku_board
def print_board():
    for i in range(0, 9):
        for j in range(0, 9):
            print(str(sudoku_board[i][j]), end=" ")
        print()


# Method to check if the inserted element is safe
def is_safe(x, y):
    key = sudoku_board[x][y]
    for i in range(0, 9):
        if i != y and sudoku_board[x][i] == key:
            return False
        if i != x and sudoku_board[i][y] == key:
            return False

    r_start = int(x / 3) * 3
    r_end = r_start + 3

    c_start = int(y / 3) * 3
    c_end = c_start + 3

    for i in range(r_start, r_end):
        for j in range(c_start, c_end):
            if i != x and j != y and sudoku_board[i][j] == key:
                return False
    return True


# method to fill the sudoku_board
def fill_board(k, keys, r, rows):
    for c in graph[keys[k]][rows[r]]:
        if sudoku_board[rows[r]][c] > 0:
            continue
        sudoku_board[rows[r]] = keys[k]
        if is_safe(rows[r], c):
            if r < len(rows) - 1:
                if fill_board(k, keys, r + 1, rows):
                    return True
                else:
                    sudoku_board[rows[r]] = 0
                    continue
            else:
                if k < len(keys) - 1:
                    if fill_board(k + 1, keys, 0, list(graph[keys[k + 1]].keys())):
                        return True
                    else:
                        sudoku_board[rows[r]] = 0
                        continue
                return True
        sudoku_board[rows[r]] = 0
    return False


# Fill the positions and remaining dictionaries
def build_positions_and_remaining():
    for i in range(0, 9):
        for j in range(0, 9):
            if sudoku_board[i][j] > 0:
                if sudoku_board[i][j] not in positions:
                    positions[sudoku_board[i][j]] = []
                positions[sudoku_board[i][j]].append([i, j])
                if sudoku_board[i][j] not in remaining:
                    remaining[sudoku_board[i][j]] = 9
                remaining[sudoku_board[i][j]] -= 1

    # Fill the elements not present in input sudoku_board
    for i in range(1, 10):
        if i not in positions:
            positions[i] = []
        if i not in remaining:
            remaining[i] = 9


# Build the graph
def build_graph():
    for k, v in positions.items():
        if k not in graph:
            graph[k] = {}

        row = list(range(0, 9))
        col = list(range(0, 9))

        for cord in v:
            row.remove(cord[0])
            col.remove(cord[1])

        if len(row) == 0 or len(col) == 0:
            continue

        for r in row:
            for c in col:
                if sudoku_board[r] == 0:
                    if r not in graph[k]:
                        graph[k][r] = []
                    graph[k][r].append(c)


build_positions_and_remaining()

# Sort the remaining map in order to start with a smaller number of elements to be filled first.
remaining = {k: v for k, v in sorted(remaining.items(), key=lambda item: item[1])}

build_graph()

keys_sorted = list(remaining.keys())
# Util called to fill the sudoku_board
fill_board(0, keys_sorted, 0, list(graph[keys_sorted[0]].keys()))

print_board()

Output:

[3, 1, 6, 5, 7, 8, 4, 9, 2]
[5, 2, 9, 1, 3, 4, 7, 6, 8]
[4, 8, 7, 6, 2, 9, 5, 3, 1]
[2, 6, 3, 4, 1, 5, 9, 8, 7]
[9, 7, 4, 8, 6, 3, 1, 2, 5]
[8, 5, 1, 7, 9, 2, 6, 4, 3]
[1, 3, 8, 9, 4, 7, 2, 5, 6]
[6, 9, 2, 3, 5, 1, 8, 7, 4]
[7, 4, 5, 2, 8, 6, 3, 1, 9]

Conclusion:

Sudoku puzzle problem is a famous problem that is asked in many MNCs and there are many methods to solve the problem. Backtracking is the best approach to solve the problem.

Next TopicDifference between method and function in python

← prev next →