Tilting Maze Ball

A ball sits on an open cell. in a rectangular maze whose walls are #. The ball initially has direction F and does not move.
For each integer second from 1 through endTime, first apply a direction event at that second if one exists, then attempt to move the ball one cell in the current direction. Directions are U, D, L, R, and F. A move that would leave the maze or enter a wall is ignored; the direction remains active.
Return the ball's final zero-based [row, column].

Function
finalMazePosition(maze: String[], startRow: int, startCol: int, eventTimes: int[], directions: String[], endTime: int) → int[]

Examples
Example 1
maze = ["....",".##.","...."]
startRow = 0
startCol = 0
eventTimes = [1,4,6]
directions = ["R","D","L"]
endTime = 8
return = [2,0]
The ball follows the open outer corridor and ends in the bottom-left corner.
Example 2
maze = ["...","...","..."]
startRow = 1
startCol = 1
eventTimes = [2,3]
directions = ["U","R"]
endTime = 4
return = [0,2]
The ball waits during second 1, then moves up once and right once before the boundary stops it.
Example 3
maze = ["###","#.#","###"]
startRow = 1
startCol = 1
eventTimes = [1]
directions = ["R"]
endTime = 3
return = [1,1]
Walls block every attempted move.

Constraints
1 <= maze.length, maze[0].length <= 200.
0 <= endTime <= 100000.
0 <= eventTimes.length = directions.length <= endTime.
Event times are strictly increasing and each lies from 1 through endTime.
The start cell is open, and every direction is U, D, L, R, or F.

The trick is that there's nothing to search. The ball has one path, set by the events, so BFS is a red herring. Walk seconds 1 through endTime, keep a pointer into the sorted event list, and at each second apply the event first if its time matches, then attempt one move. Order matters: the event applies before the move on that same second. Example 2 shows it, since the ball waits at second 1 with direction F, then moves at seconds 2 and 3. Pitfalls: clearing the direction after a blocked move, treating F as a move, off-by-one on endTime 0, and checking bounds after indexing the maze instead of before. That's O(endTime) time with O(1) extra space. If the live OA has you freezing on the loop details, StealthCoder is the hedge that gives you a correct version fast.

Drill it cold or hedge it with StealthCoder. Either way, don't walk into the OA hoping you remember the trick.