Move validation in LLD - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding move validation in a turn-based game

In a turn-based board game system, which component is primarily responsible for ensuring that a player's move is legal before updating the game state?

A The database persistence layer

B The user interface rendering component

C The network communication handler

D The game engine's move validator module

💡 Hint

Think about which part checks rules before changing the game state.

The move validator module checks if a move follows game rules before the game engine updates the state. UI and network handle display and communication, while the database stores data.

❓ Architecture

intermediate

Designing a scalable move validation system

You are designing a multiplayer online chess platform. Which architectural approach best supports scalable and consistent move validation across many concurrent games?

A Centralized move validation service with stateless validation logic and shared game state storage

B Each client validates moves independently without server verification

C Move validation embedded only in the database triggers

D Move validation done only on the client side with server accepting all moves

💡 Hint

Consider consistency and scalability for many players.

A centralized stateless validation service ensures consistent rules enforcement and scales by handling requests independently. Client-only validation risks cheating and inconsistency. Database triggers are inefficient for complex logic.

❓ scaling

advanced

Handling high load in move validation for real-time games

During peak hours, a real-time strategy game experiences thousands of move validation requests per second. Which strategy best improves system scalability without sacrificing validation accuracy?

A Store all moves in a single database table and validate moves synchronously on each insert

B Implement a distributed move validation system with sharded game state and asynchronous validation queues

C Increase client-side validation and trust clients to send only valid moves

D Disable move validation temporarily during peak load to reduce latency

💡 Hint

Think about distributing load and maintaining accuracy.

Distributed validation with sharded state and async queues balances load and keeps validation accurate. Client trust risks cheating. Single DB table causes bottlenecks. Disabling validation breaks game integrity.

❓ tradeoff

advanced

Tradeoffs between synchronous and asynchronous move validation

What is a key tradeoff when choosing asynchronous move validation over synchronous validation in a multiplayer game?

A Asynchronous validation improves responsiveness but may delay detecting invalid moves

B Asynchronous validation guarantees immediate rejection of invalid moves

C Synchronous validation reduces server load by batching moves

D Synchronous validation allows clients to skip server checks

💡 Hint

Consider timing and user experience impacts.

Asynchronous validation lets the game respond faster but invalid moves might be detected later, possibly requiring rollback. Synchronous validation checks moves immediately but can increase latency. Options B, C, and D are incorrect descriptions.

❓ estimation

expert

Estimating capacity for move validation service

A move validation service handles 10,000 concurrent games. Each game averages 2 moves per minute. Each move validation request takes 50ms CPU time on average. Estimate the minimum number of CPU cores needed to handle the load without queuing.

A Approximately 10 cores

B Approximately 7 cores

C Approximately 17 cores

D Approximately 20 cores

💡 Hint

Calculate total requests per second and CPU time per second, then divide by core capacity.

Requests per second = (10,000 games * 2 moves) / 60 = ~333.3 req/s. Total CPU time per second = 333.3 * 50ms = 16,665 ms = 16.665 seconds of CPU per second. Each core provides 1 second CPU per second, so cores needed = 16.665 ≈ 17 cores.

Practice

1. What is the primary purpose of move validation in a system design context?

easy

A. To create user interfaces

B. To speed up the system by skipping checks

C. To store user data securely

D. To ensure changes follow rules and prevent invalid actions

Solution

1. Step 1: Understand move validation role

   Move validation checks if a requested change or move follows system rules.

2. Step 2: Identify its main goal

   The goal is to prevent invalid or harmful actions that could break system logic or data.

3. Final Answer:

   To ensure changes follow rules and prevent invalid actions -> Option D

4. Quick Check:

   Move validation = Prevent invalid moves [OK]

Hint: Move validation means checking rules before allowing changes [OK]

Common Mistakes:

• Confusing validation with data storage
• Thinking validation speeds up by skipping checks
• Mixing validation with UI creation

2. Which of the following is a correct basic check in move validation logic?

easy

A. if move.position = max_position:
return True

B. if move.position == 'any':
return True

C. if move.position < 0 or move.position > max_position:
return False

D. if move.position > max_position then return False

Solution

1. Step 1: Check syntax correctness

   if move.position < 0 or move.position > max_position: return False uses proper comparison operators and syntax for boundary check.

2. Step 2: Identify errors in other options

   if move.position == 'any': return True uses string instead of number, C uses assignment (=) instead of comparison (==), D uses invalid syntax 'then'.

3. Final Answer:

   if move.position < 0 or move.position > max_position: return False -> Option C

4. Quick Check:

   Boundary check uses < and > with proper syntax [OK]

Hint: Use proper comparison operators and syntax for validation checks [OK]

Common Mistakes:

• Using assignment '=' instead of comparison '=='
• Using invalid keywords like 'then'
• Checking position against wrong data types

3. Given the code snippet for move validation, what will be the output if move.position = 5 and max_position = 4?

def validate_move(move, max_position):
    if move.position < 0 or move.position > max_position:
        return False
    return True

print(validate_move(move, max_position))

medium

A. True

B. False

C. Error

D. null

Solution

1. Step 1: Evaluate condition with given values

   move.position = 5, max_position = 4, so 5 > 4 is true.

2. Step 2: Determine return value

   Since condition is true, function returns False.

3. Final Answer:

   False -> Option B

4. Quick Check:

   5 > 4 triggers False return [OK]

Hint: Check boundary conditions carefully to predict output [OK]

Common Mistakes:

• Assuming 5 <= 4 is true
• Confusing return values
• Ignoring condition logic

4. Identify the bug in this move validation function:

def validate_move(move, max_position):
    if move.position <= 0 or move.position >= max_position:
        return False
    return True

medium

A. It incorrectly disallows move.position = 0

B. It allows move.position = max_position which should be invalid

C. It uses wrong comparison operators for boundaries

D. It returns true for all positions

Solution

1. Step 1: Analyze boundary conditions

   Condition disallows move.position <= 0, so position 0 is invalid.

2. Step 2: Check if position 0 should be allowed

   Usually position 0 is valid boundary, so disallowing it is a bug.

3. Final Answer:

   It incorrectly disallows move.position = 0 -> Option A

4. Quick Check:

   Check boundary inclusiveness carefully [OK]

Hint: Check if boundary conditions exclude valid edge values [OK]

Common Mistakes:

• Confusing < and <= in conditions
• Assuming 0 is always invalid
• Ignoring inclusive vs exclusive boundaries

5. In a system where moves must be validated for both boundary and occupancy, which design approach best ensures scalability and maintainability?

hard

A. Use separate modular validators for boundary and occupancy checks, composed in sequence

B. Combine all validation logic in a single monolithic function

C. Skip occupancy checks to improve performance

D. Validate moves only after applying them to the system state

Solution

1. Step 1: Consider modular design benefits

   Separating boundary and occupancy checks into modules improves clarity and reusability.

2. Step 2: Evaluate scalability and maintainability

   Modular validators can be updated independently and composed flexibly, aiding scalability.

3. Final Answer:

   Use separate modular validators for boundary and occupancy checks, composed in sequence -> Option A

4. Quick Check:

   Modular design = scalable and maintainable [OK]

Hint: Modular validation improves system scalability and clarity [OK]

Common Mistakes:

• Combining all logic makes code hard to maintain
• Skipping important checks reduces reliability
• Validating after applying moves risks inconsistent state