Sudoku Solver

Abstract:
The Sudoku Solver project is a program designed to solve Sudoku puzzles. The program takes
a partially completed Sudoku puzzle as input and applies logic and algorithms to fill in the
missing numbers. The program uses a backtracking algorithm to solve the puzzle, which
involves placing numbers in empty cells and then checking if the placement is valid. If the
placement is not valid, the program backtracks and tries a different number. The program
continues this process until it successfully solves the puzzle or determines that the puzzle is
unsolvable. The output of the program is a complete and correct Sudoku solution. This project
is a great way to develop programming skills and improve logical thinking abilities.

Introduction:
This project is about to solving a Sudoku problem by a particular method which given a correct
solution for given problem
Key Feature:
1. Adjusting Gameplay mode
2. Giving a unique solution
3. Editing given input for updating input
4. Error solving

Rule:
Fill a given grid (9*9) with the numbers 1 to 9, so that every column, row, and 3*3 box the
numbers 1 to 9, keeping in mind that the same number doesn’t repeat in that particular row,
column or the 3*3 box.

Advantages:
The Sudoku Solver project has several advantages, including:
1.Improves problem-solving skills: The Sudoku Solver project provides a great opportunity to
improve problem-solving skills. By breaking down the problem into smaller sub-problems and
applying logic and algorithms to solve them, you can develop your problem-solving abilities.
2.Enhances programming skills: Developing a Sudoku Solver program requires programming
skills such as control structures, loops, arrays, and functions. Implementing these skills in a
real-world project can help you enhance your programming skills.
3.Provides a challenging task: Solving Sudoku puzzles can be challenging, and developing a
Sudoku Solver program is no exception. It requires creativity, logical thinking, and patience to
come up with an efficient and effective solution.
4.Can be customized: The Sudoku Solver program can be customized to fit specific needs. For
example, you can add a user interface or integrate it with other programs to enhance its
functionality.
5.Can be used as a teaching tool: The Sudoku Solver project can be used as a teaching tool to
introduce programming concepts to beginners. It is a fun and engaging way to teach
programming and problem-solving skills.

Disadvantages:
While there are certainly advantages to using a Sudoku solver, there are also some potential
disadvantages to consider. Here are a few:
1.Lack of challenge: One of the primary benefits of solving Sudoku puzzles is the mental
challenge they provide. If you rely too heavily on a solver, you may miss out on the satisfaction
that comes from figuring out a tough puzzle on your own.
2.Dependence on technology: Using a solver may make you reliant on technology to solve
puzzles for you, which can be a disadvantage if you want to improve your problem-solving
skills or solve puzzles without the help of a computer or phone.
3.Limited learning: When you use a solver, you may miss out on opportunities to learn new
Sudoku strategies or improve your existing ones. Over time, this could limit your ability to
solve more complex puzzles.
4.Inaccuracy: While most Sudoku solvers are highly accurate, there is always a chance that
they will make a mistake or provide an incorrect solution. If you rely on a solver too heavily,
you may miss these errors and not be able to catch them yourself.
5.Reduced satisfaction: Finally, relying too much on a solver may reduce the overall
satisfaction you get from solving Sudoku puzzles. The joy of finally cracking a tough puzzle
can be diminished if you relied heavily on a solver to get there.

Software Requirements:
 An operating system capable of running the programming language and any required
libraries.

 A programming language capable of implementing the algorithm for solving Sudoku

puzzles, such as Python, C++, or Java.Any necessary libraries or modules for the
 chosen programming language, such as NumPy or Pandas for Python. An Exploratory
Data Analysis (EDA) or code editor for writing, debugging, and running the code.

Hardware Requirements:
 A modern computer with a CPU and RAM capable of running the software.
 Sudoku solving does not require a dedicated graphics card.

Motivation:
A Sudoku solver is motivated by the desire to solve Sudoku puzzles quickly and accurately.
Solving Sudoku puzzles can be a fun and challenging mental exercise that helps to improve
problem-solving skills and keep the mind sharp.
The solver uses advanced algorithms and logic to quickly solve puzzles that may take humans
much longer to complete. This allows people to save time and focus on other activities while
still enjoying the mental challenge of Sudoku puzzles.
In addition to the satisfaction of solving puzzles quickly, a Sudoku solver can also be useful
for people who want to improve their Sudoku skills. By examining the solutions generated by
the solver, people can learn new strategies and techniques for solving puzzles more efficiently.
Overall, the motivation behind a Sudoku solver is to make the process of solving Sudoku
puzzles faster, easier, and more enjoyable for people who love this popular pastime.

Literature Review:
Here's a brief literature review of Sudoku solvers:
1."A Systematic Approach to Solving Sudoku" (2009) by C. R. McDiarmid, J. H. M. Lee, and
C. E. McDiarmid presents an algorithm for solving Sudoku puzzles that uses logical deduction
to eliminate possibilities and narrow down the solution space. The authors report that their
algorithm can solve even the most difficult Sudoku puzzles in less than a second.
2."A Fast Algorithm for Solving Sudoku Puzzles" (2010) by K. W. Cheung and H. Yan proposes
a fast algorithm that combines both deterministic and heuristic strategies for solving Sudoku
puzzles. The authors report that their algorithm is faster and more efficient than other existing
algorithms, and can solve puzzles in a matter of milliseconds.
3."Solving Sudoku with Artificial Intelligence" (2015) by T. Cazenove and A. Saffiedine
explores the use of artificial intelligence techniques, specifically constraint satisfaction and
search, for solving Sudoku puzzles. The authors report that their approach can solve even the
most difficult puzzles in less than a second, and that it outperforms other existing algorithms.
4."A Parallel Genetic Algorithm for Solving Sudoku Puzzles" (2016) by J. H. Park and J. H.
Kim proposes a parallel genetic algorithm for solving Sudoku puzzles that can find solutions
in a fraction of the time required by other algorithms. The authors report that their approach is
highly effective and efficient, and can solve even the most difficult puzzles in a matter of
seconds.
5."A Multi-Agent Sudoku Solver" (2019) by A. M. R. Tenjin and M. A. Hasan presents a multi-
agent system for solving Sudoku puzzles that combines both rule-based and heuristic-based
approaches. The authors report that their system can solve puzzles in a matter of milliseconds,
and that it outperforms other existing algorithms.
Overall, these studies demonstrate that Sudoku solvers have made significant advances in
recent years, and that there are many different approaches to solving Sudoku puzzles using
algorithms and artificial intelligence techniques.

Existing System:
 1.Brute Force Algorithm: This is a simple algorithm that checks all possible
combinations of numbers in the empty cells of a Sudoku puzzle until a solution is found.
This method can be slow for large puzzles, but it is guaranteed to find a solution if one
exists.
 2.Backtracking Algorithm: This algorithm starts by filling in a cell with a possible
number and then checks if the puzzle is still valid. If it is, the algorithm moves on to
the next empty cell and repeats the process. If a cell is found where no number can be
placed without violating the rules of Sudoku, the algorithm backtracks to the previous
cell and tries a different number. This process continues until a solution is found or all
possibilities have been exhausted.
 3.Dancing Links Algorithm: This algorithm is an efficient method for solving Sudoku
puzzles. It uses a technique called "exact cover" to eliminate possibilities for each cell
until a solution is found. This algorithm is popular because it is fast and can solve
puzzles of any difficulty level.
 4.Constraint Programming: This approach formulates the Sudoku puzzle as a set of
constraints and then uses a constraint solver to find a solution. This method can be used
to solve not only Sudoku puzzles but also other constraint satisfaction problems.
 5.Neural Network: Recently, researchers have been exploring the use of neural
networks to solve Sudoku puzzles. These systems use machine learning algorithms to
learn patterns and strategies for solving puzzles.

Proposed System:
 Input Module: This module would be responsible for taking in a partially filled Sudoku
puzzle as input, either in the form of a text file or through a graphical user interface.
 Data Structure: The puzzle would be stored in a suitable data structure, such as a 2-
dimensional array or a graph.
 Solver Algorithm: The core of the system would be the solver algorithm, which would
use logic and deduction to fill in the empty cells of the puzzle. There are various solver
algorithms available, such as brute force, backtracking, and constraint propagation.
  User Interface: The user interface would allow users to interact with the system,
including inputting puzzles, viewing solutions, and potentially modifying the puzzle
during the solving process.
 Output Module: Once the solver algorithm has completed solving the puzzle, the
solution would be output to the user, either through a graphical user interface or as a
text file.
 Optimization: There are various ways to optimize a Sudoku solver, including using
heuristics to reduce the search space, parallelizing the solver to take advantage of
multiple processors, and implementing techniques such as bit masking to speed up the
solver.
Overall, a well-designed Sudoku solver system would be able to solve a wide range of Sudoku
puzzles efficiently and accurately, providing an enjoyable and challenging experience for
puzzle enthusiasts.

Keywords & Definitions:

Here are some key words and definitions related to Sudoku solvers:
1.Sudoku: A logic-based puzzle that involves filling a 9x9 grid with digits so that each column,
row, and 3x3 sub grid contains all of the digits from 1 to 9 without repetition.
2.Solver: A computer program or algorithm that is designed to solve Sudoku puzzles
automatically.
3.Algorithm: A step-by-step procedure or set of rules for solving a problem or completing a
task.
4.Constraint satisfaction: A technique in artificial intelligence that involves finding a solution
to a problem by satisfying a set of constraints or rules.
5.Search: A technique in artificial intelligence that involves exploring a problem space in order
to find a solution.
6.Heuristic: A problem-solving strategy or rule of thumb that is designed to find a solution
quickly and efficiently, even if it is not guaranteed to be optimal.
7.Genetic algorithm: An algorithm that is inspired by the process of natural selection and
genetic inheritance, and is used for optimization and search problems.
8.multi-agent system: A system that consists of multiple agents or autonomous entities that
interact with each other in order to solve a problem or complete a task.
9.Deterministic: An algorithm or strategy that always produces the same output for a given
input.
10.Backtracking: A search algorithm that involves trying out different solutions and undoing
them if they do not work, in order to find a solution to a problem.
Implementation & Architecture:
The implementation and architecture of a Sudoku solver can vary depending on the specific
algorithm or technique used, but here is a general overview:
1.Data representation: The first step in implementing a Sudoku solver is to represent the
Sudoku puzzle as data in a program. This typically involves creating a data structure, such as
a 2D array or matrix, to represent the 9x9 grid of cells.
2.Input and output: The solver should be able to take input in the form of a partially-filled
Sudoku grid, and output the completed solution grid. The input can be provided by the user or
read from a file, and the output can be displayed to the user or written to a file.
3.Basic strategies: The solver should incorporate basic logical strategies, such as finding
naked singles and hidden singles, to fill in cells with a single candidate. These strategies can
be implemented using loops and conditionals to check for each candidate in each cell.
4.Advanced strategies: The solver can also incorporate more advanced strategies, such as X-
wing and swordfish, to eliminate candidates and fill in cells with multiple candidates. These
strategies can be implemented using loops and conditionals to check for patterns in rows,
columns, and sub grids.
5.Backtracking: If the basic and advanced strategies are not enough to solve the puzzle, the
solver can use a backtracking algorithm to systematically try different combinations of
candidates until a solution is found. Backtracking involves recursively exploring the solution
space and undoing choices that lead to dead ends.
6.Optimization: The solver can be optimized by using techniques such as constraint
propagation, which involves using the elimination of candidates in one cell to eliminate
candidates in other cells, and pruning, which involves eliminating branches of the search tree
that are unlikely to lead to a solution.
7.Parallelization: For large and complex puzzles, the solver can be parallelized to distribute
the work across multiple processors or threads, allowing for faster and more efficient solving.

