Codestin Search App

Valid Sudoku - Problem

Ever wondered how those classic number puzzle games validate their boards? Welcome to the world of Sudoku validation!

You're given a 9 × 9 Sudoku board that may be partially filled. Your mission is to determine whether the current state follows all Sudoku rules - but here's the catch: you only need to validate the filled cells, not solve the entire puzzle.

The Three Sacred Rules of Sudoku:

🔴 Each row must contain digits 1-9 without repetition
🔵 Each column must contain digits 1-9 without repetition
🟢 Each 3×3 sub-box must contain digits 1-9 without repetition

Empty cells are represented by '.' and should be ignored during validation. A valid board doesn't need to be solvable - it just needs to follow the rules for existing numbers.

Input: A 9×9 matrix representing the Sudoku board
Output: true if valid, false if any rule is violated

Input & Output

example_1.py — Valid 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: true

💡 Note: This is a valid partially filled Sudoku board. All filled numbers follow the three rules: no duplicates in rows, columns, or 3×3 sub-boxes.

example_2.py — Invalid Sudoku Board

$ 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: Invalid because there are two '8's in the first column: board[0][0] = '8' and board[3][0] = '8', violating the column uniqueness rule.

example_3.py — Empty Board Edge Case

$ Input: board = [[".",...,"."],[".",".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".",".","."]]

› Output: true

💡 Note: An empty Sudoku board is considered valid since there are no digits to violate any constraints. Only filled cells need validation.

Constraints

board.length == 9
board[i].length == 9
board[i][j] is a digit 1-9 or '.'
Only filled cells need to be validated

Visualization

Tap to expand

Understanding the Visualization

Setup Guest Lists

Create guest lists for each row, column, and table section to track which families are already seated

Check Each Guest

For each seated guest, verify their family isn't already represented in their row, column, or table section

Update Records

If valid, add the family to all three relevant lists; if duplicate found, the arrangement is invalid

Validation Complete

Once all guests are checked, the seating arrangement follows all rules

Key Takeaway

🎯 Key Insight: Use hash sets to track 'family presence' (digits) in each constraint (row/column/box) simultaneously, enabling single-pass validation with immediate duplicate detection.

Asked in

⊞ Microsoft 45 a Amazon 38 G Google 32 Apple 25

The optimal solution uses one-pass hash set validation with O(1) time complexity. Create hash sets for each row, column, and 3×3 box, then traverse the board once. For each filled cell, check if the digit exists in the corresponding constraint sets - if yes, return false; otherwise, add to all three sets. The key insight is using (row/3)*3 + col/3 formula to map cells to box indices efficiently.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Validation)	O(1)	O(1)	For each cell, check entire row, column, and 3×3 box for duplicates
One-Pass Hash Set (Optimal)	O(1)	O(1)	Track all constraints simultaneously using hash sets in single board traversal

Brute Force (Nested Validation) — Algorithm Steps

Iterate through every cell in the 9×9 board
For each non-empty cell, extract its digit value
Check entire row for duplicate of this digit
Check entire column for duplicate of this digit
Calculate which 3×3 box this cell belongs to and check for duplicates
If any duplicate found, return false immediately
If all cells pass validation, return true

Visualization

Tap to expand

Step-by-Step Walkthrough

Check All Rows

Validate each row independently for duplicates

Check All Columns

Validate each column independently for duplicates

Check All 3×3 Boxes

Validate each sub-box independently for duplicates

Code -

solution.c — C

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

bool isValidSudoku(char** board, int boardSize, int* boardColSize) {
    // Check rows
    for (int i = 0; i < 9; i++) {
        bool seen[10] = {false}; // indices 1-9 for digits
        for (int j = 0; j < 9; j++) {
            char cell = board[i][j];
            if (cell != '.') {
                int digit = cell - '0';
                if (seen[digit]) return false;
                seen[digit] = true;
            }
        }
    }
    
    // Check columns
    for (int j = 0; j < 9; j++) {
        bool seen[10] = {false};
        for (int i = 0; i < 9; i++) {
            char cell = board[i][j];
            if (cell != '.') {
                int digit = cell - '0';
                if (seen[digit]) return false;
                seen[digit] = true;
            }
        }
    }
    
    // Check 3x3 boxes
    for (int boxRow = 0; boxRow < 9; boxRow += 3) {
        for (int boxCol = 0; boxCol < 9; boxCol += 3) {
            bool seen[10] = {false};
            for (int r = boxRow; r < boxRow + 3; r++) {
                for (int c = boxCol; c < boxCol + 3; c++) {
                    char cell = board[r][c];
                    if (cell != '.') {
                        int digit = cell - '0';
                        if (seen[digit]) return false;
                        seen[digit] = true;
                    }
                }
            }
        }
    }
    
    return true;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Although we have nested loops, the board size is fixed at 9×9, making it constant time. In general case, it would be O(n³) where n is board dimension.

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for iteration and comparison, no additional data structures

✓ Linear Space

89.5K Views

High Frequency

~15 min Avg. Time

2.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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Nested Validation) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler