Tic Tac Toe确定获胜者算法

Question

I initially intended to post this on the Codereview SE but since I really didn't know if the following code could be considered complete, I thought it would be a better fit here. Feel free to close this if you feel it'd be better posted somewhere else.

Considering a "valid" in terms of tic tac toe rules 3x3 array as input called game , how does this algorithm look for finding out the winner?

I'm a noob in C and programming in general and I'd like to know how good is the performance/complexity of this code, since it kind of differs from what I find on other posts in SO. Do the for loops make this unnecessarily complicated?

if (game[1][3] == game[2][2] && game[2][2] == game[3][1]) /*antidiagonal check */
    {
        w = game[1][3]; /* w is player X or O */
    }

    t1 = 0;

    for (i=0; i<=2; ++i)
    {
        if (game[i][i] == game[i+1][i+1]) /* main diagonal check */
        {
            t1 += 1;
        }
            if (t1 == 2)
            {
                w = game[i][i];
            }
    }

    for (i=0; i<=2; ++i)
    {
        t2 = 0;
        for (j=0; j<=1; ++j)
        {
            if (game[i][j] == game[i][j+1]) /* row check */
            {
                t2 += 1;
                if (t2 == 2)
                {
                    w = game[i][j];
                }
            }
        }
    }

    for (i=0; i<=1; ++i)
    {
        t3=0;
        for (j=0; j<=2; ++j)
        {
            if (game[i][j] == game[i+1][j]) /* column check */
            {
                t3 += 1;
                if (t3 == 2)
                {
                    w = game[i][j];
                }
            }
        }
    }

    if (t1<2 && t2<2 && t3<3)
    {
        printf("No winner\n");
    }
    else
    {
        printf("%c wins\n", w);
    }

Answer 1

A tic-tac-toe board has 9 tiles.

Each tile either has an X in it or it doesn't. This means that you can use a 9-bit unsigned integer to represent if each tile does/doesn't have an X ; then use this number in a (512 entry) lookup table to determine if X won.

In the same way; each tile either has an O in it or it doesn't; so you can encode that as a different 9-bit unsigned integer and use it in the same (512 entry) lookup table to determine of O won.

If the board is represented as a pair of 9-bit integers everywhere (avoiding the need to convert the state of the board), then the code becomes:

if( table[XboardState] == WIN) {
    printf("X wins\n");
} else if( table[OboardState] == WIN) {
    printf("O wins\n");
} else {
    printf("No winner\n");
}

Note: The lookup table only needs one bit per entry; so by using bitfields (and some shifting/masking to select the right bit) it could be as small as 64 bytes. Of course you could write a crude/temporary utility to generate the table for you, then "cut & paste" the table into your game's code.