

"""simple docstring"""





from __future__ import annotations

__UpperCamelCase    : Optional[Any]				 =						list[list[int]]

# assigning initial values to the grid
__UpperCamelCase    : 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
__UpperCamelCase    : 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     __SCREAMING_SNAKE_CASE    ( A_		,	A_		,	A_		,	A_					):
	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     __SCREAMING_SNAKE_CASE    ( A_					):
	for i in range(9					):
		for j in range(9					):
			if grid[i][j] == 0:
				return i, j
	return None

def     __SCREAMING_SNAKE_CASE    ( A_					):
	if location := find_empty_location(A_					):
		lowerCAmelCase__							,lowerCAmelCase__      :		Dict    							=      location
	else:
		# If the location is ``None``, then the grid is solved.
		return grid

	for digit in range(1		,	10					):
		if is_safe(A_		,	A_		,	A_		,	A_					):
			lowerCAmelCase__      :		Tuple    							=      digit

			if sudoku(A_					) is not None:
				return grid

			lowerCAmelCase__      :		Tuple    							=      0

	return None

def     __SCREAMING_SNAKE_CASE    ( A_					):
	for row in grid:
		for cell in row:
			print(A_		,	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''' + '''=''' * 2_0)
														print_solution(example_grid)
														print('''\nExample grid solution:''')
														__UpperCamelCase    : Optional[int]				 =						sudoku(example_grid)
														if solution is not None:
																					print_solution(solution)
														else:
																					print('''Cannot find a solution.''')







"""simple docstring"""





def     __SCREAMING_SNAKE_CASE    ( A_					):
	lowerCAmelCase__      :		Any    							=      int(A_					)
	if decimal in (0, 1):  # Exit cases for the recursion
		return str(A_					)
	lowerCAmelCase__							,lowerCAmelCase__      :		Any    							=      divmod(A_		,	2					)
	return binary_recursive(A_					) + str(A_					)

def     __SCREAMING_SNAKE_CASE    ( A_					):
	lowerCAmelCase__      :		Union[str, Any]    							=      str(A_					).strip()
	if not number:
		raise ValueError('''No input value was provided'''					)
	lowerCAmelCase__      :		Any    							=      '''-''' if number.startswith('''-'''					) else ''''''
	lowerCAmelCase__      :		Dict    							=      number.lstrip('''-'''					)
	if not number.isnumeric():
		raise ValueError('''Input value is not an integer'''					)
	return f'{negative}0b{binary_recursive(int(A_					)					)}'


if __name__ == "__main__":
							from doctest import testmod

							testmod()




