Move validation in LLD - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to check if a move is within the board boundaries.

LLD

def is_valid_move(x, y, board_size):
    return 0 <= x [1] board_size and 0 <= y < board_size

Drag options to blanks, or click blank then click option'

A<=

B>

C<

D>=

Attempts:

3 left

💡 Hint

Common Mistakes

Using >= instead of < causes out-of-bound errors.

Using > excludes valid positions at zero.

The move coordinates must be less than the board size to be valid.

2fill in blank

medium

Complete the code to check if the target cell is empty before moving.

LLD

def can_move(board, x, y):
    return board[x][y] == [1]

Drag options to blanks, or click blank then click option'

ANone

B0

C1

DTrue

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 or 1 may confuse empty and occupied cells.

Using True is incorrect because it's a boolean, not a cell state.

Empty cells are represented by None to indicate no piece is present.

3fill in blank

hard

Fix the error in the move validation to ensure the piece belongs to the current player.

LLD

def is_player_piece(board, x, y, player):
    return board[x][y] == [1]

Drag options to blanks, or click blank then click option'

Aplayer

Bopponent

CTrue

DNone

Attempts:

3 left

💡 Hint

Common Mistakes

Checking against opponent or None causes invalid moves.

Using True is not meaningful for piece ownership.

The piece at the position must match the current player's identifier.

4fill in blank

hard

Fill both blanks to validate a move that is inside the board and the target cell is empty.

LLD

def validate_move(board, x, y, board_size):
    return (0 <= x [1] board_size and 0 <= y [2] board_size and board[x][y] is None)

Drag options to blanks, or click blank then click option'

A<

B>

C<=

D>=

Attempts:

3 left

💡 Hint

Common Mistakes

Using >= causes out-of-bound errors.

Mixing operators leads to incorrect validation.

Both x and y must be less than board_size to be valid positions.

5fill in blank

hard

Fill all three blanks to check if a move is valid: inside board, target empty, and piece belongs to player.

LLD

def full_move_validation(board, x, y, board_size, player):
    return (0 <= x [1] board_size and 0 <= y [2] board_size and board[x][y] is [3] and board[x][y] == player)

Drag options to blanks, or click blank then click option'

A<

B>

CNone

DTrue

Attempts:

3 left

💡 Hint

Common Mistakes

Using > instead of < for boundaries.

Checking cell is True instead of None.

Not verifying piece ownership.

The move must be inside the board (x and y less than board_size), the target cell empty (None), and the piece must belong to the player.

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