private static int Print(String filename) { String text; try { text = File.ReadAllText(filename); } catch { Console.WriteLine(Program.FileNotFoundErrorMessage); return(Program.FileNotFoundError); } try { Console.WriteLine(SudokuPuzzle.Parse(text)); return(0); } catch (FormatException) { Console.WriteLine(Program.FileFormatIncorrectErrorMessage); return(Program.FileFormatIncorrectError); } }
internal Window(String filename) : this() { String text = File.ReadAllText(filename); this.Sudoku = SudokuPuzzle.Parse(text); this.Size = this.Sudoku.Size; this.UpperLimit = this.Size - 1; }
public void Initialize() { const String SUDOKU_FILENAME = "Sudoku.txt"; String sudokuText; try { sudokuText = File.ReadAllText(SUDOKU_FILENAME); } catch { Assert.Fail($"A sudoku puzzle must be exist in the current directory. The file must be called \"{SUDOKU_FILENAME}\"."); return; } const String SOLUTION_FILENAME = "Solution.txt"; String solutionText; try { solutionText = File.ReadAllText(SOLUTION_FILENAME); } catch { Assert.Fail($"A sudoku solution must be exist in the current directory. The file must be called \"{SOLUTION_FILENAME}\"."); return; } try { this.Sudoku = SudokuPuzzle.Parse(sudokuText); } catch (FormatException) { Assert.Fail($"The sudoku puzzle specified in the file {SUDOKU_FILENAME} was not in the correct format"); return; } try { this.Solution = SudokuPuzzle.Parse(solutionText); } catch (FormatException) { Assert.Fail($"The sudoku solution specified in the file {SOLUTION_FILENAME} was not in the correct format"); return; } }
public void GetsValueOfABox() { byte?[] expectedBox1 = { 5, 3, 4, 6, 7, 2, 1, 9, 8 }; byte?[] expectedBox2 = { 6, 7, 8, 1, 9, 5, 3, 4, 2 }; byte?[] expectedBox3 = { 9, 1, 2, 3, 4, 8, 5, 6, 7 }; byte?[] expectedBox4 = { 8, 5, 9, 4, 2, 6, 7, 1, 3 }; byte?[] expectedBox5 = { 7, 6, 1, 8, 5, 3, 9, 2, 4 }; byte?[] expectedBox6 = { 4, 2, 3, 7, 9, 1, 8, 5, 6 }; byte?[] expectedBox7 = { 9, 6, 1, 2, 8, 7, 3, 4, 5 }; byte?[] expectedBox8 = { 5, 3, 7, 4, 1, 9, 2, 8, 6 }; byte?[] expectedBox9 = { 2, 8, 4, 6, 3, 5, 1, 7, 9 }; var puzzle = SudokuPuzzle.Parse(@" 534 678 912 672 195 348 198 342 567 859 761 423 426 853 791 713 924 856 961 537 284 287 419 635 345 286 179 "); var box1 = puzzle.GetValuesOfBox(1); var box2 = puzzle.GetValuesOfBox(2); var box3 = puzzle.GetValuesOfBox(3); var box4 = puzzle.GetValuesOfBox(4); var box5 = puzzle.GetValuesOfBox(5); var box6 = puzzle.GetValuesOfBox(6); var box7 = puzzle.GetValuesOfBox(7); var box8 = puzzle.GetValuesOfBox(8); var box9 = puzzle.GetValuesOfBox(9); Assert.Equal(expectedBox1, box1); Assert.Equal(expectedBox2, box2); Assert.Equal(expectedBox3, box3); Assert.Equal(expectedBox4, box4); Assert.Equal(expectedBox5, box5); Assert.Equal(expectedBox6, box6); Assert.Equal(expectedBox7, box7); Assert.Equal(expectedBox8, box8); Assert.Equal(expectedBox9, box9); }
public void ChecksNumbersOfEachSection() { var invalidPuzzleAtSection1 = SudokuPuzzle.Parse(@" 534|678|912 672|195|348 398|142|567 ----------- 859|764|123 426|853|791 743|921|856 ----------- 961|537|284 287|419|635 135|286|479"); var result = this.testee.Validate(invalidPuzzleAtSection1); result.Valid.Should().BeFalse($"the puzzle is invalid because of a double 3 in section 1"); }
public void ChecksNumbersOfEachColumn() { var invalidPuzzleAtColumn4 = SudokuPuzzle.Parse(@" 514|678|932 672|195|348 398|142|567 ----------- 859|764|123 426|853|791 743|921|856 ----------- 961|537|284 287|139|615 135|286|479"); var result = this.testee.Validate(invalidPuzzleAtColumn4); result.Valid.Should().BeFalse($"the puzzle is invalid because of a double 1 in column 4"); }
public void ChecksNumbersOfEachRow() { var invalidPuzzleAtRow5 = SudokuPuzzle.Parse(@" 534|678|912 672|195|348 198|342|567 ----------- 859|761|423 426|853|891 713|924|856 ----------- 961|537|284 287|419|635 345|286|179"); var result = this.testee.Validate(invalidPuzzleAtRow5); result.Valid.Should().BeFalse($"the puzzle is invalid because of a double 8 in row 5"); }
public void ChecksSolvedPuzzle() { var puzzle = SudokuPuzzle.Parse(@" 534|678|912 672|195|348 198|342|567 ----------- 859|761|423 426|853|791 713|924|856 ----------- 961|537|284 287|419|635 345|286|179"); var result = this.testee.Validate(puzzle); result.Valid.Should().BeTrue($"the puzzle is valid - {result.Message}"); }
public void SolvesVeryEasyPuzzle() { var puzzle = SudokuPuzzle.Parse(@" 534 678 912 672 195 348 198 342 567 859 761 423 426 853 791 713 924 856 961 537 284 287 419 635 345 286 179 "); var result = this.testee.Solve(puzzle); Assert.False(true, "Not yet implemented"); }
public void TestParse() { Assert.ThrowsException <ArgumentNullException>(() => SudokuPuzzle.Parse(null)); Assert.ThrowsException <FormatException>(() => SudokuPuzzle.Parse(String.Empty)); int[,] array = new int[SudokuPuzzle.MaximumSupportedSize, SudokuPuzzle.MaximumSupportedSize]; Random random = new Random(); StringBuilder sb = new StringBuilder(); for (int i = 0; i < SudokuPuzzle.MaximumSupportedSize; i++) { for (int j = 0; j < SudokuPuzzle.MaximumSupportedSize; j++) { sb.Append(array[i, j] = random.Next(SudokuPuzzle.MaximumSupportedSize) + 1); } } SudokuPuzzle puzzle; try { puzzle = SudokuPuzzle.Parse(sb.ToString()); } catch (Exception ex) { Assert.Fail($"Threw exception: {ex}"); return; } Assert.AreEqual(puzzle.Size, SudokuPuzzle.MaximumSupportedSize); Assert.AreEqual(puzzle.Difficulty, SudokuDifficulty.None); for (int i = 0; i < SudokuPuzzle.MaximumSupportedSize; i++) { for (int j = 0; j < SudokuPuzzle.MaximumSupportedSize; j++) { Assert.AreEqual(puzzle[i, j], array[i, j]); } } }
private static int Compare(String file1, String file2) { String text1, text2; try { text1 = File.ReadAllText(file1); text2 = File.ReadAllText(file2); } catch { Console.WriteLine(Program.FileNotFoundErrorMessage); return(Program.FileNotFoundError); } SudokuPuzzle a, b; try { a = SudokuPuzzle.Parse(text1); b = SudokuPuzzle.Parse(text2); } catch (FormatException) { Console.WriteLine(Program.FileFormatIncorrectErrorMessage); return(Program.FileFormatIncorrectError); } Console.WriteLine("Sudoku puzzle A:"); Console.WriteLine(a); Console.WriteLine(); Console.WriteLine("Sudoku puzzle B:"); Console.WriteLine(b); Console.WriteLine(); Console.WriteLine(a == b ? "The two puzzles are equal." : "The two puzzles are NOT equal."); return(0); }
public void ParsesPuzzle() { var puzzle = SudokuPuzzle.Parse(@" 534 678 912 672 195 348 198 342 567 859 761 423 426 853 791 713 924 856 961 537 284 287 419 635 345 286 179 "); puzzle[1, 1].Should().Be(5); puzzle[1, 2].Should().Be(3); puzzle[1, 3].Should().Be(4); puzzle[1, 4].Should().Be(6); puzzle[1, 5].Should().Be(7); puzzle[1, 6].Should().Be(8); puzzle[1, 7].Should().Be(9); puzzle[1, 8].Should().Be(1); puzzle[1, 9].Should().Be(2); puzzle[2, 1].Should().Be(6); puzzle[2, 2].Should().Be(7); puzzle[2, 3].Should().Be(2); puzzle[2, 4].Should().Be(1); puzzle[2, 5].Should().Be(9); puzzle[2, 6].Should().Be(5); puzzle[2, 7].Should().Be(3); puzzle[2, 8].Should().Be(4); puzzle[2, 9].Should().Be(8); puzzle[3, 1].Should().Be(1); puzzle[3, 2].Should().Be(9); puzzle[3, 3].Should().Be(8); puzzle[3, 4].Should().Be(3); puzzle[3, 5].Should().Be(4); puzzle[3, 6].Should().Be(2); puzzle[3, 7].Should().Be(5); puzzle[3, 8].Should().Be(6); puzzle[3, 9].Should().Be(7); puzzle[4, 1].Should().Be(8); puzzle[4, 2].Should().Be(5); puzzle[4, 3].Should().Be(9); puzzle[4, 4].Should().Be(7); puzzle[4, 5].Should().Be(6); puzzle[4, 6].Should().Be(1); puzzle[4, 7].Should().Be(4); puzzle[4, 8].Should().Be(2); puzzle[4, 9].Should().Be(3); puzzle[5, 1].Should().Be(4); puzzle[5, 2].Should().Be(2); puzzle[5, 3].Should().Be(6); puzzle[5, 4].Should().Be(8); puzzle[5, 5].Should().Be(5); puzzle[5, 6].Should().Be(3); puzzle[5, 7].Should().Be(7); puzzle[5, 8].Should().Be(9); puzzle[5, 9].Should().Be(1); puzzle[6, 1].Should().Be(7); puzzle[6, 2].Should().Be(1); puzzle[6, 3].Should().Be(3); puzzle[6, 4].Should().Be(9); puzzle[6, 5].Should().Be(2); puzzle[6, 6].Should().Be(4); puzzle[6, 7].Should().Be(8); puzzle[6, 8].Should().Be(5); puzzle[6, 9].Should().Be(6); puzzle[7, 1].Should().Be(9); puzzle[7, 2].Should().Be(6); puzzle[7, 3].Should().Be(1); puzzle[7, 4].Should().Be(5); puzzle[7, 5].Should().Be(3); puzzle[7, 6].Should().Be(7); puzzle[7, 7].Should().Be(2); puzzle[7, 8].Should().Be(8); puzzle[7, 9].Should().Be(4); puzzle[8, 1].Should().Be(2); puzzle[8, 2].Should().Be(8); puzzle[8, 3].Should().Be(7); puzzle[8, 4].Should().Be(4); puzzle[8, 5].Should().Be(1); puzzle[8, 6].Should().Be(9); puzzle[8, 7].Should().Be(6); puzzle[8, 8].Should().Be(3); puzzle[8, 9].Should().Be(5); puzzle[9, 1].Should().Be(3); puzzle[9, 2].Should().Be(4); puzzle[9, 3].Should().Be(5); puzzle[9, 4].Should().Be(2); puzzle[9, 5].Should().Be(8); puzzle[9, 6].Should().Be(6); puzzle[9, 7].Should().Be(1); puzzle[9, 8].Should().Be(7); puzzle[9, 9].Should().Be(9); }
private static int Enumerate(String filename) { String text; if (!File.Exists(filename)) { Console.WriteLine(Program.FileNotFoundErrorMessage); return(Program.FileNotFoundError); } try { text = File.ReadAllText(filename); } catch { Console.WriteLine(Program.FileFormatIncorrectErrorMessage); return(Program.FileFormatIncorrectError); } SudokuPuzzle sudoku; try { sudoku = SudokuPuzzle.Parse(text); } catch (FormatException) { Console.WriteLine(Program.FileFormatIncorrectErrorMessage); return(Program.FileFormatIncorrectError); } bool solvable = SudokuSolver.CheckSolvable(sudoku, out bool multipleSolutions); if (solvable) { Console.WriteLine("The specified puzzle is solvable."); if (multipleSolutions) { Console.WriteLine("The specified puzzle has multiple possible solutions."); } else { Console.WriteLine("The specified puzzle has a single valid solution."); Stopwatch stopwatch = new Stopwatch(); stopwatch.Start(); SudokuSolver.RecursiveSolve(sudoku); stopwatch.Stop(); Console.WriteLine(sudoku); Console.WriteLine($"Puzzle solved recursively in {stopwatch.ElapsedMilliseconds}ms"); } } else { Console.WriteLine("The specified puzzle is NOT solvable."); } return(0); }
private static int Solve(String filename, String outfile) { String text; try { text = File.ReadAllText(filename); } catch { Console.WriteLine(Program.FileNotFoundErrorMessage); return(Program.FileNotFoundError); } SudokuPuzzle sudoku; try { sudoku = SudokuPuzzle.Parse(text); } catch (FormatException) { Console.WriteLine(Program.FileFormatIncorrectErrorMessage); return(Program.FileFormatIncorrectError); } StringBuilder sb = new StringBuilder(); sb.AppendLine("Sudoku from file, unsolved:"); sb.AppendLine(sudoku.ToString()); sb.AppendLine(); Stopwatch stopwatch = new Stopwatch(); SudokuSolver solver = new SudokuSolver(sudoku); stopwatch.Start(); IEnumerable <SudokuMove> moves = solver.Solve(); stopwatch.Stop(); double time = stopwatch.ElapsedMilliseconds; int count = 0; const int PADDING = 16; const String SEPARATOR = "\t"; sb.AppendLine(String.Join(SEPARATOR, '#', "Row(s)".PadRight(PADDING), "Column(s)".PadRight(PADDING), "Number(s)".PadRight(PADDING), "Pattern".PadRight(PADDING), "Possible".PadRight(PADDING))); foreach (SudokuMove move in moves) { sb.AppendLine(String.Join('\t', ++count, move)); } sb.AppendLine($"Solved puzzle using {count} moves in {time}ms"); /*if (!sudoku.IsComplete) * { * stopwatch.Restart(); * SudokuSolver.RecursiveSolve(sudoku); * stopwatch.Stop(); * double newTime = stopwatch.ElapsedMilliseconds; * sb.AppendLine(); * sb.AppendLine(sudoku.ToString()); * sb.AppendLine(); * sb.AppendLine($"Solved remainder of puzzle using recursion in {newTime}ms"); * sb.AppendLine($"Total time for solving is {time + newTime} ms"); * }*/ sb.AppendLine(); sb.AppendLine("Solved sudoku:"); sb.AppendLine(sudoku.ToString()); String output = sb.ToString(); if (outfile is null) { Console.WriteLine(output); } else { if (Program.WriteToFile(output, outfile)) { Console.WriteLine($"Solved puzzle using {count} moves in {time}ms"); Console.WriteLine($"Moves used to solve sudoku written to {outfile}"); } else { Console.WriteLine(Program.FileOutputErrorMessage); return(Program.FileOutputError); } } return(0); }