Sudoku Solver - Practice Coding Problems

Sudoku Solver - Problem

Imagine being handed a partially completed Sudoku puzzle - one of the world's most beloved logic games! Your mission is to write an intelligent program that can automatically solve any valid Sudoku puzzle by filling in the empty cells (marked with '.').

A complete Sudoku solution must follow three sacred rules:

Row Rule: Each of the digits 1-9 must appear exactly once in each row
Column Rule: Each of the digits 1-9 must appear exactly once in each column
Box Rule: Each of the digits 1-9 must appear exactly once in each of the 9 3×3 sub-boxes

Your algorithm needs to be smart enough to use logical deduction and backtracking to find the unique solution, just like a human solver would - but much faster!

Goal: Transform an incomplete 9×9 grid into a completely solved Sudoku puzzle.

Input & Output

example_1.py — Basic Sudoku Puzzle

$ Input: [ ["5","3",".",".","7",".",".",".","."], ["6",".",".","1","9","5",".",".","."], [".","9","8",".",".",".",".","6","."], ["8",".",".",".","6",".",".",".","3"], ["4",".",".","8",".","3",".",".","1"], ["7",".",".",".","2",".",".",".","6"], [".","6",".",".",".",".","2","8","."], [".",".",".","4","1","9",".",".","5"], [".",".",".",".","8",".",".","7","9"] ]

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

💡 Note: This is a typical Sudoku puzzle with a unique solution. The algorithm fills in the missing numbers while ensuring each row, column, and 3x3 box contains all digits 1-9 exactly once.

example_2.py — Nearly Complete Puzzle

$ Input: [ ["5","3","4","6","7","8","9","1","."], ["6","7","2","1","9","5","3","4","8"], ["1","9","8","3","4","2","5","6","7"], ["8","5","9","7","6","1","4","2","3"], ["4","2","6","8","5","3","7","9","1"], ["7","1","3","9","2","4","8","5","6"], ["9","6","1","5","3","7","2","8","4"], ["2","8","7","4","1","9","6","3","5"], ["3","4","5","2","8","6","1","7","9"] ]

💡 Note: This puzzle has only one empty cell. The constraint propagation approach would immediately identify that only '2' can go in position [0][8], making this solve in O(1) time.

example_3.py — Challenging Puzzle

$ Input: [ [".",".",".",".",".",".","6","8","."], [".",".",".",".","4",".",".",".","."], [".",".",".",".",".",".",".",".","."], [".",".",".",".",".",".",".",".","."], [".",".",".",".",".",".","4",".","."], [".",".",".",".",".",".",".",".","."], [".",".",".",".",".",".",".",".","."], [".",".",".",".","2",".",".",".","."], [".",".",".",".",".",".",".",".","."] ]

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

💡 Note: This sparse puzzle with very few given numbers represents a challenging case where backtracking becomes essential. The MCV heuristic helps by choosing cells with fewer possibilities first.

Constraints

board.length == 9
board[i].length == 9
board[i][j] is a digit 1-9 or '.'
It is guaranteed that the input board has only one solution

Visualization

Tap to expand

Understanding the Visualization

Setup Constraints

Initialize tracking sets for each row, column, and 3×3 box with digits 1-9, then remove already placed numbers

Constraint Propagation

Find cells with only one possible value and fill them immediately - like solving obvious clues first

Most Constrained Variable

Among remaining empty cells, choose the one with fewest possible values to branch on

Intelligent Backtrack

Try each possibility, update constraints, and recursively solve. Backtrack with state restoration if stuck

Key Takeaway

🎯 Key Insight: Combining constraint propagation with the Most Constrained Variable heuristic transforms an exponential search into a highly efficient algorithm that solves most Sudoku puzzles in milliseconds.

Asked in

G Google 35 a Amazon 28 Apple 22 ⊞ Microsoft 18

The optimal approach combines constraint propagation with intelligent backtracking. Use sets to track available numbers for each row, column, and 3×3 box. Apply the Most Constrained Variable heuristic to choose the empty cell with fewest possibilities, dramatically reducing the search space from 9⁸¹ to something much more manageable.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Backtracking with Constraint Propagation	O(9^k)	O(n*n)	Use sets to track constraints and apply Most Constrained Variable heuristic
Brute Force Backtracking	O(9^(n*n))	O(n*n)	Try every possible number in every empty cell with basic backtracking

Optimized Backtracking with Constraint Propagation — Algorithm Steps

Initialize sets to track available numbers for each row, column, and 3x3 box
Apply constraint propagation to fill cells with only one possible value
Use MCV heuristic: choose the empty cell with fewest possible values
Try each possible value for the chosen cell
Update constraint sets and propagate constraints
Recursively solve with the updated state
Backtrack by restoring constraint sets if no solution found

Visualization

Tap to expand

Step-by-Step Walkthrough

Track Constraints

Maintain sets of possible values for each row, column, and 3x3 box

Constraint Propagation

Fill cells that have only one possible value immediately

MCV Heuristic

Choose the empty cell with fewest possible values to branch on

Smart Backtrack

Quickly detect invalid states and backtrack with constraint restoration

Code -

solution.c — C

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

typedef struct {
    bool rows[9][10];  // rows[i][num] = available
    bool cols[9][10];  // cols[j][num] = available  
    bool boxes[9][10]; // boxes[k][num] = available
} Constraints;

void initConstraints(Constraints* c) {
    for (int i = 0; i < 9; i++) {
        for (int num = 1; num <= 9; num++) {
            c->rows[i][num] = true;
            c->cols[i][num] = true;
            c->boxes[i][num] = true;
        }
    }
}

int getPossible(char board[9][9], Constraints* c, int i, int j, int* possible) {
    if (board[i][j] != '.') return 0;
    
    int count = 0;
    int boxIdx = (i/3)*3 + j/3;
    
    for (int num = 1; num <= 9; num++) {
        if (c->rows[i][num] && c->cols[j][num] && c->boxes[boxIdx][num]) {
            possible[count++] = num;
        }
    }
    return count;
}

bool solve(char board[9][9], Constraints* c) {
    int minOptions = 10;
    int bestI = -1, bestJ = -1;
    
    // Find most constrained variable
    for (int i = 0; i < 9; i++) {
        for (int j = 0; j < 9; j++) {
            if (board[i][j] == '.') {
                int possible[9];
                int count = getPossible(board, c, i, j, possible);
                if (count < minOptions) {
                    minOptions = count;
                    bestI = i;
                    bestJ = j;
                    if (minOptions == 0) return false;
                }
            }
        }
    }
    
    if (bestI == -1) return true; // Solved
    
    int possible[9];
    int count = getPossible(board, c, bestI, bestJ, possible);
    
    for (int idx = 0; idx < count; idx++) {
        int num = possible[idx];
        int boxIdx = (bestI/3)*3 + bestJ/3;
        
        // Save state
        bool oldRow = c->rows[bestI][num];
        bool oldCol = c->cols[bestJ][num];
        bool oldBox = c->boxes[boxIdx][num];
        
        // Make move
        board[bestI][bestJ] = '0' + num;
        c->rows[bestI][num] = false;
        c->cols[bestJ][num] = false;
        c->boxes[boxIdx][num] = false;
        
        if (solve(board, c)) return true;
        
        // Backtrack
        board[bestI][bestJ] = '.';
        c->rows[bestI][num] = oldRow;
        c->cols[bestJ][num] = oldCol;
        c->boxes[boxIdx][num] = oldBox;
    }
    
    return false;
}

void solveSudoku(char board[9][9]) {
    Constraints c;
    initConstraints(&c);
    
    // Remove existing numbers
    for (int i = 0; i < 9; i++) {
        for (int j = 0; j < 9; j++) {
            if (board[i][j] != '.') {
                int num = board[i][j] - '0';
                c.rows[i][num] = false;
                c.cols[j][num] = false;
                c.boxes[(i/3)*3 + j/3][num] = false;
            }
        }
    }
    
    solve(board, &c);
}

int main() {
    char board[9][9];
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(9^k)

Where k is much smaller than 81 due to constraint propagation reducing the effective search space

✓ Linear Growth

Space Complexity

O(n*n)

Additional space for constraint sets (rows, cols, boxes) plus recursion stack

⚡ Linearithmic Space

425.0K Views

Medium Frequency

~25 min Avg. Time

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

Optimized Backtracking with Constraint Propagation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler