Move validation in LLD - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is move validation in system design?

Move validation is the process of checking if a requested action or move in a system follows the defined rules and constraints before it is accepted and executed.

beginner

Why is move validation important in multiplayer games or distributed systems?

It ensures fairness and consistency by preventing illegal or cheating moves, and keeps the system state synchronized across all participants.

intermediate

Name two common approaches to implement move validation.

1. Server-side validation: The server checks every move before accepting it.
2. Client-side validation: The client checks moves before sending, often combined with server validation for security.

intermediate

What is a potential risk if move validation is only done on the client side?

Clients can be manipulated or hacked to send illegal moves, leading to cheating or corrupt system state.

advanced

How can move validation be optimized for scalability in large systems?

By using techniques like caching valid moves, partitioning validation logic, asynchronous validation with rollback, and minimizing validation complexity.

What is the main purpose of move validation?

A To store user data securely

B To speed up the system response time

C To check if a move follows system rules before execution

D To design the user interface

Move validation ensures that every move complies with the system's rules before it is accepted.

Which approach is more secure for move validation?

A Both client-side and server-side validation

B Server-side validation only

C No validation

D Client-side validation only

Combining client-side and server-side validation improves security and user experience.

What risk arises if move validation is skipped on the server?

A Cheating and inconsistent state

B More storage space

C Better user interface

D Faster processing

Without server validation, clients can send illegal moves causing cheating and inconsistent system state.

Which technique helps scale move validation in large systems?

A Validating only once per day

B Ignoring invalid moves

C Using only client validation

D Caching valid moves

Caching reduces repeated validation work, improving scalability.

Move validation is most similar to which real-life process?

A Buying groceries

B Checking a ticket before entering a concert

C Driving a car without a license

D Watching a movie

Just like checking a ticket ensures only valid entry, move validation ensures only valid moves proceed.

Explain what move validation is and why it is critical in distributed systems or multiplayer games.

Think about how a game server keeps the game fair and synchronized.

Describe common strategies to implement move validation and how to balance security with performance.

Consider how both client and server work together to validate moves efficiently.

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