Skip to main content

Solve Sudoku Puzzle

Sudoku is a popular puzzle game that involves filling a 9x9 grid with digits from 1 to 9, with each digit appearing only once in each row, column, and 3x3 sub-grid. The game starts with some of the cells already filled with numbers, and the player's goal is to fill in the rest of the grid using logic and deduction.

To solve a Sudoku puzzle, you need to follow a set of rules and strategies. First, look for any cells that have only one possible number and fill them in. Then, scan each row, column, and sub-grid to look for missing numbers and identify any cells where a particular number can only go in one place. Use the process of elimination to eliminate numbers from cells where they can't fit based on the other numbers in the row, column, or sub-grid.

The key to solving a Sudoku puzzle is to use logical reasoning to fill in the grid, rather than guessing. If you get stuck, try looking for pairs or triplets of numbers that can only fit in specific cells, or use the "pencil marks" technique to keep track of potential numbers for each cell.

Once you've filled in all the cells, double-check your work to make sure that every row, column, and sub-grid contains all nine digits exactly once. If you've made a mistake, the grid won't add up correctly, and you'll need to go back and correct your errors.

Overall, Sudoku is a challenging yet satisfying puzzle game that requires patience, attention to detail, and logical thinking to solve. With practice, you can improve your skills and solve even the most challenging puzzles with ease.

Code Solution

// C program
// Solve Sudoku Puzzle
#include <stdio.h>

#define N 9
//Check that given number are suitable to particular row and column or not
int is_vaild(int grid[N][N], int row, int col, int num)
{
	//Define loop controlling variable
	int i = 0;
	int j = 0;
	// Test case 1
	// Check that whether given number are exist in given row and column or not
	for (i = 0; i < N; ++i)
	{
		if (grid[row][i] == num || grid[i][col] == num)
		{
			//When given number already exists in given row and column
			return 0;
		}
	}
	//Test case 2
	//Check that given number are exist in 3x3 sub grid or not
	for (i = 0; i < 3; ++i)
	{
		for (j = 0; j < 3; ++j)
		{
			if (grid[(row - row % 3) + i][(col - col % 3) + j] == num)
			{
				//When subgrid contains element
				//Then it is not valid
				return 0;
			}
		}
	}
	//When number is valid
	return 1;
}
//Find the location of empty element in given grid
int new_empty_location(int grid[N][N])
{
	//Loop controlling variable
	int i = 0;
	int j = 0;
	for (i = 0; i < N; ++i)
	{
		for (j = 0; j < N; ++j)
		{
			if (grid[i][j] == 0)
			{
				//When empty location exist
				return (N * i) + j;
			}
		}
	}
	return -1;
}
//Recursive find solution of given grid
int sudoku(int grid[N][N])
{
	int location = new_empty_location(grid);
	if (location == -1)
	{
		//When sudoku is complete
		return 1;
	}
	// Define some auxiliary variables
	int row = 0;
	int col = 0;
	int num = -1;
	if (location != 0)
	{
		//Get current change element location
		//Get element row
		row = location / N;
		//Get element column
		col = location % N;
	}
	for (num = 1; num <= 9; ++num)
	{
		if (is_vaild(grid, row, col, num) == 1)
		{
			//Set this number of location [row][col] 
			grid[row][col] = num;
			if (sudoku(grid) == 1)
			{
				// When sudoku is solved 
				return 1;
			}
			//reset value
			grid[row][col] = 0;
		}
	}
	return 0;
}
//Display grid elements
void display(int grid[N][N])
{
	//Loop controlling variable
	int i = 0;
	int j = 0;
	for (i = 0; i < N; ++i)
	{
		for (j = 0; j < N; ++j)
		{
			printf("  %d", grid[i][j]);
		}
		printf("\n");
	}
}
int main()
{
	// Given sudoku problem here
	// N number of row and col
	int grid[N][N] = {
      {  9,  0,  1,  2,  3,  0,  8,  0,  0},
      {  0,  0,  0,  0,  9,  0,  2,  0,  0},
      {  7,  0,  2,  0,  8,  0,  0,  3,  0},
      {  0,  2,  0,  0,  0,  0,  7,  6,  0},
      {  6,  1,  4,  0,  0,  0,  0,  0,  0},
      {  0,  0,  0,  0,  2,  0,  0,  0,  0},
      {  2,  7,  5,  9,  4,  0,  0,  1,  0},
      {  0,  4,  0,  7,  0,  2,  9,  5,  8},
      {  0,  0,  6,  3,  0,  0,  0,  0,  0}
	};
	display(grid);
	int result = sudoku(grid);
	if (result == 1)
	{
		printf("\n  Output Result \n\n");
		display(grid);
	}
	else
	{
		//In case given input are not have solution
		printf("\n  No result \n");
	}
	return 0;
}

Output

  9  0  1  2  3  0  8  0  0
  0  0  0  0  9  0  2  0  0
  7  0  2  0  8  0  0  3  0
  0  2  0  0  0  0  7  6  0
  6  1  4  0  0  0  0  0  0
  0  0  0  0  2  0  0  0  0
  2  7  5  9  4  0  0  1  0
  0  4  0  7  0  2  9  5  8
  0  0  6  3  0  0  0  0  0

  Output Result

  9  5  1  2  3  7  8  4  6
  4  3  8  1  9  6  2  7  5
  7  6  2  4  8  5  1  3  9
  5  2  9  8  1  3  7  6  4
  6  1  4  5  7  9  3  8  2
  3  8  7  6  2  4  5  9  1
  2  7  5  9  4  8  6  1  3
  1  4  3  7  6  2  9  5  8
  8  9  6  3  5  1  4  2  7
/*
    Java Program
    Solve sudoku puzzle
*/
class SolveSudoku
{
	//Sudoku {N} grid size
	public int size;
	public SolveSudoku(int size)
	{
		//Assuming that given size are suitable to sudoku
		this.size = size;
	}
	//Check that given number are suitable to particular row and column or not
	public boolean is_vaild(int[][] grid, int row, int col, int num)
	{
		//Define loop controlling variable
		int i = 0;
		int j = 0;
		// Test case 1
		// Check that whether given number are exist in given row and column or not
		for (i = 0; i < this.size; ++i)
		{
			if (grid[row][i] == num || grid[i][col] == num)
			{
				//When given number already exists in given row and column
				return false;
			}
		}
		//Test case 2
		//Check that given number are exist in 3x3 sub grid or not
		for (i = 0; i < 3; ++i)
		{
			for (j = 0; j < 3; ++j)
			{
				if (grid[(row - row % 3) + i][(col - col % 3) + j] == num)
				{
					//When subgrid contains element
					//Then it is not valid
					return false;
				}
			}
		}
		//When number is valid
		return true;
	}
	//Find the location of empty element in given grid
	public int new_empty_location(int[][] grid)
	{
		//Loop controlling variable
		int i = 0;
		int j = 0;
		for (i = 0; i < this.size; ++i)
		{
			for (j = 0; j < this.size; ++j)
			{
				if (grid[i][j] == 0)
				{
					//When empty element exist
					//return it's location
					return (i *this.size) + j;
				}
			}
		}
		return -1;
	}
	//Recursive find solution of given grid
	public boolean sudoku(int[][] grid)
	{
		int location = new_empty_location(grid);
		if (location == -1)
		{
			//When sudoku is complete
			return true;
		}
		// Define some auxiliary variables
		int row = 0;
		int col = 0;
		int num = -1;
		if (location != 0)
		{
			//Get current change element location
			//Get element row
			row = location / this.size;
			//Get element column
			col = location % this.size;
		}
		for (num = 1; num <= 9; num++)
		{
			if (is_vaild(grid, row, col, num) == true)
			{
				//Set this number of location [row][col] 
				grid[row][col] = num;
				if (sudoku(grid) == true)
				{
					// When sudoku is solved 
					return true;
				}
				//reset value
				grid[row][col] = 0;
			}
		}
		return false;
	}
	//Display grid elements
	public void display(int[][] grid)
	{
		//Loop controlling variable
		int i = 0;
		int j = 0;
		for (i = 0; i < this.size; ++i)
		{
			for (j = 0; j < this.size; ++j)
			{
				System.out.print(" " + grid[i][j]);
			}
			System.out.print("\n");
		}
	}
	public static void main(String[] args)
	{
		int n = 9;
		SolveSudoku obj = new SolveSudoku(n);
		int[][] grid = {
          {  9,  0,  1,  2,  3,  0,  8,  0,  0},
          {  0,  0,  0,  0,  9,  0,  2,  0,  0},
          {  7,  0,  2,  0,  8,  0,  0,  3,  0},
          {  0,  2,  0,  0,  0,  0,  7,  6,  0},
          {  6,  1,  4,  0,  0,  0,  0,  0,  0},
          {  0,  0,  0,  0,  2,  0,  0,  0,  0},
          {  2,  7,  5,  9,  4,  0,  0,  1,  0},
          {  0,  4,  0,  7,  0,  2,  9,  5,  8},
          {  0,  0,  6,  3,  0,  0,  0,  0,  0}
		};
		obj.display(grid);
		if (obj.sudoku(grid))
		{
			System.out.print("\n Output Result \n\n");
			obj.display(grid);
		}
		else
		{
			//In case given input are not have solution
			System.out.print("\n No result \n");
			obj.display(grid);
		}
	}
}

Output

 9 0 1 2 3 0 8 0 0
 0 0 0 0 9 0 2 0 0
 7 0 2 0 8 0 0 3 0
 0 2 0 0 0 0 7 6 0
 6 1 4 0 0 0 0 0 0
 0 0 0 0 2 0 0 0 0
 2 7 5 9 4 0 0 1 0
 0 4 0 7 0 2 9 5 8
 0 0 6 3 0 0 0 0 0

 Output Result

 9 5 1 2 3 7 8 4 6
 4 3 8 1 9 6 2 7 5
 7 6 2 4 8 5 1 3 9
 5 2 9 8 1 3 7 6 4
 6 1 4 5 7 9 3 8 2
 3 8 7 6 2 4 5 9 1
 2 7 5 9 4 8 6 1 3
 1 4 3 7 6 2 9 5 8
 8 9 6 3 5 1 4 2 7
//Include header file
#include <iostream>
#define N  9
using namespace std;
/*
    C++ Program
    Solve sudoku puzzle
*/
class SolveSudoku
{
	public:
	//Sudoku {N} grid size
	int size;
	SolveSudoku(int size)
	{
		//Assuming that given size are suitable to sudoku
		this->size = size;
	}
	//Check that given number are suitable to particular row and column or not
	bool is_vaild(int grid[N][N], int row, int col, int num)
	{
		//Define loop controlling variable
		int i = 0;
		int j = 0;
		// Test case 1
		// Check that whether given number are exist in given row and column or not
		for (i = 0; i < this->size; ++i)
		{
			if (grid[row][i] == num || grid[i][col] == num)
			{
				//When given number already exists in given row and column
				return false;
			}
		}
		//Test case 2
		//Check that given number are exist in 3x3 sub grid or not
		for (i = 0; i < 3; ++i)
		{
			for (j = 0; j < 3; ++j)
			{
				if (grid[(row - row % 3) + i][(col - col % 3) + j] == num)
				{
					//When subgrid contains element
					//Then it is not valid
					return false;
				}
			}
		}
		//When number is valid
		return true;
	}
	//Find the location of empty element in given grid
	int new_empty_location(int grid[N][N])
	{
		//Loop controlling variable
		int i = 0;
		int j = 0;
		for (i = 0; i < this->size; ++i)
		{
			for (j = 0; j < this->size; ++j)
			{
				if (grid[i][j] == 0)
				{
					//When empty element exist
					//return it's location
					return (i * this->size) + j;
				}
			}
		}
		return -1;
	}
	//Recursive find solution of given grid
	bool sudoku(int grid[N][N])
	{
		int location = this->new_empty_location(grid);
		if (location == -1)
		{
			//When sudoku is complete
			return true;
		}
		// Define some auxiliary variables
		int row = 0;
		int col = 0;
		int num = -1;
		if (location != 0)
		{
			//Get current change element location
			//Get element row
			row = location / this->size;
			//Get element column
			col = location % this->size;
		}
		for (num = 1; num <= 9; num++)
		{
			if (this->is_vaild(grid, row, col, num) == true)
			{
				//Set this number of location [row][col] 
				grid[row][col] = num;
				if (this->sudoku(grid) == true)
				{
					// When sudoku is solved 
					return true;
				}
				//reset value
				grid[row][col] = 0;
			}
		}
		return false;
	}
	//Display grid elements
	void display(int grid[N][N])
	{
		//Loop controlling variable
		int i = 0;
		int j = 0;
		for (i = 0; i < this->size; ++i)
		{
			for (j = 0; j < this->size; ++j)
			{
				cout << "  " << grid[i][j];
			}
			cout << "\n";
		}
	}
};
int main()
{
	SolveSudoku obj = SolveSudoku(N);
	int grid[N][N] = {
		{
			9 , 0 , 1 , 2 , 3 , 0 , 8 , 0 , 0
		} , {
			0 , 0 , 0 , 0 , 9 , 0 , 2 , 0 , 0
		} , {
			7 , 0 , 2 , 0 , 8 , 0 , 0 , 3 , 0
		} , {
			0 , 2 , 0 , 0 , 0 , 0 , 7 , 6 , 0
		} , {
			6 , 1 , 4 , 0 , 0 , 0 , 0 , 0 , 0
		} , {
			0 , 0 , 0 , 0 , 2 , 0 , 0 , 0 , 0
		} , {
			2 , 7 , 5 , 9 , 4 , 0 , 0 , 1 , 0
		} , {
			0 , 4 , 0 , 7 , 0 , 2 , 9 , 5 , 8
		} , {
			0 , 0 , 6 , 3 , 0 , 0 , 0 , 0 , 0
		}
	};
	obj.display(grid);
	if (obj.sudoku(grid))
	{
		cout << "\n Output Result \n\n";
		obj.display(grid);
	}
	else
	{
		//In case given input are not have solution
		cout << "\n No result \n";
		obj.display(grid);
	}
	return 0;
}

Output

  9  0  1  2  3  0  8  0  0
  0  0  0  0  9  0  2  0  0
  7  0  2  0  8  0  0  3  0
  0  2  0  0  0  0  7  6  0
  6  1  4  0  0  0  0  0  0
  0  0  0  0  2  0  0  0  0
  2  7  5  9  4  0  0  1  0
  0  4  0  7  0  2  9  5  8
  0  0  6  3  0  0  0  0  0

 Output Result

  9  5  1  2  3  7  8  4  6
  4  3  8  1  9  6  2  7  5
  7  6  2  4  8  5  1  3  9
  5  2  9  8  1  3  7  6  4
  6  1  4  5  7  9  3  8  2
  3  8  7  6  2  4  5  9  1
  2  7  5  9  4  8  6  1  3
  1  4  3  7  6  2  9  5  8
  8  9  6  3  5  1  4  2  7
//Include namespace system
using System;
/*
    C# Program
    Solve sudoku puzzle
*/
class SolveSudoku
{
	//Sudoku {N} grid size
	public int size;
	public SolveSudoku(int size)
	{
		//Assuming that given size are suitable to sudoku
		this.size = size;
	}
	//Check that given number are suitable to particular row and column or not
	public Boolean is_vaild(int[,] grid, int row, int col, int num)
	{
		//Define loop controlling variable
		int i = 0;
		int j = 0;
		// Test case 1
		// Check that whether given number are exist in given row and column or not
		for (i = 0; i < this.size; ++i)
		{
			if (grid[row,i] == num || grid[i,col] == num)
			{
				//When given number already exists in given row and column
				return false;
			}
		}
		//Test case 2
		//Check that given number are exist in 3x3 sub grid or not
		for (i = 0; i < 3; ++i)
		{
			for (j = 0; j < 3; ++j)
			{
				if (grid[(row - row % 3) + i,(col - col % 3) + j] == num)
				{
					//When subgrid contains element
					//Then it is not valid
					return false;
				}
			}
		}
		//When number is valid
		return true;
	}
	//Find the location of empty element in given grid
	public int new_empty_location(int[,] grid)
	{
		//Loop controlling variable
		int i = 0;
		int j = 0;
		for (i = 0; i < this.size; ++i)
		{
			for (j = 0; j < this.size; ++j)
			{
				if (grid[i,j] == 0)
				{
					//When empty element exist
					//return it's location
					return (i * this.size) + j;
				}
			}
		}
		return -1;
	}
	//Recursive find solution of given grid
	public Boolean sudoku(int[,] grid)
	{
		int location = new_empty_location(grid);
		if (location == -1)
		{
			//When sudoku is complete
			return true;
		}
		// Define some auxiliary variables
		int row = 0;
		int col = 0;
		int num = -1;
		if (location != 0)
		{
			//Get current change element location
			//Get element row
			row = location / this.size;
			//Get element column
			col = location % this.size;
		}
		for (num = 1; num <= 9; num++)
		{
			if (is_vaild(grid, row, col, num) == true)
			{
				//Set this number of location [row,col] 
				grid[row,col] = num;
				if (sudoku(grid) == true)
				{
					// When sudoku is solved 
					return true;
				}
				//reset value
				grid[row,col] = 0;
			}
		}
		return false;
	}
	//Display grid elements
	public void display(int[,] grid)
	{
		//Loop controlling variable
		int i = 0;
		int j = 0;
		for (i = 0; i < this.size; ++i)
		{
			for (j = 0; j < this.size; ++j)
			{
				Console.Write("  " + grid[i,j]);
			}
			Console.Write("\n");
		}
	}
	public static void Main(String[] args)
	{
		int n = 9;
		SolveSudoku obj = new SolveSudoku(n);
		int[,] grid = {
			{
				9 , 0 , 1 , 2 , 3 , 0 , 8 , 0 , 0
			} , {
				0 , 0 , 0 , 0 , 9 , 0 , 2 , 0 , 0
			} , {
				7 , 0 , 2 , 0 , 8 , 0 , 0 , 3 , 0
			} , {
				0 , 2 , 0 , 0 , 0 , 0 , 7 , 6 , 0
			} , {
				6 , 1 , 4 , 0 , 0 , 0 , 0 , 0 , 0
			} , {
				0 , 0 , 0 , 0 , 2 , 0 , 0 , 0 , 0
			} , {
				2 , 7 , 5 , 9 , 4 , 0 , 0 , 1 , 0
			} , {
				0 , 4 , 0 , 7 , 0 , 2 , 9 , 5 , 8
			} , {
				0 , 0 , 6 , 3 , 0 , 0 , 0 , 0 , 0
			}
		};
		obj.display(grid);
		if (obj.sudoku(grid))
		{
			Console.Write("\n Output Result \n\n");
			obj.display(grid);
		}
		else
		{
			//In case given input are not have solution
			Console.Write("\n No result \n");
			obj.display(grid);
		}
	}
}

Output

  9  0  1  2  3  0  8  0  0
  0  0  0  0  9  0  2  0  0
  7  0  2  0  8  0  0  3  0
  0  2  0  0  0  0  7  6  0
  6  1  4  0  0  0  0  0  0
  0  0  0  0  2  0  0  0  0
  2  7  5  9  4  0  0  1  0
  0  4  0  7  0  2  9  5  8
  0  0  6  3  0  0  0  0  0

 Output Result

  9  5  1  2  3  7  8  4  6
  4  3  8  1  9  6  2  7  5
  7  6  2  4  8  5  1  3  9
  5  2  9  8  1  3  7  6  4
  6  1  4  5  7  9  3  8  2
  3  8  7  6  2  4  5  9  1
  2  7  5  9  4  8  6  1  3
  1  4  3  7  6  2  9  5  8
  8  9  6  3  5  1  4  2  7
<?php
/*
    Php Program
    Solve sudoku puzzle
*/
class SolveSudoku
{
	//Sudoku {N} grid size
	public $size;

	function __construct($size)
	{
		//Assuming that given size are suitable to sudoku
		$this->size = $size;
	}
	//Check that given number are suitable to particular row and column or not
	public	function is_vaild( & $grid, $row, $col, $num)
	{
		//Define loop controlling variable
		$i = 0;
		$j = 0;
		// Test case 1
		// Check that whether given number are exist in given row and column or not
		for ($i = 0; $i < $this->size; ++$i)
		{
			if ($grid[$row][$i] == $num || $grid[$i][$col] == $num)
			{
				//When given number already exists in given row and column
				return false;
			}
		}
		//Test case 2
		//Check that given number are exist in 3x3 sub grid or not
		for ($i = 0; $i < 3; ++$i)
		{
			for ($j = 0; $j < 3; ++$j)
			{
				if ($grid[($row - $row % 3) + $i][($col - $col % 3) + $j] == $num)
				{
					//When subgrid contains element
					//Then it is not valid
					return false;
				}
			}
		}
		//When number is valid
		return true;
	}
	//Find the location of empty element in given grid
	public	function new_empty_location( & $grid)
	{
		//Loop controlling variable
		$i = 0;
		$j = 0;
		for ($i = 0; $i < $this->size; ++$i)
		{
			for ($j = 0; $j < $this->size; ++$j)
			{
				if ($grid[$i][$j] == 0)
				{
					//When empty element exist
					//return it's location
					return ($i * $this->size) + $j;
				}
			}
		}
		return -1;
	}
	//Recursive find solution of given grid
	public	function sudoku( & $grid)
	{
		$location = $this->new_empty_location($grid);
		if ($location == -1)
		{
			//When sudoku is complete
			return true;
		}
		// Define some auxiliary variables
		$row = 0;
		$col = 0;
		$num = -1;
		if ($location != 0)
		{
			//Get current change element location
			//Get element row
			$row = intval($location / $this->size);
			//Get element column
			$col = $location % $this->size;
		}
		for ($num = 1; $num <= 9; $num++)
		{
			if ($this->is_vaild($grid, $row, $col, $num) == true)
			{
				//Set this number of location [row][col] 
				$grid[$row][$col] = $num;
				if ($this->sudoku($grid) == true)
				{
					// When sudoku is solved 
					return true;
				}
				//reset value
				$grid[$row][$col] = 0;
			}
		}
		return false;
	}
	//Display grid elements
	public	function display( & $grid)
	{
		//Loop controlling variable
		$i = 0;
		$j = 0;
		for ($i = 0; $i < $this->size; ++$i)
		{
			for ($j = 0; $j < $this->size; ++$j)
			{
				echo "  ". $grid[$i][$j];
			}
			echo "\n";
		}
	}
}

function main()
{
	$n = 9;
	$obj = new SolveSudoku($n);
	$grid = array(array(9, 0, 1, 2, 3, 0, 8, 0, 0), array(0, 0, 0, 0, 9, 0, 2, 0, 0), array(7, 0, 2, 0, 8, 0, 0, 3, 0), array(0, 2, 0, 0, 0, 0, 7, 6, 0), array(6, 1, 4, 0, 0, 0, 0, 0, 0), array(0, 0, 0, 0, 2, 0, 0, 0, 0), array(2, 7, 5, 9, 4, 0, 0, 1, 0), array(0, 4, 0, 7, 0, 2, 9, 5, 8), array(0, 0, 6, 3, 0, 0, 0, 0, 0));
	$obj->display($grid);
	if ($obj->sudoku($grid))
	{
		echo "\n Output Result \n\n";
		$obj->display($grid);
	}
	else
	{
		//In case given input are not have solution
		echo "\n No result \n";
		$obj->display($grid);
	}
}
main();

Output

  9  0  1  2  3  0  8  0  0
  0  0  0  0  9  0  2  0  0
  7  0  2  0  8  0  0  3  0
  0  2  0  0  0  0  7  6  0
  6  1  4  0  0  0  0  0  0
  0  0  0  0  2  0  0  0  0
  2  7  5  9  4  0  0  1  0
  0  4  0  7  0  2  9  5  8
  0  0  6  3  0  0  0  0  0

 Output Result

  9  5  1  2  3  7  8  4  6
  4  3  8  1  9  6  2  7  5
  7  6  2  4  8  5  1  3  9
  5  2  9  8  1  3  7  6  4
  6  1  4  5  7  9  3  8  2
  3  8  7  6  2  4  5  9  1
  2  7  5  9  4  8  6  1  3
  1  4  3  7  6  2  9  5  8
  8  9  6  3  5  1  4  2  7
/*
    Node Js Program
    Solve sudoku puzzle
*/
class SolveSudoku
{
	//Sudoku {N} grid size
	constructor(size)
	{
		//Assuming that given size are suitable to sudoku
		this.size = size;
	}
	//Check that given number are suitable to particular row and column or not
	is_vaild(grid, row, col, num)
	{
		//Define loop controlling variable
		var i = 0;
		var j = 0;
		// Test case 1
		// Check that whether given number are exist in given row and column or not
		for (i = 0; i < this.size; ++i)
		{
			if (grid[row][i] == num || grid[i][col] == num)
			{
				//When given number already exists in given row and column
				return false;
			}
		}
		//Test case 2
		//Check that given number are exist in 3x3 sub grid or not
		for (i = 0; i < 3; ++i)
		{
			for (j = 0; j < 3; ++j)
			{
				if (grid[(row - row % 3) + i][(col - col % 3) + j] == num)
				{
					//When subgrid contains element
					//Then it is not valid
					return false;
				}
			}
		}
		//When number is valid
		return true;
	}
	//Find the location of empty element in given grid
	new_empty_location(grid)
	{
		//Loop controlling variable
		var i = 0;
		var j = 0;
		for (i = 0; i < this.size; ++i)
		{
			for (j = 0; j < this.size; ++j)
			{
				if (grid[i][j] == 0)
				{
					//When empty element exist
					//return it's location
					return (i * this.size) + j;
				}
			}
		}
		return -1;
	}
	//Recursive find solution of given grid
	sudoku(grid)
	{
		var location = this.new_empty_location(grid);
		if (location == -1)
		{
			//When sudoku is complete
			return true;
		}
		// Define some auxiliary variables
		var row = 0;
		var col = 0;
		var num = -1;
		if (location != 0)
		{
			//Get current change element location
			//Get element row
			row = parseInt(location / this.size);
			//Get element column
			col = location % this.size;
		}
		for (num = 1; num <= 9; num++)
		{
			if (this.is_vaild(grid, row, col, num) == true)
			{
				//Set this number of location [row][col] 
				grid[row][col] = num;
				if (this.sudoku(grid) == true)
				{
					// When sudoku is solved 
					return true;
				}
				//reset value
				grid[row][col] = 0;
			}
		}
		return false;
	}
	//Display grid elements
	display(grid)
	{
		//Loop controlling variable
		var i = 0;
		var j = 0;
		for (i = 0; i < this.size; ++i)
		{
			for (j = 0; j < this.size; ++j)
			{
				process.stdout.write("  " + grid[i][j]);
			}
			process.stdout.write("\n");
		}
	}
}

function main()
{
	var n = 9;
	var obj = new SolveSudoku(n);
	var grid = [
		[9, 0, 1, 2, 3, 0, 8, 0, 0],
		[0, 0, 0, 0, 9, 0, 2, 0, 0],
		[7, 0, 2, 0, 8, 0, 0, 3, 0],
		[0, 2, 0, 0, 0, 0, 7, 6, 0],
		[6, 1, 4, 0, 0, 0, 0, 0, 0],
		[0, 0, 0, 0, 2, 0, 0, 0, 0],
		[2, 7, 5, 9, 4, 0, 0, 1, 0],
		[0, 4, 0, 7, 0, 2, 9, 5, 8],
		[0, 0, 6, 3, 0, 0, 0, 0, 0]
	];
	obj.display(grid);
	if (obj.sudoku(grid))
	{
		process.stdout.write("\n Output Result \n\n");
		obj.display(grid);
	}
	else
	{
		//In case given input are not have solution
		process.stdout.write("\n No result \n");
		obj.display(grid);
	}
}
main();

Output

  9  0  1  2  3  0  8  0  0
  0  0  0  0  9  0  2  0  0
  7  0  2  0  8  0  0  3  0
  0  2  0  0  0  0  7  6  0
  6  1  4  0  0  0  0  0  0
  0  0  0  0  2  0  0  0  0
  2  7  5  9  4  0  0  1  0
  0  4  0  7  0  2  9  5  8
  0  0  6  3  0  0  0  0  0

 Output Result

  9  5  1  2  3  7  8  4  6
  4  3  8  1  9  6  2  7  5
  7  6  2  4  8  5  1  3  9
  5  2  9  8  1  3  7  6  4
  6  1  4  5  7  9  3  8  2
  3  8  7  6  2  4  5  9  1
  2  7  5  9  4  8  6  1  3
  1  4  3  7  6  2  9  5  8
  8  9  6  3  5  1  4  2  7
#  Python 3 Program
#  Solve sudoku puzzle

class SolveSudoku :
	
	
	def __init__(self, size) :
		# Assuming that given size are suitable to sudoku
        # Sudoku N grid size
		self.size = size
	
	# Check that given number are suitable to particular row and column or not
	def is_vaild(self, grid, row, col, num) :
		# Define loop controlling variable
		i = 0
		j = 0
		#  Test case 1
		#  Check that whether given number are exist in given row and column or not
		while (i < self.size) :
			if (grid[row][i] == num or grid[i][col] == num) :
				# When given number already exists in given row and column
				return False
			
			i += 1
		
		# Test case 2
		# Check that given number are exist in 3x3 sub grid or not
		i = 0
		while (i < 3) :
			j = 0
			while (j < 3) :
				if (grid[(row - row % 3) + i][(col - col % 3) + j] == num) :
					# When subgrid contains element
					# Then it is not valid
					return False
				
				j += 1
			
			i += 1
		
		# When number is valid
		return True
	
	# Find the location of empty element in given grid
	def new_empty_location(self, grid) :
		# Loop controlling variable
		i = 0
		j = 0
		while (i < self.size) :
			j = 0
			while (j < self.size) :
				if (grid[i][j] == 0) :
					# When empty element exist
					# return it's location
					return (i * self.size) + j
				
				j += 1
			
			i += 1
		
		return -1
	
	# Recursive find solution of given grid
	def sudoku(self, grid) :
		location = self.new_empty_location(grid)
		if (location == -1) :
			# When sudoku is complete
			return True
		
		#  Define some auxiliary variables
		row = 0
		col = 0
		num = 1
		if (location != 0) :
			# Get current change element location
			# Get element row
			row = int(location / self.size)
			# Get element column
			col = location % self.size
		
		while (num <= 9) :
			if (self.is_vaild(grid, row, col, num) == True) :
				# Set this number of location [row][col] 
				grid[row][col] = num
				if (self.sudoku(grid) == True) :
					#  When sudoku is solved 
					return True
				
				# reset value
				grid[row][col] = 0
			
			num += 1
		
		return False
	
	# Display grid elements
	def display(self, grid) :
		# Loop controlling variable
		i = 0
		j = 0
		while (i < self.size) :
			j = 0
			while (j < self.size) :
				print("  ", grid[i][j], end = "")
				j += 1
			
			print("\n", end = "")
			i += 1
		
	

def main() :
	n = 9
	obj = SolveSudoku(n)
	grid = [
		[9, 0, 1, 2, 3, 0, 8, 0, 0],
		[0, 0, 0, 0, 9, 0, 2, 0, 0],
		[7, 0, 2, 0, 8, 0, 0, 3, 0],
		[0, 2, 0, 0, 0, 0, 7, 6, 0],
		[6, 1, 4, 0, 0, 0, 0, 0, 0],
		[0, 0, 0, 0, 2, 0, 0, 0, 0],
		[2, 7, 5, 9, 4, 0, 0, 1, 0],
		[0, 4, 0, 7, 0, 2, 9, 5, 8],
		[0, 0, 6, 3, 0, 0, 0, 0, 0]
	]
	obj.display(grid)
	if (obj.sudoku(grid)) :
		print("\n Output Result \n\n", end = "")
		obj.display(grid)
	else :
		# In case given input are not have solution
		print("\n No result \n", end = "")
		obj.display(grid)
	

if __name__ == "__main__": main()

Output

   9   0   1   2   3   0   8   0   0
   0   0   0   0   9   0   2   0   0
   7   0   2   0   8   0   0   3   0
   0   2   0   0   0   0   7   6   0
   6   1   4   0   0   0   0   0   0
   0   0   0   0   2   0   0   0   0
   2   7   5   9   4   0   0   1   0
   0   4   0   7   0   2   9   5   8
   0   0   6   3   0   0   0   0   0

 Output Result

   9   5   1   2   3   7   8   4   6
   4   3   8   1   9   6   2   7   5
   7   6   2   4   8   5   1   3   9
   5   2   9   8   1   3   7   6   4
   6   1   4   5   7   9   3   8   2
   3   8   7   6   2   4   5   9   1
   2   7   5   9   4   8   6   1   3
   1   4   3   7   6   2   9   5   8
   8   9   6   3   5   1   4   2   7
#  Ruby Program
#  Solve sudoku puzzle

class SolveSudoku 

	# Define the accessor and reader of class SolveSudoku  
	attr_reader :size
	attr_accessor :size


	# Sudoku Nend grid size
	
	def initialize(size)
	
		# Assuming that given size are suitable to sudoku
		self.size = size
	end
	# Check that given number are suitable to particular row and column or not
	def is_vaild(grid, row, col, num)
	
		# Define loop controlling variable
		i = 0
		j = 0
		#  Test case 1
		#  Check that whether given number are exist in given row and column or not
		while (i < self.size)
		
			if (grid[row][i] == num || grid[i][col] == num)
			
				# When given number already exists in given row and column
				return false
			end
			i += 1
		end
		# Test case 2
		# Check that given number are exist in 3x3 sub grid or not
		i = 0
		while (i < 3)
		
			j = 0
			while (j < 3)
			
				if (grid[(row - row % 3) + i][(col - col % 3) + j] == num)
				
					# When subgrid contains element
					# Then it is not valid
					return false
				end
				j += 1
			end
			i += 1
		end
		# When number is valid
		return true
	end
	# Find the location of empty element in given grid
	def new_empty_location(grid)
	
		# Loop controlling variable
		i = 0
		j = 0
		while (i < self.size)
		
			j = 0
			while (j < self.size)
			
				if (grid[i][j] == 0)
				
					# When empty element exist
					# return it's location
					return (i * self.size) + j
				end
				j += 1
			end
			i += 1
		end
		return -1
	end
	# Recursive find solution of given grid
	def sudoku(grid)
	
		location = self.new_empty_location(grid)
		if (location == -1)
		
			# When sudoku is complete
			return true
		end
		#  Define some auxiliary variables
		row = 0
		col = 0
		num = 1
		if (location != 0)
		
			# Get current change element location
			# Get element row
			row = location / self.size
			# Get element column
			col = location % self.size
		end
		while (num <= 9)
		
			if (self.is_vaild(grid, row, col, num) == true)
			
				# Set this number of location [row][col] 
				grid[row][col] = num
				if (self.sudoku(grid) == true)
				
					#  When sudoku is solved 
					return true
				end
				# reset value
				grid[row][col] = 0
			end
			num += 1
		end
		return false
	end
	# Display grid elements
	def display(grid)
	
		# Loop controlling variable
		i = 0
		j = 0
		while (i < self.size)
		
			j = 0
			while (j < self.size)
			
				print("  ", grid[i][j])
				j += 1
			end
			print("\n")
			i += 1
		end
	end
