Valid Sudoku

Valid Sudoku - Problem

Determine if a 9 × 9 Sudoku board is valid. Only the filled cells need to be validated according to the following rules:

• Each row must contain the digits 1-9 without repetition
• Each column must contain the digits 1-9 without repetition
• Each of the nine 3 × 3 sub-boxes must contain the digits 1-9 without repetition

Note: A Sudoku board (partially filled) could be valid but is not necessarily solvable. Only the filled cells need to be validated according to the mentioned rules.

Input & Output

Example 1 — Valid Sudoku

$ 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: true

💡 Note: Each row, column, and 3×3 sub-box contains unique digits 1-9 (ignoring empty cells). No duplicates found in any region.

Example 2 — Invalid Sudoku (Row Duplicate)

$ Input: board = [["8","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: false

💡 Note: The first column contains two '8's (at positions [0,0] and [3,0]), which violates the column uniqueness rule.

Example 3 — Invalid Sudoku (Sub-box Duplicate)

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

› Output: false

💡 Note: The top-left 3×3 sub-box contains two '5's (at positions [0,0] and [2,2]), which violates the sub-box uniqueness rule.

Constraints

board.length == 9
board[i].length == 9
board[i][j] is a digit 1-9 or '.'.

Visualization

Tap to expand

Asked in

a Amazon 65 Apple 45 G Google 38 m Microsoft 32

Use hash sets to track seen digits for each row, column, and 3×3 sub-box. The key insight is calculating sub-box index as (row/3)*3 + col/3. Best approach uses single pass with 27 sets. Time: O(1), Space: O(1)

Common Approaches

✓ Triple Pass Validation

⏱️ Time: O(1) Space: O(1)

Make three separate passes through the board: first validate all rows, then all columns, then all 3×3 sub-boxes. For each validation, use a set to detect duplicates.

Single Pass with Hash Sets

⏱️ Time: O(1) Space: O(1)

Make a single pass through the board and maintain separate hash sets for each row, column, and 3×3 sub-box. For each non-empty cell, check if the digit already exists in the corresponding sets.

Triple Pass Validation — Algorithm Steps

Pass 1: Check each row for duplicates
Pass 2: Check each column for duplicates
Pass 3: Check each 3×3 sub-box for duplicates

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Rows

Validate each row has no duplicate digits

Check Columns

Validate each column has no duplicate digits

Check Sub-boxes

Validate each 3×3 box has no duplicate digits

Code -

solution.c — C

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

bool solution(char board[9][9]) {
    // Check rows
    for (int row = 0; row < 9; row++) {
        bool seen[10] = {false}; // digits 1-9
        for (int col = 0; col < 9; col++) {
            char cell = board[row][col];
            if (cell != '.') {
                int digit = cell - '0';
                if (seen[digit]) {
                    return false;
                }
                seen[digit] = true;
            }
        }
    }
    
    // Check columns
    for (int col = 0; col < 9; col++) {
        bool seen[10] = {false};
        for (int row = 0; row < 9; row++) {
            char cell = board[row][col];
            if (cell != '.') {
                int digit = cell - '0';
                if (seen[digit]) {
                    return false;
                }
                seen[digit] = true;
            }
        }
    }
    
    // Check 3x3 sub-boxes
    for (int boxRow = 0; boxRow < 3; boxRow++) {
        for (int boxCol = 0; boxCol < 3; boxCol++) {
            bool seen[10] = {false};
            for (int row = boxRow * 3; row < boxRow * 3 + 3; row++) {
                for (int col = boxCol * 3; col < boxCol * 3 + 3; col++) {
                    char cell = board[row][col];
                    if (cell != '.') {
                        int digit = cell - '0';
                        if (seen[digit]) {
                            return false;
                        }
                        seen[digit] = true;
                    }
                }
            }
        }
    }
    
    return true;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    char board[9][9];
    int row = 0, col = 0;
    
    // Parse the board from JSON format
    for (int i = 0; line[i] != '\0'; i++) {
        if (line[i] == '.' || (line[i] >= '1' && line[i] <= '9')) {
            board[row][col++] = line[i];
            if (col == 9) {
                col = 0;
                row++;
            }
        }
    }
    
    bool result = solution(board);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Always scan a fixed 9×9 = 81 cells, 3 times = 243 operations

✓ Linear Growth

Space Complexity

O(1)

Set size is at most 9 digits, constant space

✓ Linear Space

185.0K Views

High Frequency

~15 min Avg. Time

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

Triple Pass Validation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler