Word Search

Given a rectangular character grid board and a string word, return true if word can be formed by a path through the grid. Otherwise, return false.
A path may move horizontally or vertically between adjacent cells. The same grid cell cannot be used more than once in one path.

Function
wordExists(board: char[][], word: String) → boolean

Examples
Example 1
board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]]
word = "ABCCED"
return = true
The path uses the top-row cells A, B, and C, then continues down to C, left to E, and left to D.
Example 2
board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]]
word = "ABCB"
return = false
The only adjacent B that could finish the word is the cell already used after the starting A, and a cell cannot be reused.
Example 3
board = [["A"]]
word = "A"
return = true
The single grid cell forms the complete word.

Constraints
1 <= board.length <= 6
1 <= board[i].length <= 6
Every row of board has the same length.
1 <= word.length <= 15
board and word contain only uppercase and lowercase English letters.

The trick is DFS with backtracking from every cell that matches word[0]. At each step, check bounds, check the cell equals word[index], mark it used, recurse in four directions, then unmark it. Return true the moment index hits word.length. The common pitfall is forgetting to restore the cell after recursion, which poisons later paths. Another is using a separate visited matrix and allocating it on every call, which is wasteful but still passes at these sizes. A cheap early exit: count letters in the board and bail if the word needs more of a letter than exists. Complexity is roughly cells times 3 to the power of word length, which is fine at 36 cells and 15 letters. If the recursion shape slips away mid-assessment, StealthCoder is the hedge that hands you a working version while you keep typing.

If this hits your live OA and you blank, StealthCoder solves it in seconds, invisible to the proctor.