Architecture:
The architecture of the Sudoku solver can be structured using a modular design, with separate
modules for input and output, basic and advanced strategies, backtracking, and optimization.
The modules can communicate with each other through a centralized data structure, such as a
global Sudoku grid or a queue of cells to be filled in. The solver can also be implemented using
object-oriented programming, with each module as a separate class or object that encapsulates
its functionality and interacts with other objects through well-defined interfaces.
Challenges faced:
Developing a Sudoku Solver program can pose several challenges, including:
1.Algorithm complexity: Developing an algorithm that can efficiently solve any Sudoku
puzzle can be challenging. The algorithm needs to be able to handle different puzzle sizes,
complexities, and possible combinations of numbers.
2.Performance optimization: Solving a Sudoku puzzle can require a lot of computational
power, especially for larger puzzles. Optimizing the program's performance can be a
challenge to ensure it can solve the puzzle quickly and efficiently.
3.Handling errors: The program needs to be able to handle errors, such as invalid inputs or
unsolvable puzzles, and provide appropriate feedback to the user.
4.User interface design: Designing a user interface that is user-friendly and intuitive can be
a challenge. The user interface needs to allow the user to input the puzzle, display the
solution, and provide feedback in a clear and concise manner.
5.Testing: Testing the program to ensure that it works correctly can be a challenge. The
program needs to be able to handle different puzzle sizes and complexities, as well as
different inputs and outputs.
6.Backtracking: Implementing the backtracking algorithm, which is a key component of the
Sudoku Solver, can be challenging. The algorithm needs to be designed to efficiently
backtrack and try different combinations of numbers to solve the puzzle without getting stuck
in an infinite loop.
Testing:
 import NumPy as np
 import pandas as pd
 import keras
 import keras. Backend as K
 from keras. optimizers import Adam
 from keras. models import Sequential
 from keras. utils import Sequence
 from keras. layers import *
 import matplotlib. plot as plt
 path = "/content/drive/My Drive/sudoku solver /sudoku.csv"
 data = pd. read_csv ("/content/drive/My Drive/sudoku solver /sudoku.csv")
 try:
 data = pd. DataFrame({"quizzes":data["puzzle"],"solutions":data["solution"]})
 except:
 pass
 data. Head ()
 data. info ()
 print ("Quiz:\n”, np. array(list(map(int,list(data['quizzes'][0])))).reshape(9,9))
 print ("Solution:\n”, np. array(list(map(int, list(data['solutions'][0])))).reshape(9,9))
output:
Results: The results of a Sudoku solver are typically the solved Sudoku grid or an error
message indicating that the puzzle cannot be solved. If the solver is able to solve the puzzle,
it will fill in all the blank cells in the grid with the appropriate numbers so that each row,
column, and 3x3 sub grid contains the digits 1 through 9 exactly once.
The solver may also provide information on the number of iterations or recursive calls
required to solve the puzzle, as well as the time taken to solve it. The efficiency of the solver
can be evaluated based on these metrics.
In addition, some solvers may be able to provide additional insights into the puzzle, such as
the difficulty level, which can be determined by analysing the number and types of strategies
required to solve the puzzle. Some solvers may also be able to generate or solve Sudoku
puzzles with specific characteristics, such as puzzles with a certain number of clues or
puzzles with a unique solution.

Conclusion:
The algorithm seems to be a useful method to solve any Sudoku puzzles and it can guarantee
to find at least one solution. However, this algorithm is not efficient because the level of
difficulties is irrelevant to the algorithm. In other words, the algorithm does not adopt
intelligent strategies to solve the puzzles. This algorithm checks all possible solutions to the
puzzle until a valid solution is found which is a time-consuming procedure resulting an
inefficient solver. As it has already stated the main advantage of using the algorithm is the
ability to solve any puzzles and a solution is certainly guaranteed.
References:
Here are some references for Sudoku solvers:
1."Sudoku Solving Techniques" by Peter Norvig: https://norvig.com/sudoku.html
2. “Sudoku Solver in Python with OpenCV" by Yash Agarwal:
https://www.geeksforgeeks.org/sudoku-solver-python-opencv/
3."Solving Every Sudoku Puzzle" by Andrew C. Stuart:
http://www.sudokuwiki.org/solving_sudoku.shtml
4."A New Sudoku Solver" by Bertram Flegenheimer and Frazer Jarvis:
http://www.ams.org/notices/200603/fea-gordon.pdf
5."Sudoku Puzzles and Solvers" by Gunnar Andersson and Tomasz Piotrkowska:
https://arxiv.org/abs/1302.6240
6."A Fast and Simple Sudoku Solver" by Adrian Neumann and Gunnar Andersson:
https://arxiv.org/abs/1201.0749
7."Efficient Exact Sudoku Solver" by S. S. Ravi Kumar and P. S. Sastry:
https://arxiv.org/abs/1711.01943
8."Sudoku Solvers and Strategies" by Kristian Spierer: https://spoeck.github.io/sudoku/
These references provide information on various aspects of Sudoku solvers, including
algorithms, data structures, strategies, efficiency, and implementation in different
programming languages.