Win condition checking in LLD - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Identifying Win Condition Triggers

In a turn-based game, which event should trigger the win condition check to ensure the game ends promptly and correctly?

A After each player's move is fully processed and the game state is updated.

B Only at the start of the game before any moves are made.

C Randomly at fixed time intervals regardless of player actions.

D Only after all players have taken their turns in a round.

💡 Hint

Think about when the game state changes and when it makes sense to check if someone has won.

Win conditions should be checked immediately after a player's move to promptly detect a winner and end the game without unnecessary delays.

❓ Architecture

intermediate

Designing a Win Condition Checker Component

Which design best supports scalability and maintainability for a win condition checker in a multiplayer online game?

A A monolithic server that handles all game logic including win checks without modularization.

B Embedding win condition logic directly inside the player client application.

C Win condition checks performed manually by players through UI prompts.

D A separate stateless service that receives game state snapshots and returns win status.

💡 Hint

Consider separation of concerns and how to handle many simultaneous games efficiently.

A stateless service dedicated to win condition checking allows easy scaling and independent updates without affecting other game components.

❓ scaling

advanced

Handling Win Condition Checks at Scale

In a system supporting thousands of concurrent games, what is the best approach to efficiently perform win condition checks?

A Distribute win condition checks across multiple worker nodes using event-driven architecture.

B Batch process win condition checks periodically for all games in a queue.

C Perform win condition checks synchronously immediately after each move on the main game server thread.

D Let clients perform win condition checks and report results to the server.

💡 Hint

Think about load distribution and responsiveness for many simultaneous games.

Using multiple worker nodes with event-driven triggers allows parallel processing and reduces bottlenecks, improving scalability and responsiveness.

❓ tradeoff

advanced

Tradeoffs in Win Condition Checking Frequency

What is a key tradeoff when choosing to check win conditions after every move versus checking periodically in batches?

A Checking after every move requires more complex synchronization mechanisms.

B Checking after every move increases responsiveness but may increase computational load.

C Batch checking guarantees immediate win detection but uses more memory.

D Batch checking reduces computational load but may delay detecting a winner.

💡 Hint

Consider responsiveness versus resource usage.

Checking win conditions after every move ensures immediate detection but can increase CPU usage, while batch checking saves resources but delays detection.

❓ estimation

expert

Estimating Capacity for Win Condition Checking Service

A win condition checking service processes 10,000 game state updates per second. Each check takes 5 milliseconds of CPU time. How many CPU cores are needed to handle this load without delay, assuming 100% CPU utilization per core?

A 2 cores

B 500 cores

C 50 cores

D 200 cores

💡 Hint

Calculate total CPU time needed per second and divide by CPU time per core.

Each check takes 5 ms, so 10,000 checks need 50,000 ms CPU time per second, which is 50 seconds of CPU time per second. Dividing by 1 second per core means 50 cores are needed.

Practice

1. What is the primary purpose of win condition checking in a game system?

easy

A. To update the player's score after each move

B. To determine if a player has won the game by matching symbols in a row, column, or diagonal

C. To reset the game board after a draw

D. To display the game instructions to the player

Solution

1. Step 1: Understand the role of win condition checking

   Win condition checking is used to decide if the game has ended with a winner by checking patterns on the board.

2. Step 2: Identify the correct purpose among options

   Only To determine if a player has won the game by matching symbols in a row, column, or diagonal describes checking rows, columns, or diagonals for matching symbols to declare a winner.

3. Final Answer:

   To determine if a player has won the game by matching symbols in a row, column, or diagonal -> Option B

4. Quick Check:

   Win condition checking = Determine winner [OK]

Hint: Win condition means checking if someone won the game [OK]

Common Mistakes:

• Confusing win checking with score updating
• Thinking it resets the game board
• Assuming it shows instructions

2. Which of the following code snippets correctly checks a row for a win in a 3x3 tic-tac-toe board represented as a 2D array board?

easy

A. if board[row][0] != board[row][1] != board[row][2]:

B. if board[0][row] == board[1][row] == board[2][row] != None:

C. if board[row][0] == board[row][1] == board[row][2] != None:

D. if board[0][0] == board[1][1] == board[2][2] != None:

Solution

1. Step 1: Identify row checking syntax

   Checking a row means comparing all elements in the same row index but different columns.

2. Step 2: Match code to row check

   if board[row][0] == board[row][1] == board[row][2] != None: compares board[row][0], board[row][1], and board[row][2], which is correct for a row check.

3. Final Answer:

   if board[row][0] == board[row][1] == board[row][2] != None: -> Option C

4. Quick Check:

   Row check = compare same row elements [OK]

Hint: Row check compares same row, different columns [OK]

Common Mistakes:

• Mixing row and column indices
• Using != instead of == for equality
• Checking diagonal instead of row

3. Given the following 3x3 board state:

board = [["X", "O", "X"],
         ["O", "X", "O"],
         ["O", "X", "X"]]

Which of these checks will correctly identify a win for 'X' on the main diagonal?

medium

A. board[0][0] == board[1][1] == board[2][2] == "X"

B. board[0][2] == board[1][1] == board[2][0] == "X"

C. board[0][0] == board[0][1] == board[0][2] == "X"

D. board[2][0] == board[2][1] == board[2][2] == "X"

Solution

1. Step 1: Identify main diagonal positions

   Main diagonal cells are at positions (0,0), (1,1), and (2,2).

2. Step 2: Check which option matches main diagonal and 'X'

   board[0][0] == board[1][1] == board[2][2] == "X" compares these exact positions to 'X', correctly checking the main diagonal win.

3. Final Answer:

   board[0][0] == board[1][1] == board[2][2] == "X" -> Option A

4. Quick Check:

   Main diagonal check = positions (0,0),(1,1),(2,2) [OK]

Hint: Main diagonal is top-left to bottom-right [OK]

Common Mistakes:

• Confusing main diagonal with anti-diagonal
• Checking wrong row or column
• Using equality with wrong symbol

4. Consider this code snippet for checking a column win:

def check_column(board, col):
    return board[0][col] == board[1][col] == board[2][col]

What is the main issue with this code when used for win condition checking?

medium

A. It only checks rows, not columns

B. It uses incorrect indices for columns

C. It returns a list instead of a boolean

D. It does not check if the cells are not empty or None

Solution

1. Step 1: Analyze the equality check

   The code checks if all three cells in the column are equal but does not verify if they are non-empty.

2. Step 2: Identify missing condition for valid win

   Without checking for None or empty, it may falsely report a win if all cells are empty.

3. Final Answer:

   It does not check if the cells are not empty or None -> Option D

4. Quick Check:

   Check for non-empty cells to confirm win [OK]

Hint: Always check cells are not empty before confirming win [OK]

Common Mistakes:

• Ignoring empty or None cells in equality
• Mixing row and column indices
• Expecting a list return instead of boolean

5. You are designing a scalable win condition checker for an n x n board game. Which approach best balances efficiency and scalability?

hard

A. Only check the row, column, and diagonals related to the last move

B. Check all rows, columns, and both diagonals after every move

C. Check the entire board for a winner after every move

D. Check only the diagonals after every move

Solution

1. Step 1: Understand the cost of checking all lines

   Checking all rows, columns, and diagonals after every move is expensive for large boards.

2. Step 2: Focus on last move's related lines

   Only the row, column, and diagonals that include the last move can change the win state, so checking these is efficient and scalable.

3. Final Answer:

   Only check the row, column, and diagonals related to the last move -> Option A

4. Quick Check:

   Check only affected lines after move for efficiency [OK]

Hint: Check only lines affected by last move for best performance [OK]

Common Mistakes:

• Checking entire board every time wastes resources
• Ignoring diagonals in win checking
• Checking unrelated rows or columns