Sudoku Solver Using Backtracking in DSA Python - Build from Scratch

Sudoku Solver Using Backtracking

📖 Scenario: You have a Sudoku puzzle with some numbers filled in and empty cells represented by 0. Your task is to write a program that solves the Sudoku puzzle by filling in the empty cells following Sudoku rules.Sudoku rules: Each row, each column, and each 3x3 box must contain the numbers 1 to 9 without repetition.

🎯 Goal: Build a Sudoku solver using backtracking that fills the empty cells correctly and prints the solved Sudoku grid.

📋 What You'll Learn

Create a 9x9 list of lists called sudoku with the given initial puzzle

Create a function is_valid that checks if placing a number in a cell is valid

Create a function solve_sudoku that uses backtracking to solve the puzzle

Print the solved Sudoku grid in a readable format

💡 Why This Matters

🌍 Real World

Sudoku solvers are used in puzzle apps and games to check solutions or generate puzzles automatically.

💼 Career

Understanding backtracking algorithms and constraint checking is useful in software development, especially in AI, game development, and solving complex problems.

1

Create the Sudoku puzzle data structure

Create a 9x9 list of lists called sudoku with the exact values below, where 0 represents empty cells:

[
[5, 3, 0, 0, 7, 0, 0, 0, 0],
[6, 0, 0, 1, 9, 5, 0, 0, 0],
[0, 9, 8, 0, 0, 0, 0, 6, 0],
[8, 0, 0, 0, 6, 0, 0, 0, 3],
[4, 0, 0, 8, 0, 3, 0, 0, 1],
[7, 0, 0, 0, 2, 0, 0, 0, 6],
[0, 6, 0, 0, 0, 0, 2, 8, 0],
[0, 0, 0, 4, 1, 9, 0, 0, 5],
[0, 0, 0, 0, 8, 0, 0, 7, 9]
]

DSA Python

# Create the sudoku puzzle as a 9x9 list of lists with zeros for empty cells
# Your code here

Hint

Use a list of lists in Python. Each inner list is a row of the Sudoku puzzle.

2

Create the is_valid function to check number placement

Create a function called is_valid that takes four parameters: sudoku, row, col, and num. This function should return True if placing num in sudoku[row][col] does not break Sudoku rules (no duplicates in the same row, column, or 3x3 box). Otherwise, return False.

DSA Python

def is_valid(sudoku, row, col, num):
    # Your code here

Hint

Check the row, column, and 3x3 box for the number. Return False if found, else True.

3

Create the solve_sudoku function using backtracking

Create a function called solve_sudoku that takes sudoku as a parameter. Use nested loops to find an empty cell (value 0). For each empty cell, try numbers 1 to 9. Use is_valid to check if the number can be placed. If valid, place the number and recursively call solve_sudoku. If the recursive call returns True, return True. If no number fits, reset the cell to 0 and return False. If no empty cells remain, return True.

DSA Python

def solve_sudoku(sudoku):
    # Your code here

Hint

Use nested loops to find empty cells and try numbers 1 to 9. Use recursion to solve the puzzle step by step.

4

Print the solved Sudoku grid

After calling solve_sudoku(sudoku), print the solved Sudoku grid row by row. Use a for loop to print each row as a list.

DSA Python

for row in sudoku:
    # Your code here

Hint

Use a for loop to print each row of the solved Sudoku puzzle.

Practice

1. What is the main purpose of backtracking in a Sudoku solver?

easy

A. To count how many empty cells are in the Sudoku grid

B. To randomly fill the Sudoku grid without checking rules

C. To sort the numbers in each row before solving

D. To try possible numbers and undo choices if they lead to conflicts

Solution

1. Step 1: Understand backtracking role

   Backtracking tries numbers in empty cells and removes them if they cause conflicts.

2. Step 2: Compare other options

   Other options do not describe backtracking's trial and error approach.

3. Final Answer:

   To try possible numbers and undo choices if they lead to conflicts -> Option D

4. Quick Check:

   Backtracking = Try and undo choices [OK]

Hint: Backtracking means try, check, and undo if wrong [OK]

Common Mistakes:

• Thinking backtracking fills randomly without checks
• Confusing backtracking with sorting or counting
• Ignoring the undo step in backtracking

2. Which of the following is the correct Python syntax to check if a number is safe to place in a Sudoku cell using backtracking?

easy

A. if is_safe(board, row, col, num):

B. if isSafe(board, row, col, num);

C. if is_safe(board, row, col, num)

D. if is_safe board, row, col, num:

Solution

1. Step 1: Identify correct function call syntax

   Python requires parentheses and a colon after the if condition, so 'if is_safe(board, row, col, num):' is correct.

2. Step 2: Check other options for syntax errors

   if isSafe(board, row, col, num); uses semicolon instead of colon; C misses colon; D misses parentheses.

3. Final Answer:

   if is_safe(board, row, col, num): -> Option A

4. Quick Check:

   Python if syntax = condition + colon [OK]

Hint: Remember if statements end with a colon in Python [OK]

Common Mistakes:

• Forgetting the colon at the end of if statement
• Missing parentheses around function arguments
• Using semicolon instead of colon

3. What will be the output of the following code snippet when solving a Sudoku board with backtracking?

board = [
  [5, 3, 0, 0, 7, 0, 0, 0, 0],
  [6, 0, 0, 1, 9, 5, 0, 0, 0],
  [0, 9, 8, 0, 0, 0, 0, 6, 0],
  [8, 0, 0, 0, 6, 0, 0, 0, 3],
  [4, 0, 0, 8, 0, 3, 0, 0, 1],
  [7, 0, 0, 0, 2, 0, 0, 0, 6],
  [0, 6, 0, 0, 0, 0, 2, 8, 0],
  [0, 0, 0, 4, 1, 9, 0, 0, 5],
  [0, 0, 0, 0, 8, 0, 0, 7, 9]
]

solve_sudoku(board)
print(board)

medium

A. [[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]]

B. [[5,3,0,0,7,0,0,0,0],[6,0,0,1,9,5,0,0,0],[0,9,8,0,0,0,0,6,0],[8,0,0,0,6,0,0,0,3],[4,0,0,8,0,3,0,0,1],[7,0,0,0,2,0,0,0,6],[0,6,0,0,0,0,2,8,0],[0,0,0,4,1,9,0,0,5],[0,0,0,0,8,0,0,7,9]]

C. SyntaxError

D. RuntimeError

Solution

1. Step 1: Understand solve_sudoku function effect

   The solve_sudoku function fills empty cells (zeros) with correct numbers to complete the Sudoku board.

2. Step 2: Analyze output after solving

   After solving, the board will be fully filled with valid numbers, matching [[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]]'s completed grid.

3. Final Answer:

   Completed Sudoku board with all zeros replaced by correct numbers -> Option A

4. Quick Check:

   Backtracking fills zeros to complete board [OK]

Hint: Backtracking fills zeros to complete Sudoku [OK]

Common Mistakes:

• Expecting the board to remain unchanged after solve
• Confusing syntax or runtime errors with correct output
• Not recognizing that zeros are placeholders for empty cells

4. Identify the error in this backtracking Sudoku solver code snippet:

def solve(board):
    for row in range(9):
        for col in range(9):
            if board[row][col] == 0:
                for num in range(1, 10):
                    if is_safe(board, row, col, num):
                        board[row][col] = num
                        if solve(board):
                            return True
                        board[row][col] = 0
                return False
    return True

# Error: The function is_safe is not defined anywhere.

medium

A. The range for num should be range(0, 9)

B. The board size should be 8 instead of 9

C. The function is_safe is missing, causing NameError

D. The function solve should return False at the end

Solution

1. Step 1: Check for missing functions

   The code calls is_safe but does not define it, causing a NameError at runtime.

2. Step 2: Verify other options

   Board size 9 is correct for Sudoku; num range 1-9 is correct; solve returns True at end which is correct.

3. Final Answer:

   The function is_safe is missing, causing NameError -> Option C

4. Quick Check:

   Undefined function causes NameError [OK]

Hint: Always define helper functions before calling them [OK]

Common Mistakes:

• Assuming board size is 8 instead of 9
• Using wrong range for numbers (should be 1 to 9)
• Forgetting to return True when solved

5. Given a partially filled Sudoku board, which strategy best improves the efficiency of the backtracking solver?

hard

A. Fill cells randomly without checking constraints

B. Always pick the next empty cell with the fewest possible valid numbers

C. Try numbers in ascending order without checking row or column

D. Restart solving from the first cell after each failed attempt

Solution

1. Step 1: Understand backtracking optimization

   Choosing the empty cell with the fewest valid options reduces branching and speeds solving.

2. Step 2: Evaluate other options

   Random filling ignores constraints; trying numbers without checks wastes time; restarting after failure is inefficient.

3. Final Answer:

   Always pick the next empty cell with the fewest possible valid numbers -> Option B

4. Quick Check:

   Minimum options first = faster backtracking [OK]

Hint: Choose cell with fewest options to speed solving [OK]

Common Mistakes:

• Ignoring constraints when filling cells
• Trying numbers in fixed order without pruning
• Restarting solving unnecessarily wastes time