input: Write a function to find the most efficient path for a robot to take from its current location to the destination using a breadth-first search algorithm. The function should return the path as a list of tuples representing the sequence of coordinates that the robot should follow. If no path is found within the maximum number of tries, the function should return None.
  assert find_path((4, 2), (9, 9))==[[(4, 2)], [(5, 2)], [(6, 2)], [(6, 3)], [(6, 4)], [(6, 5)], [(6, 6)], [(6, 7)], [(6, 8)], [(7, 9)]]
  assert find_path((0, 0), (2, 2))==[[(0, 0)], [(1, 0)], [(2, 0)], [(2, 1)], [(2, 2)]]
  assert find_path((1, 1), (3, 3))==None
  assert find_path((5, 5), (5, 5))==[[(5, 5)]]
  assert find_path((7, 7), (10, 10))==None
output: def find_path(start, end, max_tries=1000):
      if start == end:
          return [[start]]
      
      queue = [[start]]
      visited = set()
      visited.add(start)
      
      for _ in range(max_tries):
          if not queue:
              return None
          
          path = queue.pop(0)
          current = path[-1]
          
          for dx, dy in [(0, 1), (1, 0), (0, -1), (-1, 0)]:
              next_pos = (current[0] + dx, current[1] + dy)
              
              if next_pos == end:
                  return path + [next_pos]
              
              if next_pos not in visited:
                  visited.add(next_pos)
                  queue.append(path + [next_pos])
      
      return None