[CareerCup] 17.2 Tic Tac Toe 井字棋游戏

17.2 Design an algorithm to figure out if someone has won a game oftic-tac-toe.

这道题让我们判断玩家是否能赢井字棋游戏，有下面几点需要考虑：

1. 判断是否能赢hasWon函数是调用一次还是多次，如果是多次，我们可能为了优化而需要加入一些预处理。

2. 井字棋游戏通常是3x3的大小，我们是否想要实现NxN的大小？

3. 我们需要在代码紧凑，执行速度和代码清晰之间做出选择。

#include <iostream>
#include <string>
#include <vector>
#include <ctime>

using namespace std;

int convertBoardToInt(vector<string> board) {
int factor = 1, sum = 0;
for (int i = 0; i < board.size(); ++i) {
for (int j = 0; j < board[i].size(); ++j) {
int v = 0;
if (board[i][j] == 'x') v = 1;
else if (board[i][j] == 'o') v = 2;
sum += v * factor;
factor *= 3;
}
}
return sum;
}

enum class Piece {Empty, Red, Blue};

enum class Check {Row, Column, Diagonal, ReverseDiagonal};

Piece getIthColor(vector<vector<Piece>> board, int idx, int var, Check check) {
int N = board.size();
if (check == Check::Row) {
return board[idx][var];
} else if (check == Check::Column) {
return board[var][idx];
} else if (check == Check::Diagonal) {
return board[var][var];
} else if (check == Check::ReverseDiagonal) {
return board[N - 1 - var][var];
}
return Piece::Empty;
}

Piece getWinner(vector<vector<Piece>> board, int fixed_idx, Check check) {
Piece color = getIthColor(board, fixed_idx, 0, check);
if (color == Piece::Empty) {
return Piece::Empty;
}
for (int var = 1; var < board.size(); ++var) {
if (color != getIthColor(board, fixed_idx, var, check)) {
return Piece::Empty;
}
}
return color;
}

// work for 3*3 board
Piece hasWon1(vector<vector<Piece>> board) {
for (int i = 0; i < board.size(); ++i) {
if (board[i][0] != Piece::Empty && board[i][0] == board[i][1] && board[i][0] == board[i][2]) {
return board[i][0];
}
if (board[0][i] != Piece::Empty && board[0][i] == board[1][i] && board[0][i] == board[2][i]) {
return board[0][i];
}
}
if (board[0][0] != Piece::Empty && board[0][0] == board[1][1] && board[0][0] == board[2][2]) {
return board[0][0];
}
if (board[2][0] != Piece::Empty && board[2][0] == board[1][1] && board[2][0] == board[0][2]) {
return board[2][0];
}
return Piece::Empty;
}

// N*N board
Piece hasWon2(vector<vector<Piece>> board) {
int N = board.size();
Piece winner = Piece::Empty;
for (int i = 0; i < N; ++i) {
winner = getWinner(board, i, Check::Row);
if (winner != Piece::Empty) return winner;
winner = getWinner(board, i, Check::Column);
if (winner != Piece::Empty) return winner;
}
winner = getWinner(board, -1, Check::Diagonal);
if (winner != Piece::Empty) return winner;
winner = getWinner(board, -1, Check::ReverseDiagonal);
if (winner != Piece::Empty) return winner;
return Piece::Empty;
}

// N*N board
Piece hasWon3(vector<vector<Piece>> board) {
int N = board.size(), row = 0, col = 0;
for (row = 0; row < N; ++row) {
if (board[row][0] != Piece::Empty) {
for (col = 1; col < N; ++col) {
if (board[row][col] != board[row][col - 1]) {
break;
}
}
if (col == N) return board[row][0];
}
}
for (col = 0; col < N; ++col) {
if (board[0][col] != Piece::Empty) {
for (row = 1; row < N; ++row) {
if (board[row][col] != board[row - 1][col]) {
break;
}
}
if (row == N) return board[0][col];
}
}
if (board[0][0] != Piece::Empty) {
for (row = 1; row < N; ++row) {
if (board[row][row] != board[row - 1][row - 1]) {
break;
}
}
if (row == N) return board[0][0];
}
if (board[N - 1][0] != Piece::Empty) {
for (row = 1; row < N; ++row) {
if (board[N - row - 1][row] != board[N - row][row - 1]) {
break;
}
}
if (row == N) return board[N - 1][0];
}
return Piece::Empty;
}

// N*N board
Piece hasWon4(vector<vector<Piece>> board) {
int N = board.size(), i = 0, j = 0;
vector<Piece> pieces{Piece::Red, Piece::Blue};
for (Piece color : pieces) {
for (i = 0; i < N; ++i) {
bool maybe_col = true, maybe_row = true;
for (j = 0; j < N; ++j) {
if (board[i][j] != color) maybe_row = false;
if (board[j][i] != color) maybe_col = false;
}
if (maybe_col || maybe_row) return color;
}
bool maybe_diag = true, maybe_revdiag = true;
for (i = 0; i < N; ++i) {
if (board[i][i] != color) maybe_diag = false;
if (board[N - i - 1][i] != color) maybe_revdiag = false;
}
if (maybe_diag || maybe_revdiag) return color;
}
return Piece::Empty;
}

Piece convertIntToPiece(int i) {
if (i == 1) {
return Piece::Blue;
} else if (i == 2) {
return Piece::Red;
} else {
return Piece::Empty;
}
}

void printVec(vector<vector<int>> v) {
for (int i = 0; i < v.size(); ++i) {
for (int j = 0; j < v[i].size(); ++j) {
cout << v[i][j] << " ";
}
cout << endl;
}
cout << endl;
}

void printPiece(Piece p) {
if (p == Piece::Empty) cout << "Empty" << endl;
else if (p == Piece::Red) cout << "Red" << endl;
else if (p == Piece::Blue) cout << "Blue" << endl;
}

int main() {
srand(time(NULL));
for (int k = 0; k < 10; ++k) {
int N = 3;
vector<vector<int>> v(N, vector<int>(N, 0));
vector<vector<Piece>> board(N, vector<Piece>(N));
for (int i = 0; i < N; ++i) {
for (int j = 0; j < N; ++j) {
v[i][j] = rand() % 3;
board[i][j] = convertIntToPiece(v[i][j]);
}
}
Piece p1 = hasWon1(board);
Piece p2 = hasWon2(board);
Piece p3 = hasWon3(board);
Piece p4 = hasWon4(board);
if (p1 != p2 || p2 != p3 || p3 != p4) {
printPiece(p1);
printPiece(p2);
printPiece(p3);
printPiece(p4);
printVec(v);
}
cout << endl;
}
}

CareerCup All in One 题目汇总