Minesweeper - Practice Coding Problems

Minesweeper - Problem

Welcome to the classic Minesweeper game! 🎮 Your task is to simulate the revealing logic of this beloved puzzle game.

You're given an m x n character matrix representing the game board where:

'M' - An unrevealed mine 💣
'E' - An unrevealed empty square
'B' - A revealed blank square (no adjacent mines)
'1'-'8' - Number of adjacent mines around this revealed square
'X' - A revealed mine (game over!)

You'll receive a click position [clickRow, clickCol] on an unrevealed square. Your job is to simulate the click and return the updated board following these rules:

Mine clicked ('M'): Game over! Change it to 'X'
Empty square with no adjacent mines ('E'): Change to 'B' and recursively reveal all adjacent unrevealed squares
Empty square with adjacent mines ('E'): Change to a digit ('1'-'8') showing the count

Return the board after all possible squares have been revealed.

Input & Output

example_1.py — Basic Mine Click

$ Input: board = [['E','E','E','E','E'],['E','E','M','E','E'],['E','E','E','E','E'],['E','E','E','E','E']], click = [3,0]

› Output: [['B','1','E','1','B'],['B','1','M','1','B'],['B','1','1','1','B'],['B','B','B','B','B']]

💡 Note: Clicking at (3,0) reveals a large connected area. The square has no adjacent mines, so it becomes 'B' and triggers recursive revelation of all connected empty squares. Numbers appear where there are adjacent mines.

example_2.py — Direct Mine Hit

$ Input: board = [['B','1','E','1','B'],['B','1','M','1','B'],['B','1','1','1','B'],['B','B','B','B','B']], click = [1,2]

› Output: [['B','1','E','1','B'],['B','1','X','1','B'],['B','1','1','1','B'],['B','B','B','B','B']]

💡 Note: Clicking directly on a mine ('M') at position (1,2) ends the game. The mine is revealed by changing 'M' to 'X'. No other squares are affected.

example_3.py — Single Number Reveal

$ Input: board = [['E','E','E'],['E','M','E'],['E','E','E']], click = [0,0]

› Output: [['1','E','E'],['E','M','E'],['E','E','E']]

💡 Note: Clicking at (0,0) reveals a square that has exactly 1 adjacent mine. Since there are adjacent mines, it becomes '1' and no recursive revelation occurs.

Constraints

m == board.length
n == board[i].length
1 ≤ m, n ≤ 50
board[i][j] is either 'M', 'E', 'B', or a digit from '1' to '8'
click.length == 2
0 ≤ click_r < m
0 ≤ click_c < n
board[click_r][click_c] is either 'M' or 'E'

Visualization

Tap to expand

Understanding the Visualization

Initial Click

Player clicks on an unrevealed empty square

Safety Check

Count adjacent mines - if zero, mark as 'B' and continue

Ripple Effect

Recursively reveal all adjacent unrevealed squares

Natural Boundary

Stop when reaching squares with adjacent mines (numbered squares)

Key Takeaway

🎯 Key Insight: Minesweeper revelation is a connected components problem where DFS/BFS efficiently explores safe regions until natural boundaries are reached.

Asked in

a Amazon 15 ⊞ Microsoft 12 G Google 8 B Bloomberg 6

The optimal approach uses Depth-First Search (DFS) or Breadth-First Search (BFS) to simulate minesweeper click logic. When clicking an empty square with no adjacent mines, we recursively reveal all connected empty areas. The key insight is recognizing this as a connected components problem where safe areas form regions that can be revealed together in O(m × n) time.

Common Approaches

Approach	Time	Space	Notes
✓ BFS Implementation	O(m × n)	O(m × n)	Use BFS queue instead of recursive DFS for revealing squares
Brute Force (Recursive DFS)	O(m × n)	O(m × n)	Direct implementation using recursive DFS to reveal squares

BFS Implementation — Algorithm Steps

Check if clicked square is a mine, mark as 'X' if true
Initialize a queue with the clicked position
While queue is not empty, process each square
Count adjacent mines for current square
If no mines, mark as 'B' and add all adjacent unrevealed squares to queue
If has mines, mark with count number

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Queue

Add clicked position to queue

Process Level 1

Process clicked square, add adjacent empty squares to queue

Process Level 2

Process all squares from level 1, continue expanding

Complete

Continue until queue is empty

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int directions[8][2] = {{-1,-1}, {-1,0}, {-1,1}, {0,-1}, {0,1}, {1,-1}, {1,0}, {1,1}};

typedef struct {
    int r, c;
} Position;

typedef struct {
    Position* data;
    int front, rear, capacity;
} Queue;

Queue* createQueue(int capacity) {
    Queue* q = (Queue*)malloc(sizeof(Queue));
    q->data = (Position*)malloc(capacity * sizeof(Position));
    q->front = 0;
    q->rear = -1;
    q->capacity = capacity;
    return q;
}

void enqueue(Queue* q, Position pos) {
    q->rear = (q->rear + 1) % q->capacity;
    q->data[q->rear] = pos;
}

Position dequeue(Queue* q) {
    Position pos = q->data[q->front];
    q->front = (q->front + 1) % q->capacity;
    return pos;
}

int isEmpty(Queue* q) {
    return (q->rear + 1) % q->capacity == q->front;
}

char** updateBoard(char** board, int boardSize, int* boardColSize, int* click, int clickSize, int* returnSize, int** returnColumnSizes) {
    int m = boardSize, n = boardColSize[0];
    int row = click[0], col = click[1];
    
    // If clicked on a mine
    if (board[row][col] == 'M') {
        board[row][col] = 'X';
        return board;
    }
    
    // BFS to reveal squares
    Queue* queue = createQueue(m * n);
    Position start = {row, col};
    enqueue(queue, start);
    
    while (!isEmpty(queue)) {
        Position pos = dequeue(queue);
        int r = pos.r, c = pos.c;
        
        if (r < 0 || r >= m || c < 0 || c >= n || board[r][c] != 'E') {
            continue;
        }
        
        // Count adjacent mines
        int mineCount = 0;
        for (int i = 0; i < 8; i++) {
            int nr = r + directions[i][0], nc = c + directions[i][1];
            if (nr >= 0 && nr < m && nc >= 0 && nc < n && board[nr][nc] == 'M') {
                mineCount++;
            }
        }
        
        if (mineCount == 0) {
            // No adjacent mines, mark as blank and add adjacent squares
            board[r][c] = 'B';
            for (int i = 0; i < 8; i++) {
                int nr = r + directions[i][0], nc = c + directions[i][1];
                if (nr >= 0 && nr < m && nc >= 0 && nc < n && board[nr][nc] == 'E') {
                    Position newPos = {nr, nc};
                    enqueue(queue, newPos);
                }
            }
        } else {
            // Has adjacent mines, mark with count
            board[r][c] = '0' + mineCount;
        }
    }
    
    free(queue->data);
    free(queue);
    return board;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

Still need to visit each square at most once in worst case

✓ Linear Growth

Space Complexity

O(m × n)

Queue can contain up to all squares in worst case of large connected area

⚡ Linearithmic Space

89.2K Views

Medium Frequency

~15 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

BFS Implementation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler