# 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``````

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