Practice - 5 Tasks

Answer the questions below

1fill in blank

easy

Complete the code to define the Player class with a name attribute.

LLD

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

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

Aid

Bplayer_name

Cscore

Dname

Attempts:

3 left

💡 Hint

Common Mistakes

Using a different parameter name than the attribute without assignment.

Forgetting to include the parameter in the constructor.

✗ Incorrect

The constructor takes name as a parameter to set the player's name.

2fill in blank

medium

Complete the code to initialize the Board class with a size attribute.

LLD

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

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

Adimension

Bsize

Cwidth

Dlength

Attempts:

3 left

💡 Hint

Common Mistakes

Using a different parameter name without assigning it to the attribute.

Forgetting to pass the parameter when creating the Board object.

✗ Incorrect

The constructor parameter size is used to set the board size attribute.

3fill in blank

hard

Fix the error in the Game class constructor to correctly initialize players list.

LLD

class Game:
    def __init__(self):
        self.players = [1]

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

A[]

BPlayer()

C{}

DNone

Attempts:

3 left

💡 Hint

Common Mistakes

Initializing players as a single Player object instead of a list.

Using a dictionary or None instead of a list.

✗ Incorrect

The players attribute should be an empty list to hold Player objects.

4fill in blank

hard

Fill both blanks to add a player to the game and print the player's name.

LLD

def add_player(self, player):
    self.players.[1](player)
    print(f"Player {player.[2] added")

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

Aappend

Bremove

Cname

Did

Attempts:

3 left

💡 Hint

Common Mistakes

Using remove instead of append.

Printing player.id instead of player.name.

✗ Incorrect

Use append to add the player to the list and player.name to print the player's name.

5fill in blank

hard

Fill all three blanks to initialize the game with a board and two players.

LLD

def start_game(self, board_size, player1_name, player2_name):
    self.board = Board([1])
    self.players = [Player([2]), Player([3])]

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

Aboard_size

Bplayer1_name

Cplayer2_name

Dsize

Attempts:

3 left

💡 Hint

Common Mistakes

Using incorrect variable names for board size or player names.

Mixing up player1 and player2 names.

✗ Incorrect

The board is created with board_size, and players are created with their respective names.

Practice

(1/5)

1. Which class is primarily responsible for keeping track of the current state of the game board in a typical game design involving Board, Player, and Game classes?

easy

A. Score class

B. Player class

C. Game class

D. Board class

Solution

Step 1: Understand the role of the Board class
The Board class holds the layout and current state of the game, such as positions of pieces or marks.
Step 2: Compare with Player and Game classes
The Player class stores player details, and the Game class manages turns and rules, not the board state.
Final Answer:
Board class -> Option D
Quick Check:
Board = game state holder [OK]

Hint: Board holds game state, Player holds info, Game controls flow [OK]

Common Mistakes:

Confusing Player with Board for state storage
Thinking Game class stores board state
Assuming Score class manages board

2. Which of the following is the correct way to define a Player class constructor that stores a player's name and ID in a typical object-oriented design?

easy

A. class Player { constructor(name, id) { this.name = name; this.id = id; } }

B. class Player { Player(name, id) { this.name = name; this.id = id; } }

C. function Player(name, id) { this.name = name; this.id = id; }

D. class Player { def __init__(self, name, id): self.name = name; self.id = id }

Solution

Step 1: Identify the correct constructor syntax in JavaScript
In JavaScript ES6+, the constructor method inside a class is named constructor.
Step 2: Check other options for errors
class Player { Player(name, id) { this.name = name; this.id = id; } } uses a method named Player instead of constructor; function Player(name, id) { this.name = name; this.id = id; } is a function, not a class; class Player { def __init__(self, name, id): self.name = name; self.id = id } uses Python syntax.
Final Answer:
class Player { constructor(name, id) { this.name = name; this.id = id; } } -> Option A
Quick Check:
JavaScript class constructor = constructor() [OK]

Hint: JS class constructors use 'constructor' keyword [OK]

Common Mistakes:

Using method named same as class instead of constructor
Mixing Python syntax in JavaScript
Defining constructor as a separate function

3. Given the following simplified code snippet, what will be the output after calling game.playTurn() once?

