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.