using System;

using System.Linq;

using System.Collections.Generic;

using System.Security.Cryptography;

public class Program

{

    public static void Main()

    {

        var games = new List<Player>();

​

        // play a bunch of games and return the stats of ties & wins

        for(var i = 0; i < 1000; i++)

        {

            var ttt = new TicTacToe();

            Player winner;

            GameState state;

​

            do {

                ttt.MakeMove(); // X goes first

                ttt.DrawBoard();

                (state, winner) = ttt.GetWinner(); // if any

                ttt.CurrentPlayer = ttt.CurrentPlayer == Player.X ? Player.O : Player.X;

            } while (state == GameState.Running);

​

            Console.Write("Game over... ");

            Console.WriteLine((state == GameState.Tie) ? "it was a tie" : $"{winner} wins!");

            games.Add(winner);

        }

        // could track # moves per game (ties is always 9) and see the min/max/avg for X vs O wins

        // 5 would be minimum moves, 9 max.

        Console.WriteLine($"Ties: {games.Count(o => o == Player.None)} / {games.Count}");

        Console.WriteLine($"X Wins: {games.Count(o => o == Player.X)} / {games.Count}");

        Console.WriteLine($"O Wins: {games.Count(o => o == Player.O)} / {games.Count}");

        // seems to be about 10% ties, 60% X and 30% O, assuming X goes first (using RNG for both players)

    }

}

​

public enum Player { None, X, O }

public enum GameState { Running, Winner, Tie }

​

public class TicTacToe

{

    private readonly Player[] _board = new[]

    {

        Player.None, Player.None, Player.None,

        Player.None, Player.None, Player.None,

        Player.None, Player.None, Player.None

    };

    public int Moves { get; set; } = 0;

    public Player CurrentPlayer { get; set; } = Player.X;

    public void MakeMove()

    {

        if (!TryGetMove(CurrentPlayer, out int move))

            return;

        Moves++;

        _board[move] = CurrentPlayer;       

    }

    // yes "p" is unused but this is an RNG placeholder not a min/max 

    // get-a-real-move method like it would be in an actual application.

    public bool TryGetMove(Player p, out int move)

    {       

        if (!_board.Any(o => o == Player.None))

        {

            move = 0;

            return false;

        }

        int m = 0;

​

        do

        {

            m = RandomNumberGenerator.GetInt32(9);

        } while (_board[m] != Player.None);

        move = m;       

        return true;

    }

    public (GameState, Player) GetWinner()

    {

        for (var i = 0; i < 3; i++)

        {           

            // check horizontal

            if (_board[i * 3] != Player.None && _board[i * 3] == _board[i * 3 + 1] && _board[i * 3 + 1] == _board[i * 3 + 2])

                return (GameState.Winner, _board[i * 3]);

            // check vertical

            if (_board[i] != Player.None && _board[i] == _board[i + 3] && _board[i + 3] == _board[i + 6])

                return (GameState.Winner, _board[i]);

        }

        // check diagonalsa

        if (_board[0] != Player.None && _board[0] == _board[4] && _board[4] == _board[8])

            return (GameState.Winner, _board[0]);

        if (_board[6] != Player.None && _board[6] == _board[4] && _board[4] == _board[2])

            return (GameState.Winner, _board[6]);

​

        return _board.Any(o => o == Player.None) ? (GameState.Running, Player.None) : (GameState.Tie, Player.None);

    }

    private string GetCh(int move) => _board[move] == Player.None ? " " : _board[move].ToString();

    public void DrawBoard()

    {

        Console.WriteLine($"{GetCh(0)}|{GetCh(1)}|{GetCh(2)}");

        Console.WriteLine("-+-+-");

        Console.WriteLine($"{GetCh(3)}|{GetCh(4)}|{GetCh(5)}");

        Console.WriteLine("-+-+-");

        Console.WriteLine($"{GetCh(6)}|{GetCh(7)}|{GetCh(8)}");

        Console.WriteLine($"{Moves} move{(Moves == 1 ? "" : "s")}");

        Console.WriteLine();

    }

}