Move validation and check detection in LLD - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

How to efficiently validate a chess move?

In a chess game system, which approach best ensures that a move is valid before applying it to the game state?

A Validate moves only after the game ends to optimize performance.

B Apply the move first, then check if the king is in check and revert if so.

C Only check if the move is within board boundaries and allow it without further validation.

D Check if the move follows piece movement rules, then verify it does not leave the player's king in check.

💡 Hint

Think about preventing illegal states before changing the game.

Validating moves by checking piece rules and king safety before applying prevents illegal game states and avoids costly rollbacks.

❓ Architecture

intermediate

Designing a modular move validation system

Which architecture best supports extensible move validation and check detection in a chess engine?

A Separate modules for piece movement rules, board state management, and check detection communicating via defined interfaces.

B A single monolithic module handling all validation and game logic tightly coupled.

C Only a check detection module that assumes all moves are valid.

D A module that validates moves randomly to reduce processing time.

💡 Hint

Think about maintainability and scalability.

Separating concerns into modules allows easier updates, testing, and reuse of validation and check detection logic.

❓ scaling

advanced

Scaling check detection for multiplayer chess servers

What is the best strategy to scale check detection logic for thousands of simultaneous chess games on a server?

A Use a centralized database trigger to detect checks for all games.

B Run all check detection on a single server to maintain consistency.

C Distribute games across multiple servers and run check detection independently per game instance.

D Disable check detection to improve performance at scale.

💡 Hint

Consider isolation and parallelism.

Distributing games allows parallel processing and avoids bottlenecks, enabling scalable check detection per game.

❓ tradeoff

advanced

Tradeoffs between pre-move validation and post-move check detection

Which tradeoff is true when choosing between validating moves before applying them versus detecting checks after applying moves?

A Pre-move validation prevents illegal states but may increase latency; post-move detection simplifies logic but requires rollback.

B Pre-move validation always reduces latency and complexity compared to post-move detection.

C Post-move detection is faster and never requires rollback.

D Both approaches have identical performance and complexity.

💡 Hint

Think about user experience and system complexity.

Validating before applying avoids illegal states but can add processing time; detecting after applying simplifies validation but needs rollback on illegal moves.

❓ estimation

expert

Estimating capacity for real-time check detection in a chess platform

A chess platform expects 10,000 concurrent games. Each move requires 5ms of check detection processing. Estimate the minimum number of CPU cores needed to handle peak load assuming 1 core can process 200 moves per second.

A At least 25 cores are needed to handle all moves concurrently.

B At least 50 cores are needed to handle all moves concurrently.

C At least 10 cores are needed to handle all moves concurrently.

D At least 100 cores are needed to handle all moves concurrently.

💡 Hint

Calculate moves per second and cores needed based on processing time.

Each move takes 5ms = 0.005s, so one core can process 1/0.005 = 200 moves per second. For 10,000 concurrent moves, cores = 10,000 / 200 = 50. But not all games move simultaneously; assuming half move at once, 25 cores suffice.

Practice

1. What is the primary purpose of move validation in a chess game system?

easy

A. To ensure only legal moves according to game rules are accepted

B. To update the user interface after a move

C. To save the game state to a database

D. To detect if a player is in check

Solution

1. Step 1: Understand move validation role

   Move validation checks if a move follows the rules of chess, like piece movement and board boundaries.

2. Step 2: Differentiate from other functions

   Updating UI or saving state are separate tasks; detecting check is related but distinct from move validation.

3. Final Answer:

   To ensure only legal moves according to game rules are accepted -> Option A

4. Quick Check:

   Move validation = Legal move check [OK]

Hint: Move validation means checking if a move follows rules [OK]

Common Mistakes:

• Confusing move validation with UI updates
• Thinking move validation detects check
• Assuming move validation saves game state

2. Which of the following code snippets correctly represents a basic move validation check for a rook in chess?

easy

A. if abs(start_row - end_row) == 1 and abs(start_col - end_col) == 1: return True else: return False

B. if start_row == end_row or start_col == end_col: return True else: return False

C. if abs(start_row - end_row) == abs(start_col - end_col): return True else: return False

D. if end_row == start_row + 2 or end_col == start_col + 2: return True else: return False

Solution

1. Step 1: Recall rook movement rules

   A rook moves any number of squares along a row or column, so either row or column must be the same.

2. Step 2: Match code to rules

   if start_row == end_row or start_col == end_col: return True else: return False checks if start and end share the same row or column, which matches rook moves.

3. Final Answer:

   if start_row == end_row or start_col == end_col: return True else: return False -> Option B

4. Quick Check:

   Rook moves = same row or column [OK]

Hint: Rook moves straight: same row or same column [OK]

Common Mistakes:

• Confusing rook moves with diagonal moves
• Using absolute difference for rook incorrectly
• Checking only fixed steps instead of any distance

3. Given this simplified move validation function for a king:

def is_valid_king_move(start, end):
    row_diff = abs(start[0] - end[0])
    col_diff = abs(start[1] - end[1])
    return (row_diff <= 1 and col_diff <= 1) and (row_diff + col_diff != 0)

What will is_valid_king_move((4,4), (5,5)) return?

medium

A. True

B. False

C. None

D. Error

Solution

1. Step 1: Calculate row and column differences

   row_diff = |4 - 5| = 1, col_diff = |4 - 5| = 1

2. Step 2: Evaluate conditions

   row_diff <= 1 and col_diff <= 1 is True; row_diff + col_diff != 0 is True (1+1=2)

3. Final Answer:

   True -> Option A

4. Quick Check:

   King moves one step any direction = True [OK]

Hint: King moves one square in any direction, including diagonals [OK]

Common Mistakes:

• Ignoring diagonal moves for king
• Mistaking zero move as valid
• Confusing row and column differences

4. In a check detection system, a bug causes the game to allow moves that leave the king in check. Which is the most likely cause?

medium

A. The system only checks for check after the opponent moves

B. The move validation incorrectly rejects legal moves

C. The system updates the board state before validating moves

D. The system validates moves but does not check if the king remains safe after the move

Solution

1. Step 1: Understand check detection role

   Check detection ensures no move leaves the king under attack after it is made.

2. Step 2: Identify bug cause

   If moves are validated but king safety is not checked post-move, illegal moves leaving king in check can occur.

3. Final Answer:

   The system validates moves but does not check if the king remains safe after the move -> Option D

4. Quick Check:

   Check detection missing after move = bug [OK]

Hint: Always check king safety after move validation [OK]

Common Mistakes:

• Assuming move validation covers check detection
• Checking for check only after opponent moves
• Updating board before validation causing state errors

5. You are designing a chess engine's move validation and check detection system. Which approach best ensures both correctness and performance?

hard

A. Skip move validation and rely on players to avoid illegal moves

B. Only check if the king is in check before the move, ignoring post-move state

C. First validate move legality, then simulate the move to check if king is in check, rejecting if so

D. Validate moves and check detection simultaneously by scanning the entire board every time

Solution

1. Step 1: Separate move legality and check detection

   Validate if the move follows piece rules first to avoid unnecessary checks.

2. Step 2: Simulate move and check king safety

   Temporarily apply the move and verify if the king is attacked; reject if unsafe.

3. Final Answer:

   First validate move legality, then simulate the move to check if king is in check, rejecting if so -> Option C

4. Quick Check:

   Validate then simulate for check = best practice [OK]

Hint: Validate move first, then simulate for check detection [OK]

Common Mistakes:

• Ignoring post-move king safety
• Checking entire board every time causing slowdowns
• Skipping move validation entirely