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 (BFS) approach. The function should return a list of coordinates that represent the path from the start to the end, or None if no path is found. If the start and end are the same, it should return a list containing the starting coordinate.
  def find_path(start, end):
      # Current location of the robot
      x = start[0]
      y = start[1] 
      # Destination coordinates
      goal_x = end[0] 
      goal_y = end[1] 
      # set to record the cells already visited
      visited = set() 
      # define a queue to store the tuple of current position and the path
      queue = [([x, y], [])] 
      # define a neighbor list 
      neighbor = [[1, 0], [0, 1], [-1, 0], [0, -1]] 
      # define a maximum tries
      max_tries = 100 
      # define a while loop
      while queue:
          # get current position and current path
          position, path = queue.pop(0) 
          # check if the goal is reached
          if position[0] == goal_x and position[1] == goal_y:
              return path + [position]
          # check if the current position is out of maximum tries and not visited before
          if position not in visited and max_tries > 0:
              visited.add(position)
              max_tries = max_tries - 1 
              #get all neighbors of the current position
              for neighbor_x, neighbor_y in neighbor:
                  next_x = position[0] + neighbor_x
                  next_y = position[1] + neighbor_y
                  # add to the queue
                  queue.append(([next_x, next_y], path + [position]))
      return None
  
  assert find_path((4, 2), (9, 9)) == [[4, 2], [5, 2], [5, 3], [5, 4], [5, 5], [5, 6], [5, 7], [5, 8], [5, 9], [6, 9], [7, 9], [8, 9], [9, 9]]
  assert find_path((2, 2), (2, 2)) == [[2, 2]]
  assert find_path((0, 0), (9, 9)) is not None
  assert find_path((9, 9), (0, 0)) is not None
  assert find_path((0, 0), (3, 3)) == [[0, 0], [1, 0], [1, 1], [2, 1], [2, 2], [3, 2], [3, 3]]
output: def find_path(start, end):
      x = start[0]
      y = start[1] 
      goal_x = end[0] 
      goal_y = end[1] 
      visited = set() 
      queue = [([x, y], [])] 
      neighbor = [[1, 0], [0, 1], [-1, 0], [0, -1]] 
      max_tries = 100 
      while queue:
          position, path = queue.pop(0) 
          if position[0] == goal_x and position[1] == goal_y:
              return path + [position]
          if position not in visited and max_tries > 0:
              visited.add(position)
              max_tries = max_tries - 1 
              for neighbor_x, neighbor_y in neighbor:
                  next_x = position[0] + neighbor_x
                  next_y = position[1] + neighbor_y
                  queue.append(([next_x, next_y], path + [position]))
      return None