"""simple docstring"""



from __future__ import annotations

__lowercase		:		Union[str, Any]								=				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  SCREAMING_SNAKE_CASE							(  snake_case,   snake_case,   snake_case,   snake_case):

     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							(  snake_case):

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





def  SCREAMING_SNAKE_CASE							(  snake_case):

     if location := find_empty_location(_A):
          __snake_case		,						__snake_case				=				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):
               __snake_case				=				digit

               if sudoku(_A) is not None:
                    return grid

               __snake_case				=				0

     return None





def  SCREAMING_SNAKE_CASE							(  snake_case):

     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:")
              __lowercase		:		List[str]								=				sudoku(example_grid)
              if solution is not None:
                     print_solution(solution)
              else:
                     print("Cannot find a solution.")

"""simple docstring"""



import json
import os
import tempfile

import transformers

import datasets
from utils import generate_example_dataset, get_duration


a       :						int       		=		5_0_0_0_0_0

a		,			a       :						Union[str, Any]       		=		os.path.split(__file__)
a       :						Dict       		=		os.path.join(RESULTS_BASEPATH, '''results''', RESULTS_FILENAME.replace('''.py''', '''.json'''))


@get_duration
def 			_UpperCamelCase						(    _A       ,   **_A   )     ->	Any:





    """simple docstring"""

    _UpperCAmelCase        = dataset.map(**_A   )


@get_duration
def 			_UpperCamelCase						(    _A       ,   **_A   )     ->	Dict:





    """simple docstring"""

    _UpperCAmelCase        = dataset.filter(**_A   )


def 			_UpperCamelCase						(    )     ->	Tuple:





    """simple docstring"""

    _UpperCAmelCase        = {"""num examples""": SPEED_TEST_N_EXAMPLES}
    with tempfile.TemporaryDirectory() as tmp_dir:
        _UpperCAmelCase        = datasets.Features({"""text""": datasets.Value("""string"""   ), """numbers""": datasets.Value("""float32"""   )}   )
        _UpperCAmelCase        = generate_example_dataset(
            os.path.join(_A       ,   """dataset.arrow"""   )       ,   _A       ,   num_examples=_A   )

        _UpperCAmelCase        = transformers.AutoTokenizer.from_pretrained("""bert-base-cased"""       ,   use_fast=_A   )

        def tokenize(_A   ):
            return tokenizer(examples["""text"""]   )

        _UpperCAmelCase        = map(_A   )

        _UpperCAmelCase        = map(_A       ,   batched=_A   )

        _UpperCAmelCase        = map(_A       ,   function=lambda _A   : None       ,   batched=_A   )

        with dataset.formatted_as(type="""numpy"""   ):
            _UpperCAmelCase        = map(_A       ,   function=lambda _A   : None       ,   batched=_A   )

        with dataset.formatted_as(type="""pandas"""   ):
            _UpperCAmelCase        = map(_A       ,   function=lambda _A   : None       ,   batched=_A   )

        with dataset.formatted_as(type="""torch"""       ,   columns="""numbers"""   ):
            _UpperCAmelCase        = map(_A       ,   function=lambda _A   : None       ,   batched=_A   )

        with dataset.formatted_as(type="""tensorflow"""       ,   columns="""numbers"""   ):
            _UpperCAmelCase        = map(_A       ,   function=lambda _A   : None       ,   batched=_A   )

        _UpperCAmelCase        = map(_A       ,   function=_A       ,   batched=_A   )

        _UpperCAmelCase        = filter(_A   )

        # Activate later when tokenizer support batched inputs
        # with dataset.formatted_as(type='numpy'):
        #     times[func.__name__ + " fast-tokenizer batched numpy"] = func(dataset, function=tokenize, batched=True)

    with open(_A       ,   """wb"""   ) as f:
        f.write(json.dumps(_A   ).encode("""utf-8"""   )   )


if __name__ == "__main__":  # useful to run the profiler
 benchmark_map_filter()