TRIBHUVAN UNIVERSITY

FACULTY OF HUMANITIES AND SOCIAL SCIENCE

A Project Report On
Sudoku Generator and Solver using Back-tracking Algorithm

Submitted to
Department of Computer Application
National College of Computer Studies

In partial fulfillment of the requirements for Bachelor Degree in Computer Application

Submitted By:
Rameshwor Shrestha
Salin Manandhar

Under the Supervision of

Yuba Raj Devkota

October 2024
 Tribhuwan University

Faculty of Humanities and Social Sciences

National College of Computer Studies

Supervisor’s Recommendation
I hereby recommend that this project prepared under my supervision by Rameshwor
Shrestha and Salin Manandhar entitled “Sudoku Generator and Solver using
Backtracking Algorithm" in partial fulfillment of the requirements for the degree of
Bachelor of Computer Application is recommended for the final evaluation.

………………………………………..

SIGNATURE
Yuba Raj Devkota
SUPERVISOR
Faculty Member
Department of Computer Application National
College of Computer Studies

i
i
 Tribhuwan University
Faculty of Humanities and Social Sciences
National College of Computer Studies

LETTER OF APPROVAL

This is to certify that this project prepared by Rameshwor Shrestha and Salin Manandhar
entitled “Sudoku Generator and Solver using Backtracking Algorithm " in partial
fulfillment of the requirements for the degree of Bachelor in Computer Application has
been evaluated. In our opinion it is satisfactory in the scope and quality as a project for
the required degree.
Signature of Supervisor Signature of HOD/ Coordinator

Yuba Raj Devkota Rajan Poudel

Faculty Member Faculty Member
Department of Computer Application Department of Computer Application
National College of Computer Studies National College of Computer Studies
Paknajol, Kathmandu Paknajol, Kathmandu
SIGNATURE of External Examiner
SIGNATURE of Internal Examiner

iii
 ABSTRACT
This project presents the development of a comprehensive Sudoku Solver and Generator
application utilizing the Backtracking algorithm. The system offers two primary
functionalities: solving Sudoku puzzles and generating new ones at varying levels of
difficulty, including easy, medium, hard, and expert. The Backtracking algorithm ensures
an efficient and accurate solution to any valid Sudoku puzzle, guaranteeing consistency
and correctness in puzzle-solving. The application also integrates user authentication with
secure login and registration features, allowing users to create accounts, track their
progress, and securely save their game data. A dynamic leaderboard feature ranks players
based on performance metrics such as puzzle-solving time, difficulty level, and overall
scores, fostering a competitive environment. The project is designed with an interactive
and user-friendly interface, utilizing Java Swing for a visually appealing and accessible
experience for both casual players and Sudoku enthusiasts. Emphasizing security and user
engagement, the project incorporates robust authentication protocols and real-time
leaderboard updates, aiming to deliver an engaging, competitive, and educational
experience for users. This Sudoku Solver and Generator serves as both a learning tool and
a platform for enhancing logical thinking and problem-solving skills.

Keywords: Sudoku, Backtracking Algorithm, User Authentication, Puzzle Difficulty,

Hinting, Leaderboard, Solver.

i
v
 ACKNOWLEDGEMENT
We would like to extend our heartfelt gratitude to our supervisor, Mr. Yuba Raj Devkota,
for his invaluable guidance, continuous monitoring, and unwavering motivation
throughout all phases of this project. His expertise, constructive feedback, and insightful
suggestions were instrumental in shaping the direction and success of this endeavor. We
deeply appreciate his patience, support, and the inspiration he provided, which helped us
overcome various challenges and achieve our goals. We also wish to express our sincere
appreciation to all other supervisors, professors, and mentors who offered their time,
knowledge, and encouragement. Their collective support and advice were crucial in
refining our approach and enhancing the quality of our work. Additionally, we are
grateful to our friends, peers, and family members for their constant encouragement,
moral support, and willingness to assist whenever needed. This project would not have
been possible without the collaborative efforts and contributions of everyone involved,
and we are truly thankful for their role in making it a success.

Rameshwor Shrestha

Salin Manandhar

Table of Content
ABSTRACT.......................................................................................................................iv

v
ACKNOWLEDGEMENT...................................................................................................v

Table of Content.................................................................................................................vi

List Of Abbreviation........................................................................................................viii

List of Figures....................................................................................................................ix

List of Tables.......................................................................................................................x

Chapter 1: Introduction.......................................................................................................1

1.1 Introduction...............................................................................................................1

1.2 Problem Statement....................................................................................................2

1.3 Objectives..................................................................................................................2

1.4 Scope and Limitation.................................................................................................2

1.5 Development Methodology.......................................................................................3

1.6 Report Organization..................................................................................................3

Chapter 2: Background Study and Literature Review.........................................................4

2.1 Background Study.....................................................................................................4

2.2 Literature Review......................................................................................................5

2.2.1 Review of Similar Projects.................................................................................5

2.2.2 Backtracking Algorithm.....................................................................................5

2.2.3 Other Algorithms................................................................................................7

Chapter 3: System Analysis and Design.............................................................................9

3.1 System Analysis........................................................................................................9

3.1.1 Requirement Analysis......................................................................................10

3.1.2 Feasibility Study...............................................................................................12

3.1.3 Object Modelling: Object and Class Diagram.................................................13

3.1.4 Dynamic Modelling: State and Sequence Diagram.........................................15

3.1.5 Process Modelling: Activity Diagram..............................................................17

3.2 System Design.........................................................................................................18

3.2.1 Refinement of Classes and Object....................................................................18

v
i
 3.2.2 Component Diagram........................................................................................20

3.2.3 Deployment Diagram.......................................................................................21

3.3 Algorithm Details....................................................................................................22

Chapter 4: Implementation and Testing............................................................................24

4.1 Implementation........................................................................................................24

4.1.1 Tools Used........................................................................................................24

4.1.2 Implementation Details of modules.................................................................25

4.2 Testing.....................................................................................................................33

4.2.1 Unit Testing......................................................................................................33

4.2.2 System Testing of Sudoku Generator and Solver............................................38

Chapter 5: Conclusion and Future Recommendation........................................................43

5.1 Conclusion...............................................................................................................43

5.2 Lesson Learnt / Outcome........................................................................................43

5.3 Future Recommendation.........................................................................................43

List Of Abbreviation
ID Identification
UI User Interface
MySQL My Structured Query Language
SDLC System Development Life Cycle
SQL Structured Query Language

vi
i
 List of Figures
Figure 3.1: Waterfall Model.................................................................................................
9
Figure 3.2: Usecase Diagram of Sudoku Generator and Solver ........................................
11
Figure 3.3: Object Diagram of Sudoku Generator and Solver...........................................
13
Figure 3.4: Class Diagram of Sudoku Generator and Solver.............................................
14
Figure 3.5: State Diagram of Sudoku Generator and Solver .............................................
15
Figure 3.6: Sequence Diagram of Sudoku Generator and Solver ......................................
16
Figure 3.7: Activity Diagram of Sudoku Generator and Solver ........................................
17

v
iii
Figure 3.8: Refinement Class diagram of Sudoku Generator and Solver ..........................
18
Figure 3.9: Refinement Object Diagram of Sudoku Generator and Solver .......................
19
Figure 3.10: Component Diagram of Sudoku Generator and Solver.................................
20
Figure 3.11: Deployment Diagram of Sudoku Generator and Solver ...............................
21
Figure 4.1: Leaderboard MySQL Table of the Sudoku Generator and Solver ..................
25
Figure 4.2: User MySQL Table of the Sudoku Generator and Solver...............................
25
Figure 4.3: Main Menu of Sudoku Generator and Solver .................................................
25
Figure 4.4: Login of Sudoku Generator and Solver...........................................................
26
Figure 4.5: Registration of Sudoku Generator and Solver.................................................
26
Figure 4.6: Sudoku Player of Sudoku Generator and Solver .............................................
27
Figure 4.7: Sudoku Solver of Sudoku Generator and Solver.............................................
27
Figure 4.8: Leaderboard of Sudoku Generator and Solver ................................................
28
Figure 4.9: First Code of SudokuSolver class in Sudoku Game........................................
28
Figure 4.10: Second Code of SudokuSolver class in Sudoku Game .................................
29
Figure 4.11: First Code of SudokuGenerator class in Sudoku Game ................................
30
Figure 4.12: Second Code of SudokuGenerator class in Sudoku Game............................
31

ix
 List of Tables
Table 4.1: Unit Testing of Registration in Sudoku Generator and Solver .........................
34
Table 4.2: Unit Testing of Login in Sudoku Generator and Solver ...................................
35
Table 4.3: Unit Testing of ability to play game in Sudoku Generator and Solver ............
36
Table 4.4: Unit Testing of Leaderboard in Sudoku Generator and Solver ........................
37
Table 4.5: System Testing for the Sudoku Generator and Solver (User Side) ..................
38
Table 4.6: System Testing for the Sudoku Generator and Solver (Admin Side)...............
42

x
 Chapter 1: Introduction
1.1 Introduction
Sudoku is a popular logic-based puzzle that challenges players to fill a 9x9 grid with
numbers in such a way that every row, column, and 3x3 sub-grid contains all digits from 1
to 9 without repetition. Solving Sudoku requires careful analysis, logic, and sometimes
trial-and-error. A Sudoku generator is a tool that creates new puzzles at varying levels of
difficulty, while a solver algorithm automates the process of finding solutions to any valid
Sudoku grid.

The Sudoku Solver in this project utilizes the Backtracking algorithm, a recursive
approach that systematically fills the grid by testing possible values and backtracking
whenever an invalid configuration is encountered. This method ensures that the solution, if
one exists, is reached efficiently without skipping any potential possibilities. The solver
can handle puzzles of any difficulty, from easy to expert-level grids, ensuring that each
puzzle is solved correctly.

On the other hand, the Sudoku Generator employs a random number placement strategy
combined with the Backtracking algorithm to create puzzles. The generator ensures that
each puzzle has a unique solution, adhering to Sudoku’s core rule. Additionally, by
removing a varying number of cells from a fully completed grid, the generator creates
puzzles of different difficulty levels, providing users with a range of challenges.

The project also includes user-focused features like Login/Registration and a Leaderboard.
These features allow users to create accounts, track their progress, and compare their
performance with others. The leaderboard ranks players based on the time they take to
solve puzzles and the difficulty level of the puzzles they complete, adding a competitive
aspect to the experience.

As a whole, the Sudoku Generator and Solver project not only provides an efficient
algorithmic approach to generating and solving puzzles but also enhances the user
experience by incorporating features like authentication and real-time competitive ranking.
This combination of functionality makes the project both technically robust and engaging
for Sudoku enthusiasts.

1
1.2 Problem Statement
Existing Sudoku applications often lack essential features or fail to provide a user-friendly
interface, making it difficult for users to enjoy a smooth puzzle-solving experience.
Common issues include limited puzzle variety, confusing navigation, and the absence of
personalized options, leaving users seeking a better solution.

This project aims to develop a comprehensive Sudoku application that blends advanced
functionality with ease of use and a visually appealing design. By focusing on a
usercentered interface, the app will allow users to easily generate, solve, and explore
Sudoku puzzles without hassle.

Additionally, the app will introduce unique features such as adjustable puzzle difficulty
and a leaderboard to foster competition among players. Emphasizing both performance
and aesthetics, this Sudoku application is designed to meet the evolving needs of puzzle
enthusiasts, setting a new benchmark in puzzle games.

1.3 Objectives
The objectives of this project are:
• To design a Sudoku using Java.
• To implement Backtracking Algorithm for Generating and Solving.

1.4 Scope and Limitation

The application will support generating Sudoku puzzles of varying difficulty levels and
solving existing puzzles using the Backtracking algorithm. A user-friendly graphical
interface will be developed in Java, allowing users to interact seamlessly with the
application, complete with easy navigation and puzzle management. Additionally, a
leaderboard feature will track user performance, ranking players based on solving time and
difficulty level, adding a competitive element to the experience.

However, the application will not include online cloud saving, which limits social
interaction and data persistence. Furthermore, the app may lack comprehensive tutorials or
in-depth user support resources for new players.

1.5 Development Methodology

The Waterfall model is a linear and sequential development methodology that is
structured into distinct phases. Each phase must be completed before the next one begins,
with no overlap between phases.

2
1.6 Report Organization
Chapter 1: Introduction

Chapter one introduces the concept of this project. It describes the problems that has been
existing and how its objective can tackle it. It also presents the scope and limitations of the
project.

Chapter 2: Background study and literature review

This chapter focuses on the basic ideology of how this project will be build. It traces out
the study of different platforms and their workings.

Chapter 3: System analysis and design

This chapter describes the requirements gathering, feasibility study, and designing of the
project. It includes diagrams, functionality analysis, requirement gathering technique and
process model.

Chapter 4: Implementation and testing

This chapter is designed to give information about how the project has been implemented,
what kind of software and tools has been used and the type of testing that the project has
gone through.

Chapter 5: Conclusion and future recommendation

This chapter includes the possible outcome of this project, conclusion and future
recommendations.

Chapter 2: Background Study and Literature Review

2.1 Background Study
Sudoku is a logic-based, combinatorial number-placement puzzle that consists of a 9x9
grid divided into 3x3 sub-grids, where the objective is to fill the empty cells with digits
from 1 to 9. The puzzle has specific constraints: each row, column, and sub-grid must
contain all numbers from 1 to 9 without repetition. A Sudoku generator creates such
puzzles by filling the grid while adhering to these rules, and a solver finds the correct
solution to an incomplete grid.

3
Puzzle Difficulty Levels: Sudoku puzzles can be categorized into different difficulty
levels—easy, medium, hard, and expert—based on the number of given clues (pre-filled
cells) and the complexity of the solving process. Easy puzzles provide more clues and
require simpler logical techniques, whereas harder puzzles provide fewer clues and require
more advanced solving strategies, like naked pairs or x-wing.

Solution Uniqueness: A well-designed Sudoku puzzle has only one valid solution.
Ensuring uniqueness is critical for the integrity of the puzzle. A generator must check that
after placing a certain number of clues, the puzzle still maintains a unique solution. This is
usually done by applying solving algorithms to validate that no alternative solutions exist.

Puzzle Representation: In computational terms, Sudoku puzzles are represented as 9x9

matrices or arrays. Each cell can either be filled with a number from 1 to 9 or left empty
(represented as 0 or null). The generator fills the matrix according to Sudoku rules, and the
solver processes this matrix to complete the puzzle.

Terminologies Related to Sudoku:

• Grid: The entire 9x9 puzzle structure.

• Cell: A single box in the grid where a number must be placed.
• Row: A horizontal line of 9 cells in the grid.
• Column: A vertical line of 9 cells in the grid.
• Sub-grid/Box: A 3x3 block of cells within the grid.
• Clue: A pre-filled number given in the puzzle.
• Candidate: A possible number that can be placed in an empty cell based on the
Sudoku rules.

2.2 Literature Review

2.2.1 Review of Similar Projects

Sudoku Solvers: These applications focus primarily on solving existing Sudoku puzzles.
Users can input a partially filled grid, and the solver employs algorithms, such as
Backtracking or Constraint Satisfaction, to find the solution. Some solvers provide
additional features, like step-by-step solving processes, highlighting mistakes, and offering
insights into solving techniques. Examples include "Sudoku Solver Pro" and "Sudoku
Assistant."

4
Sudoku Generators: These apps specialize in creating new Sudoku puzzles for users to
solve. They offer varying levels of difficulty and often include features to ensure unique
solutions. Generators typically allow users to select the desired difficulty level, and some
provide customization options, such as grid size and formatting. Popular examples include
"Sudoku Generator" and "247Sudoku."

Hybrid Applications: Many modern Sudoku apps combine both solving and generating
functionalities, providing users with a comprehensive experience. These applications
allow users to create their own puzzles or solve those generated by the app. Additionally,
hybrid apps often include features like hint systems, user accounts for tracking progress,
and social features such as leaderboards. Examples include "Microsoft Sudoku" and
"Sudoku.com."

Moreover, there are also specialized apps that focus on specific variations of Sudoku, such
as "Killer Sudoku," "Samurai Sudoku," and "Sudoku with irregular regions." These
variants add complexity and challenge to the traditional format, appealing to experienced
players seeking new experiences.

2.2.2 Backtracking Algorithm

Backtracking is a powerful recursive algorithmic technique widely used for solving

constraint satisfaction problems, including Sudoku puzzles. The fundamental premise of
Backtracking is to build a solution incrementally, adding elements one at a time while
continuously checking for validity. If at any point a partial solution cannot lead to a
complete and valid solution, the algorithm abandons that path—hence the term
"backtracking." [1]

In the context of Sudoku, the process begins by identifying an empty cell in the 9x9 grid.
The algorithm then attempts to place numbers from 1 to 9 into that cell. For each number,
the algorithm performs a validity check to ensure that placing the number does not violate
any of Sudoku's fundamental rules: no number may appear more than once in any row,
column, or 3x3 sub-grid [2]. This checking mechanism is crucial, as it prevents invalid
configurations early in the process.

When a valid number is placed, the algorithm proceeds recursively to the next empty cell.
This step-by-step approach continues until the grid is completely filled. If the algorithm
encounters a situation where no valid numbers can be placed in a subsequent empty cell, it

5
backtracks to the previous cell where a number was placed, removes that number, and tries
the next possible number [3]. This process of going back to the last valid configuration
allows the algorithm to explore different potential solutions efficiently.

Backtracking is particularly effective for Sudoku due to the structured nature of the puzzle.
Each placement has direct implications on the remaining empty cells, and the constraints
inherent in Sudoku make it possible to eliminate many invalid configurations quickly [2].
This systematic exploration of possibilities is where Backtracking shines; although it may
initially appear inefficient, its pruning mechanism significantly enhances performance.

The algorithm's efficiency is further amplified when implemented with additional

strategies, such as selecting the most constrained variable (choosing the empty cell with
the fewest possible legal values first) and employing constraint propagation techniques.
These enhancements reduce the number of recursive calls and backtracks needed to find a
solution, particularly in complex puzzles with unique solutions [4].

Backtracking can also be applied to generate Sudoku puzzles. In this context, the
algorithm starts with a fully filled grid and then systematically removes numbers while
ensuring that the resulting puzzle retains a unique solution. This dual capability—solving
and generating—makes Backtracking a versatile choice for Sudoku applications.

Kovacs outlines a few brute force strategies for resolving Sudoku problems. The
"unconstrained grid" puzzle has a solution that is generated at random by the simplest
approach, and then the program verifies that the solution is correct. If not, the steps are
carried out again until a solution is discovered [5]. This algorithm is easy to use and,
because it considers every potential answer, will provide a workable solution for any issue.

Though Kovacs claims the algorithm can be optimized, this approach can be
timeconsuming.

In general, the brute force method scans the blank squares, adding numbers from the
available options or eliminating unsuccessful selections in the event that a "dead-end" is
encountered [5]. Brute force, for instance, solves a puzzle by placing the number "1" in the
first square. The software advances to the next square and inserts the number "1" there if
the digit is permitted to be there by checking the row, column, and box. When the software
determines that the number "1" is incorrect, it advances the digit by one, making it 2. The
program reverts to the previous square when it detects a square where none of the digits (1

6
to 9) are allowed. That square's value rises by one. Until all 81 squares are filled with the
correct digits, the process is repeated.

2.2.3 Other Algorithms

While Backtracking is the primary algorithm for this project, several other algorithms are
also there for Sudoku application:

Dancing Links: This algorithm, developed by Donald Knuth, is an efficient method for
solving exact cover problems, which include Sudoku. Dancing Links uses a data structure
to represent the puzzle as a matrix, allowing for quick updates as numbers are placed or
removed [6]. This method is particularly effective for finding all possible solutions to a
Sudoku puzzle rather than just one.

Constraint Satisfaction: This approach focuses on defining constraints for each cell and
uses techniques to propagate these constraints to narrow down possibilities. Algorithms in
this category often employ techniques such as Arc Consistency, which helps eliminate
impossible values from cells based on the constraints of neighbouring cells [7]. While
powerful, this method can be more complex to implement compared to Backtracking.

Pencil-and-paper algorithm: In this work, a solution is implemented based on some

strategies used by humans when solving the puzzle, therefore, it is called pencil-and-paper
algorithm. The paper-and-pencil algorithm contains human strategies. These strategies
have been examined below in more details. These techniques are almost easy to
understand by human players, but it might be hard to search in the puzzle, since there are
several things to look for at the same time [8]. As there are puzzles with different types of
difficulty, the easy and medium puzzles can be solved using some simple techniques such
as unique missing method, naked singles.

In conclusion, the Backtracking algorithm remains the most suitable choice for generating
and solving Sudoku puzzles due to its efficiency and simplicity. While other algorithms,
such as Dancing Links and Constraint Satisfaction, offer alternative approaches with
specific advantages, Backtracking's ability to effectively prune invalid paths makes it the
optimal choice for this project. Understanding these various algorithms provides a
foundation for developing a robust and efficient Sudoku application that meets user needs.

7
8
 Chapter 3: System Analysis and Design
3.1 System Analysis
This project follows the Waterfall model throughout the Software Development Life Cycle
(SDLC). The choice of the Waterfall model is based on its effectiveness in rapidly
building a foundational system within a limited timeframe. It provides a clear, sequential
structure that helps define timelines and set specific deadlines for each phase of
development.

The model's linear approach is particularly suitable for this project, as the requirements
were well-defined from the start. This allowed for a smooth flow through the
development stages - requirements gathering, system design, implementation, testing,
deployment, and maintenance - ensuring efficient project management and execution.

Figure 3.1: Waterfall Model

9
3.1.1 Requirement Analysis

The process of obtaining important specifications that will be utilized to create a system is
known as requirement identification [9]. There are several ways to obtain requirements,
such as reviewing the existing system, conducting interviews, using questionnaires, etc.

i. Functional Requirement
The Sudoku application will encompass a range of features designed to enhance the
puzzlesolving experience for users. It will allow users to generate and solve Sudoku
puzzles of varying difficulty levels, utilizing a robust Backtracking algorithm to ensure
efficient and accurate solutions. Users can select different difficulty settings, ranging from
easy to expert, making the application suitable for both beginners and experienced players.

To personalize the experience, the application will include user account functionalities,
allowing users to register and log in securely. This will enable them to save their
progress, track their performance over time, and access their preferred settings from any
device. The interface will be intuitive and user-friendly, providing clear navigation
between puzzle generation, solving, and user account management.

A leaderboard feature will be integrated to foster a competitive atmosphere among users. It

will track performance metrics such as solving time and puzzle difficulty, allowing players
to compare their achievements with others. This not only adds an element of competition
but also motivates users to improve their skills and challenge themselves further.

The design will prioritize ease of use, with visual feedback for user actions and essential
information displayed clearly, such as the current puzzle state, hints, and solving
techniques. Navigation will be seamless, enabling users to quickly switch between
generating new puzzles, solving existing ones, and viewing leaderboard rankings.

10
 Figure 3.2: Usecase Diagram of Sudoku Generator and Solver

The application allows users to register and log in, creating personalized accounts for
tracking their progress. After logging in, users are taken to the main menu, where they can
choose between two primary features: Generate Sudoku and Solve Sudoku.

In the Generate Sudoku section, users can play a Sudoku game by generating new puzzles
of varying difficulty levels. This provides an interactive experience for players of all skill
levels.

In the Solve Sudoku section, users have the ability to load previously saved puzzles, save
their current progress, and display the solution to any puzzle they are working on. This
functionality offers flexibility for users to solve puzzles at their own pace.

Additionally, the app features a Leaderboard, where users can view their rankings based
on factors such as solving time and puzzle difficulty, adding a competitive element to the
experience.

ii. Non-functional Requirement

11
The application is compatible with a wide range of Java desktop environments, ensuring
optimal performance across various operating systems. It supports multiple screen sizes
and resolutions, providing an excellent user experience regardless of the display used.
Security measures are in place to protect access to Sudoku files and prevent unauthorized
modifications, ensuring safe handling of user data and preferences.

Designed with usability in mind, the application offers ease of learning and navigation for
users of all skill levels. Its interface is intuitive, allowing both beginners and experienced
players to engage with the puzzles effortlessly. Reliability has been prioritized, resulting in
stable performance with minimal crashes and bugs, supported by robust error handling and
recovery mechanisms.

Scalability is a key feature of the application, enabling it to manage a large volume of

Sudoku puzzles without performance degradation. This ensures that users can generate
and solve puzzles efficiently, even as they explore various difficulty levels. Overall, the
application delivers a comprehensive and enjoyable Sudoku-solving experience.

3.1.2 Feasibility Study

i. Technical
This system meets the technical feasibility criteria by leveraging existing technologies
such as Java, which is widely supported and has extensive documentation and community
resources. Java is a robust programming language that provides a solid foundation for
desktop application development, ensuring reliability and performance. The application
will utilize Java's rich libraries and frameworks to facilitate user interface design and
puzzle-solving functionality.

Additionally, the system incorporates local file management for storing user preferences
and puzzle data, ensuring seamless access and synchronization across sessions. Security
measures will be implemented to safeguard user data and preferences, enhancing overall
system integrity. This combination of technologies and methodologies ensures a stable and
efficient Sudoku application that meets user needs effectively.

ii. Operational
The application features an intuitive and user-friendly interface, designed to make it easy
for users to navigate and engage with their Sudoku puzzles with minimal effort. The
layout prioritizes user experience, ensuring that all essential features are readily accessible.

12
The main screen presents a visually appealing design that highlights the current puzzle
along with crucial information such as difficulty level and the number of empty cells
remaining.

Key controls, such as options for generating new puzzles, saving progress, and accessing
the leaderboard, are prominently positioned for quick access. The interface includes visual
feedback for user actions, enhancing interactivity and engagement. Overall, the design
aims to provide a seamless and enjoyable puzzle-solving experience for users of all skill
levels.

iii. Economic
The system will be economically feasible, as the primary resources required for
development and operation are a laptop, an internet connection, and electricity. This low
barrier to entry makes it accessible for both individual developers and small teams,
allowing for a cost-effective approach to building and maintaining the music player
application.

3.1.3 Object Modelling: Object and Class Diagram

Figure 3.3: Object Diagram of Sudoku Generator and Solver

The object diagram illustrates the connections between the major parts of the Sudoku

13
Solver application, outlining its organizational structure. The App class controls the
Sudoku panel (sudokuFramePanel), the main window (mainFrame), and the username of
the user.
While the Registration class facilitates the registration of new users, the LoginRegistration
class manages user login.

The MainMenu class allows users to see the leaderboard and play Sudoku games after
logging in. Scores are shown in the Leaderboard panel, sorted by difficulty.
The board, the current state of the game, and references to the SudokuGenerator and
SudokuSolver for puzzle creation and solution are all managed by the PlaySudoku class.

Figure 3.4: Class Diagram of Sudoku Generator and Solver

14
The main components and their connections inside the Sudoku Solver application are
depicted in this class diagram. Panel navigation, user sessions, and the main interface are
all controlled by the App class. User authentication and account creation are handled by
the LoginRegistration and Registration classes. The MainMenu allows users to navigate to
the game or leaderboard, while the Leaderboard interacts with the SudokuDatabase to save
and retrieve data while displaying scores dependent on difficulty.

The board, score, and lives are all managed by the PlaySudoku class. It collaborates with
the SudokuSolver to solve puzzles and the SudokuGenerator to create new ones. All of
these parts work together to control gameplay, user sessions, and scorekeeping.

3.1.4 Dynamic Modelling: State and Sequence Diagram

Figure 3.5: State Diagram of Sudoku Generator and Solver

This state diagram represents the flow of the user experience in the Sudoku Solver
application. It begins in the Idle state, where users can either start the login or registration

15
process. Upon successful login or registration, the system transitions to the Game Setup
state, where a puzzle is generated.

From there, users enter the Playing state, where they interact with the puzzle. The game
periodically moves to the Validation state to check the puzzle's correctness. If the puzzle is
invalid or completed, the game transitions to Game Over. Users can restart the game or
choose to log out, ending the session. This diagram shows the main interactions from login
to gameplay and logout.

Figure 3.6: Sequence Diagram of Sudoku Generator and Solver

The sequence diagram shows the interaction between a user and various components of a
Sudoku system, focusing on logging in and solving puzzles.

Initially, the user enters their credentials in the LoginRegistration component, which then
communicates with the JdbcConn (a database connection) to validate the user's
credentials.
If the credentials are valid, the database returns confirmation, and the user is logged in
successfully.

Next, the user requests to generate a Sudoku puzzle. This triggers the SudokuGenerator to
create a puzzle and send it to the SudokuGamePanel for the user to start playing. Once the
user solves the puzzle, the solution is passed to the SudokuSolver, which checks if it is
correct. The solution is then validated by the ValidatePuzzle component, which returns the

16
result of the validation. The user is notified of whether the solution is correct or incorrect
based on this result.

3.1.5 Process Modelling: Activity Diagram

Figure 3.7: Activity Diagram of Sudoku Generator and Solver

This activity diagram outlines the user flow in a Sudoku game application. Upon starting
the program, the user must log in or register if they are new. Once logged in, the main
menu offers two choices: play Sudoku or view the leaderboard.

If the user opts to play, a puzzle is generated, and they attempt to solve it. The system
checks the solution, updating the leaderboard for correct answers or prompting reattempts

17
for errors. Alternatively, if the user selects "View Leaderboard," the system displays top
scores. After either action, the user completes their activity and the process ends.

3.2 System Design

3.2.1 Refinement of Classes and Object

Figure 3.8: Refinement Class diagram of Sudoku Generator and Solver

The main components of a Sudoku application are divided into multiple classes in this
class diagram. The App class acts as the entrance point, controlling the user interface and
panel navigation, including SudokuFrame and Login. While the MainMenu offers options
to launch new games or check leaderboards, the Login/Registration class manages user
authentication, including username and password validation. The interface of the Sudoku
board is rendered by SudokuFrame. Through interactions with the SudokuDatabase, which
uses JDBC connections to store and retrieve player data, Leaderboard controls how the top
scores are displayed. Different difficulty levels are supported, and problems with
legitimate solutions are guaranteed by the SudokuGenerator and SudokuSolver classes,

18
which also handle puzzle creation and validation. Last but not least, PlaySudoku manages
player input and game mechanics while the game is being played.

Figure 3.9: Refinement Object Diagram of Sudoku Generator and Solver

This object diagram depicts the runtime structure of a Sudoku application, showing
specific instances and their interconnections. The app: App object is the central
component, storing the user's username and linking to the main Sudoku frame. The
loginPanel: LoginRegistration manages user authentication, referencing the main
application and its associated frame. The mainMenuPanel: MainMenu provides navigation
options and stores the user's name. The leaderboardPanel: Leaderboard object manages the
display of high scores using a combo box for difficulty selection and a table model for
leaderboard entries, interacting with the database: SudokuDatabase for data retrieval. The
sudokuFramePanel: SudokuFrame renders the Sudoku board and menu interface.
Additionally, the playSudokuPanel: PlaySudoku manages game logic, tracking user
progress, score, and time. Other objects, such as generator: SudokuGenerator and solver:
SudokuSolver, handle puzzle creation and validation, ensuring the game runs smoothly.
The connection:
JdbcConn manages the database connection for storing and retrieving user data.

19
3.2.2 Component Diagram

Figure 3.10: Component Diagram of Sudoku Generator and Solver

This component diagram shows the structure and interaction of modules in a Sudoku game
system. The User Interface (UI) includes components like the Main Menu for choosing
between gameplay or viewing the leaderboard, the Play Sudoku UI for gameplay, and the
Login/Registration UI for user authentication.

20
The Game Logic consists of the Sudoku Generator for creating puzzles, the Solver for
solving them, and the Validator for checking solutions. The Registration Logic handles
user registration, while the Database, managed by JdbcConn, stores user and puzzle data,
supporting the game's functionality. These components work together to manage users,
generate puzzles, and validate solutions.

3.2.3 Deployment Diagram

Figure 3.11: Deployment Diagram of Sudoku Generator and Solver

The deployment diagram shows the architecture of the Sudoku Solver application, where
users interact by registering, logging in, or accessing the game menu. On the client side,
key components include the MainMenu for navigation, PlaySudoku for gameplay, and the
Leaderboard for displaying top scores, all interacting with the Sudoku Database for storing
scores.

The Registration UI handles login and registration, with the Login/Registration

component managing user data stored in the User Database. This design ensures a clear

21
separation between gameplay and user data management for efficient and organized
processing.

3.3 Algorithm Details

Search Space: Backtracking explores a search space defined by all possible configurations
of the problem. For Sudoku, this space consists of all possible ways to fill the 9x9 grid
while adhering to the game's rules. The size of the search space is exponential, as there are
981 potential combinations when considering each cell can hold a digit from 1 to 9.

Decision Tree: The algorithm can be visualized as a decision tree, where each node
represents a state of the Sudoku grid. The root node represents the initial empty grid, and
each child node corresponds to a valid placement of a number in one of the empty cells.
The depth of the tree is equal to the number of empty cells, and the leaves represent
complete configurations of the grid. Backtracking systematically traverses this tree,
exploring paths until it either finds a solution or exhausts all possibilities.

Constraints: The constraints in Sudoku are mathematical conditions that must be

satisfied:

• Each number from 1 to 9 must appear exactly once in each row.

• Each number must appear exactly once in each column.

• Each number must appear exactly once in each 3x3 sub-grid.

The algorithm employs these constraints to prune the search space, allowing it to discard
invalid paths early in the process.

Algorithm Mathematical Expression

Given a 9×9 Sudoku grid 𝑃 where some cells are pre-filled with numbers (from 1 to 9)
and others are empty (denoted as 0), the goal is to fill in all the empty cells such that each
row, each column, and each 3×3 sub-grid contains all the numbers from 1 to 9 without
repetition. Variables and Functions

Puzzle Grid: 𝑃 is a 9×9 grid where 𝑃[𝑖][𝑗] represents the value at row 𝑖 and column 𝑗.

Row and Column: The algorithm iterates over the grid using row and col indices.

Valid Placement Function: isValid(𝑃,𝑖,𝑗,𝑣) checks if placing a value 𝑣 at 𝑃[𝑖][𝑗] follows

Sudoku rules.

22
The backtracking algorithm can be expressed mathematically as follows:

Base Case:
𝑠𝑜𝑙𝑣𝑒(𝑃, 𝑖,𝑗)
𝑇𝑟𝑢𝑒, 𝑖𝑓 𝑖 (𝐴𝑙𝑙 𝑟𝑜𝑤𝑠 𝑎𝑣𝑒 𝑏𝑒𝑒𝑛 𝑓𝑖𝑙𝑙𝑒𝑑, 𝑝𝑢𝑧𝑧𝑙𝑒 𝑖𝑠
𝑠𝑜𝑙𝑣𝑒𝑑)
= {𝑠𝑜𝑙𝑣𝑒(𝑃,𝑖 + 1,0), 𝑖𝑓 𝑗 (𝐸𝑛𝑑 𝑜𝑓 𝑡 𝑒 𝑐𝑢𝑟𝑟𝑒𝑛𝑡 𝑟𝑜𝑤, 𝑚𝑜𝑣𝑒 𝑡𝑜
𝑛𝑒𝑥𝑡 𝑟𝑜𝑤) 𝑠𝑜𝑙𝑣𝑒(𝑃,𝑖, 𝑗 + 1), 𝑖𝑓 𝑃 (𝐶𝑢𝑟𝑟𝑒𝑛𝑡 𝑐𝑒𝑙𝑙
𝑓𝑖𝑙𝑙𝑒𝑑, 𝑚𝑜𝑣𝑒 𝑡𝑜 𝑛𝑒𝑥𝑡 𝑐𝑒𝑙𝑙)

Recursive Step:

𝑇𝑟𝑢𝑒,𝑖𝑓 𝑎 𝑣𝑎𝑙𝑢𝑒 𝑣 𝑖𝑠 𝑓𝑜𝑢𝑛𝑑 𝑠𝑢𝑐ℎ 𝑡ℎ𝑎𝑡:

𝑖𝑠𝑉𝑎𝑙𝑖𝑑(𝑃,𝑖, 𝑗, 𝑣) = 𝑇𝑟𝑢𝑒

𝑃[𝑖][𝑗] = 𝑣(𝑃𝑙𝑎𝑐𝑒 𝑣 𝑖𝑛 𝑐𝑒𝑙𝑙 (𝑖,𝑗))

𝑠𝑜𝑙𝑣𝑒(𝑃, 𝑖,𝑗) =
𝑠𝑜𝑙𝑣𝑒(𝑃,𝑖, 𝑗 + 1) = 𝑇𝑟𝑢𝑒
(𝑅𝑒𝑐𝑢𝑟𝑠𝑖𝑣𝑒𝑙𝑦 𝑠𝑜𝑙𝑣𝑒 𝑡ℎ𝑒 𝑟𝑒𝑠𝑡 𝑜𝑓 𝑡ℎ𝑒 𝑝𝑢𝑧𝑧𝑙𝑒)
{𝑃[𝑖][𝑗] = 0, 𝑖𝑓 𝑛𝑜 𝑣𝑎𝑙𝑖𝑑 𝑣 𝑒𝑥𝑖𝑠𝑡𝑠, 𝑏𝑎𝑐𝑘𝑡𝑟𝑎𝑐𝑘 𝑏𝑦
𝑟𝑒𝑠𝑒𝑡𝑡𝑖𝑛𝑔 𝑃[𝑖][𝑗]

Validation Function: The isValid function ensures that placing a value 𝑣 at 𝑃[𝑖][𝑗] is
consistent with Sudoku rules:

𝑖𝑠𝑉𝑎𝑙𝑖𝑑(𝑃,𝑖, 𝑗, 𝑣)
𝐹𝑎𝑙𝑠𝑒,𝑖𝑓 𝑃[𝑖][𝑘] = 𝑣 𝑜𝑟 𝑃[𝑘][𝑗] = 𝑣 𝑓𝑜𝑟 𝑎𝑛𝑦 𝑘
= {𝐹𝑎𝑙𝑠𝑒, 𝑖𝑓 𝑃[𝑚][𝑛] = 𝑣 𝑓𝑜𝑟 𝑎𝑛𝑦 (𝑚, 𝑛) 𝑖𝑛 3× 3 𝑠𝑢𝑏 𝑔𝑟𝑖𝑑
𝑐𝑜𝑛𝑡𝑎𝑖𝑛𝑖𝑛𝑔 (𝑖,𝑗)
𝑇𝑟𝑢𝑒, 𝑖𝑓 𝑣 𝑖𝑠 𝑛𝑜𝑡 𝑝𝑟𝑒𝑠𝑒𝑛𝑡 𝑖𝑛 𝑡ℎ𝑒 𝑠𝑎𝑚𝑒 𝑟𝑜𝑤, 𝑐𝑜𝑙𝑢𝑚𝑛, 𝑜𝑟
𝑠𝑢𝑏 𝑔𝑟𝑖𝑑

𝑡𝑟𝑢𝑒, 𝑖𝑓 (𝑖, 𝑗) 𝑖𝑠 𝑙𝑎𝑠𝑡 𝑐𝑒𝑙𝑙 𝑎𝑛𝑑 𝑝𝑢𝑧𝑧𝑙𝑒

Backtracking expression for the sudoku generator

𝑓𝑎𝑙𝑠𝑒, 𝑖𝑠 𝑠𝑜𝑙𝑣𝑒𝑑
𝑠𝑜𝑙𝑣𝑒(𝑖, 𝑗) = { 𝑖𝑓 𝑛𝑜 𝑣𝑎𝑙𝑖𝑑 𝑛𝑢𝑚𝑏𝑒𝑟 𝑐𝑎𝑛 𝑏𝑒
𝑠𝑜𝑙𝑣𝑒(𝑖, 𝑗 + 1), 𝑝𝑙𝑎𝑐𝑒𝑑 𝑖𝑛 (𝑖,𝑗)
𝑏𝑎𝑐𝑘𝑡𝑟𝑎𝑐𝑘,
𝑖𝑓 𝑛𝑢𝑚𝑏𝑒𝑟 𝑖𝑠 𝑣𝑎𝑙𝑖𝑑 𝑎𝑛𝑑 𝑝𝑙𝑎𝑐𝑒𝑑 𝑖𝑛
(𝑖, 𝑗)
𝑖𝑓 𝑝𝑙𝑎𝑐𝑒𝑚𝑒𝑛𝑡 𝑙𝑒𝑎𝑑𝑠 𝑡𝑜 𝑑𝑒𝑎𝑑𝑒𝑛𝑑

23
 Chapter 4: Implementation and Testing
4.1 Implementation
4.1.1 Tools Used
Java
The Sudoku Solver and Generator application was developed using Java, which is
essential since it offers a stable and adaptable framework on which to create the system's
essential features and user interface. Java is mainly utilized in the construction of the
application, and its object-oriented programming features are utilized to organize the code
into readable sections. Java is used to create the Backtracking algorithm, which is the
foundation of the Sudoku Solver and guarantees dependable and effective puzzle solving.
This approach runs smoothly due to Java's robust data structures, including arrays and
recursive functions, which enable the software to handle a range of puzzle complexity
levels.

Java Swing is used for the user interface, which includes buttons, text fields, and graphical
grids that mimic the Sudoku board, to produce an engaging and interactive experience.
This enables users to play Sudoku games that are dynamically generated, submit
problems, and get immediate solutions.

MySQL

The Sudoku Solver and Generator project uses MySQL as its main database management
system to store and handle all of its crucial data. Managing leaderboards, game progress
tracking, user identification, and other essential features all depend heavily on the
database. Users' login credentials are safely saved and verified with the MySQL database
at registration, guaranteeing safe access to their accounts.

24
 Furthermore, MySQL is in charge of managing leaderboard data, which includes user
performance measures like solution time, difficulty level, and scores. To provide real-time
rankings, this data is dynamically updated and retrieved, strengthening the application's
competitive feature. Effective data storage, retrieval, and manipulation are made possible
by MySQL's robust querying features, which provide speedy access and reliable
performance. Because MySQL is a dependable option for handling the intricate data
requirements of the Sudoku Solver and Generator application, its use guarantees data
integrity, security, and scalability.

Figure 4.1: Leaderboard MySQL Table of the Sudoku Generator and Solver

Figure 4.2: User MySQL Table of the Sudoku Generator and Solver

4.1.2 Implementation Details of modules

Modules in Sudoku Generator and Solver

i. MainMenu
This class provides the main menu interface of the application, allowing users to navigate
to different sections such as playing Sudoku, solving puzzles, viewing the leaderboard,
and logging out.

25
 Figure 4.3: Main Menu of Sudoku Generator and Solver

ii. LoginRegistration
Manages the login and registration screen, providing the user interface for users to sign in
or create new accounts.

Figure 4.4: Login of Sudoku Generator and Solver

26
 Figure 4.5: Registration of Sudoku Generator and Solver

iii. PlaySudoku
Provides the user interface for playing Sudoku, including puzzle generation, solving, and
scoring. It allows the user to select the difficulty level, generate a new puzzle, check the
solution, and view the elapsed time and score. It also provides functionality to return to the
main menu.

Figure 4.6: Sudoku Player of Sudoku Generator and Solver

iv. SudokuFrame (Solver)

27
 Provides a GUI for interacting with Sudoku puzzles, including functionalities to load and
save puzzles, solve the puzzle, and reset the board. It features a grid-based board for
entering Sudoku numbers.

Figure 4.7: Sudoku Solver of Sudoku Generator and Solver

v. Leaderboard
Provides the interface to display the leaderboard, showing user scores and rankings based
on the difficulty.

28
 Figure 4.8: Leaderboard of Sudoku Generator and Solver

SudokuSolver Class
The Backtracking Algorithm is implemented in the SudokuSolver.java. It's implemented in
the private solve method.

Figure 4.9: First Code of SudokuSolver class in Sudoku Game

Figure 4.10: Second Code of SudokuSolver class in Sudoku Game

The algorithm starts at:

private static boolean solve(int[][] puzzle, int row,
int col)

First, it checks if we've reached the end of the puzzle:

29
 if (row == 9)
{ return true;
}

If we've reached the end of a row, it moves to the next row:

if (col == 9) {
return solve(puzzle, row + 1, 0);
}

If the current cell is already filled, it moves to the next cell:

if (puzzle[row][col] != 0)
{ return solve(puzzle, row, col
+ 1);
}

The core of the algorithm is in the following loop:

for (int value = 1; value <= 9; value+
+) { if (isValid(puzzle, row, col,
value)) { puzzle[row][col] =
value; if (solve(puzzle, row,
col + 1)) { return true;

}
puzzle[row][col] = 0; // Backtrack
}
}

This loop tries each value from 1 to 9 in the current cell. If a value is valid (doesn't violate
Sudoku rules), it:
• Places the value in the cell
• Recursively tries to solve the rest of the puzzle
• If the recursive call returns true, it means a solution is found
• If not, it backtracks by setting the cell back to 0 and tries the next value

If no value works for this cell, it returns false, which triggers backtracking in the previous
recursive call:

30
 return false;

The isValid method (lines 64-82) checks if placing a value in a specific cell violates any
Sudoku rules by checking the row, column, and 3x3 sub-grid.

SudokuGenerator Class
Another part is SudokuGenerator.java which contains an algorithm for generating Sudoku
puzzles.

Figure 4.11: First Code of SudokuGenerator class in Sudoku Game

31
 Figure 4.12: Second Code of SudokuGenerator class in Sudoku Game

The algorithm starts at:

private boolean solve(int row, int

col) { if (col == 9)
{ col = 0; row++;
if (row == 9) { return
true;
}
}

This part handles moving to the next row when we reach the end of a column. If we've
filled the entire grid (row == 9), we return true as we've found a solution.
if (solution[row][col] != 0) {
return solve(row, col + 1);
}

If the current cell is already filled (not 0), we move to the next cell.
List<Integer> numbers =
generateRandomNumbers(); for (int num :
numbers) {

if (isSafe(row, col, num))

{ solution[row][col] =
num; if (solve(row,
col + 1)) { return
true;
}
solution[row][col] = 0;
}
}

This is the core of the backtracking algorithm:

• We generate a list of numbers 1-9 in random order.
• For each number, we check if it's safe to place in the current cell.
• If it's safe, we place the number and recursively try to solve the rest of the grid.

32
 • If the recursive call returns true, we've found a solution.
• If not, we remove the number (backtrack) and try the next number.

return false;

If we've tried all numbers and none work, we return false to trigger backtracking.

The isSafe method (lines 157-159) checks if a number can be placed in a cell without
violating Sudoku rules:
private boolean isSafe(int row, int col, int num) {
return !usedInRow(row, num) && !usedInColumn(col,
num)
&& !usedInBox(row - row % 3, col - col % 3,
num); }

After generating a complete solution, the algorithm removes cells to create the puzzle:
private void removeCells(int
difficulty) { Random rand = new
Random(); int cellsToRemove = 81 -
difficulty; while (cellsToRemove >
0) { int row =
rand.nextInt(9); int col =
rand.nextInt(9);

if (puzzle[row][col] != 0) {
int temp = puzzle[row][col];
puzzle[row][col] = 0; if
(!hasUniqueSolution()) {
puzzle[row][col] = temp;
} else {
cellsToRemove--;
}
}
}
}

33
This method:
• Randomly selects cells to remove.
• Removes a cell's value temporarily.
• Check if the puzzle still has a unique solution.
• If not, it restores the value; if yes, it keeps the cell empty.
• Continues until the desired number of cells are removed.

4.2 Testing
4.2.1 Unit Testing

i. Unit Testing of Registration in Sudoku Generator and Solver

Test case ID: SUDRegister001

Testcase type: Unit Testing

Requirement no: 1

Module: User Registration

Status: XXX

Severity: Critical

Values: Username = “Salin01”, Password = “p@ssWord”

Pre-condition: Required one user to be registered

Summary: Conduct unit testing for the registration process within Sudoku Game to ensure
its functionality.

Table 4.1: Unit Testing of Registration in Sudoku Generator and Solver

Step Steps Inputs Expected result Actual Status
no. result

1 Open the Displays Login Page As Pass

expected
“Sudoku”
application
2 Click on Opens the As Pass
expected
“Register” Registration Page
Button

34
 3 Enter the invalid Username =
inputs Null
Password =
Null
Click on Displays dialog As Pass
expected
“Register” “Please fill in all the
Button fields”

4 Enter the valid Username =

inputs Salin01
Password =
p@ssWord

Click on Displays dialog As Pass

expected
“Register” “Registration
Button Successful ”

ii. Unit Testing of Login in Sudoku Generator and Solver

Test case ID: SUDLogin001

Testcase type: Unit Testing

Requirement no: 1

Module: User Login

Status: XXX

Severity: Critical

Values: Username = “Salin01”, Password = “p@ssWord”

Pre-condition: Required one user to be login

Summary: Conduct unit testing for the login process within Sudoku Game to ensure its
functionality.

Table 4.2: Unit Testing of Login in Sudoku Generator and Solver

Step Steps Inputs Expected result Actual Status
no. result

35
 1 Open the Displays Login Page As Pass
expected
“Sudoku”
application
2 Enter the invalid Username =
inputs ramu
Password =
ramu123

Click on Displays dialog As Pass

“Invalid username or expected
“Login” Button
password”

3 Enter the valid Username =

inputs Salin01
Password =
p@ssWord

Click on Opens homepage As Pass

expected
“Login” Button

iii. Unit Testing of the ability to play game in Sudoku Generator and Solver

Test case ID: SUDPlay001

Testcase type: Unit Testing

Requirement no: 1
Module: User Play Sudoku

Status: XXX

Severity: Critical

Values: 1 to 9

Pre-condition: Required one user to be play a game

Summary: Conduct unit testing for the user to play game within Sudoku Game to ensure
its functionality.

Table 4.3: Unit Testing of ability to play game in Sudoku Generator and Solver

36
 Step Steps Inputs Expected result Actual Status
no. result

1 Open the Displays Login As Pass

expected
“Sudoku” Page
application
2 Enter the valid Username =
inputs Salin01
Password =
p@ssWord

Click on “Login” Opens homepage As Pass

Button expected

3 Click on “Play Opens Sudoku 9X9

Sudoku” Button grids
4 Click on “Difficult Level” As Pass
“Generate” Dialog box opens expected
up
Button
Select a difficult New Game Starts As Pass
and click “Ok” expected

iv. Unit Testing of Leaderboard in Sudoku Generator and Solver

Test case ID: SUDLeaderboard001

Testcase type: Unit Testing

Requirement no: 1

Module: Leaderboard

Status: XXX

Severity: Critical

Pre-condition: Required one user to be able to see the leaderboard

Summary: Conduct unit testing for the leaderboard to be shown within Sudoku Game to
ensure its functionality.

Table 4.4: Unit Testing of Leaderboard in Sudoku Generator and Solver

37
 Step Steps Inputs Expected Actual Status
no. result result

1 Open the “Sudoku” Displays Login As Pass

application expected
Page
2 Enter the valid inputs Username =
Salin01
Password =
p@ssWord

Click on “Login” Button Opens As Pass

homepage expected

3 Select the “Leaderboard” Opens the As Pass

option from Main Menu leaderboard expected
panel

4 Select the Difficulty to Displays all the As Pass

“All” from dropdown scores expected
menu and click in
“Show” button

5 Select the Difficulty to Displays the As Pass

“Easy” from dropdown scores from expected
menu and click “Show” easy difficulty
button

4.2.2 System Testing of Sudoku Generator and Solver

i. System testing of Sudoku Generator and Solver (User Side)

Test case ID: SUDSystem001

Testcase type: System Testing

Requirement no: 1

Module: All Modules

Status: XXX

Severity: Critical

38
Values: Username = “newUser”, Password = “p@ssWord”

Pre-condition: Required one user to be able to do everything in the system

Summary: Conduct System testing for Sudoku Game to ensure its functionality
Table 4.5: System Testing for the Sudoku Generator and Solver (User Side)
S.N. Steps Input Expected Result Displayed Remarks
Result

1 Opens the Login Screen As Pass

Start the
application Expected

2 Click on the Opens the New User Pass

As
“Register” button Register page expected

3 Input
invalid Username =
values for rame
registration password =
12345@hell
o confirm
password =
hello@1234
5

Click on Displays a dialog As Pass

“Register” button “Password do not expected

match”

4 Input valid values

for registration Username
= newUser
password =
p@ssWord

Click on As Pass
Displays a dialog
expected
“Register” button
“Registration
Successful”

39
5 Input valid values
for login Username
= newUser
password =
p@ssWord

Logs in and opens the Pass

Click on “Login” As
button “Main Menu” expected

6 Click on “Play Pass

Opens the Sudoku As
Sudoku” button player expected

7 Click on Pass
Displays “Difficulty As
“Generate” button level” dialog box expected

Choosing a Choose Generates the game in As Pass

expected
difficulty level difficulty level “easy” mode
and clicking = Easy
“OK”

8 Press the “Hint” As Pass

Inputs a digit in expected
Button
the game while
highlighting the
inputted digit

9 Input incorrect Value (digit) = Highlights the incorrect As Pass

value (digit) in the 5 digit in red and expected

Sudoku game decreases the “Lives”
to 2

10 Value (letter) = Does not take the letter As Pass

Input a letter h as the input expected
value (anything
except number)

40
11 After completing As Pass
the game Displays a expected
“Congratulations”
dialog box with
score, time taken and
difficulty level

Goes back to the Main As Pass

Click “OK” on expected
Menu
the dialog box
and click the
“Back” button

12 Opens the Leaderboard As Pass

Click on expected
“Leaderboard” Panel
option

13 Difficulty = All
Selecting the
Difficulty from
drop-down menu

Click on “Show” As Pass

button Displays all the users expected
score sorted by the
shortest time taken

Goes back to Main Pass

Click on “Back” As
button Menu expected

14 Click on “Sudoku Opens the Sudoku Pass

As
Solver” Solver panel expected

15 Input Digits
Input digits in the
empty fields

Click on the As Pass

Displays “Puzzle expected
“Solve” button solved” dialog box after
solving the problem

41
 Empties the field As Pass
Click on “OK” of expected
dialog box and
press “Reset”

16 Input Sudoku Input Digits Displays Dialog box As Pass

problem with no saying “Puzzle is expected
unsolvable”
solution and
click
“Solve”

Click “OK” in Goes back to Main As Pass

expected
dialog box and Menu

“Back”

17 Click on Displays “Logged out As Pass

successfully” in expected
“Logout” and
dialog box and logs
Confirm Logout out

ii. System testing of Sudoku Generator and Solver (Admin Side)

Test case ID: SUDSystem002

Testcase type: System Testing

Requirement no: 1

Module: All Modules

Status: XXX

Severity: Critical

Values: Username = “admin1”, Password = “admin123”

Pre-condition: Required admin to be able to do everything in the system

Summary: Conduct System testing for Sudoku Game to ensure its functionality
Table 4.6: System Testing for the Sudoku Generator and Solver (Admin Side)

42
S.N. Steps Input Expected Result Displayed Remarks

Result

1 Opens the Login As Pass

Start the
application Screen Expected

2 Input valid values Username =

for admin login
admin1 password
= admin123

Click on “Login” Logs in and opens As Pass

button expected
the “Admin
Dashboard”

3 Click on “Action” Opens dialog box As Pass

button expected
with options:
“Edit” and
“Delete”

4 Click on “Edit” As Pass

option Opens dialog to expected
edit username
of specific user

New username = Saves the new As Pass

Input new username expected
username for MyNewUser
user and save

5 Deletes the specific As Pass

Click on “Action” user expected
button and click
“Delete” option

Chapter 5: Conclusion and Future Recommendation

5.1 Conclusion
In conclusion, the Sudoku Generator and Solver project successfully demonstrates the
principles of algorithmic design and implementation. The generator effectively produces
valid Sudoku puzzles by utilizing backtracking algorithms, ensuring that each puzzle

43
maintains a unique solution while varying in difficulty. The solver complements this by
providing a robust mechanism to efficiently solve any valid Sudoku puzzle presented to it,
utilizing similar algorithmic principles.

This project not only showcases the mathematical and logical foundations of Sudoku but
also highlights the significance of problem-solving techniques in programming. Through
this endeavor, we have reinforced our understanding of recursion, backtracking, and
constraint satisfaction problems, which can be applied to various domains beyond Sudoku.
Overall, the implementation serves as an engaging tool for both Sudoku enthusiasts and
developers interested in algorithmic challenges, further inspiring exploration in the field of
artificial intelligence and automated problem-solving.

5.2 Lesson Learnt / Outcome

The development of the Sudoku Generator and Solver provided valuable insights into
algorithm design and problem-solving techniques. It highlighted the importance of
backtracking as a method for both generating puzzles and solving them efficiently. This
project reinforced the understanding of recursion and how to manage complex problem
constraints. Additionally, it emphasized the significance of ensuring uniqueness in
generated puzzles and the challenges associated with maintaining varying levels of
difficulty. Overall, this experience enhanced programming skills and deepened
appreciation for the logical structure behind games like Sudoku, illustrating how
mathematical concepts can be applied in practical programming scenarios.

5.3 Future Recommendation

To further enhance the Sudoku Generator and Solver, several improvements can be made
for increased efficiency and user experience:

Algorithm Optimization: Improving the existing algorithm to make it faster can be

achieved by implementing advanced techniques such as constraint propagation and using
heuristic approaches. Techniques like the Dancing Links algorithm could be explored to
enhance the efficiency of the solving process, allowing for quicker resolution of puzzles.

Notes Feature: Implementing an ability for users to add notes in each cell would provide a
crucial aid for players, especially beginners. This feature would enable users to jot down
possible values for each cell, fostering a deeper engagement with the puzzle-solving
process.

44
45
 References

[1] R. Bird, "FUNCTIONAL PEARL: A program to solve Sudoku," Journal of

Functional Programming, pp. 1-2, 2006.

[2] K. L. Eric C. Chi, "Techniques for Solving Sudoku Puzzles," Cornell University,
2012.

[3] "Algorithm to Solve Sudoku | Sudoku Solver," geeksforgeeks, 30 July 2024. [Online].
Available: https://www.geeksforgeeks.org/sudoku-backtracking-7/.

[4] R. K. P. Arnab Kumar Maji, "Sudoku solver using minigrid based backtracking,"
IEEE, 2014.

[5] T. Kovacs, "Artificial Intelligence through Search: Solving Sudoku Puzzles,"

Department of Computer Science, University of Bristol, Bristol, 2008.

[6] D. E. Knuth, "Dancing links," Cornell University, 2000.

[7] C. M. Hoffmann, "Summary of basic 2D constraint solving," 2004.

[8] J. F. Crook, "A Pencil-and-Paper Algorithm for Solving Sudoku Puzzles," Notices of
the AMS, vol. 56, no. 4, p. 460, 2009.

[9] "Requirement Analysis Techniques," [Online]. Available:

https://www.visualparadigm.com/guide/requirements-gathering/requirement-analysis-
techniques/.

[10] D. N. Patrik Berggren, "A study of Sudoku Solving Algorithms," 2012.

46
Unit Testing for Cab Booking System
1. Unit Testing of Registration

Test Case ID: CABRegister001

Test Case Type: Unit Testing
Requirement No: 1
Module: User Registration
Status: XXX
Severity: Critical
Values: Username = "JohnDoe", Password = "Pass1234"
Pre-condition: Required one user to be registered

Steps for Unit Testing:

Step Actual
Steps Inputs Expected Result Status
No. Result

Open the "Cab

As
1 Booking" - Displays Login Page Pass
expected
application

Click on Opens the As

2 - Pass
"Register" Button Registration Page expected

Displays dialog
Enter invalid Username = Null, As
3 "Please fill in all the Pass
registration details Password = Null expected
fields"

Username = Displays dialog

Enter valid As
4 "JohnDoe", Password "Registration Pass
registration details expected
= "Pass1234" Successful"

2. Unit Testing of Login

Test Case ID: CABLogin001

Test Case Type: Unit Testing
Requirement No: 1
Module: User Login

47
Status: XXX
Severity: Critical
Values: Username = "JohnDoe", Password = "Pass1234"
Pre-condition: Required one user to log in

Steps for Unit Testing:

Step Actual
Steps Inputs Expected Result Status
No. Result

Open the "Cab

As
1 Booking" - Displays Login Page Pass
expected
application

Username = "John", Displays dialog

Enter invalid As
2 Password = "Invalid username or Pass
login details expected
"WrongPass" password"

Username = Opens the homepage

Enter valid login As
3 "JohnDoe", Password with the booking Pass
details expected
= "Pass1234" options

3. Unit Testing of Cab Booking

Test Case ID: CABBook001

Test Case Type: Unit Testing
Requirement No: 2
Module: Cab Booking
Status: XXX
Severity: Critical
Values: Pick-up Location = "Main Street", Destination = "Airport", Time = "12:30 PM"
Pre-condition: User must be logged in

Steps for Unit Testing:

Step Actual
Steps Inputs Expected Result Status
No. Result

Open the "Cab Displays booking

As
1 Booking" - options (pick-up, Pass
expected
homepage destination, time)

Pick-up = "", Displays dialog

Enter invalid As
2 Destination = "", Time = "Please fill in all Pass
booking details expected
"" booking fields"

3 Enter valid Pick-up = "Main Street", Displays booking As Pass

booking details Destination = "Airport", confirmation with

48
 Time = "12:30 PM" fare details expected

4. Unit Testing of Payment Process

Test Case ID: CABPay001

Test Case Type: Unit Testing
Requirement No: 3
Module: Payment Process
Status: XXX
Severity: Critical
Values: Payment Method = "Credit Card"
Pre-condition: User must have a confirmed booking

Steps for Unit Testing:

Step Actual
Steps Inputs Expected Result Status
No. Result

Open the "Cab

Displays payment As
1 Booking" - Pass
options expected
confirmation page

Displays dialog
Enter invalid Credit Card = "", As
2 "Invalid payment Pass
payment details Expiry = "" expected
details"

Credit Card = "1234- Confirms the

Enter valid 5678-9012-3456", payment and displays As
3 Pass
payment details Expiry = "12/25", "Payment expected
CVV = "123" Successful"

System Testing for Cab Booking System

1. System Testing of Cab Booking System (User Side)

Test Case ID: CABSystem001

Test Case Type: System Testing
Requirement No: 1

49
Module: All Modules
Status: XXX
Severity: Critical
Values: Username = "JohnDoe", Password = "Pass1234"
Pre-condition: Required one user to perform all system functionalities

Steps for System Testing:

Step Actual
Steps Input Expected Result Remarks
No. Result

Open the "Cab

Opens the Login As
1 Booking" - Pass
Page expected
application

Click on
Opens the As
2 "Register" - Pass
Registration Page expected
button

Username = Displays dialog

Register using As
3 "JohnDoe", Password "Registration Pass
valid details expected
= "Pass1234" Successful"

Username =
Login using Opens homepage As
4 "JohnDoe", Password Pass
valid details with booking options expected
= "Pass1234"

Pick-up = "Main
Displays booking
Book a cab with Street", Destination = As
5 confirmation with Pass
valid details "Airport", Time = expected
fare details
"12:30 PM"

Displays payment
Proceed to Credit Card details As
6 confirmation with Pass
payment provided expected
success message

View booking Displays past As

7 - Pass
history bookings history expected

50