递归 function 未按预期返回

Question

This is a sudoku solver, in the second function when I try to return the solved board it appears as none, but if you print the board you can see the solution. here is the code:

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

def solution(row, col, number):
    for i in range(9):
        if board[row][i] == number:
            return False
        if board[i][col] == number:
            return False
        row0 = (row // 3) *3
        col0 = (col // 3) * 3
        for i in range(3):
            for j in range(3):
                if board[row0+i][col0+j] == number:
                    return False
    return True

def solve():
    global board
    for row in range(9):
        for col in range(9):
            if board[row][col] == 0:
                for number in range(1,10):
                    if solution(row, col, number):
                        board[row][col] = number
                        solve()
                        board[row][col] = 0
                return
    [print(x) for x in board] 
    return board


print(solve())

How can I make the solve function return the new board?

Answer 1

The issue with your code is that you have two exiting points, one that returns the board :

return board

and one that returns nothing (ie None )

return

If you follow how the recursion calls are invoked, you realize that the parent call is actually returning from the None exit point. However, just passing board to that exit point does not fix the issue as you have recursive calls to solve() which are followed by setting back to 0 specific cells. So essentially, you first solve the sudoku and then unwind the whole solution back to where you started. To solve this you need to keep track of when you actually solve the sudoku and skip the setting back to 0 if the sudoku is solved.

One way of doing this (slightly rewritten to avoid the perilous use of global ) is:

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


def solution(board, row, col, number):
    for i in range(9):
        if board[row][i] == number:
            return False
        if board[i][col] == number:
            return False
    row0 = (row // 3) *3
    col0 = (col // 3) * 3
    for i in range(3):
        for j in range(3):
            if board[row0+i][col0+j] == number:
                return False
    return True


def solve(board):
    for row in range(9):
        for col in range(9):
            if board[row][col] == 0:
                is_solved = False
                for number in range(1, 10):
                    if solution(board, row, col, number):
                        board[row][col] = number
                        is_solved = solve(board)
                        if not is_solved:
                            board[row][col] = 0
                return is_solved
    return True


def print_board(board):
    for row in board:
        print(row)
    print()

print_board(board)
# [5, 3, 0, 0, 7, 0, 0, 0, 0]
# [6, 0, 0, 1, 9, 5, 0, 0, 0]
# [0, 9, 8, 0, 0, 0, 0, 6, 0]
# [8, 0, 0, 0, 6, 0, 0, 0, 3]
# [4, 0, 0, 8, 0, 3, 0, 0, 1]
# [7, 0, 0, 0, 2, 0, 0, 0, 6]
# [0, 6, 0, 0, 0, 0, 2, 8, 0]
# [0, 0, 0, 4, 1, 9, 0, 0, 5]
# [0, 0, 0, 0, 8, 0, 0, 7, 9]
solve(board)
print_board(board)
# [5, 3, 4, 6, 7, 8, 9, 1, 2]
# [6, 7, 2, 1, 9, 5, 3, 4, 8]
# [1, 9, 8, 3, 4, 2, 5, 6, 7]
# [8, 5, 9, 7, 6, 1, 4, 2, 3]
# [4, 2, 6, 8, 5, 3, 7, 9, 1]
# [7, 1, 3, 9, 2, 4, 8, 5, 6]
# [9, 6, 1, 5, 3, 7, 2, 8, 4]
# [2, 8, 7, 4, 1, 9, 6, 3, 5]
# [3, 4, 5, 2, 8, 6, 1, 7, 9]

Where essentially the solve() function is changed so that:

• it accepts a board parameter which is modified in-place
• it returns if the board was solved or not
• if the board is already solved it does not unwind the solution
• (a print_board() helper function is included for simpler visualization)

(also the solution() has been changed to include a board parameter, to avoid relying on the global board definition, and the final block is outside of the main loop because it is looped there pointlessly).

The function does not need to return board because it gets modified in-place.

If one really needs the board to be returned, one can simply include it in the return.

---

Note that if you just replace the lone return inside the loops with a break , this does not seem to work. If it does work, it will take a huge amount of time. I suspect this will eventually lead to infinite looping because you just find some partial solution and unroll it back and forth forever (this assumption is based on replacing the return in my code with a break which yields a partial solution).