Candy Crush - Practice Coding Problems

Candy Crush - Problem

Imagine you're playing the classic Candy Crush game! 🍭 You have an m x n grid filled with colorful candies, where each candy is represented by a positive integer. Empty cells are represented by 0.

Your task is to simulate the candy crushing mechanics until the board reaches a stable state. Here's how it works:

🔍 Find Matches: Identify groups of 3 or more identical candies aligned horizontally or vertically
💥 Crush Simultaneously: Remove all matched candies at once (they become 0)
🍃 Apply Gravity: Let remaining candies fall down to fill empty spaces
🔄 Repeat: Continue until no more matches can be made

Return the final stable board configuration after all possible crushing is complete.

Note: No new candies appear from above - only existing candies fall due to gravity!

Input & Output

example_1.py — Basic Horizontal Match

$ Input: board = [[110,5,112,113,114],[210,211,5,213,214],[310,311,3,313,314],[410,411,412,5,414],[5,1,512,3,3],[512,2,3,3,3],[13,14,15,16,17]]

› Output: [[0,0,0,0,0],[0,0,0,0,0],[0,0,0,0,0],[110,0,0,0,0],[210,5,0,5,0],[310,211,112,213,0],[410,311,3,313,114]]

💡 Note: The bottom row has three consecutive 3's which get crushed. After gravity, remaining candies fall down to fill empty spaces.

example_2.py — Vertical Match

$ Input: board = [[1,3,5,5,2],[3,4,3,3,1],[3,2,4,5,2],[2,4,4,5,5],[1,4,4,1,1]]

› Output: [[1,3,0,0,0],[3,4,0,0,0],[3,2,0,0,0],[2,4,0,0,0],[1,4,3,5,5]]

💡 Note: Multiple vertical matches (5,5,5 and 3,3,3) are found and crushed simultaneously, then gravity is applied.

example_3.py — No Matches

$ Input: board = [[1,2,3],[4,5,6],[7,8,9]]

› Output: [[1,2,3],[4,5,6],[7,8,9]]

💡 Note: No groups of 3+ identical candies exist, so the board remains unchanged.

Visualization

Tap to expand

Understanding the Visualization

Scan for Patterns

Look for horizontal and vertical lines of 3+ identical candies

Mark All Matches

Identify all positions that should be crushed simultaneously

Simultaneous Crush

Remove all marked candies at the same time

Apply Gravity

Drop remaining candies down to fill empty spaces

Check Stability

Repeat the process until no more matches exist

Key Takeaway

🎯 Key Insight: Mark all crushable candies first before removing any - this ensures proper simultaneous elimination as per game rules!

Time & Space Complexity

Time Complexity

⏱️

O(k * m * n * (m + n))

k iterations of crushing, each requiring O(m*n) to find matches and O(m*n) for gravity

✓ Linear Growth

Space Complexity

O(m * n)

Additional space for marking crushable positions

⚡ Linearithmic Space

Constraints

m == board.length
n == board[i].length
3 <= m, n <= 50
1 <= board[i][j] <= 2000
board[i][j] == 0 represents an empty cell

Asked in

K King 45 G Google 25 a Amazon 18 f Meta 12

The optimal approach uses simulation with efficient marking. First, scan the board to mark all crushable positions, then crush them simultaneously, apply gravity, and repeat until stable. Key insight: mark first, crush later to handle simultaneous elimination correctly.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Simulation	O(k * m * n * (m + n))	O(m * n)	Scan entire board repeatedly, crush matches, apply gravity until stable

Brute Force Simulation — Algorithm Steps

Scan entire board to find horizontal matches (3+ consecutive same values)
Scan entire board to find vertical matches (3+ consecutive same values)
Mark all matched positions for crushing
Remove all marked candies (set to 0)
Apply gravity by moving all non-zero values down
Repeat until no matches found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Board

Starting configuration with various candy types

Mark Matches

Identify horizontal and vertical matches of 3+ candies

Crush Candies

Remove all marked candies simultaneously

Apply Gravity

Drop remaining candies to fill empty spaces

Repeat Process

Continue until no more matches exist

Code -

solution.c — C

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

typedef struct {
    int i, j;
} Position;

int markCrushable(int** board, int m, int n, Position* marked) {
    int count = 0;
    int markCount = 0;
    
    // Mark horizontal matches
    for (int i = 0; i < m; i++) {
        count = 1;
        for (int j = 1; j < n; j++) {
            if (board[i][j] != 0 && board[i][j] == board[i][j-1]) {
                count++;
            } else {
                if (count >= 3 && board[i][j-1] != 0) {
                    for (int k = j-count; k < j; k++) {
                        marked[markCount++] = (Position){i, k};
                    }
                }
                count = 1;
            }
        }
        if (count >= 3 && board[i][n-1] != 0) {
            for (int k = n-count; k < n; k++) {
                marked[markCount++] = (Position){i, k};
            }
        }
    }
    
    // Mark vertical matches
    for (int j = 0; j < n; j++) {
        count = 1;
        for (int i = 1; i < m; i++) {
            if (board[i][j] != 0 && board[i][j] == board[i-1][j]) {
                count++;
            } else {
                if (count >= 3 && board[i-1][j] != 0) {
                    for (int k = i-count; k < i; k++) {
                        marked[markCount++] = (Position){k, j};
                    }
                }
                count = 1;
            }
        }
        if (count >= 3 && board[m-1][j] != 0) {
            for (int k = m-count; k < m; k++) {
                marked[markCount++] = (Position){k, j};
            }
        }
    }
    
    return markCount;
}

void applyGravity(int** board, int m, int n) {
    for (int j = 0; j < n; j++) {
        int writePos = m - 1;
        for (int i = m - 1; i >= 0; i--) {
            if (board[i][j] != 0) {
                board[writePos][j] = board[i][j];
                if (writePos != i) {
                    board[i][j] = 0;
                }
                writePos--;
            }
        }
    }
}

int** candyCrush(int** board, int boardSize, int* boardColSize, int* returnSize, int** returnColumnSizes) {
    int m = boardSize, n = boardColSize[0];
    Position* marked = (Position*)malloc(m * n * sizeof(Position));
    
    while (1) {
        int markCount = markCrushable(board, m, n, marked);
        if (markCount == 0) break;
        
        // Crush marked candies
        for (int i = 0; i < markCount; i++) {
            board[marked[i].i][marked[i].j] = 0;
        }
        
        applyGravity(board, m, n);
    }
    
    free(marked);
    *returnSize = m;
    *returnColumnSizes = boardColSize;
    return board;
}

Time & Space Complexity

Time Complexity

⏱️

O(k * m * n * (m + n))

k iterations of crushing, each requiring O(m*n) to find matches and O(m*n) for gravity

✓ Linear Growth

Space Complexity

O(m * n)

Additional space for marking crushable positions

⚡ Linearithmic Space

Constraints

m == board.length
n == board[i].length
3 <= m, n <= 50
1 <= board[i][j] <= 2000
board[i][j] == 0 represents an empty cell

43.5K Views

Medium Frequency

~25 min Avg. Time

1.9K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler