

from __future__ import annotations

UpperCAmelCase_							:					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__    :   Matrix			,a__    :   int			,a__    :   int			,a__    :   int       )					->				bool:
	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__    :   Matrix       )					->				tuple[int, int] | None:
	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__    :   Matrix       )					->				Matrix | None:
	if location := find_empty_location(a__       ):
		__A    ,				__A :			Optional[int]		    =			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__       ):
			__A :			List[str]		    =			digit

			if sudoku(a__       ) is not None:
				return grid

			__A :			Tuple		    =			0

	return None
def 							__SCREAMING_SNAKE_CASE     (   a__    :   Matrix       )					->				None:
	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''' + '''=''' * 20)
						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'''






from typing import Any






class        lowercase_      :





     def __init__(     self     :					Dict     ,							__lowerCamelCase     :					Any			):
           snake_case__       :   str	      =    data
           snake_case__       :   Dict	      =    None






class        lowercase_      :





     def __init__(     self     :					int			):
           snake_case__       :   List[Any]	      =    None





     def 			_lowerCAmelCase      (     self     :					str			):
           snake_case__       :   Any	      =    self.head
           while temp is not None:
                 print(temp.data     ,							end=' '			)
                 snake_case__       :   int	      =    temp.next
           print()





     def 			_lowerCAmelCase      (     self     :					Optional[Any]     ,							__lowerCamelCase     :					Any			):
           snake_case__       :   Union[str, Any]	      =    Node(__lowerCamelCase			)
           snake_case__       :   List[str]	      =    self.head
           snake_case__       :   Any	      =    new_node





     def 			_lowerCAmelCase      (     self     :					Dict     ,							__lowerCamelCase     :					int     ,							__lowerCamelCase     :					Tuple			):
           if node_data_a == node_data_a:
                 return
           else:
                 snake_case__       :   List[Any]	      =    self.head
                 while node_a is not None and node_a.data != node_data_a:
                       snake_case__       :   List[str]	      =    node_a.next

                 snake_case__       :   Union[str, Any]	      =    self.head
                 while node_a is not None and node_a.data != node_data_a:
                       snake_case__       :   str	      =    node_a.next

                 if node_a is None or node_a is None:
                       return

                 snake_case__      ,							snake_case__       :   Dict	      =    node_a.data, node_a.data


if __name__ == "__main__":
      A_			      =		LinkedList()
      for i in range(5, 0, -1):
            ll.push(i)

      ll.print_list()

      ll.swap_nodes(1, 4)
      print("After swapping")
      ll.print_list()
