Extensibility (NxN board, multiple players) in LLD - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the board size for an NxN game.

LLD

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

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

A10

Bsize

Cboard_size

Dn

Attempts:

3 left

💡 Hint

Common Mistakes

Using a hardcoded number instead of the parameter.

Using an undefined variable.

The board size should be set using the parameter size passed to the constructor.

2fill in blank

medium

Complete the code to add a player to the game.

LLD

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

    def add_player(self, player):
        self.players.[1](player)

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

Aappend

Badd

Cinsert

Dextend

Attempts:

3 left

💡 Hint

Common Mistakes

Using add which is for sets, not lists.

Using extend which expects an iterable.

To add a single player to the list, use the append method.

3fill in blank

hard

Fix the error in the method that checks if a move is valid on the NxN board.

LLD

def is_valid_move(self, x, y):
    if x < 0 or x >= self.size or y < 0 or y >= [1]:
        return False
    return self.grid[x][y] is None

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

Aself.size

Bself.length

Cself.board_size

Dself.dimension

Attempts:

3 left

💡 Hint

Common Mistakes

Using undefined attributes like self.length or self.dimension.

The board size is stored in self.size, so use it to check boundaries.

4fill in blank

hard

Fill both blanks to implement a method that returns the current player's turn index and increments it for multiple players.

LLD

def next_turn(self):
    current = self.current_player_index
    self.current_player_index = (self.current_player_index [1] 1) [2] len(self.players)
    return current

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

A+

B-

C%

D//

Attempts:

3 left

💡 Hint

Common Mistakes

Using subtraction instead of addition.

Using floor division instead of modulo.

Increment the index by 1 and use modulo (%) to cycle through players.

5fill in blank

hard

Fill all three blanks to create a dictionary comprehension that maps each player to their score if the score is greater than zero.

LLD

scores = { [1]: [2] for [1] in self.players if self.scores[[1]] [3] 0 }

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

Aplayer

Bself.scores[player]

C>

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using different variable names for key and loop variable.

Using < instead of > for filtering.

Use player as the key and their score as the value, filtering scores greater than zero.

Practice

1. What is the main benefit of designing a game system with an NxN board and support for multiple players?

easy

A. It allows the game to be easily extended to different board sizes and more players without major code changes.

B. It limits the game to only two players and a fixed board size.

C. It makes the game run faster by using fixed-size arrays only.

D. It removes the need for input validation.

Solution

1. Step 1: Understand extensibility in game design

   Extensibility means the system can grow or change easily without rewriting code.

2. Step 2: Apply extensibility to NxN board and multiple players

   Using flexible data structures and modular code allows changing board size and player count easily.

3. Final Answer:

   It allows the game to be easily extended to different board sizes and more players without major code changes. -> Option A

4. Quick Check:

   Extensibility = Easy growth [OK]

Hint: Extensibility means easy to add features later [OK]

Common Mistakes:

• Thinking fixed size is more extensible
• Ignoring input validation importance
• Assuming extensibility means faster code

2. Which of the following code snippets correctly initializes a flexible NxN board in Python for any given size n?

easy

A. board = [[0]*n]*n

B. board = [[0 for _ in range(n)] for _ in range(n)]

C. board = [0]*n

D. board = [0 for _ in range(n)]

Solution

1. Step 1: Understand list initialization for 2D board

   Using list comprehension creates independent inner lists for each row.

2. Step 2: Compare options for correct 2D board creation

   board = [[0 for _ in range(n)] for _ in range(n)] creates a list of lists with separate inner lists, avoiding shared references.

3. Final Answer:

   board = [[0 for _ in range(n)] for _ in range(n)] -> Option B

4. Quick Check:

   Independent rows = board = [[0 for _ in range(n)] for _ in range(n)] [OK]

Hint: Use nested list comprehensions for independent 2D lists [OK]

Common Mistakes:

• Using [[0]*n]*n causes shared inner lists
• Initializing only 1D list for 2D board
• Confusing list multiplication with comprehension

3. Given a game system supporting multiple players, what will be the output of this Python snippet?

players = ['Alice', 'Bob', 'Carol']
turns = 5
for i in range(turns):
    current = players[i % len(players)]
    print(current)

medium

A. Bob Carol Alice Bob Carol

B. Alice Bob Carol Carol Carol

C. Alice Alice Alice Alice Alice

D. Alice Bob Carol Alice Bob

Solution

1. Step 1: Understand modulo for cycling players

   The modulo operator cycles index through player list length (3).

2. Step 2: Trace each iteration's player

   i=0 -> Alice, i=1 -> Bob, i=2 -> Carol, i=3 -> Alice, i=4 -> Bob.

3. Final Answer:

   Alice Bob Carol Alice Bob -> Option D

4. Quick Check:

   Modulo cycles players = Alice Bob Carol Alice Bob [OK]

Hint: Use modulo to cycle through players repeatedly [OK]

Common Mistakes:

• Not using modulo causes index errors
• Assuming players list is longer than turns
• Confusing player order in output

4. Identify the bug in this code snippet for initializing a variable-sized board and multiple players:

def setup_game(n, players):
    board = [[None]*n]*n
    for p in players:
        print(f"Player: {p}")
    return board

setup_game(3, ['A', 'B'])

medium

A. The board rows are references to the same list, causing shared updates.

B. The players list is not printed correctly.

C. The function does not return anything.

D. The board size is fixed to 3 regardless of input.

Solution

1. Step 1: Analyze board initialization

   Using [[None]*n]*n creates rows that reference the same list object.

2. Step 2: Understand impact of shared references

   Changing one cell affects all rows because they share the same inner list.

3. Final Answer:

   The board rows are references to the same list, causing shared updates. -> Option A

4. Quick Check:

   Shared inner lists cause bugs = The board rows are references to the same list, causing shared updates. [OK]

Hint: Avoid list multiplication for nested lists [OK]

Common Mistakes:

• Ignoring shared reference problem
• Thinking players print is incorrect
• Assuming function returns nothing

5. You are designing a turn-based game with an NxN board and support for multiple players. Which design approach best supports easy extensibility for future features like variable board sizes, more players, and custom rules?

hard

A. Write all game logic in one large function for simplicity.

B. Use fixed-size arrays and hardcoded player count with separate functions for each board size.

C. Use flexible data structures (lists/dictionaries), modular functions, and validate inputs dynamically.

D. Use global variables for board and players to avoid passing parameters.

Solution

1. Step 1: Identify extensibility requirements

   Extensibility needs flexible data structures and modular code to adapt easily.

2. Step 2: Evaluate design options

   Use flexible data structures (lists/dictionaries), modular functions, and validate inputs dynamically. uses lists/dictionaries and modular functions with input validation, supporting future changes well.

3. Final Answer:

   Use flexible data structures (lists/dictionaries), modular functions, and validate inputs dynamically. -> Option C

4. Quick Check:

   Modular + flexible data = extensible design [OK]

Hint: Modular code + flexible data = easy extensibility [OK]

Common Mistakes:

• Using fixed sizes limits future changes
• Writing monolithic functions reduces flexibility
• Using globals causes maintenance issues