end
def main()

	n = 9
	obj = SolveSudoku.new(n)
	grid = [
		[9, 0, 1, 2, 3, 0, 8, 0, 0],
		[0, 0, 0, 0, 9, 0, 2, 0, 0],
		[7, 0, 2, 0, 8, 0, 0, 3, 0],
		[0, 2, 0, 0, 0, 0, 7, 6, 0],
		[6, 1, 4, 0, 0, 0, 0, 0, 0],
		[0, 0, 0, 0, 2, 0, 0, 0, 0],
		[2, 7, 5, 9, 4, 0, 0, 1, 0],
		[0, 4, 0, 7, 0, 2, 9, 5, 8],
		[0, 0, 6, 3, 0, 0, 0, 0, 0]
	]
	obj.display(grid)
	if (obj.sudoku(grid))
	
		print("\n Output Result \n\n")
		obj.display(grid)
	else
	
		# In case given input are not have solution
		print("\n No result \n")
		obj.display(grid)
	end
end
main()

Output

  9  0  1  2  3  0  8  0  0
  0  0  0  0  9  0  2  0  0
  7  0  2  0  8  0  0  3  0
  0  2  0  0  0  0  7  6  0
  6  1  4  0  0  0  0  0  0
  0  0  0  0  2  0  0  0  0
  2  7  5  9  4  0  0  1  0
  0  4  0  7  0  2  9  5  8
  0  0  6  3  0  0  0  0  0

 Output Result 

  9  5  1  2  3  7  8  4  6
  4  3  8  1  9  6  2  7  5
  7  6  2  4  8  5  1  3  9
  5  2  9  8  1  3  7  6  4
  6  1  4  5  7  9  3  8  2
  3  8  7  6  2  4  5  9  1
  2  7  5  9  4  8  6  1  3
  1  4  3  7  6  2  9  5  8
  8  9  6  3  5  1  4  2  7

/*
    Scala Program
    Solve sudoku puzzle
*/
class SolveSudoku(var size: Int)
{
	//Check that given number are suitable to particular row and column or not
	def is_vaild(grid: Array[Array[Int]], row: Int, col: Int, num: Int): Boolean = {
		//Define loop controlling variable
		var i: Int = 0;
		var j: Int = 0;
		// Test case 1
		// Check that whether given number are exist in given row and column or not
		while (i < this.size)
		{
			if (grid(row)(i) == num || grid(i)(col) == num)
			{
				//When given number already exists in given row and column
				return false;
			}
			i += 1;
		}
		//Test case 2
		//Check that given number are exist in 3x3 sub grid or not
		i = 0;
		while (i < 3)
		{
			j = 0;
			while (j < 3)
			{
				if (grid((row - row % 3) + i)((col - col % 3) + j) == num)
				{
					//When subgrid contains element
					//Then it is not valid
					return false;
				}
				j += 1;
			}
			i += 1;
		}
		//When number is valid
		return true;
	}
	//Find the location of empty element in given grid
	def new_empty_location(grid: Array[Array[Int]]): Int = {
		//Loop controlling variable
		var i: Int = 0;
		var j: Int = 0;
		while (i < this.size)
		{
			j = 0;
			while (j < this.size)
			{
				if (grid(i)(j) == 0)
				{
					//When empty element exist
					//return it's location
					return (i * this.size) + j;
				}
				j += 1;
			}
			i += 1;
		}
		return -1;
	}
	//Recursive find solution of given grid
	def sudoku(grid: Array[Array[Int]]): Boolean = {
		var location: Int = new_empty_location(grid);
		if (location == -1)
		{
			//When sudoku is complete
			return true;
		}
		// Define some auxiliary variables
		var row: Int = 0;
		var col: Int = 0;
		var num: Int = 1;
		if (location != 0)
		{
			//Get current change element location
			//Get element row
			row = (location / this.size).toInt;
			//Get element column
			col = location % this.size;
		}
		while (num <= 9)
		{
			if (is_vaild(grid, row, col, num) == true)
			{
				//Set this number of location [row][col] 
				grid(row)(col) = num;
				if (sudoku(grid) == true)
				{
					// When sudoku is solved 
					return true;
				}
				//reset value
				grid(row)(col) = 0;
			}
			num += 1;
		}
		return false;
	}
	//Display grid elements
	def display(grid: Array[Array[Int]]): Unit = {
		//Loop controlling variable
		var i: Int = 0;
		var j: Int = 0;
		while (i < this.size)
		{
			j = 0;
			while (j < this.size)
			{
				print("  " + grid(i)(j));
				j += 1;
			}
			print("\n");
			i += 1;
		}
	}
}
object Main
{
	def main(args: Array[String]): Unit = {
		var n: Int = 9;
		var obj: SolveSudoku = new SolveSudoku(n);
		var grid: Array[Array[Int]] = Array(Array(9, 0, 1, 2, 3, 0, 8, 0, 0), Array(0, 0, 0, 0, 9, 0, 2, 0, 0), Array(7, 0, 2, 0, 8, 0, 0, 3, 0), Array(0, 2, 0, 0, 0, 0, 7, 6, 0), Array(6, 1, 4, 0, 0, 0, 0, 0, 0), Array(0, 0, 0, 0, 2, 0, 0, 0, 0), Array(2, 7, 5, 9, 4, 0, 0, 1, 0), Array(0, 4, 0, 7, 0, 2, 9, 5, 8), Array(0, 0, 6, 3, 0, 0, 0, 0, 0));
		obj.display(grid);
		if (obj.sudoku(grid))
		{
			print("\n Output Result \n\n");
			obj.display(grid);
		}
		else
		{
			//In case given input are not have solution
			print("\n No result \n");
			obj.display(grid);
		}
	}
}

Output

  9  0  1  2  3  0  8  0  0
  0  0  0  0  9  0  2  0  0
  7  0  2  0  8  0  0  3  0
  0  2  0  0  0  0  7  6  0
  6  1  4  0  0  0  0  0  0
  0  0  0  0  2  0  0  0  0
  2  7  5  9  4  0  0  1  0
  0  4  0  7  0  2  9  5  8
  0  0  6  3  0  0  0  0  0

 Output Result

  9  5  1  2  3  7  8  4  6
  4  3  8  1  9  6  2  7  5
  7  6  2  4  8  5  1  3  9
  5  2  9  8  1  3  7  6  4
  6  1  4  5  7  9  3  8  2
  3  8  7  6  2  4  5  9  1
  2  7  5  9  4  8  6  1  3
  1  4  3  7  6  2  9  5  8
  8  9  6  3  5  1  4  2  7
/*
    Swift Program
    Solve sudoku puzzle
*/
class SolveSudoku
{
	//Sudoku {N} grid size
	var size: Int;
	init(_ size: Int)
	{
		//Assuming that given size are suitable to sudoku
		self.size = size;
	}
	//Check that given number are suitable to particular row and column or not
	func is_vaild(_ grid: [
		[Int]
	], _ row: Int, _ col: Int, _ num: Int) -> Bool
	{
		//Define loop controlling variable
		var i: Int = 0;
		var j: Int = 0;
		// Test case 1
		// Check that whether given number are exist in given row and column or not
		while (i < self.size)
		{
			if (grid[row][i] == num || grid[i][col] == num)
			{
				//When given number already exists in given row and column
				return false;
			}
			i += 1;
		}
		//Test case 2
		//Check that given number are exist in 3x3 sub grid or not
		i = 0;
		while (i < 3)
		{
			j = 0;
			while (j < 3)
			{
				if (grid[(row - row % 3) + i][(col - col % 3) + j] == num)
				{
					//When subgrid contains element
					//Then it is not valid
					return false;
				}
				j += 1;
			}
			i += 1;
		}
		//When number is valid
		return true;
	}
	//Find the location of empty element in given grid
	func new_empty_location(_ grid: [
		[Int]
	]) -> Int
	{
		//Loop controlling variable
		var i: Int = 0;
		var j: Int = 0;
		while (i < self.size)
		{
			j = 0;
			while (j < self.size)
			{
				if (grid[i][j] == 0)
				{
					//When empty element exist
					//return it"s location
					return (i * self.size) + j;
				}
				j += 1;
			}
			i += 1;
		}
		return -1;
	}
	//Recursive find solution of given grid
	func sudoku(_ grid: inout[[Int]]) -> Bool
	{
		let location: Int = self.new_empty_location(grid);
		if (location == -1)
		{
			//When sudoku is complete
			return true;
		}
		// Define some auxiliary variables
		var row: Int = 0;
		var col: Int = 0;
		var num: Int = 1;
		if (location != 0)
		{
			//Get current change element location
			//Get element row
			row = location / self.size;
			//Get element column
			col = location % self.size;
		}
		while (num <= 9)
		{
			if (self.is_vaild(grid, row, col, num) == true)
			{
				//Set this number of location [row][col] 
				grid[row][col] = num;
				if (self.sudoku(&grid) == true)
				{
					// When sudoku is solved 
					return true;
				}
				//reset value
				grid[row][col] = 0;
			}
			num += 1;
		}
		return false;
	}
	//Display grid elements
	func display(_ grid: [
		[Int]
	])
	{
		//Loop controlling variable
		var i: Int = 0;
		var j: Int = 0;
		while (i < self.size)
		{
			j = 0;
			while (j < self.size)
			{
				print("  ", grid[i][j], terminator: "");
				j += 1;
			}
			print("\n", terminator: "");
			i += 1;
		}
	}
}
func main()
{
	let n: Int = 9;
	let obj: SolveSudoku = SolveSudoku(n);
	var grid: [
		[Int]
	] = [
		[9, 0, 1, 2, 3, 0, 8, 0, 0],
		[0, 0, 0, 0, 9, 0, 2, 0, 0],
		[7, 0, 2, 0, 8, 0, 0, 3, 0],
		[0, 2, 0, 0, 0, 0, 7, 6, 0],
		[6, 1, 4, 0, 0, 0, 0, 0, 0],
		[0, 0, 0, 0, 2, 0, 0, 0, 0],
		[2, 7, 5, 9, 4, 0, 0, 1, 0],
		[0, 4, 0, 7, 0, 2, 9, 5, 8],
		[0, 0, 6, 3, 0, 0, 0, 0, 0]
	];
	obj.display(grid);
	if (obj.sudoku(&grid))
	{
		print("\n Output Result \n\n", terminator: "");
		obj.display(grid);
	}
	else
	{
		//In case given input are not have solution
		print("\n No result \n", terminator: "");
		obj.display(grid);
	}
}
main();

Output

   9   0   1   2   3   0   8   0   0
   0   0   0   0   9   0   2   0   0
   7   0   2   0   8   0   0   3   0
   0   2   0   0   0   0   7   6   0
   6   1   4   0   0   0   0   0   0
   0   0   0   0   2   0   0   0   0
   2   7   5   9   4   0   0   1   0
   0   4   0   7   0   2   9   5   8
   0   0   6   3   0   0   0   0   0

 Output Result

   9   5   1   2   3   7   8   4   6
   4   3   8   1   9   6   2   7   5
   7   6   2   4   8   5   1   3   9
   5   2   9   8   1   3   7   6   4
   6   1   4   5   7   9   3   8   2
   3   8   7   6   2   4   5   9   1
   2   7   5   9   4   8   6   1   3
   1   4   3   7   6   2   9   5   8
   8   9   6   3   5   1   4   2   7
Last updated on by Kalkicode




Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.

New Comment