Board and piece hierarchy in LLD - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare the base class for all pieces.

LLD

class [1]:
    def __init__(self, color):
        self.color = color

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

ACell

BBoard

CPiece

DGame

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'Board' instead of 'Piece' as the base class name.

The base class for all pieces should be named Piece to represent any game piece.

2fill in blank

medium

Complete the code to define the board class with a grid attribute.

LLD

class [1]:
    def __init__(self, rows, cols):
        self.grid = [[None for _ in range(cols)] for _ in range(rows)]

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

ABoard

BPiece

CCell

DGame

Attempts:

3 left

💡 Hint

Common Mistakes

Confusing 'Piece' with 'Board' when naming the class.

The class representing the game board should be named Board and contain a grid attribute.

3fill in blank

hard

Fix the error in the piece subclass definition for a chess knight.

LLD

class Knight([1]):
    def __init__(self, color):
        super().__init__(color)

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

ACell

BPiece

CBoard

DGame

Attempts:

3 left

💡 Hint

Common Mistakes

Inheriting from Board or Game instead of Piece.

The Knight class should inherit from the base Piece class.

4fill in blank

hard

Fill both blanks to complete the method that moves a piece on the board.

LLD

def move_piece(self, from_pos, to_pos):
    piece = self.grid[1]from_pos[0]][from_pos[1]]
    self.grid[2]to_pos[0]][to_pos[1]] = piece

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

A[

B(

C]

D)

Attempts:

3 left

💡 Hint

Common Mistakes

Using parentheses instead of square brackets for list indexing.

To access and assign elements in a 2D list, square brackets [ ] are used.

5fill in blank

hard

Fill all three blanks to complete the dictionary comprehension that maps piece names to their counts.

LLD

piece_counts = [1]: [2] for [3] in pieces}

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

Apiece.name

Bpieces.count(piece)

Cpiece

Dpiece.color

Attempts:

3 left

💡 Hint

Common Mistakes

Using piece.color as key instead of piece.name.

Using the wrong variable in the loop.

The dictionary comprehension maps each piece's name to how many times it appears in the list.

Practice

1. What is the main purpose of having a base Piece class in a board game design?

easy

A. To manage network communication between players

B. To define common properties like position and type for all pieces

C. To handle user input events

D. To store the entire board layout

Solution

1. Step 1: Understand the role of a base class

   A base class provides shared properties and methods for all derived classes, avoiding repetition.

2. Step 2: Apply to board game pieces

   All pieces share common traits like position and type, so the base Piece class holds these.

3. Final Answer:

   To define common properties like position and type for all pieces -> Option B

4. Quick Check:

   Base class = common properties [OK]

Hint: Base class holds shared traits for all pieces [OK]

Common Mistakes:

• Confusing board layout storage with piece properties
• Thinking base class handles user input
• Assuming base class manages network tasks

2. Which of the following is the correct way to declare a subclass King that extends a base Piece class in a typical object-oriented design?

easy

A. class King extends Piece { constructor(position) { super(position); } }

B. function King() { this.position = position; } extends Piece

C. class King inherits Piece { constructor() { } }

D. King = Piece + position

Solution

1. Step 1: Identify correct subclass syntax

   In modern OOP, a subclass uses extends keyword and calls super() in constructor.

2. Step 2: Check each option

   class King extends Piece { constructor(position) { super(position); } } uses correct syntax: class King extends Piece { constructor(position) { super(position); } }.

3. Final Answer:

   class King extends Piece { constructor(position) { super(position); } } -> Option A

4. Quick Check:

   Subclass syntax = extends + super() [OK]

Hint: Subclass uses extends and calls super() in constructor [OK]

Common Mistakes:

• Using incorrect keywords like inherits
• Placing extends after function declaration
• Trying to add properties with '+' operator

3. Given this code snippet for a board and pieces, what will be the output of console.log(board.pieces[0].type);?

class Piece {
  constructor(type, position) {
    this.type = type;
    this.position = position;
  }
}
class Board {
  constructor() {
    this.pieces = [];
  }
  addPiece(piece) {
    this.pieces.push(piece);
  }
}
const board = new Board();
board.addPiece(new Piece('Knight', 'B1'));

medium

A. undefined

B. "B1"

C. Error: pieces is not defined

D. "Knight"

Solution

1. Step 1: Understand object creation and storage

   A new Piece with type 'Knight' and position 'B1' is created and added to board.pieces.

2. Step 2: Access the first piece's type

   board.pieces[0] refers to the first piece, so board.pieces[0].type is 'Knight'.

3. Final Answer:

   "Knight" -> Option D

4. Quick Check:

   First piece type = 'Knight' [OK]

Hint: First piece type is stored in pieces[0].type [OK]

Common Mistakes:

• Confusing position with type
• Assuming pieces array is empty
• Expecting an error due to missing pieces

4. Identify the error in this piece hierarchy code snippet:

class Piece {
  constructor(type, position) {
    this.type = type;
    this.position = position;
  }
}
class Queen extends Piece {
  constructor(position) {
    this.type = 'Queen';
    this.position = position;
  }
}

medium

A. Position should not be passed to constructor

B. Queen class should not have a constructor

C. Missing call to super() in Queen constructor

D. Type should be passed as parameter to Queen constructor

Solution

1. Step 1: Review subclass constructor rules

   In subclasses, the constructor must call super() before using this.

2. Step 2: Check Queen constructor

   Queen constructor assigns this.type and this.position without calling super(), causing an error.

3. Final Answer:

   Missing call to super() in Queen constructor -> Option C

4. Quick Check:

   Subclass constructor must call super() first [OK]

Hint: Always call super() before using this in subclass constructor [OK]

Common Mistakes:

• Forgetting super() call in subclass constructor
• Trying to assign this before super()
• Assuming constructor is optional in subclass

5. You want to design a scalable board game system where each piece type has unique movement rules. Which design approach best supports adding new piece types without changing existing code?

hard

A. Use a base Piece class and create subclasses for each piece type implementing their own move logic

B. Store all piece types and moves in a single large switch-case statement

C. Keep piece types as strings and handle moves in a separate global function with if-else

D. Use a flat list of pieces with no hierarchy and hardcode moves in the board class

Solution

1. Step 1: Understand scalability and extensibility

   Good design allows adding new piece types without modifying existing code, following open-closed principle.

2. Step 2: Evaluate design options

   Subclassing Piece lets each piece implement its own move logic, enabling easy extension.

3. Final Answer:

   Use a base Piece class and create subclasses for each piece type implementing their own move logic -> Option A

4. Quick Check:

   Subclassing = scalable and extensible design [OK]

Hint: Subclass each piece type for unique moves [OK]

Common Mistakes:

• Using large switch-case blocks that are hard to maintain
• Handling moves globally with if-else reduces flexibility
• Hardcoding moves in board class limits scalability