Sudoku Puzzle Generator and Solver

21CSC204J SUBJECT - DESIGN & ANALYSIS OF ALGORITHMS

A MINI-PROJECT REPORT

Submitted By

Vikash P [RA2211042020009]
Srivarshan S [RA2211042020015]
Ramakrishnan S G [RA2211042020024]

in partial fulfillment for the award of the degree

of

BACHELOR OF TECHNOLOGY
in

COMPUTER SCIENCE AND ENGINEERING

of

FACULTY OF ENGINEERING AND TECHNOLOGY

SRM INSTITUTE OF SCIENCE AND TECHNOLOGY

RAMAPURAM CAMPUS, CHENNAI-600089
MAY 2024
 SRM INSTITUTE OF SCIENCE AND TECHNOLOGY
(Deemed to be University U/S 3 of UGC Act, 1956)

BONAFIDE CERTIFICATE

Certified that this mini project report titled “Sudoku Puzzle Generator and
Solver” is the bonafide work of “VIKASH P(RA2211042020009),
SRIVARSHAN S (RA2211042020015), RAMAKRISHNAN S G
(RA2211042020024)”

SIGNATURE
Ms.Aishwarya.K M.E

Assistant Professor,

Computer Science and Engineering,

SRM Institute of Science and
Technology, Ramapuram Campus,
Chennai.
 SRM INSTITUTE OF SCIENCE AND TECHNOLOGY

RAMAPURAM, CHENNAI -600089

DECLARATION

We hereby declare that the entire work contained in this mini project report titled “Sudoku
Puzzle Generator and Solver” has been carried out by VIKASH P [RA2211042020009],
SRIVARSHAN S [RA2211042020015], RAMAKRISHNAN S G [RA2211042020024]
at
SRM Institute of Science and Technology, Ramapuram Campus, Chennai - 600089,

Place: Chennai

Date:
 ABSTRACT

This abstract presents the design and implementation of a Sudoku generator

and solver program. Sudoku is a popular puzzle game that requires filling a
9x9 grid with digits so that each column, each row, and each of the nine 3x3
subgrids contains all of the digits from 1 to 9.

The Sudoku generator module utilizes backtracking algorithms combined

with heuristic techniques to produce puzzles of varying difficulties. It starts
with an empty grid and fills it step by step, ensuring that each number is
placed logically while maintaining uniqueness and symmetry. The generator
allows users to specify the level of difficulty they desire, ranging from easy to
hard and generates puzzles accordingly.

The solver component employs sophisticated algorithms to find solutions to

Sudoku puzzles. It utilizes constraint satisfaction techniques, logical
deduction, and backtracking to systematically explore possible solutions until
a valid one is found. The solver is capable of handling puzzles of different
complexities and provides an efficient and accurate solution.

The software offers a user-friendly interface where users can generate new
puzzles for solving, or let the software solve existing puzzles. It includes
features such as user score, and puzzle difficulty levels.

Overall, the Sudoku generator and solver software provides an engaging and
challenging experience for Sudoku enthusiasts, offering endless puzzles to
solve and enjoy while showcasing the effectiveness of various algorithms in
generating and solving Sudoku puzzles.
 TABLE OF CONTENTS

Chapter No. Title Page No.

ABSTRACT iv

LIST OF FIGURES xi

INTRODUCTION 1

1 1.1 Overview 1
1.2 Problem Statement 2
1.3 Aim of the Project 3
1.4 Scope of the Project 4
SOFTWARE AND HARDWARE 5

SPECIFICATIONS
2 2.1 Hardware Requirements 5
2.2 Software Requirements 5
PROJECT DESCRIPTION 6

3.1 Introduction 6
3 3.2 Algorithm Used 7
3.3 Advantages of Algorithm used 9
3.4 Architecture Diagram 10
3.5 Explanation of the Project 11
3.6 Output Results 12
3.7 Conclusion 13
APPENDIX 14
Source Code 14
 LIST OF FIGURES
Fig No. Figure Name Page No.
4.1 Architecture Diagram 10
4.2 Output Screen 12
 CHAPTER 1

INTRODUCTION

1.1 Overview

Sudoku, a Japanese puzzle craze that has swept the globe, is a game of logic and numbers
that challenges players of all skill levels. Its allure lies in its simple rules yet complex
solutions, making it a beloved pastime for enthusiasts seeking mental stimulation and
strategic engagement. With its grid of cells waiting to be filled with digits, Sudoku presents
an ideal playground for computational algorithms to flex their muscles in both generation
and solving.

In this digital age, where automation permeates various facets of our lives, the
development of automated Sudoku generators and solvers not only enhances the
accessibility and convenience of the game but also showcases the prowess of
computational techniques in tackling intricate logical puzzles. This project delves into the
realm of Sudoku generation and solving, presenting a comprehensive exploration of
algorithms and methodologies employed in crafting puzzles and finding their solutions.

The primary objective of this work is twofold: first, to develop an automated Sudoku
generator capable of producing puzzles of varying difficulty levels, ensuring their
uniqueness and solvability; and second, to devise an efficient solver algorithm capable of
accurately solving Sudoku puzzles within reasonable timeframes. Through the
amalgamation of heuristic strategies, constraint satisfaction techniques, and advanced
search algorithms, we aim to create a robust computational framework that caters to both
puzzle generation and solving aspects of Sudoku.

By harnessing the computational power afforded by modern programming languages such

as Python, we embark on a journey to explore the intricate nuances of Sudoku puzzles,
unravelling the underlying patterns and structures that govern their creation and solution.
Through rigorous testing and evaluation, we seek to validate the efficacy of our automated
system, showcasing its ability to generate captivating puzzles and solve them with
precision.

1
1.2 Problem Statement

The problem statement for a Sudoku generator and solver revolves around the need for an
automated system capable of both creating and solving Sudoku puzzles. Specifically, it
involves addressing the challenges of efficiently generating unique and solvable Sudoku
puzzles of varying difficulty levels and accurately solving existing puzzles within
reasonable timeframes.

The key points of the problem statement include:

a) Creating an algorithm to automatically generate Sudoku puzzles that are unique and
solvable through logic alone.
b) Ensuring the generated puzzles cater to different skill levels by adjusting their
difficulty levels.
c) Developing strategies to efficiently create puzzles while maintaining their quality
and uniqueness.
d) Designing an algorithm to accurately and efficiently solve Sudoku puzzles.
e) Implementing techniques such as constraint propagation and logical deduction to
systematically find solutions.
f) Ensuring the solver can handle puzzles of varying complexities and provide correct
solutions within reasonable timeframes.
g) Providing functionalities for users to generate new puzzles, solve existing ones, and
adjust difficulty levels seamlessly.

By addressing these challenges, the objective is to develop a comprehensive computational

solution that enhances the accessibility and enjoyment of Sudoku puzzles for enthusiasts
while showcasing the capabilities of computational algorithms in solving complex
logical challenges.

2
1.3 Aim of the Project

The primary objective of the Sudoku generator and solver system is to provide a
comprehensive computational solution for the creation and solution of Sudoku puzzles.

This objective encompasses several key aspects:

Automated Puzzle Generation: The system aims to automatically generate Sudoku puzzles
of varying difficulty levels. These puzzles should be unique, ensuring that there is only one
solution, and solvable by logic alone, without requiring guessing or trial and error.

Diverse Challenge Levels: The generator component seeks to produce puzzles that cater to
a wide range of players, from beginners to seasoned enthusiasts. By adjusting the
complexity of generated puzzles, the system aims to provide engaging gameplay
experiences for users of different skill levels.

Efficient Puzzle Solving: The solver component aims to accurately and efficiently solve
Sudoku puzzles, regardless of their complexity. It should employ intelligent algorithms and
logical deduction techniques to systematically search for and identify optimal solutions
within reasonable timeframes.

Reliability and Performance: Both the generator and solver components strive to exhibit
reliability and high performance. The system should consistently generate unique and
solvable puzzles, while the solver should reliably find correct solutions for a diverse set of
Sudoku grids, demonstrating its effectiveness and accuracy.

Usability and Accessibility: The system aims to be user-friendly and accessible to a wide
audience. It should provide intuitive interfaces for generating and solving puzzles, allowing
users to interact with the system effortlessly and enjoyably.

Overall, the objective of the Sudoku generator and solver system is to offer a robust and
versatile computational tool for Sudoku enthusiasts, enhancing their puzzle-solving
experience and showcasing the capabilities of computational algorithms in tackling
complex logical challenges.

3
1.4 Scope of the Project

The scope of the Sudoku generator and solver project encompasses the development,
implementation, and evaluation of an automated system for generating and solving Sudoku
puzzles.

The project includes the following key aspects:

a) Generator Development: Designing and implementing algorithms for automated

Sudoku puzzle generation. Incorporating heuristic strategies and constraint
satisfaction techniques to ensure the uniqueness and solvability of generated
puzzles. Creating functionality to generate puzzles of varying difficulty levels to
cater to different skill levels of players.
b) Solver Development: Designing and implementing algorithms for automated
Sudoku puzzle solving. Utilizing advanced search algorithms, constraint
propagation, and logical deduction techniques to efficiently find solutions to
Sudoku puzzles. Developing functionality to solve puzzles of varying complexities,
ensuring accurate and timely solutions.
c) System Implementation: Implementing the generator and solver components in a
programming language such as Python. Creating user-friendly interfaces for
interacting with the system, including options for generating new puzzles, solving
existing puzzles, and adjusting puzzle difficulty levels.

Thus, the scope of the project is focused on creating a functional and reliable Sudoku
generator and solver system that can serve as a valuable tool for puzzle enthusiasts,
showcasing the capabilities of computational algorithms in solving complex logical
puzzles.

CHAPTER 2
4
 SOFTWARE AND HARDWARE SPECIFICATIONS

2.1 Hardware Requirements

Processor (CPU):

Any modern processor capable of running Python efficiently should suffice. The game's
computational requirements are minimal.

Memory (RAM):

A minimum of 2GB RAM is recommended for smooth execution of the game. More RAM
may be beneficial if running other applications simultaneously.

2.2 Software Requirements

Operating System:

a) The Sudoku game can run on various operating systems that support Python,
including: Windows, macOS (OS X), Linux distributions.
b) Python Interpreter: Python 3.x (where x is 6 or later) should be installed on your
system. The game was developed using Python 3.6 or higher.
c) Required Python Libraries:

random: This is a built-in module used for generating random numbers and
shuffling sequences.

copy: Another built-in module used for creating deep copies of objects.

d) Integrated Development Environment (IDE) or Text Editor:

You can use any text editor (e.g., Visual Studio Code, Sublime Text, Atom)
or Python IDE (e.g., PyCharm, IDLE) to edit and run the Python code.

CHAPTER 3
5
 PROJECT DESCRIPTION

3.1 Introduction

Sudoku, a popular Japanese puzzle game embraced worldwide, challenges players with its
logical rules and numerical grids, providing mental stimulation and strategic enjoyment for
all levels of expertise. Its simplicity in rules belies the complexity of its solutions, making
it a favourite pastime for those seeking engaging puzzles.

In today's digital era, where automation plays a significant role, the development of
automated Sudoku generators and solvers not only increases accessibility and convenience
but also demonstrates the power of computational methods in tackling intricate puzzles.
This project focuses on Sudoku puzzle generation and solving, exploring various
algorithms and methodologies used in crafting puzzles and finding their solutions.

The main goals of this project are two-fold: first, to create an automated Sudoku generator
capable of producing puzzles of different difficulty levels, ensuring uniqueness and
solvability; and second, to devise an efficient solver algorithm capable of solving Sudoku
puzzles accurately within reasonable timeframes. By combining heuristic strategies,
constraint satisfaction techniques, and advanced search algorithms, we aim to build a
strong computational framework that addresses both puzzle generation and solving aspects
of Sudoku.

Utilizing the computational capabilities of modern programming languages like Python, we

delve into the complexities of Sudoku puzzles, uncovering the underlying patterns and
structures governing their creation and solution. Through thorough testing and evaluation,
we aim to validate the effectiveness of our automated system, showcasing its ability to
generate engaging puzzles and solve them with precision.

6
3.2 Algorithm Used

Sudoku, a globally cherished puzzle game, has become a playground for computational
algorithms, enabling automated generation and solving. The puzzle's appeal lies in its
simple rules yet complex solutions, offering enthusiasts mental stimulation and strategic
engagement. In the digital age, automated Sudoku generators and solvers not only enhance
accessibility but also demonstrate the prowess of computational techniques in tackling
intricate puzzles.

1. Sudoku Solver using Backtracking:

The backtracking algorithm for solving Sudoku involves recursively attempting to place
numbers (1-9) in empty cells while adhering to Sudoku rules—no duplicate numbers in
rows, columns, or 3x3 subgrids. If a number placement violates rules, the algorithm
backtracks, trying a different number until a valid solution is found. Optimization
strategies include starting with cells having fewer options, employing constraint
propagation techniques, and using heuristics to enhance efficiency.

2. Sudoku Generator using Backtracking:

To generate Sudoku puzzles, start with an empty grid and solve it using backtracking.
Randomly remove filled cells from the solved grid while ensuring solvability and
uniqueness. Verify puzzle uniqueness and adjust the difficulty by controlling the number
of cells removed. Optimization techniques involve applying symmetry constraints and
implementing unique solution checks during generation.

3. Sudoku Solver using Constraint Satisfaction:

In constraint satisfaction-based solving, each cell represents a variable with a domain

(possible values 1-9). Constraints ensure no duplicate numbers in rows, columns, or
subgrids. Techniques like forward checking and maintaining arc consistency reduce
variable domains, aiding search efficiency. Depth-first search with backtracking explores
the solution space, applying heuristic variables and value selection for optimization.

7
4. Sudoku Solver using Recursion:

This recursive solver iteratively fills empty cells by trying possible values (1-9) and
verifying rule compliance. If valid, the algorithm recursively solves the next empty cell.
Backtracking occurs if a solution path leads to an invalid state. Optimization involves
heuristic cell and value selection, constraint propagation, and pruning techniques to
enhance efficiency.

5. Sudoku Generator using Recursion:

The recursive generator starts with an empty grid and randomly fills cells, ensuring rule
compliance. If a value is valid, the generator recurses to fill the next cell until the grid is
complete. Difficulty control involves adjusting backtracking steps. Optimization includes
symmetry breaking to avoid redundant solutions and ensuring unique puzzle generation.

6. Randomization in Sudoku Generator and Solver:

Randomization techniques are employed in both puzzle generation and solving to introduce
variation and enhance efficiency. These techniques include random cell and value
selection, shuffling orders, and applying symmetry transformations. Randomization can
influence difficulty levels and aid in escaping local optima during the search.

In summary, Sudoku puzzle generation and solving are rich areas for algorithmic
exploration, leveraging backtracking, constraint satisfaction, recursion, and randomization
to craft and solve puzzles efficiently while embracing the intricacies of logical constraints
and computational techniques.

8
3.3 Advantages of Algorithm used

Here are some advantages of implementing a Sudoku generator and solver:

1. Efficiency:

By leveraging efficient algorithms and optimization techniques from DAA, the Sudoku
generator and solver can perform complex operations such as constraint satisfaction and
backtracking efficiently. DAA provides a framework for analyzing the time and space
complexity of algorithms, ensuring that the generator and solver can handle large Sudoku
puzzles with minimal computational resources.

2. Scalability:

Algorithms designed using DAA principles are often scalable, allowing the generator and
solver to handle Sudoku puzzles of varying sizes and complexities. Whether it's a standard
9x9 Sudoku puzzle or a larger variant with different grid sizes, the generator and solver can
adapt to the task at hand.

3. Correctness:

DAA emphasizes rigorous analysis and correctness proofs of algorithms, ensuring that the
Sudoku generator produces valid and solvable puzzles while the solver accurately finds
solutions. Through careful design and testing, potential errors and edge cases are identified
and addressed, resulting in reliable functionality.

4. Flexibility:

DAA provides a wide range of algorithmic techniques and approaches, allowing

developers to experiment with different strategies for Sudoku generation and solving.
Developers can customize the generator and solver to incorporate specific features or
optimizations tailored to different use cases or user preferences.

5. Optimization:

DAA encourages the exploration of optimization techniques such as constraint

propagation, pruning, and heuristic selection, which can significantly improve the
performance of the generator and solver. By fine-tuning algorithms and data structures
based on empirical analysis and profiling, the Sudoku generator and solver can achieve
optimal performance.

9
3.4 Architecture Diagram

Figure 4.1: Architecture Diagram

10
3.5 Explanation of the Project

The workflow of the Sudoku Solver project can be detailed through a series of steps
starting with user interaction and progressing through puzzle generation, solving, and
validation. Initially, the program prompts the user to choose a difficulty level for the
Sudoku puzzle, which determines the number of initial clues provided in the puzzle grid.
Once the difficulty is selected, the program generates a Sudoku puzzle by first filling the
diagonal 3x3 grids with random numbers to ensure initial uniqueness within these
subgrids.

The puzzle generation process then utilizes a backtracking algorithm to fully solve the
board, guaranteeing a valid and complete solution. Subsequently, a subset of numbers is
removed from the solved board to create the puzzle grid, ensuring the resulting puzzle has
a unique solution. The generated puzzle is presented to the user in a text-based format,
with empty cells represented by dots or zeros, prompting the user to start solving by
inputting numbers into the empty cells based on Sudoku rules.

Upon completing the puzzle or requesting a solution check, the program utilizes the
backtracking algorithm again to verify the correctness of the user's solution. Finally, the
program allows users to continue solving puzzles or generate new puzzles based on their
preference, with a focus on modularity and readability in the underlying code structure for
maintainability and extensibility. This detailed workflow encapsulates the user journey and
the intricate steps involved in generating, solving, and validating Sudoku puzzles within
the Sudoku Solver project.

11
3.6 Output Results

The output and results for a Sudoku generator and solver implemented would typically
include the following:

a) Sudoku Generator Output:

Generated Sudoku puzzles of varying difficulty levels. The output could be in the
form of a 9x9 grid representing the Sudoku puzzle, with some cells filled in as
clues and others left empty.

b) Sudoku Solver Output:

Solutions to Sudoku puzzles are provided as a 9x9 grid, with each cell filled in with
the correct value. If the solver cannot find a solution for a given puzzle.

Figure 4.2: Output Screen

12
3.7 Conclusion

In conclusion, the development of an automated Sudoku generator and solver system

represents a significant advancement in the realm of recreational puzzle solving. Through
the integration of computational algorithms and heuristic techniques, this project has
successfully tackled the challenges of puzzle generation and solution, offering a
comprehensive solution for Sudoku enthusiasts.
The automated Sudoku generator component excels in crafting puzzles of varying
difficulty levels, ensuring their uniqueness and solvability. By leveraging constraint
satisfaction techniques and heuristic strategies, the generator produces engaging puzzles
that cater to players of all skill levels. Whether beginners seeking a gentle introduction to
the game or seasoned experts craving a formidable challenge, the generator delivers
puzzles that captivate and entertain.
Conversely, the Sudoku solver component demonstrates remarkable efficiency and
accuracy in solving puzzles of varying complexities. By employing advanced search
algorithms, constraint propagation, and logical deduction techniques, the solver navigates
the puzzle space with precision, swiftly identifying optimal solutions within reasonable
timeframes. Whether faced with straightforward grids or intricate puzzles, the solver rises
to the challenge, reliably providing correct solutions with commendable speed.
The seamless integration of the generator and solver components into a user-friendly
system further enhances the project's appeal. With intuitive interfaces and robust
functionality, users can effortlessly generate new puzzles, solve existing ones, and adjust
difficulty levels to suit their preferences. The system's reliability and performance are
underscored by thorough testing and evaluation, affirming its effectiveness in delivering a
rewarding puzzle-solving experience.
In summary, the Sudoku generator and solver system presented herein exemplify the
synergy between human ingenuity and computational prowess. By harnessing the power of
algorithms, this project not only enriches the experience of Sudoku enthusiasts but also
showcases the potential of technology to enhance recreational activities and deepen our
understanding of complex logical challenges.

13
 APPENDIX

Source Code

import random
import copy

def print_board(board):
horizontal_line = "+-------+-------+------+"
print(horizontal_line)
for i in range(9):
row_string = "| "
for j in range(9):
if board[i][j] == 0:
row_string += ". "
else:
row_string += str(board[i][j]) + " "
if j % 3 == 2:
row_string += "| "
print(row_string)
if i % 3 == 2:
print(horizontal_line)

def is_valid(board, row, col, num):

"""Check if placing 'num' at board[row][col] is a valid move."""
# Check row and column
for i in range(9):
if board[row][i] == num or board[i][col] == num:
return False

# Check 3x3 grid

start_row, start_col = 3 * (row // 3), 3 * (col // 3)

14
 for i in range(start_row, start_row + 3):
for j in range(start_col, start_col + 3):
if board[i][j] == num:
return False

return True

def solve_sudoku(board):
"""Use backtracking to solve the Sudoku puzzle."""
empty_cell = find_empty(board)
if not empty_cell:
return True # Puzzle solved

row, col = empty_cell

for num in range(1, 10):
if is_valid(board, row, col, num):
board[row][col] = num
if solve_sudoku(board):
return True
board[row][col] = 0 # Backtrack

return False

def find_empty(board):
"""Find the first empty cell (represented by 0) in the Sudoku board."""
for i in range(9):
for j in range(9):
if board[i][j] == 0:
return (i, j)
return None

def generate_sudoku():
"""Generate a Sudoku puzzle with a unique solution."""

15
 board = [[0] * 9 for _ in range(9)]

# Fill the diagonal 3x3 grids with shuffled numbers

for i in range(0, 9, 3):
numbers = shuffle_numbers()
for j in range(3):
board[i + j][i + j] = numbers[j]

# Solve the board to get a complete solution

solve_sudoku(board)

# Shuffle the board to create a unique puzzle

shuffled_board = shuffle_board(board)

# Create a puzzle by removing numbers while ensuring a unique solution

num_clues = random.randint(30, 40)
cells = [(i, j) for i in range(9) for j in range(9)]
random.shuffle(cells)
for (i, j) in cells:
if num_clues > 0 and shuffled_board[i][j] != 0:
temp = shuffled_board[i][j]
shuffled_board[i][j] = 0
# Check if the puzzle has a unique solution
temp_board = copy.deepcopy(shuffled_board)
if not solve_sudoku(temp_board):
shuffled_board[i][j] = temp # Restore the value
else:
num_clues -= 1

return shuffled_board

def shuffle_numbers():
"""Generate a random permutation of numbers 1-9."""

16
 numbers = list(range(1, 10))
random.shuffle(numbers)
return numbers

def shuffle_board(board):
"""Shuffle rows, columns, and numbers within the Sudoku board."""
# Shuffle rows within each 3x3 grid
for _ in range(3):
random.shuffle(board)

# Transpose the board to shuffle columns

board = list(map(list, zip(*board)))
for _ in range(3):
random.shuffle(board)

# Transpose back to restore the original orientation

board = list(map(list, zip(*board)))
return board

def main():
print("Welcome to Unique Sudoku Challenge!")
player_name = input("Enter your name: ")
print(f"Hello, {player_name}! Let's solve some unique Sudoku puzzles.")

score = 0
while True:
print("\nChoose difficulty level:")
print("1. Easy")
print("2. Medium")
print("3. Hard")
print("4. Quit")

choice = input("Enter your choice (1-4): ")

17
 if choice == "4":
print(f"Thank you for playing, {player_name}! Your final score is {score}.")
break

if choice in ["1", "2", "3"]:

sudoku_board = generate_sudoku()

print("Generated Sudoku Puzzle:")

print_board(sudoku_board)

solve_choice = input("Do you want to see the solution? (yes/no): ").lower()

if solve_choice == "yes":
solved_board = copy.deepcopy(sudoku_board)
solve_sudoku(solved_board)
print("Sudoku Solution:")
print_board(solved_board)

# Calculate score based on difficulty

if choice == "1":
score += 10
elif choice == "2":
score += 20
elif choice == "3":
score += 30

print(f"Your current score: {score}")

else:
print("Invalid choice. Please choose a valid option.")

if name == " main ":

main()

18