class Player {
  constructor(name) { this.name = name; }
}
class Board {
  constructor() { this.state = ['-', '-', '-']; }
  mark(position, symbol) { this.state[position] = symbol; }
}
class Game {
  constructor() {
    this.board = new Board();
    this.players = [new Player('Alice'), new Player('Bob')];
    this.currentPlayerIndex = 0;
  }
  playTurn() {
    const player = this.players[this.currentPlayerIndex];
    this.board.mark(0, this.currentPlayerIndex === 0 ? 'X' : 'O');
    this.currentPlayerIndex = 1 - this.currentPlayerIndex;
    return this.board.state;
  }
}
const game = new Game();
console.log(game.playTurn());

medium

A. ['X', '-', '-']

B. ['O', '-', '-']

C. ['-', '-', '-']

D. Error: mark method not found

Solution

Step 1: Analyze initial state and playTurn logic
Board state starts as ['-', '-', '-']. Current player index is 0, so symbol 'X' is placed at position 0.
Step 2: Update currentPlayerIndex and return state
After marking, currentPlayerIndex switches to 1. The returned board state is ['X', '-', '-'].
Final Answer:
['X', '-', '-'] -> Option A
Quick Check:
First turn marks 'X' at position 0 [OK]

Hint: First player marks 'X' at position 0 on first turn [OK]

Common Mistakes:

Assuming 'O' is placed first
Not updating currentPlayerIndex
Confusing board state initialization

4. In the following code snippet, what is the main issue that will cause the game to not switch players correctly?

class Game {
  constructor() {
    this.players = ['Alice', 'Bob'];
    this.currentPlayerIndex = 0;
  }
  nextTurn() {
    this.currentPlayerIndex += 1;
    if (this.currentPlayerIndex > this.players.length) {
      this.currentPlayerIndex = 0;
    }
  }
}

medium

A. Players array should contain Player objects, not strings

B. The condition should be >= players.length, not >

C. currentPlayerIndex should start at 1, not 0

D. nextTurn method should decrement currentPlayerIndex

Solution

Step 1: Understand player index bounds
Array indices go from 0 to length-1. If currentPlayerIndex equals players.length, it is out of bounds.
Step 2: Check condition for resetting index
The condition uses > players.length, which misses the case when currentPlayerIndex == players.length, causing an error.
Final Answer:
The condition should be >= players.length, not > -> Option B
Quick Check:
Index reset condition must include equality [OK]

Hint: Check array index bounds carefully for off-by-one errors [OK]

Common Mistakes:

Using > instead of >= for index reset
Ignoring zero-based indexing
Thinking player array type causes index error

5. You want to design a turn-based game system using Board, Player, and Game classes. Which design choice best supports adding new game rules and multiple player types (e.g., human, AI) without changing existing code much?

hard

A. Use global variables for player types and rules to simplify access

B. Keep all logic inside Game class and add if-else for player types and rules

C. Use inheritance: create subclasses like HumanPlayer and AIPlayer from Player, and extend Game with rule classes

D. Store all player and rule info in Board class to centralize state

Solution

Step 1: Consider extensibility and separation of concerns
Inheritance allows creating specialized Player types without modifying base Player class, supporting new behaviors.
Step 2: Use modular design for rules
Extending Game with separate rule classes or modules keeps code clean and easy to maintain.
Final Answer:
Use inheritance: create subclasses like HumanPlayer and AIPlayer from Player, and extend Game with rule classes -> Option C
Quick Check:
Inheritance and modular rules = easy extension [OK]

Hint: Use inheritance and modular rules for easy feature addition [OK]

Common Mistakes:

Putting all logic in one class causing messy code
Using global variables leading to hard-to-maintain code
Storing rules in Board instead of Game

Board, Player, Game classes in LLD - Interactive Code Practice

Start learning this pattern below

Practice

Solution

Step 1: Understand the role of the Board class

Step 2: Compare with Player and Game classes

Final Answer:

Quick Check:

Solution

Step 1: Identify the correct constructor syntax in JavaScript

Step 2: Check other options for errors

Final Answer:

Quick Check:

Solution

Step 1: Analyze initial state and playTurn logic

Step 2: Update currentPlayerIndex and return state

Final Answer:

Quick Check:

Solution

Step 1: Understand player index bounds

Step 2: Check condition for resetting index

Final Answer:

Quick Check:

Solution

Step 1: Consider extensibility and separation of concerns

Step 2: Use modular design for rules

Final Answer:

Quick Check: