Check if Move is Legal - Practice Coding Problems

Check if Move is Legal - Problem

You are given a 0-indexed 8 x 8 grid board, where board[r][c] represents the cell (r, c) on a game board. On the board, free cells are represented by '.', white cells are represented by 'W', and black cells are represented by 'B'.

Each move in this game consists of choosing a free cell and changing it to the color you are playing as (either white or black). However, a move is only legal if, after changing it, the cell becomes the endpoint of a good line (horizontal, vertical, or diagonal).

A good line is a line of three or more cells (including the endpoints) where:

The endpoints of the line are one color
The remaining cells in the middle are the opposite color
No cells in the line are free

Given two integers rMove and cMove and a character color representing the color you are playing as ('W' for white or 'B' for black), return true if changing cell (rMove, cMove) to color is a legal move, or false if it is not legal.

Input & Output

Example 1 — Valid Black Move

$ Input: board = [[".",".",".","B",".",".",".","."],[".",".",".","W",".",".",".","."],[".",".",".","W",".",".",".","."],[".",".",".","W",".",".",".","."],...], rMove = 4, cMove = 3, color = "B"

› Output: true

💡 Note: Placing 'B' at (4,3) creates a good line vertically: B at (0,3) -> W at (1,3), W at (2,3), W at (3,3) -> B at (4,3)

Example 2 — Invalid Move on Occupied Cell

$ Input: board = [[".",".",".",".",".",".",".","."],[".","B",".",".",".",".",".","."],[".",".","W",".",".",".",".","."],[".",".",".","W",".",".",".","."],...], rMove = 1, cMove = 1, color = "B"

› Output: false

💡 Note: Cell (1,1) is already occupied by 'B', so the move is illegal

Example 3 — No Valid Line Formation

$ Input: board = [[".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".","."],...], rMove = 0, cMove = 0, color = "W"

› Output: false

💡 Note: Placing 'W' at (0,0) doesn't create any good line since there are no other pieces on the board

Constraints

board.length == 8
board[i].length == 8
0 ≤ rMove, cMove < 8
board[rMove][cMove] == '.'
color is either 'W' or 'B'

Visualization

Tap to expand

Understanding the Visualization

Input

8x8 board with W/B/. cells, target position and color

Process

Check 8 directions for good lines (same-opposite-same pattern)

Output

true if at least one good line exists, false otherwise

Key Takeaway

🎯 Key Insight: A move is legal if it creates at least one good line in any direction

Asked in

G Google 15 M Microsoft 12 A Amazon 8

The key insight is that a move is legal if it forms at least one "good line" in any of the 8 directions. A good line has endpoints of the same color with opposite-colored pieces in between. Best approach uses direction vectors with helper function for clean, maintainable code. Time: O(1), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Direction Check	O(1)	O(1)	Check all 8 directions manually for valid lines
Optimized Direction Vector Check	O(1)	O(1)	Use direction vectors with early termination for efficiency

Brute Force Direction Check — Algorithm Steps

Check each of 8 directions individually
For each direction, scan outward to find opposite colors followed by same color
Validate minimum line length of 3

Visualization

Tap to expand

Step-by-Step Walkthrough

Place Piece

Try placing the piece at target position

Check Directions

Check all 8 directions for opposite-color pieces

Validate Line

Ensure line ends with same color

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

bool solution(char board[8][8], int rMove, int cMove, char color) {
    if (board[rMove][cMove] != '.') {
        return false;
    }
    
    char opposite = (color == 'B') ? 'W' : 'B';
    
    // Check all 8 directions manually
    int directions[8][2] = {
        {-1, -1}, {-1, 0}, {-1, 1},
        {0, -1},           {0, 1},
        {1, -1},  {1, 0},  {1, 1}
    };
    
    for (int i = 0; i < 8; i++) {
        int dr = directions[i][0], dc = directions[i][1];
        // Check in this direction
        int r = rMove + dr, c = cMove + dc;
        bool foundOpposite = false;
        
        // Skip if first cell is not opposite color
        if (r < 0 || r >= 8 || c < 0 || c >= 8 || board[r][c] != opposite) {
            continue;
        }
        
        foundOpposite = true;
        r += dr;
        c += dc;
        
        // Continue until we find same color or go out of bounds
        while (r >= 0 && r < 8 && c >= 0 && c < 8) {
            if (board[r][c] == '.') {
                break;
            }
            if (board[r][c] == color) {
                if (foundOpposite) {
                    return true;
                }
                break;
            }
            r += dr;
            c += dc;
        }
    }
    
    return false;
}

int main() {
    char board[8][8];
    int rMove, cMove;
    char color;
    
    // Simplified input parsing for this example
    scanf("%d", &rMove);
    scanf("%d", &cMove);
    scanf(" %c", &color);
    
    bool result = solution(board, rMove, cMove, color);
    printf(result ? "true\n" : "false\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Fixed 8x8 board means constant operations regardless of input size

✓ Linear Growth

Space Complexity

O(1)

Only using variables, no extra data structures

✓ Linear Space

15.2K Views

Medium Frequency

~25 min Avg. Time

485 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Direction Check — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler