Open In App

Check if the given chessboard is valid or not

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Share
Report issue
Report

Given an NXN chessboard. The task is to check if the given chessboard is valid or not. A chess board is considered valid if every 2 adjacent cells are painted with different color. Two cells are considered adjacent if they share a boundary. 

First chessboard is valid whereas the second is invalid.

Examples: 

Input : N = 2
C = { 
      { 1, 0 },
      { 0, 1 }
    }
Output : Yes

Input : N = 2
C = { 
      { 0, 0 },
      { 0, 0 }
    }
Output : No

Observe, on a chess board, every adjacent pair of cells is painted in a different color. 
So, for each cell (i, j), check whether the adjacent cells i.e 
(i + 1, j), (i -1, j), (i, j + 1), (i, j – 1) is painted with different color than (i, j) or not.

Pseudocode: 

int X[] = {0, -1, 0, 1};
int Y[] = {1, 0, -1, 0};

bool validateConfiguration(int M[N][N]) 
{
  bool isValid = true;
  for (int i = 0; i < N; i++)
  {
    for (int j = 0; j < N; j++)
    {
      for (int k = 0; k < 4; k++)
      {
         int newX = i + X[k];
         int newY = j + Y[k];
         if (newX < N && newY < N && newX >= 0 &&
             newY >= 0 && M[newX][newY] == M[i][j])
         {
              isValid = false;
         } 
       }
     }
  }
  return isValid;
}

Implementation:

C++




#include <bits/stdc++.h>
using namespace std;
#define MAX 2
 
// Check if the given chess board is valid or not.
bool isValid(int c[][MAX], int n)
{
    int X[] = { 0, -1, 0, 1 };
    int Y[] = { 1, 0, -1, 0 };
    bool isValid = true;
 
    // Traversing each cell of the chess board.
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
 
            // for each adjacent cells
            for (int k = 0; k < 4; k++) {
                int newX = i + X[k];
                int newY = j + Y[k];
 
                // checking if they have different color
                if (newX < n && newY < n && newX >= 0 &&
                    newY >= 0 && c[newX][newY] == c[i][j]) {
                    isValid = false;
                }
            }
        }
    }
    return isValid;
}
 
// Driven Program
int main()
{
    int n = 2;
    int c[2][2] = { { 1, 0 },
                    { 0, 1 } };
 
    (isValid(c, n)) ? (cout << "Yes") : (cout << "No");
    return 0;
}


Java




// Check if the given chess
// board is valid or not
class GFG
{
static int MAX = 2;
 
static boolean isValid(int c[][], int n)
{
    int X[] = { 0, -1, 0, 1 };
    int Y[] = { 1, 0, -1, 0 };
    boolean isValid = true;
 
    // Traversing each cell
    // of the chess board.
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
 
            // for each adjacent cells
            for (int k = 0; k < 4; k++)
            {
                int newX = i + X[k];
                int newY = j + Y[k];
 
                // checking if they have
                // different color
                if (newX < n && newY < n &&
                    newX >= 0 && newY >= 0 &&
                    c[newX][newY] == c[i][j])
                {
                    isValid = false;
                }
            }
        }
    }
    return isValid;
}
 
// Driver Code
public static void main(String[] args)
{
    int n = 2;
    int[][] c = {{ 1, 0 },
                 { 0, 1 }};
 
    if (isValid(c, n))
        System.out.println("Yes");
    else
        System.out.println("No");
}
}
 
// This code is contributed by ChitraNayal


Python 3




# Python 3 Program to Check
# if the given chessboard
# is valid or not
MAX = 2
 
# Check if the given chess
# board is valid or not.
def isValid(c, n) :
 
    X = [ 0, -1, 0, 1]
    Y = [ 1, 0, -1, 0]
    isValid = True
 
    # Traversing each cell
    # of the chess board.
    for i in range(n) :
        for j in range(n) :
             
            # for each adjacent cells
            for k in range(n) :
                newX = i + X[k]
                newY = j + Y[k]
 
                # checking if they have
                # different color
                if (newX < n and newY < n and
                    newX >= 0 and newY >= 0 and
                    c[newX][newY] == c[i][j]) :
                    isValid = false
 
    return isValid
     
# Driver Code
if __name__ == "__main__" :
    n = 2
    c = [ [1, 0],
          [0, 1] ]
 
    if isValid(c, n) :
        print("Yes")
 
    else :
        print("No")
                     
# This code is contributed
# by ANKITRAI1


C#




// Check if the given chess
// board is valid or not.
using System;
 
class GFG
{
 
static bool isValid(int[,] c, int n)
{
    int[] X = { 0, -1, 0, 1 };
    int[] Y = { 1, 0, -1, 0 };
    bool isValid = true;
 
    // Traversing each cell
    // of the chess board.
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
 
            // for each adjacent cells
            for (int k = 0; k < 4; k++)
            {
                int newX = i + X[k];
                int newY = j + Y[k];
 
                // checking if they have different color
                if (newX < n && newY < n &&
                    newX >= 0 && newY >= 0 &&
                    c[newX, newY] == c[i, j])
                {
                    isValid = false;
                }
            }
        }
    }
    return isValid;
}
 
// Driver Code
public static void Main()
{
    int n = 2;
    int[,] c = {{ 1, 0 },
                { 0, 1 }};
 
    if (isValid(c, n))
        Console.Write("Yes");
    else
        Console.Write("No");
}
}
 
// This code is contributed by ChitraNayal


PHP




<?php
// Check if the given chess
// board is valid or not.
function isValid(&$c, $n)
{
    $X = array( 0, -1, 0, 1 );
    $Y = array( 1, 0, -1, 0 );
    $isValid = true;
 
    // Traversing each cell
    // of the chess board.
    for ($i = 0; $i < $n; $i++)
    {
        for ($j = 0; $j < $n; $j++)
        {
 
            // for each adjacent cells
            for ($k = 0; $k < 4; $k++)
            {
                $newX = $i + $X[$k];
                $newY = $j + $Y[$k];
 
                // checking if they have different color
                if ($newX < $n && $newY < $n &&
                    $newX >= 0 && $newY >= 0 &&
                    $c[$newX][$newY] == $c[$i][$j])
                {
                    $isValid = false;
                }
            }
        }
    }
    return $isValid;
}
 
// Driver Code
$n = 2;
$c = array(array(1, 0),
           array(0, 1));
 
echo (isValid($c, $n)) ? "Yes" : "No";
 
// This code is contributed by ChitraNayal
?>


Javascript




<script>
 
var MAX = 2;
 
// Check if the given chess
// board is valid or not.
function isValid(c, n)
{
    var X = [ 0, -1, 0, 1 ];
    var Y = [ 1, 0, -1, 0 ];
    var isValid = true;
 
    // Traversing each cell of the chess board.
    for (var i = 0; i < n; i++) {
        for (var j = 0; j < n; j++) {
 
            // for each adjacent cells
            for (var k = 0; k < 4; k++) {
                var newX = i + X[k];
                var newY = j + Y[k];
 
                // checking if they have
                // different color
                if (newX < n && newY < n &&
                newX >= 0 &&
                newY >= 0 &&
                c[newX][newY] == c[i][j]) {
                    isValid = false;
                }
            }
        }
    }
    return isValid;
}
 
// Driven Program
var n = 2;
var c = [ [ 1, 0 ],
                [ 0, 1 ] ];
(isValid(c, n)) ? (document.write( "Yes")) :
(document.write( "No"));
 
</script>


Output

Yes

Time complexity: O(N^2) for given an N*N chessboard
Auxiliary space: O(1)

Implementation: A simpler approach would be to check if the cells with even sums are of the same color. 

C++




#include <bits/stdc++.h>
using namespace std;
bool checkBoard(vector<vector<int>> board)
{
    int base = board[0][0];
    bool flag = true;
  
    for(int i = 0; i < board.size(); i++)
    {
        for( int j = 0; j < board[i].size(); j++)
        {
            if(( i + j ) % 2 == 0)
            {
                if( board[i][j] != base )
                {
                    return false;
                }
            }
            else
            {
                if (board[i][j] == base)
                {
                    return false;
                }
            }
        }
    }
    return true;
}
int main()
{
    vector<vector<int>> board1={{0, 1},
                                {1, 0}};
                     
    vector<vector<int>> board2={{1, 0, 1},
                                {0, 1, 0},
                                {1, 0, 1}};
                     
    vector<vector<int>> board3={{1, 0, 1},
                                {0, 1, 0},
                                {1, 1, 1}};
  
    if(checkBoard(board1))
    cout << "true\n";
    else
    cout << "false\n";
     
    if(checkBoard(board2))
    cout << "true\n";
    else
    cout << "false\n";
     
    if(checkBoard(board3))
    cout << "true\n";
    else
    cout << "false\n";
     
    return 0;
}
//This code is contributed by aditya942003patil


Java




/*package whatever //do not write package name here */
import java.io.*;
class GFG
{
 
  static boolean checkBoard(int[][] board)
  {
    int base = board[0][0];
    boolean flag = true;
 
    for(int i = 0; i < board.length; i++)
    {
      for( int j = 0; j < board[i].length; j++)
      {
        if(( i + j ) % 2 == 0)
        {
          if( board[i][j] != base )
          {
            return false;
          }
        }
        else
        {
          if (board[i][j] == base)
          {
            return false;
          }
        }
      }
    }
    return true;
  }
 
  // Driver code
  public static void main (String[] args) {
 
    int[][] board1={{0, 1}, {1, 0}};
    int[][] board2={{1, 0, 1},{0, 1, 0},{1, 0, 1}};
    int[][] board3={{1, 0, 1},{0, 1, 0},{1, 1, 1}};
 
    System.out.println(checkBoard(board1));
    System.out.println(checkBoard(board2));
    System.out.println(checkBoard(board3));
  }
}
 
// This code is contributed by rag2127


Python3




# Write Python3 code here
def checkBoard(board) :
    base = board[0][0]
    flag = True
    for i in range(len(board)) :
        for j in range(len(board[i])) :
            if( i + j ) % 2 == 0 :
                if board[i][j] != base :
                    return False
            else :
                if board[i][j] == base :
                    return False
    return True
     
board1 = [[0, 1], [1, 0]]
board2 = [[1, 0, 1], [0, 1, 0], [1, 0, 1]]
board3 = [[1, 0, 1], [0, 1, 0], [1, 1, 1]]
print(checkBoard(board1))
print(checkBoard(board2))
print(checkBoard(board3))


C#




using System;
public class GFG
{
 
  static bool checkBoard(int[,] board)
  {
    int Base = board[0, 0];
 
    for(int i = 0; i < board.GetLength(0); i++)
    {
      for( int j = 0; j < board.GetLength(1); j++)
      {
        if(( i + j ) % 2 == 0)
        {
          if( board[i, j] != Base )
          {
            return false;
          }
        }
        else
        {
          if (board[i, j] == Base)
          {
            return false;
          }
        }
      }
    }
    return true;
  }
 
  // Driver code
  static public void Main ()
  {
    int[,] board1 = {{0, 1}, {1, 0}};
    int[,] board2 = {{1, 0, 1},{0, 1, 0},{1, 0, 1}};
    int[,] board3 = {{1, 0, 1},{0, 1, 0},{1, 1, 1}};
 
    Console.WriteLine(checkBoard(board1));
    Console.WriteLine(checkBoard(board2));
    Console.WriteLine(checkBoard(board3));
  }
}
 
// This code is contributed by avanitrachhadiya2155


Javascript




<script>
     
    function checkBoard(board)
    {
        let base = board[0][0];
    let flag = true;
  
    for(let i = 0; i < board.length; i++)
    {
      for( let j = 0; j < board[i].length; j++)
      {
        if(( i + j ) % 2 == 0)
        {
          if( board[i][j] != base )
          {
            return false;
          }
        }
        else
        {
          if (board[i][j] == base)
          {
            return false;
          }
        }
      }
    }
    return true;
    }
     
    // Driver code
    let board1 = [[0, 1], [1, 0]];
    let board2 = [[1, 0, 1], [0, 1, 0], [1, 0, 1]];
    let board3 = [[1, 0, 1], [0, 1, 0], [1, 1, 1]];
     
    document.write(checkBoard(board1)+"<br>")
    document.write(checkBoard(board2)+"<br>")
    document.write(checkBoard(board3)+"<br>")
 
 
// This code is contributed by unknown2108
 
</script>


Output

true
true
false

Time complexity: O(N^2) for given an N*N chessboard
Auxiliary space: O(1)



Last Updated : 23 Sep, 2022
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads