Sliding Puzzle - Practice Coding Problems

Sliding Puzzle - Problem

Array Dynamic Programming Backtracking Breadth-First Search Memoization Matrix Hard

🧩 The Classic Sliding Puzzle Challenge

Imagine you have a 2×3 sliding puzzle - the classic handheld game where you slide numbered tiles to arrange them in order. You have tiles numbered 1 through 5 and one empty space represented by 0.

The Goal: Arrange the puzzle to reach the solved state: [[1,2,3],[4,5,0]]

The Rules: You can only move by swapping the empty space (0) with any of its 4-directionally adjacent numbered tiles (up, down, left, right).

Your Mission: Given any starting configuration, find the minimum number of moves required to solve the puzzle. If it's impossible to solve, return -1.

This is a classic state-space search problem that tests your understanding of graph traversal algorithms!

Input & Output

example_1.py — Basic case requiring 1 move

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

› Output: 1

💡 Note: We need only one move to reach the target. Swap 0 and 5: [[1,2,3],[4,0,5]] → [[1,2,3],[4,5,0]]

example_2.py — Multiple moves required

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

› Output: 4

💡 Note: We need 4 moves: [[1,2,3],[5,4,0]] → [[1,2,0],[5,4,3]] → [[1,0,2],[5,4,3]] → [[1,4,2],[5,0,3]] → [[1,4,2],[0,5,3]] → [[0,4,2],[1,5,3]] (Actually need different sequence, this shows complexity)

example_3.py — Impossible case

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

› Output: -1

💡 Note: This configuration is impossible to solve. The puzzle has an odd number of inversions, making it unsolvable.

Constraints

board.length == 2
board[i].length == 3
0 <= board[i][j] <= 5
Each value board[i][j] is unique
The puzzle contains exactly one 0 and numbers 1 through 5

Visualization

Tap to expand

Understanding the Visualization

State Representation

Convert 2D board to string: [[1,2,3],[4,0,5]] becomes '123405'

Define Transitions

From each state, generate all possible next states by moving 0

BFS Exploration

Use BFS to explore states level by level, guaranteeing shortest path

Target Detection

Stop when we reach target state '123450'

Return Moves

The level at which we find the target is the minimum moves

Key Takeaway

🎯 Key Insight: BFS explores all states at distance d before exploring any state at distance d+1, guaranteeing that the first time we reach the target, we've found the shortest path!

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 25

The optimal solution uses Breadth-First Search (BFS) to explore all possible puzzle states level by level. Since BFS explores states by distance from the start, the first time we reach the target state [[1,2,3],[4,5,0]], we're guaranteed to have found the minimum number of moves. Key insights: represent the board as a string for easy manipulation, use a neighbors map to define valid moves for each position, and track visited states to avoid cycles.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (DFS with Backtracking)	O(6!)	O(6!)	Try all possible move sequences using depth-first search
Breadth-First Search (BFS) - Optimal	O(6!)	O(6!)	Explore all possible states level by level to guarantee minimum moves

Brute Force (DFS with Backtracking) — Algorithm Steps

Start from initial board state
For current state, find position of empty space (0)
Try moving 0 in all 4 valid directions
For each valid move, swap and recursively solve
Keep track of visited states to avoid cycles
Return minimum moves found across all paths

Visualization

Tap to expand

Step-by-Step Walkthrough

Start State

Begin with initial puzzle configuration

Try First Move

Move empty space to first valid position

Recurse Deeply

Continue exploring this path until dead end or solution

Backtrack

Return and try next possible move

Repeat

Continue until all paths explored

Code -

solution.c — C

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

int neighbors[6][4] = {
    {1, 3, -1, -1}, {0, 2, 4, -1}, {1, 5, -1, -1},
    {0, 4, -1, -1}, {1, 3, 5, -1}, {2, 4, -1, -1}
};

int dfs(char* state, char* target, int moves, char visited[][7], int visitedCount) {
    if (strcmp(state, target) == 0) return moves;
    if (moves > 20) return INT_MAX;
    
    // Add to visited
    strcpy(visited[visitedCount], state);
    visitedCount++;
    
    // Find zero position
    int zeroPos = -1;
    for (int i = 0; i < 6; i++) {
        if (state[i] == '0') {
            zeroPos = i;
            break;
        }
    }
    
    int minMoves = INT_MAX;
    
    for (int i = 0; i < 4 && neighbors[zeroPos][i] != -1; i++) {
        int neighbor = neighbors[zeroPos][i];
        
        // Create new state
        char newState[7];
        strcpy(newState, state);
        char temp = newState[zeroPos];
        newState[zeroPos] = newState[neighbor];
        newState[neighbor] = temp;
        
        // Check if visited
        int isVisited = 0;
        for (int j = 0; j < visitedCount; j++) {
            if (strcmp(visited[j], newState) == 0) {
                isVisited = 1;
                break;
            }
        }
        
        if (!isVisited) {
            char newVisited[1000][7];
            for (int j = 0; j < visitedCount; j++) {
                strcpy(newVisited[j], visited[j]);
            }
            int result = dfs(newState, target, moves + 1, newVisited, visitedCount);
            if (result < minMoves) {
                minMoves = result;
            }
        }
    }
    
    return minMoves;
}

int slidingPuzzle(int** board, int boardSize, int* boardColSize) {
    char target[] = "123450";
    char start[7] = {0};
    
    int idx = 0;
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 3; j++) {
            start[idx++] = board[i][j] + '0';
        }
    }
    
    if (strcmp(start, target) == 0) return 0;
    
    char visited[1000][7];
    int result = dfs(start, target, 0, visited, 0);
    return result == INT_MAX ? -1 : result;
}

Time & Space Complexity

Time Complexity

⏱️

O(6!)

In worst case, explores all possible permutations of the 6 positions

✓ Linear Growth

Space Complexity

O(6!)

Recursion stack depth and visited states storage

✓ Linear Space

78.5K Views

Medium Frequency

~25 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

🧩 The Classic Sliding Puzzle Challenge

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (DFS with Backtracking) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler