Sudoku Solver Using Backtracking in DSA Java - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to check if a number is already in the given row.

DSA Java

for (int col = 0; col < 9; col++) {
    if (board[row][col] == [1]) {
        return false;
    }
}

Drag options to blanks, or click blank then click option'

Arow

Bnum

Ccol

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong variable instead of 'num'.

Checking columns instead of rows.

We check if the number 'num' is already present in the row by comparing each cell in that row.

2fill in blank

medium

Complete the code to check if a number is already in the given column.

DSA Java

for (int row = 0; row < 9; row++) {
    if (board[row][col] == [1]) {
        return false;
    }
}

Drag options to blanks, or click blank then click option'

Anum

B9

Ccol

Drow

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong variable instead of 'num'.

Checking rows instead of columns.

We check if 'num' is already present in the column by comparing each cell in that column.

3fill in blank

hard

Fix the error in calculating the starting row of the 3x3 box.

DSA Java

int boxStartRow = row - row % [1];

Drag options to blanks, or click blank then click option'

A1

B2

C3

D9

Attempts:

3 left

💡 Hint

Common Mistakes

Using 2 or 9 instead of 3.

Forgetting modulo operation.

Each 3x3 box starts at a row index that is a multiple of 3, so we use modulo 3.

4fill in blank

hard

Fill both blanks to check if 'num' is in the 3x3 box starting at (boxStartRow, boxStartCol).

DSA Java

for (int r = [1]; r < [1] + 3; r++) {
    for (int c = [2]; c < [2] + 3; c++) {
        if (board[r][c] == num) {
            return false;
        }
    }
}

Drag options to blanks, or click blank then click option'

AboxStartRow

BboxStartCol

Crow

Dcol

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'row' or 'col' instead of box start variables.

Looping beyond the 3x3 box.

We loop from the box start row and column to cover the 3x3 box cells.

5fill in blank

hard

Fill all three blanks to complete the backtracking solve method that tries numbers 1 to 9 in empty cells.

DSA Java

for (int num = [1]; num <= [2]; num++) {
    if (isSafe(board, row, col, num)) {
        board[row][col] = num;
        if (solveSudoku(board)) {
            return true;
        } else {
            board[row][col] = [3];
        }
    }
}

Drag options to blanks, or click blank then click option'

A1

B9

C0

D-1

Attempts:

3 left

💡 Hint

Common Mistakes

Trying numbers outside 1-9 range.

Resetting cells to -1 instead of 0.

We try numbers 1 to 9. If a number fits, we place it. If it leads to no solution, we reset the cell to 0 (empty).

Practice

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

easy

A. To randomly fill the Sudoku board with numbers

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

C. To sort the Sudoku board numbers in ascending order

D. To count how many empty cells are in the Sudoku board

Solution

1. Step 1: Understand backtracking role

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

2. Step 2: Compare with other options

   Sorting or random filling does not solve Sudoku logically; counting empty cells is not solving.

3. Final Answer:

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

4. Quick Check:

   Backtracking = Try and undo choices [OK]

Hint: Backtracking means try and undo wrong moves [OK]

Common Mistakes:

• Thinking backtracking sorts numbers
• Assuming backtracking fills randomly
• Confusing backtracking with counting cells

2. Which of the following Java method signatures correctly represents a backtracking Sudoku solver method?

easy

A. public boolean solveSudoku(int[][] board)

B. void solveSudoku(int board[][])

C. public int solveSudoku(int[][] board, int row, int col)

D. boolean solveSudoku()

Solution

1. Step 1: Check method return type and parameters

   The solver should return boolean to indicate success and take the board as input.

2. Step 2: Validate options

   public boolean solveSudoku(int[][] board) matches this: returns boolean and takes int[][] board. void solveSudoku(int board[][]) returns void, not suitable. public int solveSudoku(int[][] board, int row, int col) returns int and has extra parameters, uncommon. boolean solveSudoku() has no parameters, so can't solve given board.

3. Final Answer:

   public boolean solveSudoku(int[][] board) -> Option A

4. Quick Check:

   Boolean return + board parameter = public boolean solveSudoku(int[][] board) [OK]

Hint: Solver returns boolean and takes board as int[][] [OK]

Common Mistakes:

• Using void return type for solver
• Missing board parameter
• Returning int instead of boolean

3. What will be the output of the following code snippet after calling solveSudoku(board) on a partially filled 9x9 Sudoku board?

int[][] 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}
};
boolean solved = solveSudoku(board);
System.out.println(solved);

medium

A. Compilation error

B. false

C. true

D. Runtime exception

Solution

1. Step 1: Understand the input board

   The given board is a valid Sudoku puzzle with empty cells (0) and solvable configuration.

2. Step 2: Analyze solveSudoku output

   Backtracking solver returns true if it finds a solution. Since this is a standard solvable puzzle, it returns true.

3. Final Answer:

   true -> Option C

4. Quick Check:

   Solvable board returns true [OK]

Hint: Valid puzzle solved returns true [OK]

Common Mistakes:

• Assuming false means no solution without checking
• Confusing output with board print
• Expecting exceptions on valid input

4. Identify the bug in this backtracking Sudoku solver snippet:

public boolean solveSudoku(int[][] board) {
  for (int row = 0; row < 9; row++) {
    for (int col = 0; col < 9; col++) {
      if (board[row][col] == 0) {
        for (int num = 1; num <= 9; num++) {
          if (isSafe(board, row, col, num)) {
            board[row][col] = num;
            if (solveSudoku(board)) {
              return true;
            } else {
              board[row][col] = 0;
            }
          }
        }
        return false;
      }
    }
  }
  return true;
}

medium

A. Using wrong data type for board

B. Incorrect loop ranges for row and col

C. Not checking if board is already solved before recursion

D. Missing return false when no number fits in empty cell

Solution

1. Step 1: Analyze the nested loops and recursion

   The code tries numbers 1-9 in empty cells and recurses if safe.

2. Step 2: Identify missing return false

   If no number fits, the function should return false to backtrack, but here it continues loops and returns true at end incorrectly.

3. Final Answer:

   Missing return false when no number fits in empty cell -> Option D

4. Quick Check:

   Backtracking needs return false on failure [OK]

Hint: Return false if no valid number found in cell [OK]

Common Mistakes:

• Forgetting to return false to backtrack
• Returning true too early
• Ignoring base case for solved board

5. Given a 9x9 Sudoku board with multiple empty cells, which approach best improves the efficiency of the backtracking solver?

hard

A. Use a heuristic to select the empty cell with the fewest possible valid numbers first

B. Try numbers 1 to 9 in order for each empty cell without any checks

C. Fill all empty cells with 1 initially and then backtrack

D. Randomly assign numbers to empty cells and check if solved

Solution

1. Step 1: Understand naive backtracking

   Trying numbers 1-9 in order for each cell is simple but slow for complex puzzles.

2. Step 2: Identify heuristic improvement

   Selecting the empty cell with fewest valid options (minimum remaining value heuristic) reduces branching and speeds solving.

3. Step 3: Evaluate other options

   Filling all with 1 or random assignment leads to many conflicts and inefficiency.

4. Final Answer:

   Use a heuristic to select the empty cell with the fewest possible valid numbers first -> Option A

5. Quick Check:

   Heuristic cell choice speeds backtracking [OK]

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

Common Mistakes:

• Trying numbers blindly without heuristics
• Filling cells with fixed number initially
• Random assignments causing many retries