Piece movement rules (polymorphism) in LLD - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding polymorphism in piece movement

In a chess game design, each piece moves differently. How does polymorphism help in implementing movement rules?

A It uses static methods to define movement rules that cannot be overridden.

B It forces all pieces to share the same movement logic, reducing code duplication.

C It stores all movement rules in a single global function that all pieces call.

D It allows each piece class to define its own move method, enabling different movement behaviors through a common interface.

💡 Hint

Think about how different pieces can have unique move logic but still be treated as the same type.

Polymorphism allows each piece subclass to implement its own move method. This means the game can call move on any piece without knowing its exact type, and the correct movement rules will apply.

❓ Architecture

intermediate

Designing piece movement with polymorphism

You are designing a chess game. Which class design best uses polymorphism for piece movement?

A Use a global function that takes piece type and position to calculate moves, without classes.

B Create a Piece class with a single move() method that uses if-else to check piece type and apply movement.

C Create a base Piece class with an abstract move() method. Each piece subclass implements move() with its own logic.

D Define movement rules in a configuration file and parse them at runtime without polymorphism.

💡 Hint

Consider how polymorphism avoids complex conditionals and supports extensibility.

Using an abstract move() method in a base class and overriding it in subclasses is a classic polymorphic design. It keeps code clean and easy to extend.

❓ scaling

advanced

Scaling piece movement rules for new game variants

You want to add new chess variants with additional pieces and movement rules. How does polymorphism help scale your design?

A By allowing new piece classes to inherit from the base Piece class and override move(), new rules integrate seamlessly.

B By modifying the base Piece class move() method to include all new movement rules for every variant.

C By storing all movement rules in a single monolithic function that checks piece type and variant.

D By duplicating the entire codebase for each variant to handle different movement rules.

💡 Hint

Think about how inheritance and overriding support adding new behaviors without changing existing code.

Polymorphism allows new piece types to be added as subclasses with their own move implementations. This avoids changing existing code and supports easy extension.

❓ tradeoff

advanced

Tradeoffs of polymorphism vs conditional logic in piece movement

What is a key tradeoff when using polymorphism for piece movement rules compared to using conditional statements inside a single method?

A Polymorphism reduces the number of classes but makes adding new pieces harder.

B Polymorphism improves code clarity and extensibility but may increase the number of classes and complexity.

C Using conditionals is more extensible and easier to maintain than polymorphism.

D Polymorphism always results in slower performance than conditionals.

💡 Hint

Consider maintainability and class count when choosing design approaches.

Polymorphism leads to cleaner, modular code and easier extension but can increase the number of classes and complexity of the class hierarchy.

❓ component

expert

Request flow for validating piece movement using polymorphism

In a chess game system, describe the flow of a move request using polymorphism to validate if a piece can move to a target square.

A Client sends move request → Game controller calls piece.move(target) → Piece subclass validates move → Returns valid/invalid → Controller updates board.

B Client sends move request → Game controller checks piece type → Calls global validateMove(piece, target) function → Updates board.

C Client sends move request → Game controller uses a switch-case on piece type to call specific validation functions → Updates board.

D Client sends move request → Board directly updates piece position without validation → Game controller logs move.

💡 Hint

Focus on how polymorphism lets the controller treat all pieces uniformly.

The controller calls move() on the piece object. Polymorphism ensures the correct subclass method runs to validate the move. This keeps the controller simple and extensible.

Practice

1. What is the main benefit of using polymorphism for piece movement rules in a game design?

easy

A. It allows each piece to have its own move logic without type checks.

B. It forces all pieces to share the same move logic.

C. It requires manual checking of piece types before moving.

D. It prevents pieces from moving on the board.

Solution

1. Step 1: Understand polymorphism concept

   Polymorphism allows different objects to be treated through a common interface while having their own behavior.

2. Step 2: Apply to piece movement

   Each piece class implements its own move() method, so no need to check piece type before moving.

3. Final Answer:

   It allows each piece to have its own move logic without type checks. -> Option A

4. Quick Check:

   Polymorphism = own move logic without type checks [OK]

Hint: Polymorphism means no type checks for moves [OK]

Common Mistakes:

• Thinking all pieces share the same move logic
• Believing manual type checks are needed
• Confusing polymorphism with inheritance only

2. Which of the following is the correct way to declare a base class method for piece movement in a polymorphic design?

easy

A. move(self): pass

B. def move(self): pass

C. def move(): pass

D. def move(self, board): return

Solution

1. Step 1: Recall method declaration syntax in Python

   Instance methods must have self as the first parameter.

2. Step 2: Identify correct method signature

   def move(self): pass correctly declares a method with self and no implementation.

3. Final Answer:

   def move(self): pass -> Option B

4. Quick Check:

   Method with self parameter = def move(self): pass [OK]

Hint: Instance methods always start with self parameter [OK]

Common Mistakes:

• Omitting self parameter in method
• Using incorrect syntax without def keyword
• Adding unnecessary parameters without context

3. Given the following code, what will be the output?

class Piece:
    def move(self):
        return "Base move"

class Knight(Piece):
    def move(self):
        return "L-shaped move"

pieces = [Piece(), Knight()]
for p in pieces:
    print(p.move())

medium

A. Base move\nL-shaped move

B. L-shaped move\nL-shaped move

C. Error: move() not implemented

D. Base move\nBase move

Solution

1. Step 1: Understand method overriding

   Subclass Knight overrides move() to return "L-shaped move".

2. Step 2: Trace the loop output

   First object is Piece, prints "Base move"; second is Knight, prints "L-shaped move".

3. Final Answer:

   Base move\nL-shaped move -> Option A

4. Quick Check:

   Base class and overridden subclass moves printed [OK]

Hint: Subclass method overrides base method output [OK]

Common Mistakes:

• Assuming base method always runs
• Expecting same output for all pieces
• Confusing method overriding with overloading

4. Identify the error in the following polymorphic piece movement code:

class Piece:
    def move(self):
        pass

class Bishop(Piece):
    def move():
        print("Diagonal move")

b = Bishop()
b.move()

medium

A. Cannot instantiate Bishop directly

B. Piece.move() should return a value

C. Bishop.move() missing self parameter

D. print statement syntax error

Solution

1. Step 1: Check method signatures

   Bishop.move() lacks self parameter, so it is not a proper instance method.

2. Step 2: Understand call context

   Calling b.move() passes self automatically, causing a TypeError due to missing parameter.

3. Final Answer:

   Bishop.move() missing self parameter -> Option C

4. Quick Check:

   Instance methods must have self parameter [OK]

Hint: Instance methods always need self parameter [OK]

Common Mistakes:

• Ignoring missing self in subclass method
• Thinking base class method must return value
• Assuming print syntax is wrong

5. You are designing a chess game using polymorphism for piece movement. How should you structure your classes to allow easy addition of new piece types without changing existing code?

hard

A. Write a single move() function with if-else for each piece type.

B. Implement move logic only in the base class and override rarely.

C. Use global variables to track piece types and moves.

D. Create a base Piece class with an abstract move() method; each piece subclass implements move().

Solution

1. Step 1: Apply polymorphism design principle

   Use a base class with an abstract or empty move() method to define interface.

2. Step 2: Implement subclasses for each piece

   Each piece subclass provides its own move() logic, enabling extension without modifying base code.

3. Final Answer:

   Create a base Piece class with an abstract move() method; each piece subclass implements move(). -> Option D

4. Quick Check:

   Base class + subclass move() = scalable design [OK]

Hint: Base class with abstract move() enables easy extension [OK]

Common Mistakes:

• Using if-else instead of polymorphism
• Relying on global variables for logic
• Putting all move logic in base class only