


from __future__ import annotations

_lowercase							:   List[str]						=						list[list[int]]

# assigning initial values to the grid
_lowercase							:   Matrix						=						[
    [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],
]

# a grid with no solution
_lowercase							:   Matrix						=						[
    [5, 0, 6, 5, 0, 8, 4, 0, 3],
    [5, 2, 0, 0, 0, 0, 0, 0, 2],
    [1, 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],
]





def 	_lowerCAmelCase					( UpperCamelCase__:  Matrix				,       UpperCamelCase__:  int				,       UpperCamelCase__:  int				,       UpperCamelCase__:  int    )			-> bool:





	"""simple docstring"""







	for i in range(9    ):
		if grid[row][i] == n or grid[i][column] == n:
			return False

	for i in range(3    ):
		for j in range(3    ):
			if grid[(row - row % 3) + i][(column - column % 3) + j] == n:
				return False

	return True





def 	_lowerCAmelCase					( UpperCamelCase__:  Matrix    )			-> tuple[int, int] | None:





	"""simple docstring"""







	for i in range(9    ):
		for j in range(9    ):
			if grid[i][j] == 0:
				return i, j
	return None





def 	_lowerCAmelCase					( UpperCamelCase__:  Matrix    )			-> Matrix | None:





	"""simple docstring"""







	if location := find_empty_location(UpperCamelCase__    ):
		A       ,      A             =					location
	else:
		# If the location is ``None``, then the grid is solved.
		return grid

	for digit in range(1				,       10    ):
		if is_safe(UpperCamelCase__				,       UpperCamelCase__				,       UpperCamelCase__				,       UpperCamelCase__    ):
			A             =					digit

			if sudoku(UpperCamelCase__    ) is not None:
				return grid

			A             =					0

	return None





def 	_lowerCAmelCase					( UpperCamelCase__:  Matrix    )			-> None:





	"""simple docstring"""







	for row in grid:
		for cell in row:
			print(UpperCamelCase__				,       end=""" """    )
		print()


if __name__ == "__main__":
				# make a copy of grid so that you can compare with the unmodified grid
				for example_grid in (initial_grid, no_solution):
								print("\nExample grid:\n" + "=" * 20)
								print_solution(example_grid)
								print("\nExample grid solution:")
								_lowercase							:   Tuple						=						sudoku(example_grid)
								if solution is not None:
												print_solution(solution)
								else:
												print("Cannot find a solution.")







from ..utils import DummyObject, requires_backends






class    _UpperCamelCase     (       metaclass=__snake_case					):

				"""simple docstring"""







				lowerCAmelCase					=			['note_seq']

				def __init__(    self					, *a__					, **a__ )						->					Optional[int]:
					requires_backends(self					, ["""note_seq"""] )

				@classmethod
				def   _UpperCAmelCase       (    cls					, *a__					, **a__ )						->					Dict:
					requires_backends(cls					, ["""note_seq"""] )

				@classmethod
				def   _UpperCAmelCase       (    cls					, *a__					, **a__ )						->					Optional[int]:
					requires_backends(cls					, ["""note_seq"""] )



