Sudoku Solver

Sudoku Solver - Problem

Write a program to solve a Sudoku puzzle by filling the empty cells.

A sudoku solution must satisfy all of the following rules:

Each of the digits 1-9 must occur exactly once in each row.
Each of the digits 1-9 must occur exactly once in each column.
Each of the digits 1-9 must occur exactly once in each of the 9 3x3 sub-boxes of the grid.

The '.' character indicates empty cells.

Note: You may assume that the given Sudoku puzzle will have a solution and is guaranteed to be unique.

Input & Output

Example 1 — Partial Sudoku Board

$ Input: board = [["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: The empty cells (marked with '.') are filled so that each row, column, and 3x3 box contains digits 1-9 exactly once. For example, row 0 becomes [5,3,4,6,7,8,9,1,2] — all digits present exactly once.

Constraints

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

Visualization

Tap to expand

Asked in

M Microsoft 35 H HashiCorp 12 a Amazon 28 G Google 22

Use backtracking with constraint sets (row, column, box) for O(1) validation. For each empty cell, try digits 1-9 that don't conflict with existing digits in the same row, column, or 3x3 box. Place the digit, recurse to the next empty cell, and backtrack if stuck. Time: O(9^m) worst case but heavily pruned in practice. Space: O(n²) for constraint sets.

Common Approaches

✓ Brute Force Backtracking

⏱️ Time: O(9^m × n²) Space: O(m)

For each empty cell, try placing digits 1 through 9. After placing a digit, check if the entire board is still valid by scanning all rows, columns, and 3x3 boxes. If valid, move to the next empty cell. If no digit works, backtrack.

Optimized Backtracking with Constraint Sets

⏱️ Time: O(9^m) Space: O(n²)

Maintain three sets of sets: one for each row, column, and 3x3 box. Before placing a digit, check all three sets in O(1). After placing, add the digit to the sets. On backtrack, remove it. This avoids scanning the board repeatedly.

Brute Force Backtracking — Algorithm Steps

Step 1: Find the next empty cell (marked with '.')
Step 2: Try placing digits '1' through '9'
Step 3: After placing, validate entire board (all rows, columns, 3x3 boxes)
Step 4: If valid, recurse to next empty cell
Step 5: If no digit works, reset cell to '.' and backtrack

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Empty

Scan board for '.' cells

Try Digit

Place '1' through '9'

Validate

Check all rows, columns, boxes

Backtrack

Undo if no digit works

Code -

solution.c — C

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

char board[9][9];

int isValid(int row, int col, char num) {
    for (int i = 0; i < 9; i++) {
        if (board[row][i] == num) return 0;
        if (board[i][col] == num) return 0;
    }
    int boxR = 3 * (row / 3), boxC = 3 * (col / 3);
    for (int i = boxR; i < boxR + 3; i++)
        for (int j = boxC; j < boxC + 3; j++)
            if (board[i][j] == num) return 0;
    return 1;
}

int solve() {
    for (int i = 0; i < 9; i++) {
        for (int j = 0; j < 9; j++) {
            if (board[i][j] == '.') {
                for (char n = '1'; n <= '9'; n++) {
                    if (isValid(i, j, n)) {
                        board[i][j] = n;
                        if (solve()) return 1;
                        board[i][j] = '.';
                    }
                }
                return 0;
            }
        }
    }
    return 1;
}

int main() {
    char line[2048];
    fgets(line, sizeof(line), stdin);
    int idx = 0, len = strlen(line);
    for (int i = 0; i < 9; i++) {
        for (int j = 0; j < 9; j++) {
            while (idx < len && line[idx] != '"') idx++;
            idx++;
            board[i][j] = line[idx];
            idx += 2;
        }
    }
    solve();
    printf("[");
    for (int i = 0; i < 9; i++) {
        if (i > 0) printf(",");
        printf("[");
        for (int j = 0; j < 9; j++) {
            if (j > 0) printf(",");
            printf("\"%c\"", board[i][j]);
        }
        printf("]");
    }
    printf("]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(9^m × n²)

m empty cells, each tries 9 digits, each validation scans n² cells where n=9

✓ Linear Growth

Space Complexity

O(m)

Recursion depth equals number of empty cells

⚠ Quadratic Space

52.0K Views

High Frequency

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Backtracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler