Killer Sudoku Solver.

Transcription

1 Killer Sudoku Solver Student: Mohammed Rizwan Supervisor: Dr. Andrea Schalk Date: 29 th April

2 Killer Sudoku Solver Student: Mohammed Rizwan Supervisor: Dr. Andrea Schalk Date: 29 th April 2008 Abstract Killer Sudoku is a puzzle game which combines elements of two other puzzle games, Sudoku and Kakuro. However, when compared to original Sudoku, there has been relatively little research conducted into the logic and techniques required to complete Killer Sudoku puzzles. This report describes the design and development of the Killer Sudoku Solver, which solves Killer Sudoku puzzles by employing human-like reasoning. To prove its success, the solver is able to explain its decisions and works with user-inputted puzzles. The results of how the solver performs are discussed in detail, which are then used to evaluate the success of this project. Possible extensions to the solver are also discussed. 2

3 Acknowledgements Firstly, I would like to like to thank Dr. Andrea Schalk, for her invaluable support and guidance throughout the course of the project. Thanks also go to the Killer Sudoku community, my friends and of course, my family. 3

4 Table of Contents Chapter 1: Introduction Sudoku and Killer Sudoku in the United Kingdom The Project Project Objectives Functional Requirements Non-Functional Requirements...13 Chapter 2: Background Sudoku Solving Techniques Measuring Difficulty Kakuro Solving Techniques Measuring Difficulty Killer Sudoku Solving Techniques Measuring Difficulty Software Development Methodology Waterfall Methodology Spiral Methodology The Unified Process...29 Chapter 3: Design Design Overview Development Methodology Decision Program Architecture Internal Representation Grid Game Puzzle State Puzzle History Grid Restriction User Interface Eight Golden Rules of Interface Design Use Case 1: Play and Solve a Puzzle Use Case 2: Input a Puzzle Solver Input Designs Solver GUI Designs Puzzle Input GUI Design Solving Techniques...41 Chapter 4: Implementation and Solving Techniques Development Tools

5 4.2. Internal Representation Puzzle Grid Initialisation Puzzle History User Interface Solver Grid Puzzle Input Grid Puzzle Input Error Prevention Cell Colours User Input Help Documents Solving Techniques Evaluators Grid Manipulator Rule Interface One and Two Solution Cages Technique Row and Column Value Checker Technique Holes and Stubs Techniques Sum Checker Technique Cage Possible Finder Technique Eight Cell Technique Cell Impossible Count Technique Cage Completion Technique...58 Chapter 5: User-Software Interaction Use Cases Play and Solve Puzzle Use Case Input Puzzle Use Case Puzzle History Usage One Solution Technique Holes Technique Sum Checker Technique Value Checker Technique...66 Chapter 6: Results Solver Success Effectiveness of the Solving Techniques Puzzle Difficulty...71 Chapter 7: Conclusion Project Summary Conclusion Future Work...77 References

6 Glossary...82 Appendix A: Eight Golden Rules of Interface Design...83 Appendix B: XML Puzzle...85 Appendix C: User Help Documents...88 Appendix D: Killer Sudoku Questionnaire

7 Table of Figures Figure 1.1: Dr. Kawashima s Brain Training screenshot...9 Figure 2.1: A Sudoku puzzle from The Times Figure 2.2: The result of cross-hatch scanning...16 Figure 2.3: Sudoku puzzle showing the use of the candidate lines technique...17 Figure 2.4: An X-Wing Figure 2.5: An empty Kakuro puzzle Figure 2.6: A solved Kakuro puzzle...20 Figure 2.7: Cross referencing...22 Figure 2.8: Criss-cross arithmetic...23 Figure 2.9: Criss-cross arithmetic with multiple cells...23 Figure 2.10: A typical Killer Sudoku puzzle...25 Figure 2.11: Stub technique with two columns Figure 3.1: Input method one Figure 3.2: Input method two Figure 3.3: Design 1 for the solver interface...38 Figure 3.4: Design 2 for the solver interface...39 Figure 3.5: Design for the puzzle input screen...41 Figure 4.1: Overview of the internal representation of the software Figure 4.2: XML representation for a puzzle in its initial state Figure 4.3: XML representation for a puzzle in its second state...45 Figure 4.4: Code extract from the parsecell() method...47 Figure 4.5: Code extract from the parsecage() method Figure 4.6: An example puzzle history window...48 Figure 4.7: A grid showing a half-completed puzzle...50 Figure 4.8: Error message displayed when user inputs an erroneous cage...51 Figure 4.9: Grids displaying the default colours and the max colours Figure 4.10: Code implemented for the Rule interface Figure 5.1: Puzzle selection...59 Figure 5.2: User attempt at the puzzle Figure 5.3: The action history...60 Figure 5.4: Text-free history Figure 5.5: The states of the puzzle; from a fully incomplete puzzle to a complete one...61 Figure 5.6: Message notifying the user that the solver could not solve the puzzle...62 Figure 5.7: Input of pre-filled cells Figure 5.8: Input of the cages...63 Figure 5.9: Edit Cage and Delete Cage options...63 Figure 5.10: Invalid puzzle notification Figure 5.11: A one solution cage...64 Figure 5.12: One Solution Cage explanation...64 Figure 5.13: A screenshot of a two cell hole...65 Figure 5.14: One Region Hole possible set...65 Figure 5.15: Effect of the hole technique...65 Figure 5.16: Sum Checker technique screenshot...66 Figure 5.17: Sum Checker explanation Figure 5.18: Value Checker screenshot...67 Figure 5.19: Value Checker rule explanation

8 Figure 6.1: Success rate histogram for the Killer Sudoku Online website Figure 6.2: Success rate histogram for the The Times book...69 Figure 6.3: Success rate histogram for the The Big Book of Killer Su Doku book...70 Figure 6.4: Solving technique analysis...71 Figure 6.5: Comparison of solved and unsolved puzzles...72 Figure 6.6: Average states histogram for the Killer Sudoku Online website Figure 6.7: Average states histogram for the The Times book...73 Figure 6.8: Average states histogram for the The Big Book of Killer Su Doku book...74 Figure 7.1: A puzzle which could not be further solved by the solver

9 Chapter 1: Introduction 1.1. Sudoku and Killer Sudoku in the United Kingdom Over the last 3 years, the popularity of Sudoku in the United Kingdom has risen considerably [1]. Sudoku is a number placement game played on (typically) a 9 x 9 grid. The grid is empty, except a few cells, for which values are provided. These pre-filled cells are expected to provide enough clues to help the user fill in the rest of the grid. The grid must then be completed such that every row, column and nonet 1 contains every digit from 1-9 (depending on the grid size) exactly once. A certain degree of logic is required to solve the various Sudoku puzzles. British newspapers have done much to promote Sudoku by publishing daily puzzles and even producing books containing many Sudoku puzzles. In recent years, Sudoku has also found a home in our computers, appearing on many Sudoku-dedicated websites and even in video games (Figure 1.1). This has led to a wider range of players having access to Sudoku puzzles, and has also meant that such puzzle games are no longer restricted to just being played with a pen and paper. Figure 1.1: A screenshot [2] from the popular Nintendo DS game, Dr. Kawashima s Brain Training, which has topped 1m sales in the UK [3]. 1 All items in bold are further explained in the Glossary. Additionally, references are cited using square brackets; i.e. [ ]. Full details of references are presented in the References section of this report. 9

10 The increased levels of interest have resulted in extensive research being conducted into Sudoku. Techniques for both solving and creating puzzles have been the subject for much of this study. The research has largely been successful, with highly advanced solvers available freely over the Internet. However, the focus of this project is not Sudoku, but is in fact a variant called Killer Sudoku. The premise of Killer Sudoku is the same as that of Sudoku; namely to complete the grid with every row, column and nonet containing the digits from 1-9 exactly once 2. The fundamental difference is that, unlike Sudoku, the grid does not have any pre-filled cells. Rather, the player is faced with an empty grid made up of cages. Each cage has a value attached to it and is made up of an indeterminate number of cells. The sum of the cell values in the cage must be equal to the cage value. This additional mathematical aspect comes from a puzzle game called Kakuro. These cages are the only hints the player has in order to complete the puzzle. There is much to suggest that Killer Sudoku will find popularity in the United Kingdom, and indeed, in the western world. Much like Sudoku before it, Killer Sudoku became popular in Japan first, where Killer Sudoku (or Samunamupure as it is known in Japan; Killer Sudoku is a phrase coined by The Times [4]) became the choice game for those who had grown weary of Sudoku, or indeed for those who were simply looking for a puzzle game to complement Sudoku. One could propose that we are witnessing this already in the United Kingdom. National newspapers, such as The Times and Guardian, have already started printing daily Killer Sudoku puzzles on their games pages, and many bookshops now stock Killer Sudoku puzzle compilations alongside original Sudoku books. Despite the growing popularity of Killer Sudoku, there has been relatively little study expended into the formulation of Killer Sudoku solving techniques. Whilst various websites contain some tips for players, they are not particularly exhaustive, and certainly would not help players tackle the harder Killer Sudoku puzzles. Most importantly however, a logical Killer Sudoku solver does not yet exist. 2 Unless stated otherwise, I will assume that the Sudoku and Killer Sudoku puzzles under discussion are being played on 9x9 grids. 10

11 1.2. The Project Project Objectives The aim of the project was to produce a solver for Killer Sudoku. Unlike many of the Sudoku solvers out there, this solver aimed to use human-like reasoning and behaviour to solve Killer Sudoku puzzles. This would mean that each puzzle would be approached differently, with the solving policy being adapted for each puzzle. The alternative to this approach would be to create a solver which employs a brute-force solving strategy. This would involve trying out every possible value at every cell, and iterating until the solution was reached. While this would invariably solve puzzles, it would not provide us with any useful analyses on Killer Sudoku. We would not be able to find the most effective solving techniques or even attempt to surmise the factors which contribute towards the difficulty of Killer Sudoku puzzles. By imitating a human player however, the solver would be able to explain its decisions to the user, to show exactly how a puzzle was solved. This would then provide the opportunity for the solver to be used as a learning aid, for players who wish to become more proficient Killer Sudoku players. Furthermore, it was hoped that analysis of the performance and behaviour of the solver would reveal effective solving techniques, how to measure the difficulty of Killer Sudoku puzzles and more. Thus, the objectives identified for the project were: Objective 1: To develop a program which solves Killer Sudoku puzzles by employing human-like logic and reasoning. Objective 2: To assess the effectiveness of the various solving techniques. Objective 3: To investigate the means by which the difficulty of Killer Sudoku puzzles can be measured Functional Requirements The following functional requirements were identified: 11

12 1.2.2a: The software should be able to solve medium-rated difficulty puzzles from the Killer Sudoku Online [5] website. In order to test the capabilities of the solver, it is imperative that the puzzles used are challenging. Additionally, they should come from a source which regularly publishes an array of puzzles; ranging from easy to difficult puzzles, with a level of consistency between the various difficulties. Upon discussion with Dr. Andrea Schalk, it was agreed that the puzzles from the Killer Sudoku Online website will be used. This does not mean that testing is limited to just this source b: Users should be able to input puzzles into the software. In order to provide the solver with puzzles to solve, a mechanism to allow users to input their own puzzles should exist c: The software should allow users to play Killer Sudoku. To effectively fulfil the software s role as a learning aid, it is essential that the users are first allowed to attempt the puzzle d: The solver should provide the user with feedback, explaining the steps it took in order to solve a puzzle. Upon solving a puzzle, the solver must offer a detailed explanation of how the puzzle was solved. The user should be able to step through the solution, viewing the result of the decisions the solver made e: If the solver cannot successfully solve a puzzle, it should notify the user of this and subsequently present the user with the half-completed puzzle. It is likely that the solver will have to attempt a puzzle it cannot solve. In such cases, the solver must be able to make available its progress to the user. The user will then be able to attempt to complete the rest of the puzzle. 12

13 Non-Functional Requirements The following non-functional requirements have been identified: 1.2.3a: Help documentation should be provided. Due to the fact that the solver is aimed at all types of users, help documentation is required to cater for those who are unfamiliar with Killer Sudoku, or who simply need help operating the software b: The solver should be able to solve puzzles quicker than a human player. While the main priority is for the software to solve Killer Sudoku puzzles, it should do so in less time than it would take for a human player to solve the puzzle c: The software should be platform independent. The program must work on various operating systems. 13

14 Chapter 2: Background 2.1. Sudoku As discussed, Sudoku is a number placement game typically played on a 9 by 9 grid. The aim of the game is to fill the grid, ensuring that every row, column and nonet contains the digits 1-9 exactly once. Originally created in New York in 1979 where it was named Number Place, Sudoku found widespread popularity in Japan during the late 1980s and throughout the 1990s [6]. In recent years, Sudoku has become a household name in the UK, with regular puzzles being published in newspapers and on dedicated websites Solving Techniques The techniques needed for solving Sudoku puzzles are well documented, to the extent that the many techniques now have an agreed name within the Sudoku community. In general, there are two types of solving techniques; one type which results in the assignment of a value to a cell, and the second type which helps to reduce the possible values a cell might be. Some techniques for solving Sudoku puzzles are examined: Sudoku Technique 1: Naked Single Cells which have only one possible value are known as Naked Singles. Such cells may not be obvious naked singles from the outset, and as a result, need to be checked for regularly. Furthermore, naked singles can become apparent in a number of ways. For example, when a row, column or nonet has had 8 of its cells filled in, the remaining cell in the region will only have one possible value, thus becoming a naked single. Sudoku Technique 2: Hidden Single Hidden singles are cells which seemingly have many different possible values, but upon closer inspection, can actually only contain a certain value. Unlike naked singles where 14

15 a cell is marked with only one possibility, hidden single cells may be marked with many possibilities. However, by examining the region the cell belongs to, one may notice that a value appears only in that cell as a possibility. As all values must appear exactly once in a region, the other possible values for the cell must therefore be discarded. Sudoku Technique 3: Cross Hatch Scanning Cross hatch scanning [7] is a technique used to eliminate possible values from cells and can lead to some cells being assigned values. The technique involves looking at each numeral from 1 to 9, and drawing a line through any rows and columns in which they appear. In general, those numerals which have the most occurrences in the grid are targeted first. The result of this process is a grid in which one can visually see where the numeral can and can not occur. Consider the example Sudoku puzzle given in Figure 2.1. Figure 2.1: A Sudoku puzzle [8] from The Times. This particular puzzle was rated as Difficult. The puzzle shown in this figure has not had any cells solved yet (i.e. the cell values shown are the pre-filled ones). By employing the cross-hatching technique on this grid we find that 15

16 the value 1 must go into the cells R1C2 and R4C7 3 scanning reveals that cell R6C7 must contain a 3. (Figure 2.2). Further cross-hatch Figure 2.2: The result of cross-hatch scanning with the numeral 1. Sudoku Technique 4: Candidate Lines The candidate lines technique is one which helps minimise the possible values a cell can contain. Whereas the cross-hatch scanning relied on looking primarily along rows and columns, the candidate lines strategy examines the possible values in each nonet first. Upon doing so, the player can identify which possible values lie within the same row or column. If they lie in just one of these horizontal or vertical regions, the value under scrutiny can be removed as a possible value from the rest of the row or column. The example in Figure 2.3 shows clearly the use of this technique. Looking at the bottom-right nonet 4, the value 4 is only possible in column eight. Therefore, the rest of this column can not contain a 4, meaning that any cells with the possible value of 4 are amended accordingly. This allows the player to deduce that cell R7C8 must hold the value 2. 3 Cell coordinates will be given in the form RpCq, where p and q are the row and column numbers respectively. Figure 2.1 displays the row and column numbers. 4 Nonets, like rows and columns, will also be numbered, and will be presented in the form Nr, where r is a number from 1 to 9. The numbering will start from left to right, advancing from bottom to top. Hence, the bottom-right nonet is given by N3. 16

17 Figure 2.3: Sudoku puzzle showing the use of the candidate lines technique [9]. Although not a solving technique in itself, an important task for players is to mark any possible cell values they have worked out. These markings are known as pencil marks. Sudoku Technique 5: X-Wing There are occasions during the puzzle when a value can only be housed in four cells in a particular way: two of these cells lie in one row, and the other two belong in a different row. Furthermore, these two of these cells also lie in a particular column, with the remaining two in a separate column. In such a case, the X-Wing technique comes into play. A simple way to spot an X-Wing is when a rectangle can be formed by the cells involved. The X- Wing technique is principally used to minimise the possible values a cell can contain. An example of an X-Wing is given in Figure

18 Figure 2.4: An X-Wing with the value 1 [10]. As is visible, an X-Wing has been formed with the highlighted cells: R2C4, R2C7, R6C4 and R6C7. The value 1 must be present in column 4 and in column 7. Thus, if cell R2C4 contains a 1, then R2C7 can not contain it, meaning that R6C7 will therefore contain 1. The reverse case is also true. This allows for the value 1 to be removed from the possible values of all other cells in rows 2 and 6. In this particular example, the result is that cell R6C9 is assigned the value Measuring Difficulty Although Sudoku puzzles vary in difficulty, there is still much debate as to how to measure this. It was initially felt that the number of given values could be used as a barometer of difficulty. However, Helmut Simonis research into Sudoku [11] suggests that there are actually three main factors which influence the difficulty of a puzzle: The number of pre-filled cells. The placement of the pre-filled cells. 18

19 The value of the pre-filled cells. The combination of these three determines the techniques required to solve a given puzzle. The more complex the solving strategy required (such as X-Wing compared to cross-hatch scanning), the more difficult the puzzle is. This idea has been incorporated by many puzzle setters, and as a result the difficulty of puzzles is now rated on the solving strategies needed to complete the puzzle Kakuro Kakuro is a puzzle game which requires the user to employ simple arithmetic and logic to solve it. It is often referred to as the mathematical transliteration of the crossword [12] due to the grid appearance and the fact that the entries of white cells are filled horizontally (from left to right) and vertically (from top to bottom). Similar to a crossword, the aim is to completely fill in the white cells. In Kakuro however, the black cells provide the clues needed to complete the game. Every white cell should be filled such that the values in each entry sum to equal the number in the corresponding black cell. It must be noted that a cell can not contain a value less than 1 or greater than 9. Of course, puzzle setters are free to choose their own colours, and are not forced to use black or white. An example of an empty (Figure 2.5) and solved (Figure 2.6) Kakuro puzzle is provided. As one can see, none of the cells are pre-filled. Like Sudoku, its origins lie in New York, where it was first published by Dell Puzzle Magazines (the same magazine to first print Sudoku). Kakuro has been hugely successful in Japan, and has started to emerge in Britain [13], with some newspapers providing daily puzzles for their readers. 19

20 Figure 2.5: An empty Kakuro puzzle [14]. Figure 2.6: A solved Kakuro puzzle [14] Solving Techniques In comparison to Sudoku, techniques for completing Kakuro puzzles are not as well documented. While tips can be found, the names given to each solving strategy varies from source to source. It is interesting to note that many sources do not make a clear distinction between simple techniques and more advanced ones. This suggests that all techniques are used, irrespective of the puzzle s difficulty. 20

21 Kakuro Technique 1: Lone Square When there is only one cell remaining in an entry, its value must be equal to the required sum of the entry, minus the sum of the filled in values. For example, if an entry has three cells, two of which are filled with value 5 and 6, and its total must be equal to 12, the remaining cell must contain the value 1, as 12 (5 + 6) is equal to 1. Kakuro Technique 2: Single Solution Entries A technique for generating useful possible cell values quickly is to target those entries which only have a single value combination. An example would be to create the sum of 17 using only two cells. There is only one solution for this and that is With this information the user can further reduce the possible values of any adjacent entries. Entries which have two possible value combinations are also considered as they can often provide hints as to which values are definitely required in the entry. An example is an entry of sum 8 with three cells; it can be filled with or We can see that the value 1 is definitely going to appear in the entry. Kakuro Technique 3: Cross Referencing Cross referencing works by recognising where vertical and horizontal entries cross. The sum combinations for both entries are calculated; any values which appear in all combinations for both entries are candidates for being placed in the cell where the entries cross. 21

22 Figure 2.7: Cross referencing performed on the highlighted cell. While initially it seems that this technique only helps reduce the possible values for the cell in question, in some cases, it can result in a value being assigned. The example in Figure 2.7 presents such a case. The highlighted cell shows where the horizontal 12 sum entry and the vertical 6 sum entry cross. Although there are various ways create the sum of 12 using two numerals, there is only one combination which allows 6 to be created from three numerals; This means that the highlighted cell must hold the value 1, 2 or 3. By reviewing the combinations for the 12 entry, we can see that 12 can not be created by using a 1 or a 2. It can however be created by using a 3 (and adding 9). Therefore, the value of the highlighted cell must be 3. Kakuro Technique 4: Criss-Cross Arithmetic The criss-cross arithmetic technique focuses on those cells which appear at turning points on the grid, and are often referred to as corner-squares. They can be recognised as they often provide links from a cluster of entries to another cluster. As a result, there are only ever a few of these types of cells in a grid. The criss-cross strategy adds and subtracts the sums of the entries to determine the value of the corner-square. An example is shown in Figure

23 Figure 2.8: Criss-cross arithmetic performed on the highlighted cell. This cell is often referred to as a corner-square. The value for the highlighted cell is deduced by taking the sum of the vertical entries, , and subtracting the sum of the horizontal entries, Therefore, the value of the highlighted cell is equal to 21 minus 19; which is 2. It must be noted that this technique can work for multiple connected corner-squares (Figure 2.9). In such cases, the technique will not necessarily assign values to the cells, but will reduce the possible values the cells can contain. Figure 2.9: Criss-cross arithmetic with multiple cells [15]. 23

24 Measuring Difficulty As pre-filled values are generally not provided (though they can be included by the puzzle setter to make the puzzles very easy), the factors which determine the difficulty of Kakuro puzzles differ from those of Sudoku. One of the obvious ways to determine difficulty is by examining the provided clues. If there are many entries whose clues indicate that there are only one or two possible combinations, the puzzle will be easier than those with fewer single combination entries. However, there is no agreed means of measuring and setting difficulty for Kakuro, and as a result, difficulty is often set depending upon how long it takes an average skilled player to complete the puzzle. In order to make Kakuro puzzles more difficult, some puzzle setters have started to add twists to the rules, such as using multiplication instead of addition and decimal numbers in place of integer values Killer Sudoku Killer Sudoku is a variant of Sudoku which incorporates the mathematical elements of Kakuro. The grids have rows, columns and nonets indistinguishable from Sudoku, and additionally contain cages made up of numerous cells. These cages have the same purpose as entries do in Kakuro. The aim of the game is to complete the grid ensuring that every region contains the values from 1 to 9 exactly once, and that the sums of the cages are met exactly by the values in the cage cells. Other constraints imposed are that cages can not contain duplicate values, and thus, can not contain more than nine cells. An example puzzle can be seen below (Figure 2.10). Its reputation in Japan has garnered much attention from the Western world. Although its popularity has not quite reached those levels achieved by Sudoku, it has certainly proven to be more popular than Kakuro, with many Killer Sudoku puzzle books now available. Additionally, dedicated Killer Sudoku websites and newspapers have begun to publish daily Killer Sudoku puzzles. 24

25 Figure 2.10: A typical Killer Sudoku puzzle [5] Solving Techniques Killer Sudoku Technique 1: Single and Double Solution Cages Similar to Kakuro technique 2, this technique inspects those cages which have only one possible value combination. In doing so, the possible values for the cells in that cage can be drastically reduced. In some cases, any cells which lie in the same region as the cage cells can also be affected. This also works by looking at cages which have multiple possible value combinations and spotting those values which appear in all combinations. However, it is very time consuming to examine all cages in this way, so often only those cages which have one or two possible solutions are considered. This technique is normally employed at the start of a puzzle, and provides some initial values to work with. 25

26 A cage which has three cells and a sum value of 23 is an example of a single solution cage. It can only be created using However, if the cage had a sum value of 22, it would be a double solution cage as the possible value combinations are and Killer Sudoku Technique 2: Sub-Cage Analysis With every cell that is completed, the number of unsolved cells in the cage it belongs to is reduced. Thus, the remaining cells can be thought of as a sub-cage of the original cage. If the number of cells in the sub-cage is one, then the value for the cell must be equal to the cage sum minus the sum of the cell values in the cage. However, if the number of the cells in the sub-cage is greater than one, then the sub-cage can be checked to see if it is a single or double solution cage. This can further reduce the possible values of the remaining cells in the cage, and those which share the same regions as the cells. Killer Sudoku Technique 3: Stubs and Holes There are often cases when nearly all of a region s cells belong to cages which do not span into other regions. For example, there may be a row which has eight of its cells belonging to cages which do not span any other rows. However the ninth cell may be a part of a cage which does span multiple rows. In this case, this cell is a hole. With the knowledge that the total sum of the row must be 45, the value of the ninth cell can be worked out. This is done by subtracting the sum of the cage sums from 45. If one considers the cells of a cage which spans into other regions, a stub may be found. This occurs when the cage in question has only one cell which belongs to a different region. The stub cell can be worked out by totalling the cage sums and subtracting 45. While the above examples illustrate that stubs and holes can be used to assign values to cells, it is often helpful to consider stubs and holes which may be made up of multiple cells. Although this technique may not allocate any values to the cells, the possible values of the cells may still be reduced further. An advanced holes and stubs technique is one which treats multiple bordering regions as one region. Figure 2.11 shows an example of a two column stub. In the example, the cages in columns eight and nine are almost all contained wholly in those two columns. 26

27 However, one cage spans over into column 7. The cell in C7 can therefore be treated as a stub, the value of which can be worked out by adding up the cage totals, and subtracting 2 x 45 from it (2 times 45 is done as two columns are being used). The sum of the cages is 99, thus the value of the cell is 99 minus 90, which is equal to 9. Figure 2.11: Stub technique with two columns [5] Measuring Difficulty As discussed, the difficulty of Sudoku can be measured by examining the values provided by the puzzle setter. But as Killer Sudoku puzzles generally do not contain prefilled cells, we find that, like Kakuro, there is not an agreed way to measure and attach a difficulty level to a puzzle. Some puzzle setters mark the difficulty dependent upon how long it would take a player to complete the puzzle. Others try to assess the complexity of the solving strategies required, and assign the difficulty accordingly. Some sources simply change the grid size; smaller grids are used for beginners as this reduces the number of possible values and also makes the arithmetic simpler. Conversely, larger grids increase the difficultly level of the puzzles. One of the aims of this project is to try to determine a uniform way of measuring the difficulty of puzzles. 27

28 2.4. Software Development Methodology A key decision in the software development process is the choice of software development methodology to be used. The methodology chosen determines the order in which the various modules of software are developed and can also specify how much time is to be spent on the various phases of software development (such as requirements analysis, design, implementation etc). I will briefly consider three possible methodologies Waterfall Methodology When using the waterfall methodology, the phases of the development process do not overlap. As a result, once one phase ends, the next one begins. This sequential nature of the waterfall model means that it is often used in projects where the requirements of the system are well understood. This has resulted in criticism of the waterfall model. David L. Parnas, the developer of the concept of modular design, has stated that the constantly changing nature of software development requires backtracking to the earlier phases regularly [16]. Further studies confirm Parnas beliefs, with one source claiming that 87% out of over a thousand projects using the waterfall model failed, before continuing to state that waterfall-style scope management was the single largest contributing factor for failure, being cited in 82% of the projects as the number one problem. [17] Spiral Methodology The spiral methodology can be thought of as an iterative version of the waterfall methodology. The project is broken up into spirals, with each spiral containing every phase (from requirements through to system integration). Early spirals are often used to produce 28

29 prototypes of the final program. Analysis of the prototypes can lead to new requirements and designs for the following spirals [18]. The tentative make-up of the spiral model means that it can often be a long time before usable components are available to the end-user The Unified Process The Unified Process is a methodology designed to be as flexible as the project requires. As a result, there exist many different adaptations of it and it is applicable to projects of varying size. The main idea behind the Unified Process is that everything produced at any given point is developed to a standard such that it can be included in the final system. This means that prototypes are not explicitly created. Additionally, it avoids the pitfalls of the waterfall cycle by being an iterative process. Iterations are referred to as timeboxes. Within each timebox, a component of the final system is completely developed, from design to testing, and is integrated into the partially developed system. Furthermore, the most important units of the system are developed first [19]. 29

30 Chapter 3: Design 3.1. Design Overview Development Methodology Decision Before work on a software development project can begin, a development methodology must be chosen. As noted earlier, the selected methodology determines how the project is developed. The advantages and disadvantages of three different methodologies were discussed; waterfall, spiral and the Unified Process. Upon consideration, the Unified Process methodology was chosen. The timescale of the project suggested that there simply was not enough time to develop prototypes as suggested by the spiral methodology. The sequential nature and failure rate of the waterfall model suggest that it is not suited to this project, where the requirements are not fully known before the design and implementation. The flexibility of the Unified Process was appealing, as it allowed for the riskiest elements of the system to be built first. The knowledge gained of the domain and technology would then be available for use to aid the development of the subsequent system components Program Architecture Upon entering the design phase, the architecture of the system was divided into three parts using the Model, View and Controller (MVC) architectural pattern. The MVC pattern is used to divide the system logic from the visual interface the user sees. This allows the logic components to be changed without requiring a change in the user interface components (and vice versa). Although this separation of system units is not an explicit requirement, it is a desirable feature to have in a software project. The three components as identified by the MVC pattern are: Model: The model refers to the internal representation of the system. The grid, cells, cages etc. are presented to the other system components for modification. 30

31 View: The view refers to the visual interface of the system. This allows users to understand the state of the system. In particular, the interface informs the user of the status of the puzzle, as well as presenting the various options available to the user. Controller: The controller refers to the components of the system that alter the state of the model. The model can be altered in two ways: by the solving techniques and by user events (e.g. key presses, mouse clicks) Internal Representation When following the style of a Unified Process guided project, system components are built in timeboxes. Additionally, those components which are the riskiest or most important are developed first. Although it could be argued that the collection of solving techniques the solver employs is the most important component, a framework needed to be designed, implemented and tested first. As a result, the first timebox was allocated to creating the model for the solver. The model provides the internal representation for the Killer Sudoku game. In order for a Killer Sudoku game to be modelled, a representation was needed for the grid, and for the game itself. It must be noted that the system was designed to be implemented as an objectoriented software project. In order to better support the MVC pattern in an object-oriented program, two sets of design patterns were used; GRASP patterns and Gang of Four Patterns [19]. These patterns helped to decide upon the objects needed, and the responsibilities to be assigned to each object. A Killer Sudoku grid is made up of many parts; cells, regions (rows, columns and nonets) and cages. The high cohesion design pattern suggests that objects should be focused and manageable. This results in objects which have a precise meaning and role within the software. By applying this pattern, it can be seen that the components which make up the grid (the cells, regions and cages), should be contained within individual objects. 31

32 Grid Cells, regions and cages are represented as individual objects. The grid is an object which contains the cell, region and cage objects, as well as information on its current state. For example, it is aware of how many of its cells have had a value assigned to them. Due to the separation of the components in the grid, the grid object is the only one which has exclusive access to them all. For example, as cell can not access information belonging to its row directly, the grid object provides the information. This form of object separation supports another design pattern; low coupling. The low coupling pattern proposes that the impact of change can be reduced if the responsibilities between objects is minimised. This can be seen in the case above, where the grid is the only object with the responsibility of holding the information of all the other components. As a result, if the information in one of the components changes, the only other object affected is the grid. It must be made clear, that whilst the grid is highly coupled to the other types of objects, it still remains highly cohesive. The low impact of change provided by the use of the design patterns further supports the aims of an MVC architectural system Game While the grid contains the information that the user is concerned with (i.e. cell values, cage sums and lengths etc.), the game is responsible for handling the execution of the solving techniques to be applied to the grid. In addition to these responsibilities, the game also monitors the state of the grid, and deduces whether progress is being made. If not, subsequent solving techniques are applied accordingly. Additionally, the game is responsible for holding the information regarding the various states the grid has been in. This information is then relayed onto the user as part of the feedback (as specified by functional requirement 1.2.2d). 32

33 Puzzle The puzzle is responsible for providing the data required to initialise the grid. In particular, the puzzle describes the cages. The descriptions include the sum of the cage, as well as the cells included in the cage. As some puzzles help the user by providing a number of pre-filled cells, the puzzle must also provide these cell values to the grid. The initialising information held by the puzzle is regarded as the first state of the game State In essence, states are used as a measurement of time in the puzzle. Each state provides a snapshot of the grid at a particular time. The puzzle moves onto the next state upon each cycle of its solving techniques. The state holds the values of each cell, as well as any possible and impossible values the cells have. By storing the details of each state in the game, the progress of the puzzle can be viewed from the beginning to the end Puzzle History The system is able to provide the user with an account of how the puzzle was solved. In particular, this account describes the history of actions performed on each individual cell. These details include what sort of action was performed (set the actual value, updated the list of possible values or updated the list of impossible values) on that cell, as well explaining the technique used to perform the action Grid Restriction Due to the fact that an aim of the project was to investigate the techniques required to solve Killer Sudoku puzzles, a decision to work only with 9 x 9 grids was made. This decision was further supported by the fact that, as discussed, smaller grids (e.g. 6 x 6) are 33

34 generally easier and larger grids (e.g. 12 x 12) are more difficult. As I was aiming to solve medium difficulty rated puzzles from Killer Sudoku Online, which primarily publishes 9 x 9 grid puzzles, the decision to limit the size makes sense User Interface The user interface serves many purposes. As well as allowing the user to take control of the underlying model, it also presents the user with a visual representation of the model. Despite the purposes it serves, it was considered to be the least risky component in the system, and was thus assigned to be created during the third (and last) timebox. In order to design an effective user interface, interface design principles were considered along with system use cases. Use cases are often examined in order to discover the requirements of a system and its components. The two main tasks that users of the software face are: Play and solve a puzzle. Input a puzzle. The resulting interface requirements were used to evaluate the various potential designs Eight Golden Rules of Interface Design Shneiderman s Eight Golden Rules of Interface Design [20] were considered when designing the user interface. These design principles are guidelines to ensure that the interface is as user friendly as possible, as well as fulfilling its purpose. A detailed description of these guidelines is provided in Appendix A Use Case 1: Play and Solve a Puzzle 34

35 puzzle was: The proposed set of actions required for the user to successfully play and solve a The user loads the software and opens a puzzle he wants to play. The system subsequently displays the puzzle grid to the user. He is then able to key in values and possible values into any cell he chooses. The system updates the grid display accordingly. At any time during the game, the user can ask the solver to complete the puzzle. Upon this request, the system tries to solve the puzzle, updates the grid with its progress and notifies the user whether or not the solving process was successful. If the process was successful the user can choose to view the puzzle history. Furthermore, he can cycle through the puzzle states, from start to finish, viewing how the puzzle was completed. At the end of the desired session, the user exits from the system. Thus, the main interface requirements that were taken from this use case were: There are three cases when the numerals in the grid update; when the user inputs a value, when the solver has finished solving a puzzle and when the different states are displayed. The options to view the puzzle history and traverse through the puzzle states are made available after the solver has successfully solved the puzzle under review Use Case 2: Input a Puzzle the system was: The proposed set of actions required for the user to successfully input a puzzle into The user loads the software and chooses to input a puzzle. She inputs any given cell values and defines the cages required. The user can only request to store the puzzle when every cell in the grid has been allocated to a cage or assigned a value. If the total of the cage sums and cell values is equal to 405, the puzzle is saved. Otherwise it is an invalid puzzle and the user is notified. Throughout the process, the software notifies the user of any errors which exist in the puzzle. 35

36 Thus, the main interface requirements that were taken from this use case were: Pre-filled cells must be input before defining the cages. Errors are clearly highlighted as and when they occur Solver Input Designs After deciding upon the interface requirements, various interface designs for the solver were considered. In particular, the grid input was considered separately to the overall graphical user interface (GUI). Two possible input methods were considered: 1. Before inputting a value, the user defines the input mode to use. The mode in use defines whether entered values are to be considered as actual values or possible values. 2. The user inputs values into the cell. If the value is the only numeral to be entered into the cell, it is viewed as being the actual cell value. Otherwise, it is considered as a possible value. The first input method is illustrated in Figure 3.1. In the diagram, mode 1 refers to the input mode where actual values are placed in cells. Input mode 2 allows for possible values to be entered. The initial mode is set to 1 and is changed by the user. The second input method is shown in Figure 3.2. There is only a single mode of input. In order to identify actual cell values from possible cells values, the number of values in a cell is examined. If there is only one value in the cell, it is displayed as being the actual cell value. Otherwise, the values are presented as possible values for that cell. 36

37 Figure 3.1: Input method one; two modes are used to distinguish between the input of actual cell values and possible ones. Figure 3.2: Input method two; single mode of input where possible and actual cell values are distinguished by the number of digits in the cell. Input method two was chosen as it more closely supported the rule of allowing an easy reversal of actions. Additionally, although conceptually Killer Sudoku players input values in two modes (actual values and possible values), placing the responsibility of alternating between the modes on the user is one which could result in a violation of interface rules 7 and 8. Users may not feel they are the initiators of their actions, but are in fact responding to what the software requires of them. Furthermore, users must remember to switch modes before inputting values. This conflicts with the aim of reducing short-term memory load Solver GUI Designs After taking into account the various interface requirements, a core design was created and then improved upon. 37

38 Design 1 (Figure 3.3) was the first attempt at designing an interface for the solver. It was created such that it met the identified requirements and that it did not infringe upon Shneiderman s interface principles. Design 1 has four main components: Component A: The grid. Component B: The puzzle history box. Component C: A button allows the user to automatically solve the puzzle. A drop-down box allows the user to choose which state to view. Component D: The menu bar to provide options to do various tasks, such as load a puzzle, create a puzzle, exit the system etc. Although all the components are on screen at all times, not all of them are required all the time. For example, the puzzle history box is only needed after the solver has successfully solved a puzzle. Additionally, the drop down box does not allow incremental traversal through the states to be achieved easily. Figure 3.3: Design 1 for the solver interface. 38