Sudoku Algorithms Explained

Published on January 6, 2026

2 min read

Interactive Demo

Explore how Sudoku algorithms work step by step:

Step 1: The Empty Grid

Sudoku is played on a 9x9 grid divided into nine 3x3 boxes. Each cell will contain a number from 1 to 9.

The 9x9 grid is divided into nine 3x3 boxes. Every cell will contain a number from 1 to 9.

The Three Constraints

Every valid Sudoku must satisfy:

Row: Each row contains 1-9 exactly once
Column: Each column contains 1-9 exactly once
Box: Each 3×3 box contains 1-9 exactly once

Core Algorithms

Constraint Validation

Check if placing a number is valid:

const isValid = (grid: Grid, row: number, col: number, num: number): boolean => {
  // Check row
  if (grid[row].some(cell => cell.value === num)) return false;

  // Check column
  if (grid.some(r => r[col].value === num)) return false;

  // Check 3x3 box
  const boxRow = Math.floor(row / 3) * 3;
  const boxCol = Math.floor(col / 3) * 3;
  for (let r = boxRow; r < boxRow + 3; r++) {
    for (let c = boxCol; c < boxCol + 3; c++) {
      if (grid[r][c].value === num) return false;
    }
  }

  return true;
};

Backtracking Solver

The core solving algorithm - try each number, backtrack on failure:

const solve = (grid: Grid): boolean => {
  const empty = findEmptyCell(grid);
  if (!empty) return true; // Solved!

  const { row, col } = empty;

  for (let num = 1; num <= 9; num++) {
    if (isValid(grid, row, col, num)) {
      grid[row][col].value = num;

      if (solve(grid)) return true;

      grid[row][col].value = null; // Backtrack
    }
  }

  return false;
};

Puzzle Generation

Generate a complete solution using randomized backtracking
Remove cells while ensuring unique solution remains

const generatePuzzle = (cellsToRemove: number): Grid => {
  const grid = createEmptyGrid();
  fillWithRandomSolution(grid);

  const positions = shuffle(getAllPositions());
  let removed = 0;

  for (const { row, col } of positions) {
    if (removed >= cellsToRemove) break;

    const backup = grid[row][col].value;
    grid[row][col].value = null;

    if (!hasUniqueSolution(grid)) {
      grid[row][col].value = backup; // Restore - removing creates ambiguity
    } else {
      removed++;
    }
  }

  return grid;
};

Candidate Calculation

Find possible numbers for a cell by eliminating used values:

const getCandidates = (grid: Grid, row: number, col: number): number[] => {
  const used = new Set<number>();

  // Collect from row, column, and box
  grid[row].forEach(c => c.value && used.add(c.value));
  grid.forEach(r => r[col].value && used.add(r[col].value));

  // Check 3x3 box
  const boxRow = Math.floor(row / 3) * 3;
  const boxCol = Math.floor(col / 3) * 3;
  for (let r = boxRow; r < boxRow + 3; r++) {
    for (let c = boxCol; c < boxCol + 3; c++) {
      if (grid[r][c].value) used.add(grid[r][c].value);
    }
  }

  return [1,2,3,4,5,6,7,8,9].filter(n => !used.has(n));
};