Ein Algorithmus zur Bestimmung Tic Tac Toe Spiel vorbei
https://stackoverflow.com/questions/1056316
-
20-08-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianFrage
Ich habe ein Spiel von Tic-Tac-Toe in Java geschrieben und meine aktuelle Methode das Ende des Spiel-Accounts für folgende mögliche Szenarien für das Spiel ist über die Bestimmung:
- Die Karte ist voll, und kein Sieger hat noch erklärt: Spiel ist ein Unentschieden .
- Cross hat gewonnen.
- Kreis hat gewonnen.
Leider, dies zu tun, liest er durch einen vordefinierten Satz dieser Szenarien aus einer Tabelle. Das ist nicht unbedingt schlecht, wenn man, dass es nur 9 Räume auf einem Brett und damit der Tisch ist etwas klein, aber gibt es eine bessere Art und Weise algorithmisch zu bestimmen, ob das Spiel vorbei ist? Die Bestimmung, ob jemand gewonnen hat oder nicht, ist das Fleisch des Problems, da die Überprüfung, ob 9 Räume voll sind trivial.
Die Tabelle Methode könnte die Lösung sein, aber wenn nicht, was ist? Auch was ist, wenn das Brett war nicht Größe n=9? Was ist, wenn es ein viel größeres Bord war, sagt n=16, n=25, und so weiter, die Anzahl der hintereinander abgestellte Gegenstände verursachen, um zu gewinnen zu x=4, x=5, etc? Ein allgemeiner Algorithmus für alle n = { 9, 16, 25, 36 ... } zu benutzen?
Lösung
Sie wissen, dass eine erfolgreiche Bewegung erst nach X oder O passieren kann, hat ihren letzten Zug gemacht, so dass Sie nur Zeile / Spalte mit optionaler diag, die enthalten sind in diesem Schritt suchen können Sie Ihren Suchraum zu begrenzen, wenn einen Gewinn zu bestimmen versuchen, Tafel. da es auch eine festgelegte Anzahl von Zügen in einem Zieh Tic-Tac-Toe-Spiel, sobald der letzte Zug ist gemacht, wenn es nicht ein Gewinnzug ist es standardmäßig ist ein Unentschieden-Spiel.
Bearbeiten: Mit diesem Code ist für ein n von n-Board mit n in Folge zu gewinnen (3x3 Platte requries 3 in einer Reihe, usw.)
edit: Code hinzugefügt anti diag zu überprüfen, kann ich nicht einen nicht-Schleife Weg finden, um zu bestimmen, ob der Punkt auf der anti diag so thats war, warum dieser Schritt fehlt
public class TripleT {
enum State{Blank, X, O};
int n = 3;
State[][] board = new State[n][n];
int moveCount;
void Move(int x, int y, State s){
if(board[x][y] == State.Blank){
board[x][y] = s;
}
moveCount++;
//check end conditions
//check col
for(int i = 0; i < n; i++){
if(board[x][i] != s)
break;
if(i == n-1){
//report win for s
}
}
//check row
for(int i = 0; i < n; i++){
if(board[i][y] != s)
break;
if(i == n-1){
//report win for s
}
}
//check diag
if(x == y){
//we're on a diagonal
for(int i = 0; i < n; i++){
if(board[i][i] != s)
break;
if(i == n-1){
//report win for s
}
}
}
//check anti diag (thanks rampion)
if(x + y == n - 1){
for(int i = 0; i < n; i++){
if(board[i][(n-1)-i] != s)
break;
if(i == n-1){
//report win for s
}
}
}
//check draw
if(moveCount == (Math.pow(n, 2) - 1)){
//report draw
}
}
}
Andere Tipps
Sie können ein magisches Quadrat http://mathworld.wolfram.com/MagicSquare.html, wenn eine Zeile, Spalte oder diag bis 15 summiert sich dann ein Spieler gewonnen hat.
Dies ist ähnlich href="https://stackoverflow.com/questions/1056316/algorithm-for-determining-tic-tac-toe-game-over-java/1058804#1058804"> Osama ALASSIRY Antwort auf , aber es handelt konstanten Raum und lineare Zeit für linear-Raum und mit konstanter Zeit. Das heißt, es gibt keinen Looping nach der Initialisierung.
Initialisiere ein Paar (0,0) für jede Reihe, jede Spalte und den zwei Diagonalen (diagonal & anti-diagonal). Diese Paare repräsentieren die akkumulierte (sum,sum) der Stücke in der entsprechenden Zeile, Spalte oder Diagonale, wobei
A piece from player A has value (1,0) A piece from player B has value (0,1)
Wenn ein Spieler eine Figur platziert, aktualisieren, um das entsprechende Zeilenpaar, Spaltenpaar und diagonale Paare (wenn auf den Diagonalen). Falls eine neu aktualisierte Zeile, Spalte oder diagonal Paar gleich entweder (n,0) oder (0,n) dann entweder A oder B gewonnen werden.
Asymptotic Analyse:
O(1) time (per move) O(n) space (overall)
Für die Speichernutzung, verwenden Sie 4*(n+1) ganze Zahlen sind.
two_elements*n_rows + two_elements*n_columns + two_elements*two_diagonals = 4*n + 4 integers = 4(n+1) integers
Übung: Können Sie sehen, wie für ein Unentschieden in O (1) Zeit zu testen, pro-Bewegung? Wenn ja, können Sie das Spiel früh auf ein Unentschieden beenden.
Wie über diesen Pseudo-Code:
Nachdem ein Spieler ablegt ein Stück an der Position (x, y):
col=row=diag=rdiag=0
winner=false
for i=1 to n
if cell[x,i]=player then col++
if cell[i,y]=player then row++
if cell[i,i]=player then diag++
if cell[i,n-i+1]=player then rdiag++
if row=n or col=n or diag=n or rdiag=n then winner=true
Ich würde ein Array von char [n, n], mit O, X und Raum für leer.
- einfach.
- Eine Schleife.
- Fünf einfache Variablen. 4 ganze Zahlen und ein boolean
- Waagen für jede Größe von n.
- prüft nur aktuelles Stück.
- Keine Magie. :)
Heres meiner Lösung, die ich für ein Projekt schrieb ich arbeite in Javascript. Wenn Sie nicht die Speicherkosten von wenigen Arrays dagegen ist es wahrscheinlich die schnellste und einfachste Lösung, die Sie finden werden. Es wird vorausgesetzt, dass die Position des letzten Zug kennen.
/*
* Determines if the last move resulted in a win for either player
* board: is an array representing the board
* lastMove: is the boardIndex of the last (most recent) move
* these are the boardIndexes:
*
* 0 | 1 | 2
* ---+---+---
* 3 | 4 | 5
* ---+---+---
* 6 | 7 | 8
*
* returns true if there was a win
*/
var winLines = [
[[1, 2], [4, 8], [3, 6]],
[[0, 2], [4, 7]],
[[0, 1], [4, 6], [5, 8]],
[[4, 5], [0, 6]],
[[3, 5], [0, 8], [2, 6], [1, 7]],
[[3, 4], [2, 8]],
[[7, 8], [2, 4], [0, 3]],
[[6, 8], [1, 4]],
[[6, 7], [0, 4], [2, 5]]
];
function isWinningMove(board, lastMove) {
var player = board[lastMove];
for (var i = 0; i < winLines[lastMove].length; i++) {
var line = winLines[lastMove][i];
if(player === board[line[0]] && player === board[line[1]]) {
return true;
}
}
return false;
}
Ich schrieb dies für meine C-Programmierung Klasse.
ich es bin Entsendung weil keiner von den anderen Beispielen hier wird mit jeder Größe arbeiten rechteckigen Raster und einem beliebigen Anzahl N -in-einer-Reihe aufeinander folgende Marken zu gewinnen .
Sie werden meinen Algorithmus finden, wie es ist, in der checkWinner() Funktion. Dabei spielt es keine magischen Zahlen oder etwas Phantasie verwendet für einen Gewinner zu überprüfen, ist es einfach verwendet vier für Schleifen -. Der Code gut kommentiert, damit ich es für sich selbst sprechen lasse ich denke,
// This program will work with any whole number sized rectangular gameBoard.
// It checks for N marks in straight lines (rows, columns, and diagonals).
// It is prettiest when ROWS and COLS are single digit numbers.
// Try altering the constants for ROWS, COLS, and N for great fun!
// PPDs come first
#include <stdio.h>
#define ROWS 9 // The number of rows our gameBoard array will have
#define COLS 9 // The number of columns of the same - Single digit numbers will be prettier!
#define N 3 // This is the number of contiguous marks a player must have to win
#define INITCHAR ' ' // This changes the character displayed (a ' ' here probably looks the best)
#define PLAYER1CHAR 'X' // Some marks are more aesthetically pleasing than others
#define PLAYER2CHAR 'O' // Change these lines if you care to experiment with them
// Function prototypes are next
int playGame (char gameBoard[ROWS][COLS]); // This function allows the game to be replayed easily, as desired
void initBoard (char gameBoard[ROWS][COLS]); // Fills the ROWSxCOLS character array with the INITCHAR character
void printBoard (char gameBoard[ROWS][COLS]); // Prints out the current board, now with pretty formatting and #s!
void makeMove (char gameBoard[ROWS][COLS], int player); // Prompts for (and validates!) a move and stores it into the array
int checkWinner (char gameBoard[ROWS][COLS], int player); // Checks the current state of the board to see if anyone has won
// The starting line
int main (void)
{
// Inits
char gameBoard[ROWS][COLS]; // Our gameBoard is declared as a character array, ROWS x COLS in size
int winner = 0;
char replay;
//Code
do // This loop plays through the game until the user elects not to
{
winner = playGame(gameBoard);
printf("\nWould you like to play again? Y for yes, anything else exits: ");
scanf("%c",&replay); // I have to use both a scanf() and a getchar() in
replay = getchar(); // order to clear the input buffer of a newline char
// (http://cboard.cprogramming.com/c-programming/121190-problem-do-while-loop-char.html)
} while ( replay == 'y' || replay == 'Y' );
// Housekeeping
printf("\n");
return winner;
}
int playGame(char gameBoard[ROWS][COLS])
{
int turn = 0, player = 0, winner = 0, i = 0;
initBoard(gameBoard);
do
{
turn++; // Every time this loop executes, a unique turn is about to be made
player = (turn+1)%2+1; // This mod function alternates the player variable between 1 & 2 each turn
makeMove(gameBoard,player);
printBoard(gameBoard);
winner = checkWinner(gameBoard,player);
if (winner != 0)
{
printBoard(gameBoard);
for (i=0;i<19-2*ROWS;i++) // Formatting - works with the default shell height on my machine
printf("\n"); // Hopefully I can replace these with something that clears the screen for me
printf("\n\nCongratulations Player %i, you've won with %i in a row!\n\n",winner,N);
return winner;
}
} while ( turn < ROWS*COLS ); // Once ROWS*COLS turns have elapsed
printf("\n\nGame Over!\n\nThere was no Winner :-(\n"); // The board is full and the game is over
return winner;
}
void initBoard (char gameBoard[ROWS][COLS])
{
int row = 0, col = 0;
for (row=0;row<ROWS;row++)
{
for (col=0;col<COLS;col++)
{
gameBoard[row][col] = INITCHAR; // Fill the gameBoard with INITCHAR characters
}
}
printBoard(gameBoard); // Having this here prints out the board before
return; // the playGame function asks for the first move
}
void printBoard (char gameBoard[ROWS][COLS]) // There is a ton of formatting in here
{ // That I don't feel like commenting :P
int row = 0, col = 0, i=0; // It took a while to fine tune
// But now the output is something like:
printf("\n"); //
// 1 2 3
for (row=0;row<ROWS;row++) // 1 | |
{ // -----------
if (row == 0) // 2 | |
{ // -----------
printf(" "); // 3 | |
for (i=0;i<COLS;i++)
{
printf(" %i ",i+1);
}
printf("\n\n");
}
for (col=0;col<COLS;col++)
{
if (col==0)
printf("%i ",row+1);
printf(" %c ",gameBoard[row][col]);
if (col<COLS-1)
printf("|");
}
printf("\n");
if (row < ROWS-1)
{
for(i=0;i<COLS-1;i++)
{
if(i==0)
printf(" ----");
else
printf("----");
}
printf("---\n");
}
}
return;
}
void makeMove (char gameBoard[ROWS][COLS],int player)
{
int row = 0, col = 0, i=0;
char currentChar;
if (player == 1) // This gets the correct player's mark
currentChar = PLAYER1CHAR;
else
currentChar = PLAYER2CHAR;
for (i=0;i<21-2*ROWS;i++) // Newline formatting again :-(
printf("\n");
printf("\nPlayer %i, please enter the column of your move: ",player);
scanf("%i",&col);
printf("Please enter the row of your move: ");
scanf("%i",&row);
row--; // These lines translate the user's rows and columns numbering
col--; // (starting with 1) to the computer's (starting with 0)
while(gameBoard[row][col] != INITCHAR || row > ROWS-1 || col > COLS-1) // We are not using a do... while because
{ // I wanted the prompt to change
printBoard(gameBoard);
for (i=0;i<20-2*ROWS;i++)
printf("\n");
printf("\nPlayer %i, please enter a valid move! Column first, then row.\n",player);
scanf("%i %i",&col,&row);
row--; // See above ^^^
col--;
}
gameBoard[row][col] = currentChar; // Finally, we store the correct mark into the given location
return; // And pop back out of this function
}
int checkWinner(char gameBoard[ROWS][COLS], int player) // I've commented the last (and the hardest, for me anyway)
{ // check, which checks for backwards diagonal runs below >>>
int row = 0, col = 0, i = 0;
char currentChar;
if (player == 1)
currentChar = PLAYER1CHAR;
else
currentChar = PLAYER2CHAR;
for ( row = 0; row < ROWS; row++) // This first for loop checks every row
{
for ( col = 0; col < (COLS-(N-1)); col++) // And all columns until N away from the end
{
while (gameBoard[row][col] == currentChar) // For consecutive rows of the current player's mark
{
col++;
i++;
if (i == N)
{
return player;
}
}
i = 0;
}
}
for ( col = 0; col < COLS; col++) // This one checks for columns of consecutive marks
{
for ( row = 0; row < (ROWS-(N-1)); row++)
{
while (gameBoard[row][col] == currentChar)
{
row++;
i++;
if (i == N)
{
return player;
}
}
i = 0;
}
}
for ( col = 0; col < (COLS - (N-1)); col++) // This one checks for "forwards" diagonal runs
{
for ( row = 0; row < (ROWS-(N-1)); row++)
{
while (gameBoard[row][col] == currentChar)
{
row++;
col++;
i++;
if (i == N)
{
return player;
}
}
i = 0;
}
}
// Finally, the backwards diagonals:
for ( col = COLS-1; col > 0+(N-2); col--) // Start from the last column and go until N columns from the first
{ // The math seems strange here but the numbers work out when you trace them
for ( row = 0; row < (ROWS-(N-1)); row++) // Start from the first row and go until N rows from the last
{
while (gameBoard[row][col] == currentChar) // If the current player's character is there
{
row++; // Go down a row
col--; // And back a column
i++; // The i variable tracks how many consecutive marks have been found
if (i == N) // Once i == N
{
return player; // Return the current player number to the
} // winnner variable in the playGame function
} // If it breaks out of the while loop, there weren't N consecutive marks
i = 0; // So make i = 0 again
} // And go back into the for loop, incrementing the row to check from
}
return 0; // If we got to here, no winner has been detected,
} // so we pop back up into the playGame function
// The end!
// Well, almost.
// Eventually I hope to get this thing going
// with a dynamically sized array. I'll make
// the CONSTANTS into variables in an initGame
// function and allow the user to define them.
Wenn das Board n × n dann gibt es n Zeilen n Spalten und 2 Diagonalen . Überprüfen Sie jede dieser für alle-X oder alle-O ein Gewinner zu finden.
Wenn es dauert nur x < n aufeinanderfolgende Plätze zu gewinnen, dann ist es ein wenig komplizierter. Die naheliegendste Lösung ist jeder x × x Platz für einen Gewinner zu überprüfen. Hier einige Code, dass demonstriert.
(Ich habe nicht wirklich testen Sie diese * hust *, aber es hat kompiliert auf dem ersten Versuch, yay me!)
public class TicTacToe
{
public enum Square { X, O, NONE }
/**
* Returns the winning player, or NONE if the game has
* finished without a winner, or null if the game is unfinished.
*/
public Square findWinner(Square[][] board, int lengthToWin) {
// Check each lengthToWin x lengthToWin board for a winner.
for (int top = 0; top <= board.length - lengthToWin; ++top) {
int bottom = top + lengthToWin - 1;
for (int left = 0; left <= board.length - lengthToWin; ++left) {
int right = left + lengthToWin - 1;
// Check each row.
nextRow: for (int row = top; row <= bottom; ++row) {
if (board[row][left] == Square.NONE) {
continue;
}
for (int col = left; col <= right; ++col) {
if (board[row][col] != board[row][left]) {
continue nextRow;
}
}
return board[row][left];
}
// Check each column.
nextCol: for (int col = left; col <= right; ++col) {
if (board[top][col] == Square.NONE) {
continue;
}
for (int row = top; row <= bottom; ++row) {
if (board[row][col] != board[top][col]) {
continue nextCol;
}
}
return board[top][col];
}
// Check top-left to bottom-right diagonal.
diag1: if (board[top][left] != Square.NONE) {
for (int i = 1; i < lengthToWin; ++i) {
if (board[top+i][left+i] != board[top][left]) {
break diag1;
}
}
return board[top][left];
}
// Check top-right to bottom-left diagonal.
diag2: if (board[top][right] != Square.NONE) {
for (int i = 1; i < lengthToWin; ++i) {
if (board[top+i][right-i] != board[top][right]) {
break diag2;
}
}
return board[top][right];
}
}
}
// Check for a completely full board.
boolean isFull = true;
full: for (int row = 0; row < board.length; ++row) {
for (int col = 0; col < board.length; ++col) {
if (board[row][col] == Square.NONE) {
isFull = false;
break full;
}
}
}
// The board is full.
if (isFull) {
return Square.NONE;
}
// The board is not full and we didn't find a solution.
else {
return null;
}
}
}
Ich weiß nicht, Java, die gut, aber ich weiß, C, also versuchte ich ADK magisches Quadrat Idee (zusammen mit Hardwareguy der Suche Einschränkung ).
// tic-tac-toe.c
// to compile:
// % gcc -o tic-tac-toe tic-tac-toe.c
// to run:
// % ./tic-tac-toe
#include <stdio.h>
// the two types of marks available
typedef enum { Empty=2, X=0, O=1, NumMarks=2 } Mark;
char const MarkToChar[] = "XO ";
// a structure to hold the sums of each kind of mark
typedef struct { unsigned char of[NumMarks]; } Sum;
// a cell in the board, which has a particular value
#define MAGIC_NUMBER 15
typedef struct {
Mark mark;
unsigned char const value;
size_t const num_sums;
Sum * const sums[4];
} Cell;
#define NUM_ROWS 3
#define NUM_COLS 3
// create a sum for each possible tic-tac-toe
Sum row[NUM_ROWS] = {0};
Sum col[NUM_COLS] = {0};
Sum nw_diag = {0};
Sum ne_diag = {0};
// initialize the board values so any row, column, or diagonal adds to
// MAGIC_NUMBER, and so they each record their sums in the proper rows, columns,
// and diagonals
Cell board[NUM_ROWS][NUM_COLS] = {
{
{ Empty, 8, 3, { &row[0], &col[0], &nw_diag } },
{ Empty, 1, 2, { &row[0], &col[1] } },
{ Empty, 6, 3, { &row[0], &col[2], &ne_diag } },
},
{
{ Empty, 3, 2, { &row[1], &col[0] } },
{ Empty, 5, 4, { &row[1], &col[1], &nw_diag, &ne_diag } },
{ Empty, 7, 2, { &row[1], &col[2] } },
},
{
{ Empty, 4, 3, { &row[2], &col[0], &ne_diag } },
{ Empty, 9, 2, { &row[2], &col[1] } },
{ Empty, 2, 3, { &row[2], &col[2], &nw_diag } },
}
};
// print the board
void show_board(void)
{
size_t r, c;
for (r = 0; r < NUM_ROWS; r++)
{
if (r > 0) { printf("---+---+---\n"); }
for (c = 0; c < NUM_COLS; c++)
{
if (c > 0) { printf("|"); }
printf(" %c ", MarkToChar[board[r][c].mark]);
}
printf("\n");
}
}
// run the game, asking the player for inputs for each side
int main(int argc, char * argv[])
{
size_t m;
show_board();
printf("Enter moves as \"<row> <col>\" (no quotes, zero indexed)\n");
for( m = 0; m < NUM_ROWS * NUM_COLS; m++ )
{
Mark const mark = (Mark) (m % NumMarks);
size_t c, r;
// read the player's move
do
{
printf("%c's move: ", MarkToChar[mark]);
fflush(stdout);
scanf("%d %d", &r, &c);
if (r >= NUM_ROWS || c >= NUM_COLS)
{
printf("illegal move (off the board), try again\n");
}
else if (board[r][c].mark != Empty)
{
printf("illegal move (already taken), try again\n");
}
else
{
break;
}
}
while (1);
{
Cell * const cell = &(board[r][c]);
size_t s;
// update the board state
cell->mark = mark;
show_board();
// check for tic-tac-toe
for (s = 0; s < cell->num_sums; s++)
{
cell->sums[s]->of[mark] += cell->value;
if (cell->sums[s]->of[mark] == MAGIC_NUMBER)
{
printf("tic-tac-toe! %c wins!\n", MarkToChar[mark]);
goto done;
}
}
}
}
printf("stalemate... nobody wins :(\n");
done:
return 0;
}
Es kompiliert und Tests gut.
% gcc -o tic-tac-toe tic-tac-toe.c
% ./tic-tac-toe
| |
---+---+---
| |
---+---+---
| |
Enter moves as " " (no quotes, zero indexed)
X's move: 1 2
| |
---+---+---
| | X
---+---+---
| |
O's move: 1 2
illegal move (already taken), try again
O's move: 3 3
illegal move (off the board), try again
O's move: 2 2
| |
---+---+---
| | X
---+---+---
| | O
X's move: 1 0
| |
---+---+---
X | | X
---+---+---
| | O
O's move: 1 1
| |
---+---+---
X | O | X
---+---+---
| | O
X's move: 0 0
X | |
---+---+---
X | O | X
---+---+---
| | O
O's move: 2 0
X | |
---+---+---
X | O | X
---+---+---
O | | O
X's move: 2 1
X | |
---+---+---
X | O | X
---+---+---
O | X | O
O's move: 0 2
X | | O
---+---+---
X | O | X
---+---+---
O | X | O
tic-tac-toe! O wins!
% ./tic-tac-toe
| |
---+---+---
| |
---+---+---
| |
Enter moves as " " (no quotes, zero indexed)
X's move: 0 0
X | |
---+---+---
| |
---+---+---
| |
O's move: 0 1
X | O |
---+---+---
| |
---+---+---
| |
X's move: 0 2
X | O | X
---+---+---
| |
---+---+---
| |
O's move: 1 0
X | O | X
---+---+---
O | |
---+---+---
| |
X's move: 1 1
X | O | X
---+---+---
O | X |
---+---+---
| |
O's move: 2 0
X | O | X
---+---+---
O | X |
---+---+---
O | |
X's move: 2 1
X | O | X
---+---+---
O | X |
---+---+---
O | X |
O's move: 2 2
X | O | X
---+---+---
O | X |
---+---+---
O | X | O
X's move: 1 2
X | O | X
---+---+---
O | X | X
---+---+---
O | X | O
stalemate... nobody wins :(
%
Das hat Spaß gemacht, danke!
Eigentlich darüber nachzudenken, die Sie nicht ein magisches Quadrat brauchen, nur eine Zählung für jede Zeile / Spalte / diagonal. Dies ist ein wenig einfacher als ein magisches Quadrat zu verallgemeinern × n Matrizen n, da Sie nur n müssen zählen.
Ich habe die gleiche Frage in einem meiner Interviews gefragt. Meine Gedanken: Initialisieren der Matrix mit 0. Halten Sie 3-Arrays 1) sum_row (Größe n) 2) sum_column (Größe n) 3) diagonal (Größe 2)
Für jeden Schritt von (X) dekrementieren Feld Wert von 1 und für jeden Schritt von (0) Inkrementieren um 1. An jedem Punkt, wenn die Zeile / Spalte / diagonal in der aktuellen Bewegung modifiziert wurde, hat Summe entweder -3 oder +3 bedeutet jemand das Spiel gewonnen hat. Für ein Unentschieden können wir oben Ansatz verwenden, um die Variable Movecount zu halten.
Glaubst du, ich bin etwas fehlt?
Edit: Gleiche kann für nxn-Matrix verwendet werden. Summe sollte sogar +3 oder -3.
eine nicht-Schleife Art und Weise zu bestimmen, ob der Punkt auf dem anti diag ist:
`if (x + y == n - 1)`
Ich habe einige Optimierungen in der Zeile, Spalte, diagonal überprüft. Sein vor allem in der ersten verschachtelten Schleife entschieden, wenn wir eine bestimmte Spalte oder diagonal überprüfen müssen. So vermeiden wir Überprüfung der Spalten oder Diagonalen spart Zeit. Dies macht große Wirkung, wenn die Plattengröße mehr und eine erhebliche Anzahl der Zellen werden nicht gefüllt ist.
Hier ist der Java-Code dafür.
int gameState(int values[][], int boardSz) {
boolean colCheckNotRequired[] = new boolean[boardSz];//default is false
boolean diag1CheckNotRequired = false;
boolean diag2CheckNotRequired = false;
boolean allFilled = true;
int x_count = 0;
int o_count = 0;
/* Check rows */
for (int i = 0; i < boardSz; i++) {
x_count = o_count = 0;
for (int j = 0; j < boardSz; j++) {
if(values[i][j] == x_val)x_count++;
if(values[i][j] == o_val)o_count++;
if(values[i][j] == 0)
{
colCheckNotRequired[j] = true;
if(i==j)diag1CheckNotRequired = true;
if(i + j == boardSz - 1)diag2CheckNotRequired = true;
allFilled = false;
//No need check further
break;
}
}
if(x_count == boardSz)return X_WIN;
if(o_count == boardSz)return O_WIN;
}
/* check cols */
for (int i = 0; i < boardSz; i++) {
x_count = o_count = 0;
if(colCheckNotRequired[i] == false)
{
for (int j = 0; j < boardSz; j++) {
if(values[j][i] == x_val)x_count++;
if(values[j][i] == o_val)o_count++;
//No need check further
if(values[i][j] == 0)break;
}
if(x_count == boardSz)return X_WIN;
if(o_count == boardSz)return O_WIN;
}
}
x_count = o_count = 0;
/* check diagonal 1 */
if(diag1CheckNotRequired == false)
{
for (int i = 0; i < boardSz; i++) {
if(values[i][i] == x_val)x_count++;
if(values[i][i] == o_val)o_count++;
if(values[i][i] == 0)break;
}
if(x_count == boardSz)return X_WIN;
if(o_count == boardSz)return O_WIN;
}
x_count = o_count = 0;
/* check diagonal 2 */
if( diag2CheckNotRequired == false)
{
for (int i = boardSz - 1,j = 0; i >= 0 && j < boardSz; i--,j++) {
if(values[j][i] == x_val)x_count++;
if(values[j][i] == o_val)o_count++;
if(values[j][i] == 0)break;
}
if(x_count == boardSz)return X_WIN;
if(o_count == boardSz)return O_WIN;
x_count = o_count = 0;
}
if( allFilled == true)
{
for (int i = 0; i < boardSz; i++) {
for (int j = 0; j < boardSz; j++) {
if (values[i][j] == 0) {
allFilled = false;
break;
}
}
if (allFilled == false) {
break;
}
}
}
if (allFilled)
return DRAW;
return INPROGRESS;
}
Ich bin spät die Partei, aber ich wollte einen Vorteil, darauf hinzuweisen, dass ich auf der Verwendung eines Magie Platz , nämlich, dass es verwendet werden kann, einen Verweis auf den Platz zu bekommen, die den Gewinn oder Verlust aus dem nächsten Zuge verursachen würde, anstatt nur verwendet wird, zu berechnen, wenn ein Spiel vorbei ist.
Nehmen Sie dieses magische Quadrat:
4 9 2
3 5 7
8 1 6
Zuerst stellte eine scores Array auf, die jedes Mal, wenn ein Zug gemacht wird erhöht. Siehe diese Antwort . Wenn wir nun illegal X spielen zweimal in Folge auf [0,0] und [0,1], dann ist die scores Array wie folgt aussieht:
[7, 0, 0, 4, 3, 0, 4, 0];
Und das Board sieht wie folgt aus:
X . .
X . .
. . .
Dann alles, was wir tun, um eine Referenz zu erhalten, die quadratisch / Block zu gewinnen auf ist:
get_winning_move = function() {
for (var i = 0, i < scores.length; i++) {
// keep track of the number of times pieces were added to the row
// subtract when the opposite team adds a piece
if (scores[i].inc === 2) {
return 15 - state[i].val; // 8
}
}
}
In der Realität erfordert die Implementierung einige zusätzliche Tricks, wie nummerierten Tasten Handling (in JavaScript), aber ich fand es ziemlich einfach und genossen die Freizeit-Math.
Ich mag diesen Algorithmus, da es eine 1x9 vs 3x3 Darstellung der Platine verwendet.
private int[] board = new int[9];
private static final int[] START = new int[] { 0, 3, 6, 0, 1, 2, 0, 2 };
private static final int[] INCR = new int[] { 1, 1, 1, 3, 3, 3, 4, 2 };
private static int SIZE = 3;
/**
* Determines if there is a winner in tic-tac-toe board.
* @return {@code 0} for draw, {@code 1} for 'X', {@code -1} for 'Y'
*/
public int hasWinner() {
for (int i = 0; i < START.length; i++) {
int sum = 0;
for (int j = 0; j < SIZE; j++) {
sum += board[START[i] + j * INCR[i]];
}
if (Math.abs(sum) == SIZE) {
return sum / SIZE;
}
}
return 0;
}
Eine weitere Option: erzeugen Sie Ihre Tabelle mit Code. Bis zu Symmetrie gibt es nur drei Möglichkeiten zu gewinnen: Randreihe, mittlere Reihe oder diagonal. Nehmen Sie diese drei und drehen sie um jede Art und Weise möglich:
def spin(g): return set([g, turn(g), turn(turn(g)), turn(turn(turn(g)))])
def turn(g): return tuple(tuple(g[y][x] for y in (0,1,2)) for x in (2,1,0))
X,s = 'X.'
XXX = X, X, X
sss = s, s, s
ways_to_win = ( spin((XXX, sss, sss))
| spin((sss, XXX, sss))
| spin(((X,s,s),
(s,X,s),
(s,s,X))))
können diese Symmetrien mehr Anwendungen in Ihrem Spiel-Spielcode: wenn Sie auf ein Brett erhalten Sie bereits eine gedrehte Version gesehen haben, können Sie nur den zwischengespeicherten Wert nehmen oder zwischengespeichert besten bewegen von diesem einen (und unrotate es zurück). Dies ist in der Regel viel schneller als das Spiel subtree zu bewerten.
(links Flipping und rechts die gleiche Art und Weise helfen, sie nicht hier waren notwendig, weil die Menge der Drehungen des Gewinnmusters ist spiegelsymmetrisch.)
Hier ist eine Lösung, die ich mit aufkommen, das die Symbole als Zeichen speichert und verwendet das int-Wert des char, um herauszufinden, ob X oder O (Blick auf dem Schiedsrichter-Code) gewonnen hat
public class TicTacToe {
public static final char BLANK = '\u0000';
private final char[][] board;
private int moveCount;
private Referee referee;
public TicTacToe(int gridSize) {
if (gridSize < 3)
throw new IllegalArgumentException("TicTacToe board size has to be minimum 3x3 grid");
board = new char[gridSize][gridSize];
referee = new Referee(gridSize);
}
public char[][] displayBoard() {
return board.clone();
}
public String move(int x, int y) {
if (board[x][y] != BLANK)
return "(" + x + "," + y + ") is already occupied";
board[x][y] = whoseTurn();
return referee.isGameOver(x, y, board[x][y], ++moveCount);
}
private char whoseTurn() {
return moveCount % 2 == 0 ? 'X' : 'O';
}
private class Referee {
private static final int NO_OF_DIAGONALS = 2;
private static final int MINOR = 1;
private static final int PRINCIPAL = 0;
private final int gridSize;
private final int[] rowTotal;
private final int[] colTotal;
private final int[] diagonalTotal;
private Referee(int size) {
gridSize = size;
rowTotal = new int[size];
colTotal = new int[size];
diagonalTotal = new int[NO_OF_DIAGONALS];
}
private String isGameOver(int x, int y, char symbol, int moveCount) {
if (isWinningMove(x, y, symbol))
return symbol + " won the game!";
if (isBoardCompletelyFilled(moveCount))
return "Its a Draw!";
return "continue";
}
private boolean isBoardCompletelyFilled(int moveCount) {
return moveCount == gridSize * gridSize;
}
private boolean isWinningMove(int x, int y, char symbol) {
if (isPrincipalDiagonal(x, y) && allSymbolsMatch(symbol, diagonalTotal, PRINCIPAL))
return true;
if (isMinorDiagonal(x, y) && allSymbolsMatch(symbol, diagonalTotal, MINOR))
return true;
return allSymbolsMatch(symbol, rowTotal, x) || allSymbolsMatch(symbol, colTotal, y);
}
private boolean allSymbolsMatch(char symbol, int[] total, int index) {
total[index] += symbol;
return total[index] / gridSize == symbol;
}
private boolean isPrincipalDiagonal(int x, int y) {
return x == y;
}
private boolean isMinorDiagonal(int x, int y) {
return x + y == gridSize - 1;
}
}
}
Auch sind hier meine Unit-Tests zu validieren es tatsächlich funktioniert
import static com.agilefaqs.tdd.demo.TicTacToe.BLANK;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import org.junit.Test;
public class TicTacToeTest {
private TicTacToe game = new TicTacToe(3);
@Test
public void allCellsAreEmptyInANewGame() {
assertBoardIs(new char[][] { { BLANK, BLANK, BLANK },
{ BLANK, BLANK, BLANK },
{ BLANK, BLANK, BLANK } });
}
@Test(expected = IllegalArgumentException.class)
public void boardHasToBeMinimum3x3Grid() {
new TicTacToe(2);
}
@Test
public void firstPlayersMoveMarks_X_OnTheBoard() {
assertEquals("continue", game.move(1, 1));
assertBoardIs(new char[][] { { BLANK, BLANK, BLANK },
{ BLANK, 'X', BLANK },
{ BLANK, BLANK, BLANK } });
}
@Test
public void secondPlayersMoveMarks_O_OnTheBoard() {
game.move(1, 1);
assertEquals("continue", game.move(2, 2));
assertBoardIs(new char[][] { { BLANK, BLANK, BLANK },
{ BLANK, 'X', BLANK },
{ BLANK, BLANK, 'O' } });
}
@Test
public void playerCanOnlyMoveToAnEmptyCell() {
game.move(1, 1);
assertEquals("(1,1) is already occupied", game.move(1, 1));
}
@Test
public void firstPlayerWithAllSymbolsInOneRowWins() {
game.move(0, 0);
game.move(1, 0);
game.move(0, 1);
game.move(2, 1);
assertEquals("X won the game!", game.move(0, 2));
}
@Test
public void firstPlayerWithAllSymbolsInOneColumnWins() {
game.move(1, 1);
game.move(0, 0);
game.move(2, 1);
game.move(1, 0);
game.move(2, 2);
assertEquals("O won the game!", game.move(2, 0));
}
@Test
public void firstPlayerWithAllSymbolsInPrincipalDiagonalWins() {
game.move(0, 0);
game.move(1, 0);
game.move(1, 1);
game.move(2, 1);
assertEquals("X won the game!", game.move(2, 2));
}
@Test
public void firstPlayerWithAllSymbolsInMinorDiagonalWins() {
game.move(0, 2);
game.move(1, 0);
game.move(1, 1);
game.move(2, 1);
assertEquals("X won the game!", game.move(2, 0));
}
@Test
public void whenAllCellsAreFilledTheGameIsADraw() {
game.move(0, 2);
game.move(1, 1);
game.move(1, 0);
game.move(2, 1);
game.move(2, 2);
game.move(0, 0);
game.move(0, 1);
game.move(1, 2);
assertEquals("Its a Draw!", game.move(2, 0));
}
private void assertBoardIs(char[][] expectedBoard) {
assertArrayEquals(expectedBoard, game.displayBoard());
}
}
Voll Lösung: https://github.com/nashjain/tictactoe/tree/master / java
Wie wärs mit einem folgenden Ansatz für 9 Slots? Deklarieren 9 ganzzahlige Variablen für eine 3x3-Matrix (a1, a2 .... a9) wobei a1, a2, a3 repräsentieren row-1 und a1, a4, a7 würde column-1 bilden (man auf die Idee kommen). Verwenden Sie ‚1‘, um anzuzeigen, Spieler-1 und ‚2‘ Spieler-2 anzuzeigen.
Es gibt 8 mögliche Gewinnkombinationen: Win-1: a1 + a2 + a3 (Antwort 3 werden könnte oder 6 basierend auf dem Spieler gewonnen) Win-2: a4 + a5 + a6 Win-3: a7 + a8 + a9 Win-4: a1 + a4 + a7 .... Win-7: a1 + a5 + a9 Win-8: a3 + a5 + a7
Jetzt wissen wir, dass, wenn der Spieler einer Kreuz a1 dann brauchen wir Summe von 3 Variablen neu zu bewerten: Win-1, Win-4 und Win-7. Unabhängig davon, welche 'Win-?' Variablen erreicht 3 oder 6 zuerst das Spiel gewinnt. Wenn Win-1 Variable erreicht 6 zuerst, dann Spieler-2 gewinnt.
Ich verstehe, dass diese Lösung nicht leicht skalierbar ist.
Dies ist eine wirklich einfache Art und Weise zu überprüfen.
public class Game() {
Game player1 = new Game('x');
Game player2 = new Game('o');
char piece;
Game(char piece) {
this.piece = piece;
}
public void checkWin(Game player) {
// check horizontal win
for (int i = 0; i <= 6; i += 3) {
if (board[i] == player.piece &&
board[i + 1] == player.piece &&
board[i + 2] == player.piece)
endGame(player);
}
// check vertical win
for (int i = 0; i <= 2; i++) {
if (board[i] == player.piece &&
board[i + 3] == player.piece &&
board[i + 6] == player.piece)
endGame(player);
}
// check diagonal win
if ((board[0] == player.piece &&
board[4] == player.piece &&
board[8] == player.piece) ||
board[2] == player.piece &&
board[4] == player.piece &&
board[6] == player.piece)
endGame(player);
}
}
Wenn Sie boarder Feld haben 5 * 5 zum Beispiel, ich nächste Methode zur Überprüfung:
public static boolean checkWin(char symb) {
int SIZE = 5;
for (int i = 0; i < SIZE-1; i++) {
for (int j = 0; j <SIZE-1 ; j++) {
//vertical checking
if (map[0][j] == symb && map[1][j] == symb && map[2][j] == symb && map[3][j] == symb && map[4][j] == symb) return true; // j=0
}
//horisontal checking
if(map[i][0] == symb && map[i][1] == symb && map[i][2] == symb && map[i][3] == symb && map[i][4] == symb) return true; // i=0
}
//diagonal checking (5*5)
if (map[0][0] == symb && map[1][1] == symb && map[2][2] == symb && map[3][3] == symb && map[4][4] == symb) return true;
if (map[4][0] == symb && map[3][1] == symb && map[2][2] == symb && map[1][3] == symb && map[0][4] == symb) return true;
return false;
}
Ich denke, es ist klar, aber wahrscheinlich nicht der optimalste Weg.
Hier ist meine Lösung, die einen 2-dimensionalen Array mit:
private static final int dimension = 3;
private static final int[][] board = new int[dimension][dimension];
private static final int xwins = dimension * 1;
private static final int owins = dimension * -1;
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int count = 0;
boolean keepPlaying = true;
boolean xsTurn = true;
while (keepPlaying) {
xsTurn = (count % 2 == 0);
System.out.print("Enter i-j in the format:");
if (xsTurn) {
System.out.println(" X plays: ");
} else {
System.out.println(" O plays: ");
}
String result = null;
while (result == null) {
result = parseInput(scanner, xsTurn);
}
String[] xy = result.split(",");
int x = Integer.parseInt(xy[0]);
int y = Integer.parseInt(xy[1]);
keepPlaying = makeMove(xsTurn, x, y);
count++;
}
if (xsTurn) {
System.out.print("X");
} else {
System.out.print("O");
}
System.out.println(" WON");
printArrayBoard(board);
}
private static String parseInput(Scanner scanner, boolean xsTurn) {
String line = scanner.nextLine();
String[] values = line.split("-");
int x = Integer.parseInt(values[0]);
int y = Integer.parseInt(values[1]);
boolean alreadyPlayed = alreadyPlayed(x, y);
String result = null;
if (alreadyPlayed) {
System.out.println("Already played in this x-y. Retry");
} else {
result = "" + x + "," + y;
}
return result;
}
private static boolean alreadyPlayed(int x, int y) {
System.out.println("x-y: " + x + "-" + y + " board[x][y]: " + board[x][y]);
if (board[x][y] != 0) {
return true;
}
return false;
}
private static void printArrayBoard(int[][] board) {
for (int i = 0; i < dimension; i++) {
int[] height = board[i];
for (int j = 0; j < dimension; j++) {
System.out.print(height[j] + " ");
}
System.out.println();
}
}
private static boolean makeMove(boolean xo, int x, int y) {
if (xo) {
board[x][y] = 1;
} else {
board[x][y] = -1;
}
boolean didWin = checkBoard();
if (didWin) {
System.out.println("keep playing");
}
return didWin;
}
private static boolean checkBoard() {
//check horizontal
int[] horizontalTotal = new int[dimension];
for (int i = 0; i < dimension; i++) {
int[] height = board[i];
int total = 0;
for (int j = 0; j < dimension; j++) {
total += height[j];
}
horizontalTotal[i] = total;
}
for (int a = 0; a < horizontalTotal.length; a++) {
if (horizontalTotal[a] == xwins || horizontalTotal[a] == owins) {
System.out.println("horizontal");
return false;
}
}
//check vertical
int[] verticalTotal = new int[dimension];
for (int j = 0; j < dimension; j++) {
int total = 0;
for (int i = 0; i < dimension; i++) {
total += board[i][j];
}
verticalTotal[j] = total;
}
for (int a = 0; a < verticalTotal.length; a++) {
if (verticalTotal[a] == xwins || verticalTotal[a] == owins) {
System.out.println("vertical");
return false;
}
}
//check diagonal
int total1 = 0;
int total2 = 0;
for (int i = 0; i < dimension; i++) {
for (int j = 0; j < dimension; j++) {
if (i == j) {
total1 += board[i][j];
}
if (i == (dimension - 1 - j)) {
total2 += board[i][j];
}
}
}
if (total1 == xwins || total1 == owins) {
System.out.println("diagonal 1");
return false;
}
if (total2 == xwins || total2 == owins) {
System.out.println("diagonal 2");
return false;
}
return true;
}
Konstante Zeit O (8) im Durchschnitt 4 kurz und ist. Spieler = Kurznummer. Braucht zusätzliche Prüfungen für dafür, dass Bewegung gültig ist.
// O(8)
boolean isWinner(short X) {
for (int i = 0; i < 8; i++)
if ((X & winCombinations[i]) == winCombinations[i])
return true;
return false;
}
short[] winCombinations = new short[]{
7, 7 << 3, 7 << 6, // horizontal
73, 73 << 1, 73 << 2, // vertical
273, // diagonal
84 // anti-diagonal
};
for (short X = 0; X < 511; X++)
System.out.println(isWinner(X));
Ich entwickelte einen Algorithmus für diese als Teil eines Wissenschaftsprojekt einmal.
Sie grundsätzlich rekursiv teilen das Board in einen Haufen von 2x2 Rects überlappen, das Testen der verschiedenen möglichen Kombinationen für auf einem 2x2-Quadrat zu gewinnen.
Es ist langsam, aber es hat den Vorteil, auf jeder Größe Bord arbeiten, mit ziemlich linearem Speicherbedarf.
Ich wünsche, ich könnte meine Implementierung
finden