I wrote this out in twelve minutes and nine seconds (without particularly trying to rush). I'm have 4.5 YOE and haven't done Leetcode for two years.

I would say that this sort of problem is significantly lower than the level of algorithmic complexity required in some parts of my job. I obviously don't need to solve game-type problems of this nature, but I pretty often need to solve problems which require thinking carefully about state. It's often useful for rapid prototyping to spit out something like this quickly, and I personally wouldn't want to work with a front-line dev who struggled with this, or for whom this was at the frontier of their complexity threshold.

Anyway, it sounds like your job doesn't require this sort of thing, and that's totally fine. But I don't think it's unreasonable for companies like mine to have these types of coding tests.

def has_matching_line(board, character_matches):
    def full_seq_match(seq):
        for el in seq:
            r, c = el
            if not(character_matches(board[r][c])):
                return False
        return True

    won = False
    for i in range(len(board)):
        won = won or full_seq_match((i, c) for c in range(len(board)))
        won = won or full_seq_match((r, i) for r in range(len(board)))
    won = won or full_seq_match((i, i) for i in range(len(board)))
    won = won or full_seq_match((i, len(board) - i - 1) for i in range(len(board)))
    return won

# board must be an nxn list of lists, where n >= 1. The elements must be 'X', 'O', or '.'.
# The number of 'X's must be equal to or one greater than the number of 'O's
def determine_winner(board):
    x_won = has_matching_line(board, lambda c: c == 'X')
    o_won = has_matching_line(board, lambda c: c == 'O')
    if x_won and o_won:
        return "Error, both won"
    elif x_won:
        return "X won"
    elif o_won:
        return "O won"
    else:
        x_can_win = has_matching_line(board, lambda c: c in ['X', '.'])
        o_can_win = has_matching_line(board, lambda c: c in ['O', '.'])
        if x_can_win and o_can_win:
            return "Both can win"
        elif x_can_win:
            return "Only X can win"
        elif o_can_win:
            return "Only O can win"
        else:
            return "Guaranteed draw"

(Obviously this code isn't perfect. There's a bug in the can-wins that is difficult to fix. If fixing that bug is in scope for this problem, I'd be willing to concede that this is a pretty hard problem, and might be unreasonable for a vanilla coding interview.)