Board, Player, Game classes in LLD - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Identify the primary responsibility of the Game class

In a simple board game design, which of the following best describes the main responsibility of the Game class?

A Manage the overall game flow, including turns and win conditions

B Store the positions of pieces on the board

C Represent a player with their attributes and actions

D Handle user input and display the game interface

💡 Hint

Think about which class controls the sequence of play and decides when the game ends.

The Game class is responsible for managing the game flow, such as alternating turns between players and checking if someone has won. The Board stores piece positions, and Player represents individual players.

❓ Architecture

intermediate

Choose the best design for Player and Board interaction

Which design best supports a Player interacting with the Board in a turn-based game?

A Board directly modifies Player attributes during a move

B Player has a method to make a move that updates the Board state

C Game class modifies Player and Board independently without interaction

D Player and Board communicate only through a global variable

💡 Hint

Consider which class should initiate changes to the board during a player's turn.

The Player should have a method to make a move that updates the Board state. This keeps responsibilities clear and interactions controlled.

❓ scaling

advanced

Scaling the Board class for large games

For a game with a very large board (e.g., 1000x1000 cells), which approach best optimizes memory and performance?

A Use a sparse data structure to store only occupied cells

B Create a separate Board instance for each player

C Store all cells in a 2D array regardless of occupancy

D Store only the last move and reconstruct board state on demand

💡 Hint

Think about how to avoid wasting memory on empty cells.

Using a sparse data structure stores only occupied cells, saving memory and improving performance for large boards.

❓ tradeoff

advanced

Tradeoff between Player class complexity and Game class control

What is a key tradeoff when giving the Player class more decision-making logic versus centralizing logic in the Game class?

A Centralizing logic in Game always improves performance

B More logic in Player reduces code reuse across different games

C More logic in Player increases modularity but can complicate coordination

D Centralizing logic in Game makes Player classes harder to test

💡 Hint

Consider how distributing logic affects modularity and coordination.

Giving Player more logic improves modularity but can make coordinating game flow harder. Centralizing logic simplifies coordination but reduces modularity.

❓ component

expert

Estimate capacity for concurrent games in a server

A server runs multiple concurrent games, each with 2 players and a 10x10 board. Each game requires 1MB memory and 5ms CPU per turn. The server has 16GB RAM and 2GHz CPU with 8 cores. Estimate the maximum number of games it can handle simultaneously without performance degradation.

A About 10,000 games limited by memory

B About 12,800 games limited by CPU

C About 16,000 games limited by memory

D About 3,200 games limited by CPU

💡 Hint

Calculate max games by dividing total resources by per-game usage, then find the bottleneck.

Memory allows 16,000 games (16GB / 1MB). CPU per core can handle 200 turns per second (1000ms/5ms). With 8 cores, total 1,600 turns per second. Assuming 1 turn per game per second, CPU limits to ~1,600 games.

Practice

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

1. 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.

2. 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.

3. Final Answer:

   Board class -> Option D

4. 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

1. Step 1: Identify the correct constructor syntax in JavaScript

   In JavaScript ES6+, the constructor method inside a class is named constructor.

2. 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.

3. Final Answer:

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

4. 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

1. 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.

2. Step 2: Update currentPlayerIndex and return state

   After marking, currentPlayerIndex switches to 1. The returned board state is ['X', '-', '-'].

3. Final Answer:

   ['X', '-', '-'] -> Option A

4. 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

1. Step 1: Understand player index bounds

   Array indices go from 0 to length-1. If currentPlayerIndex equals players.length, it is out of bounds.

2. Step 2: Check condition for resetting index

   The condition uses > players.length, which misses the case when currentPlayerIndex == players.length, causing an error.

3. Final Answer:

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

4. 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

1. Step 1: Consider extensibility and separation of concerns

   Inheritance allows creating specialized Player types without modifying base Player class, supporting new behaviors.

2. Step 2: Use modular design for rules

   Extending Game with separate rule classes or modules keeps code clean and easy to maintain.

3. Final Answer:

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

4. 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