# Validity of a given Tic-Tac-Toe board configuration

A Tic-Tac-Toe board is given after some moves are played. Find out if the given board is valid, i.e., is it possible to reach this board position after some moves or not.
Note that every arbitrary filled grid of 9 spaces isn’t valid e.g. a grid filled with 3 X and 6 O isn’t valid situation because each player needs to take alternate turns.

Input is given as a 1D array of size 9.

Examples:

`Input: board[] =  {'X', 'X', 'O',                    'O', 'O', 'X',                   'X', 'O', 'X'};Output: ValidInput: board[] =  {'O', 'X', 'X',                    'O', 'X', 'X',                   'O', 'O', 'X'};Output: Invalid(Both X and O cannot win)Input: board[] =  {'O', 'X', ' ',                    ' ', ' ', ' ',                   ' ', ' ', ' '};Output: Valid(Valid board with only two moves played)`
Recommended Practice

Basically, to find the validity of an input grid, we can think of the conditions when an input grid is invalid. Let no. of “X”s be countX and no. of “O”s be countO. Since we know that the game starts with X, a given grid of Tic-Tac-Toe game would be definitely invalid if following two conditions meet

1. countX != countO AND
2. countX != countO + 1
• Since “X” is always the first move, second condition is also required.
• Now does it mean that all the remaining board positions are valid one? The answer is NO. Think of the cases when input grid is such that both X and O are making straight lines. This is also not
• valid position because the game ends when one player wins. So we need to check the following condition as well
3. If input grid shows that both the players are in winning situation, it’s an invalid position.
4. If input grid shows that the player with O has put a straight-line (i.e. is in win condition) and countX != countO, it’s an invalid position. The reason is that O plays his move only after X plays his
• move. Since X has started the game, O would win when both X and O has played equal no. of moves.
5. If input grid shows that X is in winning condition than xCount must be one greater that oCount.
• Armed with above conditions i.e. a), b), c) and d), we can now easily formulate an algorithm/program to check the validity of a given Tic-Tac-Toe board position.
`1)  countX == countO or countX == countO + 12)  If O is in win condition then check      a)     If X also wins, not valid     b)     If xbox != obox , not valid3)  If X is in win condition then check if xCount is     one more than oCount or not  `

Another way to find the validity of a given board is using ‘inverse method’ i.e. rule out all the possibilities when a given board is invalid.

## C++

 `// C++ program to check whether a given tic tac toe``// board is valid or not``#include ``using` `namespace` `std;` `// This matrix is used to find indexes to check all``// possible winning triplets in board[0..8]``int` `win[8][3] = {{0, 1, 2}, ``// Check first row.``                ``{3, 4, 5}, ``// Check second Row``                ``{6, 7, 8}, ``// Check third Row``                ``{0, 3, 6}, ``// Check first column``                ``{1, 4, 7}, ``// Check second Column``                ``{2, 5, 8}, ``// Check third Column``                ``{0, 4, 8}, ``// Check first Diagonal``                ``{2, 4, 6}}; ``// Check second Diagonal` `// Returns true if character 'c' wins. c can be either``// 'X' or 'O'``bool` `isCWin(``char` `*board, ``char` `c)``{``    ``// Check all possible winning combinations``    ``for` `(``int` `i=0; i<8; i++)``        ``if` `(board[win[i][0]] == c &&``            ``board[win[i][1]] == c &&``            ``board[win[i][2]] == c )``            ``return` `true``;``    ``return` `false``;``}` `// Returns true if given board is valid, else returns false``bool` `isValid(``char` `board[9])``{``    ``// Count number of 'X' and 'O' in the given board``    ``int` `xCount=0, oCount=0;``    ``for` `(``int` `i=0; i<9; i++)``    ``{``    ``if` `(board[i]==``'X'``) xCount++;``    ``if` `(board[i]==``'O'``) oCount++;``    ``}` `    ``// Board can be valid only if either xCount and oCount``    ``// is same or count is one more than oCount``    ``if` `(xCount==oCount || xCount==oCount+1)``    ``{``        ``// Check if 'O' is winner``        ``if` `(isCWin(board, ``'O'``))``        ``{``            ``// Check if 'X' is also winner, then``            ``// return false``            ``if` `(isCWin(board, ``'X'``))``                ``return` `false``;` `            ``// Else return true xCount and yCount are same``            ``return` `(xCount == oCount);``        ``}` `        ``// If 'X' wins, then count of X must be greater``        ``if` `(isCWin(board, ``'X'``) && xCount != oCount + 1)``        ``return` `false``; ` `        ``// If 'O' is not winner, then return true``        ``return` `true``;``    ``}``    ``return` `false``;``}` `// Driver program``int` `main()``{``char` `board[] = {``'X'``, ``'X'``, ``'O'``,``                ``'O'``, ``'O'``, ``'X'``,``                ``'X'``, ``'O'``, ``'X'``};``(isValid(board))? cout << ``"Given board is valid"``:``                    ``cout << ``"Given board is not valid"``;``return` `0;``}`

## Java

 `// Java program to check whether a given tic tac toe ``// board is valid or not ``import` `java.io.*;``class` `GFG {` `// This matrix is used to find indexes to check all ``// possible winning triplets in board[0..8] ``    ``static` `int` `win[][] = {{``0``, ``1``, ``2``}, ``// Check first row. ``    ``{``3``, ``4``, ``5``}, ``// Check second Row ``    ``{``6``, ``7``, ``8``}, ``// Check third Row ``    ``{``0``, ``3``, ``6``}, ``// Check first column ``    ``{``1``, ``4``, ``7``}, ``// Check second Column ``    ``{``2``, ``5``, ``8``}, ``// Check third Column ``    ``{``0``, ``4``, ``8``}, ``// Check first Diagonal ``    ``{``2``, ``4``, ``6``}}; ``// Check second Diagonal ` `// Returns true if character 'c' wins. c can be either ``// 'X' or 'O' ``    ``static` `boolean` `isCWin(``char``[] board, ``char` `c) {``        ``// Check all possible winning combinations ``        ``for` `(``int` `i = ``0``; i < ``8``; i++) {``            ``if` `(board[win[i][``0``]] == c``                    ``&& board[win[i][``1``]] == c``                    ``&& board[win[i][``2``]] == c) {``                ``return` `true``;``            ``}``        ``}``        ``return` `false``;``    ``}` `// Returns true if given board is valid, else returns false ``    ``static` `boolean` `isValid(``char` `board[]) {``        ``// Count number of 'X' and 'O' in the given board ``        ``int` `xCount = ``0``, oCount = ``0``;``        ``for` `(``int` `i = ``0``; i < ``9``; i++) {``            ``if` `(board[i] == ``'X'``) {``                ``xCount++;``            ``}``            ``if` `(board[i] == ``'O'``) {``                ``oCount++;``            ``}``        ``}` `        ``// Board can be valid only if either xCount and oCount ``        ``// is same or count is one more than oCount ``        ``if` `(xCount == oCount || xCount == oCount + ``1``) {``            ``// Check if 'O' is winner ``            ``if` `(isCWin(board, ``'O'``)) {``                ``// Check if 'X' is also winner, then ``                ``// return false ``                ``if` `(isCWin(board, ``'X'``)) {``                    ``return` `false``;``                ``}` `                ``// Else return true xCount and yCount are same ``                ``return` `(xCount == oCount);``            ``}` `            ``// If 'X' wins, then count of X must be greater ``            ``if` `(isCWin(board, ``'X'``) && xCount != oCount + ``1``) {``                ``return` `false``;``            ``}` `            ``// If 'O' is not winner, then return true ``            ``return` `true``;``        ``}``        ``return` `false``;``    ``}` `// Driver program ``    ``public` `static` `void` `main(String[] args) {``        ``char` `board[] = {``'X'``, ``'X'``, ``'O'``, ``'O'``, ``'O'``, ``'X'``, ``'X'``, ``'O'``, ``'X'``};` `        ``if` `((isValid(board))) {``            ``System.out.println(``"Given board is valid"``);``        ``} ``else` `{``            ``System.out.println(``"Given board is not valid"``);``        ``}``    ``}``}``//this code contributed by PrinciRaj1992`

## Python3

 `# Python3 program to check whether a given tic tac toe``# board is valid or not` `# Returns true if char wins. Char can be either``# 'X' or 'O'``def` `win_check(arr, char):``    ``# Check all possible winning combinations``    ``matches ``=` `[[``0``, ``1``, ``2``], [``3``, ``4``, ``5``],``               ``[``6``, ``7``, ``8``], [``0``, ``3``, ``6``],``               ``[``1``, ``4``, ``7``], [``2``, ``5``, ``8``],``               ``[``0``, ``4``, ``8``], [``2``, ``4``, ``6``]]` `    ``for` `i ``in` `range``(``8``):``        ``if``(arr[(matches[i][``0``])] ``=``=` `char ``and``            ``arr[(matches[i][``1``])] ``=``=` `char ``and``            ``arr[(matches[i][``2``])] ``=``=` `char):``            ``return` `True``    ``return` `False` `def` `is_valid(arr):``    ``# Count number of 'X' and 'O' in the given board``    ``xcount ``=` `arr.count(``'X'``)``    ``ocount ``=` `arr.count(``'O'``)``    ` `    ``# Board can be valid only if either xcount and ocount``    ``# is same or count is one more than oCount``    ``if``(xcount ``=``=` `ocount``+``1` `or` `xcount ``=``=` `ocount):``        ``# Check if O wins``        ``if` `win_check(arr, ``'O'``):``            ``# Check if X wins, At a given point only one can win, ``            ``# if X also wins then return Invalid``            ``if` `win_check(arr, ``'X'``):``                ``return` `"Invalid"` `            ``# O can only win if xcount == ocount in case where whole``            ``# board has values in each position.``            ``if` `xcount ``=``=` `ocount:``                ``return` `"Valid"` `        ``# If X wins then it should be xc == oc + 1, ``        ``# If not return Invalid     ``        ``if` `win_check(arr, ``'X'``) ``and` `xcount !``=` `ocount``+``1``:``            ``return` `"Invalid"``        ` `        ``# if O is not the winner return Valid ``        ``if` `not` `win_check(arr, ``'O'``):``            ``return` `"valid"``        ` `    ``# If nothing above matches return invalid``    ``return` `"Invalid"`  `# Driver Code``arr ``=` `[``'X'``, ``'X'``, ``'O'``,``       ``'O'``, ``'O'``, ``'X'``, ``       ``'X'``, ``'O'``, ``'X'``]``print``(``"Given board is "` `+` `is_valid(arr))`

## C#

 `// C# program to check whether a given ``// tic tac toe board is valid or not ``using` `System;` `class` `GFG``{` `// This matrix is used to find indexes``// to check all possible winning triplets``// in board[0..8] ``public` `static` `int``[][] win = ``new` `int``[][]``{``    ``new` `int``[] {0, 1, 2},``    ``new` `int``[] {3, 4, 5},``    ``new` `int``[] {6, 7, 8},``    ``new` `int``[] {0, 3, 6},``    ``new` `int``[] {1, 4, 7},``    ``new` `int``[] {2, 5, 8},``    ``new` `int``[] {0, 4, 8},``    ``new` `int``[] {2, 4, 6}``};` `// Returns true if character 'c' ``// wins. c can be either 'X' or 'O' ``public` `static` `bool` `isCWin(``char``[] board, ``                          ``char` `c)``{``    ``// Check all possible winning``    ``// combinations ``    ``for` `(``int` `i = 0; i < 8; i++)``    ``{``        ``if` `(board[win[i][0]] == c && ``            ``board[win[i][1]] == c && ``            ``board[win[i][2]] == c)``        ``{``            ``return` `true``;``        ``}``    ``}``    ``return` `false``;``}` `// Returns true if given board ``// is valid, else returns false ``public` `static` `bool` `isValid(``char``[] board)``{``    ``// Count number of 'X' and ``    ``// 'O' in the given board ``    ``int` `xCount = 0, oCount = 0;``    ``for` `(``int` `i = 0; i < 9; i++)``    ``{``        ``if` `(board[i] == ``'X'``)``        ``{``            ``xCount++;``        ``}``        ``if` `(board[i] == ``'O'``)``        ``{``            ``oCount++;``        ``}``    ``}` `    ``// Board can be valid only if either ``    ``// xCount and oCount is same or count``    ``// is one more than oCount ``    ``if` `(xCount == oCount ||``        ``xCount == oCount + 1)``    ``{``        ``// Check if 'O' is winner ``        ``if` `(isCWin(board, ``'O'``))``        ``{``            ``// Check if 'X' is also winner, ``            ``// then return false ``            ``if` `(isCWin(board, ``'X'``))``            ``{``                ``return` `false``;``            ``}` `            ``// Else return true xCount ``            ``// and yCount are same ``            ``return` `(xCount == oCount);``        ``}` `        ``// If 'X' wins, then count of ``        ``// X must be greater ``        ``if` `(isCWin(board, ``'X'``) && ``            ``xCount != oCount + 1)``        ``{``            ``return` `false``;``        ``}` `        ``// If 'O' is not winner, ``        ``// then return true ``        ``return` `true``;``    ``}``    ``return` `false``;``}` `// Driver Code ``public` `static` `void` `Main(``string``[] args)``{``    ``char``[] board = ``new` `char``[] {``'X'``, ``'X'``, ``'O'``, ``'O'``, ``'O'``,``                                    ``'X'``, ``'X'``, ``'O'``, ``'X'``};` `    ``if` `((isValid(board)))``    ``{``        ``Console.WriteLine(``"Given board is valid"``);``    ``}``    ``else``    ``{``        ``Console.WriteLine(``"Given board is not valid"``);``    ``}``}``}` `// This code is contributed by Shrikant13`

## Javascript

 ``

## PHP

 ``

Output
```Given board is valid

```

Time complexity: O(1)
Auxiliary Space: O(1), since no extra space has been taken.

Approach 2:

The algorithm to check if a Tic-Tac-Toe board is valid or not is as follows:

• Initialize a 2D array win of size 8×3, which contains all possible winning combinations in Tic-Tac-Toe. Each row of the win array represents a winning combination, and each element in a row represents a cell index on the board.
• Define a function isCWin(board, c) which takes a board configuration board and a character c (‘X’ or ‘O’) as inputs, and returns true if character c has won on the board.
• Inside the isCWin function, iterate over each row of the win array. Check if the board has the same character c at all three cell indices of the current row. If yes, return true, as the character c has won.
• Define a function isValid(board) which takes a board configuration board as input, and returns true if the board is valid, else returns false.
• Inside the isValid function, count the number of ‘X’ and ‘O’ characters on the board, and store them in xCount and oCount variables, respectively.
• The board can be valid only if either xCount and oCount are the same, or xCount is one more than oCount.
• If ‘O’ is a winner on the board, check if ‘X’ is also a winner. If yes, return false as both ‘X’ and ‘O’ cannot win at the same time. If not, return true if xCount and oCount are the same, else return false.
• If ‘X’ is a winner on the board, then xCount must be one more than oCount. If not, return false.
• If ‘O’ is not a winner, return true as the board is valid.

Here is the code of the above approach:

## C++

 `// Returns true if character 'c' wins. c can be either``// 'X' or 'O'``#include``using` `namespace` `std;``bool` `isWinner(``char` `*board, ``char` `c)``{``    ``// Check all possible winning combinations``    ``if` `((board[0] == c && board[1] == c && board[2] == c) ||``        ``(board[3] == c && board[4] == c && board[5] == c) ||``        ``(board[6] == c && board[7] == c && board[8] == c) ||``        ``(board[0] == c && board[3] == c && board[6] == c) ||``        ``(board[1] == c && board[4] == c && board[7] == c) ||``        ``(board[2] == c && board[5] == c && board[8] == c) ||``        ``(board[0] == c && board[4] == c && board[8] == c) ||``        ``(board[2] == c && board[4] == c && board[6] == c))``        ``return` `true``;``    ` `    ``return` `false``;``}` `// Returns true if given board is valid, else returns false``bool` `isValid(``char` `board[9])``{``    ``// Count number of 'X' and 'O' in the given board``    ``int` `xCount=0, oCount=0;``    ``for` `(``int` `i=0; i<9; i++)``    ``{``        ``if` `(board[i]==``'X'``) xCount++;``        ``if` `(board[i]==``'O'``) oCount++;``    ``}` `    ``// Board can be valid only if either xCount and oCount``    ``// is same or count is one more than oCount``    ``if` `(xCount==oCount || xCount==oCount+1)``    ``{``        ``// Check if there is only one winner``        ``if` `(isWinner(board, ``'X'``) && isWinner(board, ``'O'``))``            ``return` `false``;``        ` `        ``// If 'X' wins, then count of X must be greater``        ``if` `(isWinner(board, ``'X'``) && xCount != oCount + 1)``            ``return` `false``;``        ` `        ``// If 'O' wins, then count of X must be same as oCount``        ``if` `(isWinner(board, ``'O'``) && xCount != oCount)``            ``return` `false``;` `        ``return` `true``;``    ``}``    ``return` `false``;``}` `// Driver program``int` `main()``{``    ``char` `board[] = {``'X'``, ``'X'``, ``'O'``,``                    ``'O'``, ``'O'``, ``'X'``,``                    ``'X'``, ``'O'``, ``'X'``};``    ``(isValid(board))? cout << ``"Given board is valid"``:``                        ``cout << ``"Given board is not valid"``;``    ``return` `0;``}`

## Java

 `import` `java.util.Arrays;` `public` `class` `TicTacToe {``    ` `    ``// Returns true if character 'c' wins. c can be either 'X' or 'O'``    ``public` `static` `boolean` `isWinner(``char``[] board, ``char` `c) {``        ``// Check all possible winning combinations``        ``if` `((board[``0``] == c && board[``1``] == c && board[``2``] == c) ||``            ``(board[``3``] == c && board[``4``] == c && board[``5``] == c) ||``            ``(board[``6``] == c && board[``7``] == c && board[``8``] == c) ||``            ``(board[``0``] == c && board[``3``] == c && board[``6``] == c) ||``            ``(board[``1``] == c && board[``4``] == c && board[``7``] == c) ||``            ``(board[``2``] == c && board[``5``] == c && board[``8``] == c) ||``            ``(board[``0``] == c && board[``4``] == c && board[``8``] == c) ||``            ``(board[``2``] == c && board[``4``] == c && board[``6``] == c))``            ``return` `true``;``        ` `        ``return` `false``;``    ``}` `    ``// Returns true if given board is valid, else returns false``    ``public` `static` `boolean` `isValid(``char``[] board) {``        ``// Count number of 'X' and 'O' in the given board``        ``int` `xCount = ``0``, oCount = ``0``;``        ``for` `(``int` `i = ``0``; i < ``9``; i++) {``            ``if` `(board[i] == ``'X'``)``                ``xCount++;``            ``if` `(board[i] == ``'O'``)``                ``oCount++;``        ``}` `        ``// Board can be valid only if either xCount and oCount is same or count is one more than oCount``        ``if` `(xCount == oCount || xCount == oCount + ``1``) {``            ``// Check if there is only one winner``            ``if` `(isWinner(board, ``'X'``) && isWinner(board, ``'O'``))``                ``return` `false``;``            ` `            ``// If 'X' wins, then count of X must be greater``            ``if` `(isWinner(board, ``'X'``) && xCount != oCount + ``1``)``                ``return` `false``;``            ` `            ``// If 'O' wins, then count of X must be same as oCount``            ``if` `(isWinner(board, ``'O'``) && xCount != oCount)``                ``return` `false``;` `            ``return` `true``;``        ``}``        ``return` `false``;``    ``}` `    ``// Driver program``    ``public` `static` `void` `main(String[] args) {``        ``char``[] board = {``'X'``, ``'X'``, ``'O'``,``                        ``'O'``, ``'O'``, ``'X'``,``                        ``'X'``, ``'O'``, ``'X'``};``        ` `        ``if` `(isValid(board))``            ``System.out.println(``"Given board is valid"``);``        ``else``            ``System.out.println(``"Given board is not valid"``);``    ``}``}`

## Python3

 `# Python Program for the above approach``def` `isWinner(board, c):``    ``# Check all possible winning combinations``    ``if` `(board[``0``] ``=``=` `c ``and` `board[``1``] ``=``=` `c ``and` `board[``2``] ``=``=` `c) ``or` `\``       ``(board[``3``] ``=``=` `c ``and` `board[``4``] ``=``=` `c ``and` `board[``5``] ``=``=` `c) ``or` `\``       ``(board[``6``] ``=``=` `c ``and` `board[``7``] ``=``=` `c ``and` `board[``8``] ``=``=` `c) ``or` `\``       ``(board[``0``] ``=``=` `c ``and` `board[``3``] ``=``=` `c ``and` `board[``6``] ``=``=` `c) ``or` `\``       ``(board[``1``] ``=``=` `c ``and` `board[``4``] ``=``=` `c ``and` `board[``7``] ``=``=` `c) ``or` `\``       ``(board[``2``] ``=``=` `c ``and` `board[``5``] ``=``=` `c ``and` `board[``8``] ``=``=` `c) ``or` `\``       ``(board[``0``] ``=``=` `c ``and` `board[``4``] ``=``=` `c ``and` `board[``8``] ``=``=` `c) ``or` `\``       ``(board[``2``] ``=``=` `c ``and` `board[``4``] ``=``=` `c ``and` `board[``6``] ``=``=` `c):``        ``return` `True` `    ``return` `False`  `def` `isValid(board):``    ``# Count number of 'X' and 'O' in the given board``    ``xCount ``=` `0``    ``oCount ``=` `0``    ``for` `i ``in` `range``(``9``):``        ``if` `board[i] ``=``=` `'X'``:``            ``xCount ``+``=` `1``        ``if` `board[i] ``=``=` `'O'``:``            ``oCount ``+``=` `1` `    ``# Board can be valid only if either xCount and oCount``    ``# is same or count is one more than oCount``    ``if` `xCount ``=``=` `oCount ``or` `xCount ``=``=` `oCount ``+` `1``:``        ``# Check if there is only one winner``        ``if` `isWinner(board, ``'X'``) ``and` `isWinner(board, ``'O'``):``            ``return` `False` `        ``# If 'X' wins, then count of X must be greater``        ``if` `isWinner(board, ``'X'``) ``and` `xCount !``=` `oCount ``+` `1``:``            ``return` `False` `        ``# If 'O' wins, then count of X must be same as oCount``        ``if` `isWinner(board, ``'O'``) ``and` `xCount !``=` `oCount:``            ``return` `False` `        ``return` `True` `    ``return` `False`  `# Driver program``board ``=` `[``'X'``, ``'X'``, ``'O'``,``         ``'O'``, ``'O'``, ``'X'``,``         ``'X'``, ``'O'``, ``'X'``]` `if` `isValid(board):``    ``print``(``"Given board is valid"``)``else``:``    ``print``(``"Given board is not valid"``)``# THIS CODE IS CONTRIBUTED BY KIRTI AGARWAL`

## C#

 `using` `System;` `public` `class` `TicTacToe {``    ` `    ``// Returns true if character 'c' wins. c can be either 'X' or 'O'``    ``public` `static` `bool` `IsWinner(``char``[] board, ``char` `c) {``        ``// Check all possible winning combinations``        ``if` `((board[0] == c && board[1] == c && board[2] == c) ||``            ``(board[3] == c && board[4] == c && board[5] == c) ||``            ``(board[6] == c && board[7] == c && board[8] == c) ||``            ``(board[0] == c && board[3] == c && board[6] == c) ||``            ``(board[1] == c && board[4] == c && board[7] == c) ||``            ``(board[2] == c && board[5] == c && board[8] == c) ||``            ``(board[0] == c && board[4] == c && board[8] == c) ||``            ``(board[2] == c && board[4] == c && board[6] == c))``            ``return` `true``;``        ` `        ``return` `false``;``    ``}` `    ``// Returns true if given board is valid, else returns false``    ``public` `static` `bool` `IsValid(``char``[] board) {``        ``// Count number of 'X' and 'O' in the given board``        ``int` `xCount = 0, oCount = 0;``        ``for` `(``int` `i = 0; i < 9; i++) {``            ``if` `(board[i] == ``'X'``)``                ``xCount++;``            ``if` `(board[i] == ``'O'``)``                ``oCount++;``        ``}` `        ``// Board can be valid only if either xCount and oCount is same or count is one more than oCount``        ``if` `(xCount == oCount || xCount == oCount + 1) {``            ``// Check if there is only one winner``            ``if` `(IsWinner(board, ``'X'``) && IsWinner(board, ``'O'``))``                ``return` `false``;``            ` `            ``// If 'X' wins, then count of X must be greater``            ``if` `(IsWinner(board, ``'X'``) && xCount != oCount + 1)``                ``return` `false``;``            ` `            ``// If 'O' wins, then count of X must be same as oCount``            ``if` `(IsWinner(board, ``'O'``) && xCount != oCount)``                ``return` `false``;` `            ``return` `true``;``        ``}``        ``return` `false``;``    ``}` `    ``// Driver program``    ``public` `static` `void` `Main(``string``[] args) {``        ``char``[] board = { ``'X'``, ``'X'``, ``'O'``,``                         ``'O'``, ``'O'``, ``'X'``,``                         ``'X'``, ``'O'``, ``'X'` `};` `        ``if` `(IsValid(board))``            ``Console.WriteLine(``"Given board is valid"``);``        ``else``            ``Console.WriteLine(``"Given board is not valid"``);``    ``}``}`

## Javascript

 `// Returns true if character 'c' wins. c can be either 'X' or 'O'``function` `isWinner(board, c) {``    ``// Check all possible winning combinations``    ``if` `(``        ``(board[0] === c && board[1] === c && board[2] === c) ||``        ``(board[3] === c && board[4] === c && board[5] === c) ||``        ``(board[6] === c && board[7] === c && board[8] === c) ||``        ``(board[0] === c && board[3] === c && board[6] === c) ||``        ``(board[1] === c && board[4] === c && board[7] === c) ||``        ``(board[2] === c && board[5] === c && board[8] === c) ||``        ``(board[0] === c && board[4] === c && board[8] === c) ||``        ``(board[2] === c && board[4] === c && board[6] === c)``    ``) {``        ``return` `true``;``    ``}` `    ``return` `false``;``}` `// Returns true if given board is valid, else returns false``function` `isValid(board) {``    ``// Count number of 'X' and 'O' in the given board``    ``let xCount = 0;``    ``let oCount = 0;``    ``for` `(let i = 0; i < 9; i++) {``        ``if` `(board[i] === ``'X'``) xCount++;``        ``if` `(board[i] === ``'O'``) oCount++;``    ``}` `    ``// Board can be valid only if either xCount and oCount``    ``// is same or count is one more than oCount``    ``if` `(xCount == oCount || xCount == oCount + 1) {``        ``// Check if there is only one winner``        ``if` `(isWinner(board, ``'X'``) && isWinner(board, ``'O'``)) {``            ``return` `false``;``        ``}` `        ``// If 'X' wins, then count of X must be greater``        ``if` `(isWinner(board, ``'X'``) && xCount !== oCount + 1) {``            ``return` `false``;``        ``}` `        ``// If 'O' wins, then count of X must be same as oCount``        ``if` `(isWinner(board, ``'O'``) && xCount !== oCount) {``            ``return` `false``;``        ``}` `        ``return` `true``;``    ``}` `    ``return` `false``;``}` `// Driver program``const board = [``'X'``, ``'X'``, ``'O'``, ``'O'``, ``'O'``, ``'X'``, ``'X'``, ``'O'``, ``'X'``];``isValid(board) ? console.log(``'Given board is valid'``) : console.log(``'Given board is not valid'``);`

Output
```Given board is valid

```

Time complexity: O(N^2)
Auxiliary Space: O(N)