Tic-tac-toe

enum Player { X = 1, O = -1 }

/** n x n board with an O(1) win check: one running sum per row, column and diagonal. */
class Board {
  private cells: (Player | null)[][];
  private rows: number[];
  private cols: number[];
  private diag = 0;
  private anti = 0;
  private moves = 0;

  constructor(readonly n = 3) {
    this.cells = Array.from({ length: n }, () => Array<Player | null>(n).fill(null));
    this.rows = Array(n).fill(0);
    this.cols = Array(n).fill(0);
  }

  /** Returns true if this move wins. */
  place(r: number, c: number, p: Player): boolean {
    const n = this.n;
    if (r < 0 || r >= n || c < 0 || c >= n) throw new Error("off the board");
    if (this.cells[r][c] !== null) throw new Error("cell taken");
    this.cells[r][c] = p;
    this.moves++;
    this.rows[r] += p;
    this.cols[c] += p;
    if (r === c) this.diag += p;
    if (r + c === n - 1) this.anti += p;
    return [this.rows[r], this.cols[c], this.diag, this.anti].some((s) => Math.abs(s) === n);
  }

  full(): boolean { return this.moves === this.n * this.n; }
}

/** Owns the rules: whose turn it is, and when the game is over. */
class Game {
  private board: Board;
  private turn = Player.X;
  private result: string | null = null;

  constructor(n = 3) { this.board = new Board(n); }

  play(r: number, c: number): string {
    if (this.result) return `rejected: game over (${this.result})`;
    let won: boolean;
    try {
      won = this.board.place(r, c, this.turn);
    } catch (e) {
      return `rejected: ${(e as Error).message}`;
    }
    const mover = Player[this.turn];
    if (won) this.result = `${mover} wins`;
    else if (this.board.full()) this.result = "draw";
    this.turn = this.turn === Player.X ? Player.O : Player.X;
    return `${mover} at (${r},${c})` + (this.result ? `: ${this.result}` : "");
  }
}

const g = new Game();
for (const [r, c] of [[0, 0], [1, 1], [1, 1], [0, 1], [2, 2], [0, 2], [2, 0]]) console.log(g.play(r, c));

enum Player {
    X(1), O(-1);

    final int value;

    Player(int value) {
        this.value = value;
    }
}

/** n x n board with an O(1) win check: one running sum per row, column and diagonal. */
class Board {
    final int n;
    private final Player[][] cells;
    private final int[] rows, cols;
    private int diag, anti, moves;

    Board(int n) {
        this.n = n;
        cells = new Player[n][n];
        rows = new int[n];
        cols = new int[n];
    }

    /** Returns true if this move wins. */
    boolean place(int r, int c, Player p) {
        if (r < 0 || r >= n || c < 0 || c >= n) throw new IllegalArgumentException("off the board");
        if (cells[r][c] != null) throw new IllegalArgumentException("cell taken");
        cells[r][c] = p;
        moves++;
        rows[r] += p.value;
        cols[c] += p.value;
        if (r == c) diag += p.value;
        if (r + c == n - 1) anti += p.value;
        return Math.abs(rows[r]) == n || Math.abs(cols[c]) == n || Math.abs(diag) == n || Math.abs(anti) == n;
    }

    boolean full() {
        return moves == n * n;
    }
}

/** Owns the rules: whose turn it is, and when the game is over. */
class Game {
    private final Board board;
    private Player turn = Player.X;
    private String result;

    Game(int n) {
        board = new Board(n);
    }

    String play(int r, int c) {
        if (result != null) return "rejected: game over (" + result + ")";
        boolean won;
        try {
            won = board.place(r, c, turn);
        } catch (IllegalArgumentException e) {
            return "rejected: " + e.getMessage();
        }
        String mover = turn.name();
        if (won) result = mover + " wins";
        else if (board.full()) result = "draw";
        turn = turn == Player.X ? Player.O : Player.X;
        return mover + " at (" + r + "," + c + ")" + (result != null ? ": " + result : "");
    }
}

public class Main {
    public static void main(String[] args) {
        Game g = new Game(3);
        int[][] moves = {{0, 0}, {1, 1}, {1, 1}, {0, 1}, {2, 2}, {0, 2}, {2, 0}};
        for (int[] m : moves) System.out.println(g.play(m[0], m[1]));
    }
}