/**
* Generates puzzle based on current puzzle
* (different puzzle, same solution).
*
* @see SudokuGenerator
* @see SudokuGenerator#PARAM_DO_NOT_TRANSFORM
* @see SudokuGenerator#generate()
*/
private void generateFromCurrentPuzzle()
{
generator = new SudokuGenerator(puzzle, SudokuGenerator.PARAM_DO_NOT_TRANSFORM);
setGeneratorOptions();
int[,] generated = generator.generate();
if (generator.getGeneratorState() == SudokuGenerator.GENERATOR_GEN_FINISHED)
{
trackPuzzleUndo();
puzzle = generated;
}
else
{
JanetConsole.println(">>> !!! Error while generating puzzle !!! <<<");
JanetConsole.println(generator.getMessages());
}
}
/**
* Generates random puzzle with unique solution.
*
* @see SudokuGenerator
* @see SudokuGenerator#PARAM_GEN_RND_BOARD
* @see SudokuGenerator#generate()
*/
private void generateRandomPuzzle()
{
generator = new SudokuGenerator(SudokuGenerator.PARAM_GEN_RND_BOARD);
setGeneratorOptions();
int[,] generated = generator.generate();
if (generator.getGeneratorState() == SudokuGenerator.GENERATOR_GEN_FINISHED)
{
trackPuzzleUndo();
puzzle = generated;
}
else
{
JanetConsole.println(">>> !!! Error while generating random puzzle !!! <<<");
JanetConsole.println(generator.getMessages());
}
}
/**
* Start the Janet-Sudoku Tutorial code.
* @param args No arguments are considered.
*/
public static void Start()
{
String tmpDir = FileX.getTmpDir();
{
/*
* Simple sudoku generation.
*/
SudokuStore.consolePrintln("");
SudokuStore.consolePrintln("Simple sudoku generation.");
SudokuGenerator sg = new SudokuGenerator();
int[,] puzzle = sg.generate();
SudokuStore.consolePrintBoard(puzzle);
}
{
/*
* Simple sudoku generation + parameters.
*/
SudokuStore.consolePrintln("");
SudokuStore.consolePrintln("Simple sudoku generation + parameters.");
SudokuGenerator sg = new SudokuGenerator(SudokuGenerator.PARAM_GEN_RND_BOARD);
int[,] puzzle = sg.generate();
SudokuStore.consolePrintBoard(puzzle);
}
{
/*
* Simple sudoku generation + puzzle rating.
*/
SudokuStore.consolePrintln("");
SudokuStore.consolePrintln("Simple sudoku generation + puzzle rating.");
SudokuGenerator sg = new SudokuGenerator();
int[,] puzzle = sg.generate();
int rating = SudokuStore.calculatePuzzleRating(puzzle);
SudokuStore.consolePrintBoard(puzzle);
SudokuStore.consolePrintln("Puzzle rating: " + rating);
}
{
/*
* Solving sudoku example.
*/
SudokuStore.consolePrintln("");
SudokuStore.consolePrintln("Solving sudoku example.");
SudokuSolver ss = new SudokuSolver(SudokuPuzzles.PUZZLE_EXAMPLE_001);
SudokuStore.consolePrintBoard(ss.getBoard());
ss.solve();
SudokuStore.consolePrintBoard(ss.getSolvedBoard());
}
{
/*
* Saving board examples
*/
SudokuStore.consolePrintln("");
SudokuStore.consolePrintln("Saving board examples " + tmpDir);
SudokuStore.saveBoard(SudokuPuzzles.PUZZLE_EXAMPLE_001, tmpDir + "sudoku-board-ex-1.txt");
SudokuStore.saveBoard(SudokuPuzzles.PUZZLE_EXAMPLE_001, tmpDir + "sudoku-board-ex-2.txt", "This is a head comment");
SudokuStore.saveBoard(SudokuPuzzles.PUZZLE_EXAMPLE_001, tmpDir + "sudoku-board-ex-3.txt", "This is a head comment", "And a tail comment");
SudokuSolver ss = new SudokuSolver(1);
ss.solve();
ss.saveSolvedBoard(tmpDir + "sudoku-board-ex-sol.txt", "Solution for the PUZZLE_EXAMPLE_001");
}
/*
* And many other staff provided by the library :-)
*/
}
/**
* Test scenario implementation.
* @param testId Test id.
* @param threadId Thread id.
* @return True is test successful, otherwise false.
*/
static bool runTest(int testId, int threadId) {
bool testResult = true;
String testDesc = "", resultDesc = "";
int[,] a = {
{0,0,0,8,0,0,0,0,0},
{4,0,0,0,1,5,0,3,0},
{0,2,9,0,4,0,5,1,8},
{0,4,0,0,0,0,1,2,0},
{0,0,0,6,0,2,0,0,0},
{0,3,2,0,0,0,0,9,0},
{6,9,3,0,5,0,8,7,0},
{0,5,0,4,8,0,0,0,1},
{0,0,0,0,0,3,0,0,0}
};
switch(testId) {
case 0:
testDesc = "SudokuSolver.setCell(int, int, int)";
{
SudokuSolver s = new SudokuSolver();
s.setCell(0,0,0);
s.setCell(1,0,4);
s.setCell(2,0,0);
s.setCell(3,0,0);
s.setCell(4,0,0);
s.setCell(5,0,0);
s.setCell(6,0,6);
s.setCell(7,0,0);
s.setCell(8,0,0);
s.setCell(0,1,0);
s.setCell(1,1,0);
s.setCell(2,1,2);
s.setCell(3,1,4);
s.setCell(4,1,0);
s.setCell(5,1,3);
s.setCell(6,1,9);
s.setCell(7,1,5);
s.setCell(8,1,0);
s.setCell(0,2,0);
s.setCell(1,2,0);
s.setCell(2,2,9);
s.setCell(3,2,0);
s.setCell(4,2,0);
s.setCell(5,2,2);
s.setCell(6,2,3);
s.setCell(7,2,0);
s.setCell(8,2,0);
s.setCell(0,3,8);
s.setCell(1,3,0);
s.setCell(2,3,0);
s.setCell(3,3,0);
s.setCell(4,3,6);
s.setCell(5,3,0);
s.setCell(6,3,0);
s.setCell(7,3,4);
s.setCell(8,3,0);
s.setCell(0,4,0);
s.setCell(1,4,1);
s.setCell(2,4,4);
s.setCell(3,4,0);
s.setCell(4,4,0);
s.setCell(5,4,0);
s.setCell(6,4,5);
s.setCell(7,4,8);
s.setCell(8,4,0);
s.setCell(0,5,0);
s.setCell(1,5,5);
s.setCell(2,5,0);
s.setCell(3,5,0);
s.setCell(4,5,2);
s.setCell(5,5,0);
s.setCell(6,5,0);
s.setCell(7,5,0);
s.setCell(8,5,3);
s.setCell(0,6,0);
s.setCell(1,6,0);
s.setCell(2,6,5);
s.setCell(3,6,1);
s.setCell(4,6,0);
s.setCell(5,6,0);
s.setCell(6,6,8);
s.setCell(7,6,0);
s.setCell(8,6,0);
s.setCell(0,7,0);
s.setCell(1,7,3);
s.setCell(2,7,1);
s.setCell(3,7,2);
s.setCell(4,7,0);
s.setCell(5,7,9);
s.setCell(6,7,7);
s.setCell(7,7,0);
s.setCell(8,7,0);
s.setCell(0,8,0);
s.setCell(1,8,0);
s.setCell(2,8,8);
s.setCell(3,8,0);
s.setCell(4,8,0);
s.setCell(5,8,0);
s.setCell(6,8,0);
s.setCell(7,8,1);
s.setCell(8,8,0);
int[,] b = s.getBoard();
if ( (SudokuStore.boardsAreEqual(a, b) == true) ) {
resultDesc = "Expecting equal - are equal.";
} else {
resultDesc = "Expecting equal - are not equal.";
testResult = false;
SudokuStore.consolePrintln(s.getMessages());
}
}
break;
case 1:
testDesc = "SudokuSolver.getCellDigit(int, int)";
{
SudokuSolver s1 = new SudokuSolver(a);
SudokuSolver s2 = new SudokuSolver();
for (int i = 0; i < SudokuBoard.BOARD_SIZE; i++)
for (int j = 0; j < SudokuBoard.BOARD_SIZE; j++) {
int d = s1.getCellDigit(i, j);
s2.setCell(i, j, d);
}
int[,] b = s2.getBoard();
if ( (SudokuStore.boardsAreEqual(a, b) == true) ) {
resultDesc = "Expecting equal - are equal.";
} else {
resultDesc = "Expecting equal - are not equal.";
testResult = false;
}
}
break;
case 2:
testDesc = "SudokuSolver.getBoardCopy()";
{
SudokuSolver s = new SudokuSolver(a);
int[,] b = s.getBoard();
int[,] c = s.getBoardCopy();
if ( (SudokuStore.boardsAreEqual(b, c) == true) ) {
resultDesc = "Expecting equal - are equal.";
} else {
resultDesc = "Expecting equal - are not equal.";
testResult = false;
}
}
break;
case 3:
testDesc = "SudokuSolver.getSolutionBoardCells()";
{
SudokuSolver s = new SudokuSolver(a);
s.solve();
int[,] b = s.getSolvedBoard();
int[,] c = SudokuStore.boardCopy(a);
BoardCell[] sol = s.getSolutionBoardCells();
foreach (BoardCell bc in sol)
c[bc.rowIndex, bc.colIndex] = bc.digit;
if ( (SudokuStore.boardsAreEqual(b, c) == true) ) {
resultDesc = "Expecting equal - are equal.";
} else {
resultDesc = "Expecting equal - are not equal.";
testResult = false;
}
}
break;
case 4:
testDesc = "SudokuSolver.getAllBoardCells()";
{
SudokuSolver s = new SudokuSolver(a);
int[,] b = s.getBoardCopy();
int[,] c = new int[SudokuBoard.BOARD_SIZE, SudokuBoard.BOARD_SIZE];
BoardCell[] bc = s.getAllBoardCells();
foreach (BoardCell cell in bc) {
c[cell.rowIndex, cell.colIndex] = cell.digit;
}
if ( (SudokuStore.boardsAreEqual(b, c) == true) ) {
resultDesc = "Expecting equal - are equal.";
} else {
resultDesc = "Expecting equal - are not equal.";
testResult = false;
}
}
break;
case 5:
testDesc = "SudokuSolver.getAllSolutionsList()";
{
SudokuSolver s = new SudokuSolver( SudokuPuzzles.PUZZLE_NON_UNIQUE_SOLUTION );
s.findAllSolutions();
List<SudokuBoard> solList;
solList = s.getAllSolutionsList();
foreach (SudokuBoard sb in solList) {
if (SudokuStore.checkSolvedBoard( sb.board ) == false) {
testResult = false;
break;
}
}
if ( testResult == true ) {
resultDesc = "Expecting each solution valid - each is valid.";
} else {
resultDesc = "Expecting each solution valid - found not valid.";
}
}
break;
case 6:
testDesc = "SudokuGenerator -> generate -> save -> load -> compare";
{
String filePath = FileX.getTmpDir() + FileX.genRndFileName(20, "txt");
SudokuGenerator g = new SudokuGenerator(SudokuGenerator.PARAM_GEN_RND_BOARD);
int[,] generated = g.generate();
g.saveBoard(filePath, "generated", "saved");
int[,] loaded = SudokuStore.loadBoard(filePath);
FileX.removeFile(filePath);
if (SudokuStore.boardsAreEqual(generated, loaded) == false)
testResult = false;
if ( testResult == true ) {
resultDesc = "Expecting equal - are equal.";
} else {
resultDesc = "Expecting equal - are not equal.";
}
}
break;
case 7:
testDesc = "SudokuSolver -> solve -> save -> load -> compare";
{
String filePath = FileX.getTmpDir() + FileX.genRndFileName(20, "txt");
SudokuSolver s = new SudokuSolver(SudokuStore.getPuzzleExample());
s.solve();
int[,] solved = s.getSolvedBoard();
s.saveSolvedBoard(filePath, "solved", "saved");
int[,] loaded = SudokuStore.loadBoard(filePath);
FileX.removeFile(filePath);
if (SudokuStore.boardsAreEqual(solved, loaded) == false)
testResult = false;
if ( testResult == true ) {
resultDesc = "Expecting equal - are equal.";
} else {
resultDesc = "Expecting equal - are not equal.";
}
}
break;
}
if (testResult == true)
SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + " " + testDesc + " " + resultDesc + " >>> ApiTests, result: OK");
else
SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + " " + testDesc + " " + resultDesc + " >>> ApiTests, result: ERROR");
return testResult;
}
/**
* Test scenario implementation.
* @param testId Test id.
* @param threadId Thread id.
* @return True is test successful, otherwise false.
*/
static bool runTest(int testId, int threadId)
{
SudokuSolver solverGen, solverInit;
SudokuGenerator g;
int solUnq;
int[,] genPuzzle;
int[,] solvedGen, solvedInit, initBoard;
bool testResult = true;
switch (testId)
{
case 0:
for (int example = 0; example < SudokuPuzzles.NUMBER_OF_PUZZLE_EXAMPLES; example++)
{
g = new SudokuGenerator(example, SudokuGenerator.PARAM_DO_NOT_TRANSFORM);
genPuzzle = g.generate();
solverGen = new SudokuSolver(genPuzzle);
ErrorCodes.consolePrintlnIfError(solverGen.solve());
solverInit = new SudokuSolver(example);
ErrorCodes.consolePrintlnIfError(solverInit.solve());
solUnq = solverGen.checkIfUniqueSolution();
ErrorCodes.consolePrintlnIfError(solUnq);
solvedGen = solverGen.getSolvedBoard();
solvedInit = solverInit.getSolvedBoard();
if ((solUnq == SudokuSolver.SOLUTION_UNIQUE) && (SudokuStore.boardsAreEqual(solvedGen, solvedInit) == true))
{
//SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by example number, example: " + example + ", solution unique and correct: YES, time (g, s1, s2): " + g.getComputingTime() + " s., " + solverGen.getComputingTime() + " s., " + solverInit.getComputingTime() + " s.");
}
else
{
testResult = false;
SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by example number, example: " + example + ", solution unique and correct: NO, time (g, s1, s2): " + g.getComputingTime() + " s., " + solverGen.getComputingTime() + " s., " + solverInit.getComputingTime() + " s.");
Console.WriteLine("Initial board");
SudokuStore.consolePrintBoard(SudokuStore.getPuzzleExample(example));
Console.WriteLine("Generated puzzle");
SudokuStore.consolePrintBoard(genPuzzle);
Console.WriteLine("Solved initial board");
SudokuStore.consolePrintBoard(solvedInit);
Console.WriteLine("Solved generated puzzle");
SudokuStore.consolePrintBoard(solvedGen);
}
}
break;
case 1:
for (int example = 0; example < SudokuPuzzles.NUMBER_OF_PUZZLE_EXAMPLES; example++)
{
initBoard = SudokuStore.getPuzzleExample(example);
g = new SudokuGenerator(initBoard, SudokuGenerator.PARAM_DO_NOT_TRANSFORM, SudokuGenerator.PARAM_DO_NOT_SOLVE);
genPuzzle = g.generate();
solverGen = new SudokuSolver(genPuzzle);
ErrorCodes.consolePrintlnIfError(solverGen.solve());
solverInit = new SudokuSolver(initBoard);
ErrorCodes.consolePrintlnIfError(solverInit.solve());
solUnq = solverGen.checkIfUniqueSolution();
ErrorCodes.consolePrintlnIfError(solUnq);
solvedGen = solverGen.getSolvedBoard();
solvedInit = solverInit.getSolvedBoard();
if ((solUnq == SudokuSolver.SOLUTION_UNIQUE) && (SudokuStore.boardsAreEqual(solvedGen, solvedInit) == true))
{
//SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by example board, example: " + example + ", solution unique and correct: YES, time (g, s1, s2): " + g.getComputingTime() + " s., " + solverGen.getComputingTime() + " s., " + solverInit.getComputingTime() + " s.");
}
else
{
testResult = false;
SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by example board, example: " + example + ", solution unique and correct: NO, time (g, s1, s2): " + g.getComputingTime() + " s., " + solverGen.getComputingTime() + " s., " + solverInit.getComputingTime() + " s.");
Console.WriteLine("Initial board");
SudokuStore.consolePrintBoard(initBoard);
Console.WriteLine("Generated puzzle");
SudokuStore.consolePrintBoard(genPuzzle);
Console.WriteLine("Solved initial board");
SudokuStore.consolePrintBoard(solvedInit);
Console.WriteLine("Solved generated puzzle");
SudokuStore.consolePrintBoard(solvedGen);
}
}
break;
case 2:
for (int example = 0; example < SudokuPuzzles.NUMBER_OF_PUZZLE_EXAMPLES; example++)
{
g = new SudokuGenerator(example);
genPuzzle = g.generate();
solverGen = new SudokuSolver(genPuzzle);
ErrorCodes.consolePrintlnIfError(solverGen.solve());
solUnq = solverGen.checkIfUniqueSolution();
ErrorCodes.consolePrintlnIfError(solUnq);
solvedGen = solverGen.getSolvedBoard();
if ((solUnq == SudokuSolver.SOLUTION_UNIQUE) && (SudokuStore.checkPuzzle(genPuzzle) == true))
{
//SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by example number, example: " + example + ", solution unique and correct: YES, time (g, s): " + g.getComputingTime() + " s., " + solverGen.getComputingTime() + " s., ");
}
else
{
testResult = false;
SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by example number, example: " + example + ", solution unique and correct: NO, time (g, s): " + g.getComputingTime() + " s., " + solverGen.getComputingTime() + " s., ");
Console.WriteLine("Generated puzzle");
SudokuStore.consolePrintBoard(genPuzzle);
Console.WriteLine("Solved generated puzzle");
SudokuStore.consolePrintBoard(solvedGen);
}
}
break;
case 3:
for (int example = 0; example < SudokuPuzzles.NUMBER_OF_PUZZLE_EXAMPLES; example++)
{
initBoard = SudokuStore.getPuzzleExample(example);
g = new SudokuGenerator(initBoard, SudokuGenerator.PARAM_DO_NOT_SOLVE);
genPuzzle = g.generate();
solverGen = new SudokuSolver(genPuzzle);
ErrorCodes.consolePrintlnIfError(solverGen.solve());
solUnq = solverGen.checkIfUniqueSolution();
ErrorCodes.consolePrintlnIfError(solUnq);
solvedGen = solverGen.getSolvedBoard();
if ((solUnq == SudokuSolver.SOLUTION_UNIQUE) && (SudokuStore.checkPuzzle(genPuzzle) == true))
{
//SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by example board, example: " + example + ", solution unique and correct: YES, time (g, s): " + g.getComputingTime() + " s., " + solverGen.getComputingTime() + " s., ");
}
else
{
testResult = false;
SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by example board, example: " + example + ", solution unique and correct: NO, time (g, s): " + g.getComputingTime() + " s., " + solverGen.getComputingTime() + " s., ");
Console.WriteLine("Generated puzzle");
SudokuStore.consolePrintBoard(genPuzzle);
Console.WriteLine("Solved initial board");
SudokuStore.consolePrintBoard(solvedGen);
}
}
break;
case 5:
initBoard = SudokuPuzzles.PUZZLE_EMPTY;
g = new SudokuGenerator(initBoard);
genPuzzle = g.generate();
solverGen = new SudokuSolver(genPuzzle);
ErrorCodes.consolePrintlnIfError(solverGen.solve());
solUnq = solverGen.checkIfUniqueSolution();
ErrorCodes.consolePrintlnIfError(solUnq);
solvedGen = solverGen.getSolvedBoard();
if ((solUnq == SudokuSolver.SOLUTION_UNIQUE) && (SudokuStore.checkPuzzle(genPuzzle) == true))
{
//SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by empty board, solution unique and correct: YES, time (g, s): " + g.getComputingTime() + " s., " + solverGen.getComputingTime() + " s., ");
}
else
{
testResult = false;
SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by empty board, solution unique and correct: NO, time (g, s): " + g.getComputingTime() + " s., " + solverGen.getComputingTime() + " s., ");
Console.WriteLine("Generated puzzle");
SudokuStore.consolePrintBoard(genPuzzle);
Console.WriteLine("Solved initial board");
SudokuStore.consolePrintBoard(solvedGen);
}
break;
case 6:
initBoard = SudokuPuzzles.PUZZLE_EMPTY;
g = new SudokuGenerator(initBoard, SudokuGenerator.PARAM_DO_NOT_SOLVE);
if (g.getGeneratorState() == SudokuGenerator.GENERATOR_INIT_FAILED)
{
SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by empty board, solution unique and correct: YES, time (g, s): ");
}
else
{
testResult = false;
SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by empty board, solution unique and correct: NO, time (g, s): ");
SudokuStore.consolePrintln("Generator state: " + g.getGeneratorState());
Console.WriteLine(g.getMessages());
}
break;
case 7:
initBoard = SudokuPuzzles.PUZZLE_ERROR;
g = new SudokuGenerator(initBoard, SudokuGenerator.PARAM_DO_NOT_SOLVE);
if (g.getGeneratorState() == SudokuGenerator.GENERATOR_INIT_FAILED)
{
SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by PUZZLE_ERROR + PARAM_DO_NOT_SOLVE, init failed: YES.");
}
else
{
testResult = false;
SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by PUZZLE_ERROR + PARAM_DO_NOT_SOLVE, init failed: NO.");
SudokuStore.consolePrintln("Generator state: " + g.getGeneratorState());
Console.WriteLine(g.getMessages());
}
break;
case 8:
initBoard = SudokuPuzzles.PUZZLE_NON_UNIQUE_SOLUTION;
g = new SudokuGenerator(initBoard);
genPuzzle = g.generate();
solverGen = new SudokuSolver(genPuzzle);
ErrorCodes.consolePrintlnIfError(solverGen.solve());
solUnq = solverGen.checkIfUniqueSolution();
ErrorCodes.consolePrintlnIfError(solUnq);
solvedGen = solverGen.getSolvedBoard();
if ((solUnq == SudokuSolver.SOLUTION_UNIQUE) && (SudokuStore.checkPuzzle(genPuzzle) == true))
{
//SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by empty board, solution unique and correct: YES, time (g, s): " + g.getComputingTime() + " s., " + solverGen.getComputingTime() + " s., ");
}
else
{
testResult = false;
SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by empty board, solution unique and correct: NO, time (g, s): " + g.getComputingTime() + " s., " + solverGen.getComputingTime() + " s., ");
Console.WriteLine("Generated puzzle");
SudokuStore.consolePrintBoard(genPuzzle);
Console.WriteLine("Solved initial board");
SudokuStore.consolePrintBoard(solvedGen);
}
break;
case 9:
initBoard = SudokuPuzzles.PUZZLE_NON_UNIQUE_SOLUTION;
g = new SudokuGenerator(initBoard, SudokuGenerator.PARAM_DO_NOT_SOLVE);
if (g.getGeneratorState() == SudokuGenerator.GENERATOR_INIT_FAILED)
{
SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by PUZZLE_NON_UNIQUE_SOLUTION + PARAM_DO_NOT_SOLVE, init failed: YES.");
}
else
{
testResult = false;
SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by PUZZLE_NON_UNIQUE_SOLUTION + PARAM_DO_NOT_SOLVE, init failed: NO.");
SudokuStore.consolePrintln("Generator state: " + g.getGeneratorState());
Console.WriteLine(g.getMessages());
}
break;
}
if (testResult == true)
{
SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + " >>>>>>>>>>>>>>>>>>>>>> SudokuGenerator, result: OK");
}
else
{
SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + " >>>>>>>>>>>>>>>>>>>>>> SudokuGenerator, result: ERROR");
}
return(testResult);
}
/**
* Test scenario implementation.
* @param testId Test id.
* @param threadId Thread id.
* @return True is test successful, otherwise false.
*/
static bool runTest(int testId, int threadId) {
SudokuSolver solverGen, solverInit;
SudokuGenerator g;
int solUnq;
int[,] genPuzzle;
int[,] solvedGen, solvedInit, initBoard;
bool testResult = true;
switch(testId) {
case 0:
for (int example = 0; example < SudokuPuzzles.NUMBER_OF_PUZZLE_EXAMPLES; example++) {
g = new SudokuGenerator(example, SudokuGenerator.PARAM_DO_NOT_TRANSFORM);
genPuzzle = g.generate();
solverGen = new SudokuSolver(genPuzzle);
ErrorCodes.consolePrintlnIfError(solverGen.solve());
solverInit = new SudokuSolver(example);
ErrorCodes.consolePrintlnIfError(solverInit.solve());
solUnq = solverGen.checkIfUniqueSolution();
ErrorCodes.consolePrintlnIfError(solUnq);
solvedGen = solverGen.getSolvedBoard();
solvedInit = solverInit.getSolvedBoard();
if ( (solUnq == SudokuSolver.SOLUTION_UNIQUE) && ( SudokuStore.boardsAreEqual(solvedGen, solvedInit) == true ) ) {
//SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by example number, example: " + example + ", solution unique and correct: YES, time (g, s1, s2): " + g.getComputingTime() + " s., " + solverGen.getComputingTime() + " s., " + solverInit.getComputingTime() + " s.");
} else {
testResult = false;
SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by example number, example: " + example + ", solution unique and correct: NO, time (g, s1, s2): " + g.getComputingTime() + " s., " + solverGen.getComputingTime() + " s., " + solverInit.getComputingTime() + " s.");
Console.WriteLine("Initial board");
SudokuStore.consolePrintBoard(SudokuStore.getPuzzleExample(example));
Console.WriteLine("Generated puzzle");
SudokuStore.consolePrintBoard(genPuzzle);
Console.WriteLine("Solved initial board");
SudokuStore.consolePrintBoard(solvedInit);
Console.WriteLine("Solved generated puzzle");
SudokuStore.consolePrintBoard(solvedGen);
}
}
break;
case 1:
for (int example = 0; example < SudokuPuzzles.NUMBER_OF_PUZZLE_EXAMPLES; example++) {
initBoard = SudokuStore.getPuzzleExample(example);
g = new SudokuGenerator(initBoard, SudokuGenerator.PARAM_DO_NOT_TRANSFORM, SudokuGenerator.PARAM_DO_NOT_SOLVE);
genPuzzle = g.generate();
solverGen = new SudokuSolver(genPuzzle);
ErrorCodes.consolePrintlnIfError(solverGen.solve());
solverInit = new SudokuSolver(initBoard);
ErrorCodes.consolePrintlnIfError(solverInit.solve());
solUnq = solverGen.checkIfUniqueSolution();
ErrorCodes.consolePrintlnIfError(solUnq);
solvedGen = solverGen.getSolvedBoard();
solvedInit = solverInit.getSolvedBoard();
if ( (solUnq == SudokuSolver.SOLUTION_UNIQUE) && ( SudokuStore.boardsAreEqual(solvedGen, solvedInit) == true ) ) {
//SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by example board, example: " + example + ", solution unique and correct: YES, time (g, s1, s2): " + g.getComputingTime() + " s., " + solverGen.getComputingTime() + " s., " + solverInit.getComputingTime() + " s.");
} else {
testResult = false;
SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by example board, example: " + example + ", solution unique and correct: NO, time (g, s1, s2): " + g.getComputingTime() + " s., " + solverGen.getComputingTime() + " s., " + solverInit.getComputingTime() + " s.");
Console.WriteLine("Initial board");
SudokuStore.consolePrintBoard(initBoard);
Console.WriteLine("Generated puzzle");
SudokuStore.consolePrintBoard(genPuzzle);
Console.WriteLine("Solved initial board");
SudokuStore.consolePrintBoard(solvedInit);
Console.WriteLine("Solved generated puzzle");
SudokuStore.consolePrintBoard(solvedGen);
}
}
break;
case 2:
for (int example = 0; example < SudokuPuzzles.NUMBER_OF_PUZZLE_EXAMPLES; example++) {
g = new SudokuGenerator(example);
genPuzzle = g.generate();
solverGen = new SudokuSolver(genPuzzle);
ErrorCodes.consolePrintlnIfError(solverGen.solve());
solUnq = solverGen.checkIfUniqueSolution();
ErrorCodes.consolePrintlnIfError(solUnq);
solvedGen = solverGen.getSolvedBoard();
if ( (solUnq == SudokuSolver.SOLUTION_UNIQUE) && ( SudokuStore.checkPuzzle(genPuzzle) == true ) ) {
//SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by example number, example: " + example + ", solution unique and correct: YES, time (g, s): " + g.getComputingTime() + " s., " + solverGen.getComputingTime() + " s., ");
} else {
testResult = false;
SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by example number, example: " + example + ", solution unique and correct: NO, time (g, s): " + g.getComputingTime() + " s., " + solverGen.getComputingTime() + " s., ");
Console.WriteLine("Generated puzzle");
SudokuStore.consolePrintBoard(genPuzzle);
Console.WriteLine("Solved generated puzzle");
SudokuStore.consolePrintBoard(solvedGen);
}
}
break;
case 3:
for (int example = 0; example < SudokuPuzzles.NUMBER_OF_PUZZLE_EXAMPLES; example++) {
initBoard = SudokuStore.getPuzzleExample(example);
g = new SudokuGenerator(initBoard, SudokuGenerator.PARAM_DO_NOT_SOLVE);
genPuzzle = g.generate();
solverGen = new SudokuSolver(genPuzzle);
ErrorCodes.consolePrintlnIfError(solverGen.solve());
solUnq = solverGen.checkIfUniqueSolution();
ErrorCodes.consolePrintlnIfError(solUnq);
solvedGen = solverGen.getSolvedBoard();
if ( (solUnq == SudokuSolver.SOLUTION_UNIQUE) && ( SudokuStore.checkPuzzle(genPuzzle) == true ) ) {
//SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by example board, example: " + example + ", solution unique and correct: YES, time (g, s): " + g.getComputingTime() + " s., " + solverGen.getComputingTime() + " s., ");
} else {
testResult = false;
SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by example board, example: " + example + ", solution unique and correct: NO, time (g, s): " + g.getComputingTime() + " s., " + solverGen.getComputingTime() + " s., ");
Console.WriteLine("Generated puzzle");
SudokuStore.consolePrintBoard(genPuzzle);
Console.WriteLine("Solved initial board");
SudokuStore.consolePrintBoard(solvedGen);
}
}
break;
case 5:
initBoard = SudokuPuzzles.PUZZLE_EMPTY;
g = new SudokuGenerator(initBoard);
genPuzzle = g.generate();
solverGen = new SudokuSolver(genPuzzle);
ErrorCodes.consolePrintlnIfError(solverGen.solve());
solUnq = solverGen.checkIfUniqueSolution();
ErrorCodes.consolePrintlnIfError(solUnq);
solvedGen = solverGen.getSolvedBoard();
if ( (solUnq == SudokuSolver.SOLUTION_UNIQUE) && ( SudokuStore.checkPuzzle(genPuzzle) == true ) ) {
//SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by empty board, solution unique and correct: YES, time (g, s): " + g.getComputingTime() + " s., " + solverGen.getComputingTime() + " s., ");
} else {
testResult = false;
SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by empty board, solution unique and correct: NO, time (g, s): " + g.getComputingTime() + " s., " + solverGen.getComputingTime() + " s., ");
Console.WriteLine("Generated puzzle");
SudokuStore.consolePrintBoard(genPuzzle);
Console.WriteLine("Solved initial board");
SudokuStore.consolePrintBoard(solvedGen);
}
break;
case 6:
initBoard = SudokuPuzzles.PUZZLE_EMPTY;
g = new SudokuGenerator(initBoard, SudokuGenerator.PARAM_DO_NOT_SOLVE);
if ( g.getGeneratorState() == SudokuGenerator.GENERATOR_INIT_FAILED ) {
SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by empty board, solution unique and correct: YES, time (g, s): ");
} else {
testResult = false;
SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by empty board, solution unique and correct: NO, time (g, s): ");
SudokuStore.consolePrintln("Generator state: " + g.getGeneratorState());
Console.WriteLine(g.getMessages());
}
break;
case 7:
initBoard = SudokuPuzzles.PUZZLE_ERROR;
g = new SudokuGenerator(initBoard, SudokuGenerator.PARAM_DO_NOT_SOLVE);
if ( g.getGeneratorState() == SudokuGenerator.GENERATOR_INIT_FAILED ) {
SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by PUZZLE_ERROR + PARAM_DO_NOT_SOLVE, init failed: YES.");
} else {
testResult = false;
SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by PUZZLE_ERROR + PARAM_DO_NOT_SOLVE, init failed: NO.");
SudokuStore.consolePrintln("Generator state: " + g.getGeneratorState());
Console.WriteLine(g.getMessages());
}
break;
case 8:
initBoard = SudokuPuzzles.PUZZLE_NON_UNIQUE_SOLUTION;
g = new SudokuGenerator(initBoard);
genPuzzle = g.generate();
solverGen = new SudokuSolver(genPuzzle);
ErrorCodes.consolePrintlnIfError(solverGen.solve());
solUnq = solverGen.checkIfUniqueSolution();
ErrorCodes.consolePrintlnIfError(solUnq);
solvedGen = solverGen.getSolvedBoard();
if ( (solUnq == SudokuSolver.SOLUTION_UNIQUE) && ( SudokuStore.checkPuzzle(genPuzzle) == true ) ) {
//SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by empty board, solution unique and correct: YES, time (g, s): " + g.getComputingTime() + " s., " + solverGen.getComputingTime() + " s., ");
} else {
testResult = false;
SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by empty board, solution unique and correct: NO, time (g, s): " + g.getComputingTime() + " s., " + solverGen.getComputingTime() + " s., ");
Console.WriteLine("Generated puzzle");
SudokuStore.consolePrintBoard(genPuzzle);
Console.WriteLine("Solved initial board");
SudokuStore.consolePrintBoard(solvedGen);
}
break;
case 9:
initBoard = SudokuPuzzles.PUZZLE_NON_UNIQUE_SOLUTION;
g = new SudokuGenerator(initBoard, SudokuGenerator.PARAM_DO_NOT_SOLVE);
if ( g.getGeneratorState() == SudokuGenerator.GENERATOR_INIT_FAILED ) {
SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by PUZZLE_NON_UNIQUE_SOLUTION + PARAM_DO_NOT_SOLVE, init failed: YES.");
} else {
testResult = false;
SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by PUZZLE_NON_UNIQUE_SOLUTION + PARAM_DO_NOT_SOLVE, init failed: NO.");
SudokuStore.consolePrintln("Generator state: " + g.getGeneratorState());
Console.WriteLine(g.getMessages());
}
break;
}
if (testResult == true)
SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + " >>>>>>>>>>>>>>>>>>>>>> SudokuGenerator, result: OK");
else
SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + " >>>>>>>>>>>>>>>>>>>>>> SudokuGenerator, result: ERROR");
return testResult;
}
/**
* Test scenario implementation.
* @param testId Test id.
* @param threadId Thread id.
* @return True is test successful, otherwise false.
*/
static bool runTest(int testId, int threadId)
{
bool testResult = true;
String testDesc = "", resultDesc = "";
int[,] a =
{
{ 0, 0, 0, 8, 0, 0, 0, 0, 0 },
{ 4, 0, 0, 0, 1, 5, 0, 3, 0 },
{ 0, 2, 9, 0, 4, 0, 5, 1, 8 },
{ 0, 4, 0, 0, 0, 0, 1, 2, 0 },
{ 0, 0, 0, 6, 0, 2, 0, 0, 0 },
{ 0, 3, 2, 0, 0, 0, 0, 9, 0 },
{ 6, 9, 3, 0, 5, 0, 8, 7, 0 },
{ 0, 5, 0, 4, 8, 0, 0, 0, 1 },
{ 0, 0, 0, 0, 0, 3, 0, 0, 0 }
};
switch (testId)
{
case 0:
testDesc = "SudokuSolver.setCell(int, int, int)";
{
SudokuSolver s = new SudokuSolver();
s.setCell(0, 0, 0);
s.setCell(1, 0, 4);
s.setCell(2, 0, 0);
s.setCell(3, 0, 0);
s.setCell(4, 0, 0);
s.setCell(5, 0, 0);
s.setCell(6, 0, 6);
s.setCell(7, 0, 0);
s.setCell(8, 0, 0);
s.setCell(0, 1, 0);
s.setCell(1, 1, 0);
s.setCell(2, 1, 2);
s.setCell(3, 1, 4);
s.setCell(4, 1, 0);
s.setCell(5, 1, 3);
s.setCell(6, 1, 9);
s.setCell(7, 1, 5);
s.setCell(8, 1, 0);
s.setCell(0, 2, 0);
s.setCell(1, 2, 0);
s.setCell(2, 2, 9);
s.setCell(3, 2, 0);
s.setCell(4, 2, 0);
s.setCell(5, 2, 2);
s.setCell(6, 2, 3);
s.setCell(7, 2, 0);
s.setCell(8, 2, 0);
s.setCell(0, 3, 8);
s.setCell(1, 3, 0);
s.setCell(2, 3, 0);
s.setCell(3, 3, 0);
s.setCell(4, 3, 6);
s.setCell(5, 3, 0);
s.setCell(6, 3, 0);
s.setCell(7, 3, 4);
s.setCell(8, 3, 0);
s.setCell(0, 4, 0);
s.setCell(1, 4, 1);
s.setCell(2, 4, 4);
s.setCell(3, 4, 0);
s.setCell(4, 4, 0);
s.setCell(5, 4, 0);
s.setCell(6, 4, 5);
s.setCell(7, 4, 8);
s.setCell(8, 4, 0);
s.setCell(0, 5, 0);
s.setCell(1, 5, 5);
s.setCell(2, 5, 0);
s.setCell(3, 5, 0);
s.setCell(4, 5, 2);
s.setCell(5, 5, 0);
s.setCell(6, 5, 0);
s.setCell(7, 5, 0);
s.setCell(8, 5, 3);
s.setCell(0, 6, 0);
s.setCell(1, 6, 0);
s.setCell(2, 6, 5);
s.setCell(3, 6, 1);
s.setCell(4, 6, 0);
s.setCell(5, 6, 0);
s.setCell(6, 6, 8);
s.setCell(7, 6, 0);
s.setCell(8, 6, 0);
s.setCell(0, 7, 0);
s.setCell(1, 7, 3);
s.setCell(2, 7, 1);
s.setCell(3, 7, 2);
s.setCell(4, 7, 0);
s.setCell(5, 7, 9);
s.setCell(6, 7, 7);
s.setCell(7, 7, 0);
s.setCell(8, 7, 0);
s.setCell(0, 8, 0);
s.setCell(1, 8, 0);
s.setCell(2, 8, 8);
s.setCell(3, 8, 0);
s.setCell(4, 8, 0);
s.setCell(5, 8, 0);
s.setCell(6, 8, 0);
s.setCell(7, 8, 1);
s.setCell(8, 8, 0);
int[,] b = s.getBoard();
if ((SudokuStore.boardsAreEqual(a, b) == true))
{
resultDesc = "Expecting equal - are equal.";
}
else
{
resultDesc = "Expecting equal - are not equal.";
testResult = false;
SudokuStore.consolePrintln(s.getMessages());
}
}
break;
case 1:
testDesc = "SudokuSolver.getCellDigit(int, int)";
{
SudokuSolver s1 = new SudokuSolver(a);
SudokuSolver s2 = new SudokuSolver();
for (int i = 0; i < SudokuBoard.BOARD_SIZE; i++)
{
for (int j = 0; j < SudokuBoard.BOARD_SIZE; j++)
{
int d = s1.getCellDigit(i, j);
s2.setCell(i, j, d);
}
}
int[,] b = s2.getBoard();
if ((SudokuStore.boardsAreEqual(a, b) == true))
{
resultDesc = "Expecting equal - are equal.";
}
else
{
resultDesc = "Expecting equal - are not equal.";
testResult = false;
}
}
break;
case 2:
testDesc = "SudokuSolver.getBoardCopy()";
{
SudokuSolver s = new SudokuSolver(a);
int[,] b = s.getBoard();
int[,] c = s.getBoardCopy();
if ((SudokuStore.boardsAreEqual(b, c) == true))
{
resultDesc = "Expecting equal - are equal.";
}
else
{
resultDesc = "Expecting equal - are not equal.";
testResult = false;
}
}
break;
case 3:
testDesc = "SudokuSolver.getSolutionBoardCells()";
{
SudokuSolver s = new SudokuSolver(a);
s.solve();
int[,] b = s.getSolvedBoard();
int[,] c = SudokuStore.boardCopy(a);
BoardCell[] sol = s.getSolutionBoardCells();
foreach (BoardCell bc in sol)
{
c[bc.rowIndex, bc.colIndex] = bc.digit;
}
if ((SudokuStore.boardsAreEqual(b, c) == true))
{
resultDesc = "Expecting equal - are equal.";
}
else
{
resultDesc = "Expecting equal - are not equal.";
testResult = false;
}
}
break;
case 4:
testDesc = "SudokuSolver.getAllBoardCells()";
{
SudokuSolver s = new SudokuSolver(a);
int[,] b = s.getBoardCopy();
int[,] c = new int[SudokuBoard.BOARD_SIZE, SudokuBoard.BOARD_SIZE];
BoardCell[] bc = s.getAllBoardCells();
foreach (BoardCell cell in bc)
{
c[cell.rowIndex, cell.colIndex] = cell.digit;
}
if ((SudokuStore.boardsAreEqual(b, c) == true))
{
resultDesc = "Expecting equal - are equal.";
}
else
{
resultDesc = "Expecting equal - are not equal.";
testResult = false;
}
}
break;
case 5:
testDesc = "SudokuSolver.getAllSolutionsList()";
{
SudokuSolver s = new SudokuSolver(SudokuPuzzles.PUZZLE_NON_UNIQUE_SOLUTION);
s.findAllSolutions();
List <SudokuBoard> solList;
solList = s.getAllSolutionsList();
foreach (SudokuBoard sb in solList)
{
if (SudokuStore.checkSolvedBoard(sb.board) == false)
{
testResult = false;
break;
}
}
if (testResult == true)
{
resultDesc = "Expecting each solution valid - each is valid.";
}
else
{
resultDesc = "Expecting each solution valid - found not valid.";
}
}
break;
case 6:
testDesc = "SudokuGenerator -> generate -> save -> load -> compare";
{
String filePath = FileX.getTmpDir() + FileX.genRndFileName(20, "txt");
SudokuGenerator g = new SudokuGenerator(SudokuGenerator.PARAM_GEN_RND_BOARD);
int[,] generated = g.generate();
g.saveBoard(filePath, "generated", "saved");
int[,] loaded = SudokuStore.loadBoard(filePath);
FileX.removeFile(filePath);
if (SudokuStore.boardsAreEqual(generated, loaded) == false)
{
testResult = false;
}
if (testResult == true)
{
resultDesc = "Expecting equal - are equal.";
}
else
{
resultDesc = "Expecting equal - are not equal.";
}
}
break;
case 7:
testDesc = "SudokuSolver -> solve -> save -> load -> compare";
{
String filePath = FileX.getTmpDir() + FileX.genRndFileName(20, "txt");
SudokuSolver s = new SudokuSolver(SudokuStore.getPuzzleExample());
s.solve();
int[,] solved = s.getSolvedBoard();
s.saveSolvedBoard(filePath, "solved", "saved");
int[,] loaded = SudokuStore.loadBoard(filePath);
FileX.removeFile(filePath);
if (SudokuStore.boardsAreEqual(solved, loaded) == false)
{
testResult = false;
}
if (testResult == true)
{
resultDesc = "Expecting equal - are equal.";
}
else
{
resultDesc = "Expecting equal - are not equal.";
}
}
break;
}
if (testResult == true)
{
SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + " " + testDesc + " " + resultDesc + " >>> ApiTests, result: OK");
}
else
{
SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + " " + testDesc + " " + resultDesc + " >>> ApiTests, result: ERROR");
}
return(testResult);
}
/**
* Start the Janet-Sudoku Tutorial code.
* @param args No arguments are considered.
*/
public static void Start() {
String tmpDir = FileX.getTmpDir();
{
/*
* Simple sudoku generation.
*/
SudokuStore.consolePrintln("");
SudokuStore.consolePrintln("Simple sudoku generation.");
SudokuGenerator sg = new SudokuGenerator();
int[,] puzzle = sg.generate();
SudokuStore.consolePrintBoard(puzzle);
}
{
/*
* Simple sudoku generation + parameters.
*/
SudokuStore.consolePrintln("");
SudokuStore.consolePrintln("Simple sudoku generation + parameters.");
SudokuGenerator sg = new SudokuGenerator(SudokuGenerator.PARAM_GEN_RND_BOARD);
int[,] puzzle = sg.generate();
SudokuStore.consolePrintBoard(puzzle);
}
{
/*
* Simple sudoku generation + puzzle rating.
*/
SudokuStore.consolePrintln("");
SudokuStore.consolePrintln("Simple sudoku generation + puzzle rating.");
SudokuGenerator sg = new SudokuGenerator();
int[,] puzzle = sg.generate();
int rating = SudokuStore.calculatePuzzleRating(puzzle);
SudokuStore.consolePrintBoard(puzzle);
SudokuStore.consolePrintln("Puzzle rating: " + rating);
}
{
/*
* Solving sudoku example.
*/
SudokuStore.consolePrintln("");
SudokuStore.consolePrintln("Solving sudoku example.");
SudokuSolver ss = new SudokuSolver(SudokuPuzzles.PUZZLE_EXAMPLE_001);
SudokuStore.consolePrintBoard(ss.getBoard());
ss.solve();
SudokuStore.consolePrintBoard(ss.getSolvedBoard());
}
{
/*
* Saving board examples
*/
SudokuStore.consolePrintln("");
SudokuStore.consolePrintln("Saving board examples " + tmpDir);
SudokuStore.saveBoard(SudokuPuzzles.PUZZLE_EXAMPLE_001, tmpDir + "sudoku-board-ex-1.txt");
SudokuStore.saveBoard(SudokuPuzzles.PUZZLE_EXAMPLE_001, tmpDir + "sudoku-board-ex-2.txt", "This is a head comment");
SudokuStore.saveBoard(SudokuPuzzles.PUZZLE_EXAMPLE_001, tmpDir + "sudoku-board-ex-3.txt", "This is a head comment", "And a tail comment");
SudokuSolver ss = new SudokuSolver(1);
ss.solve();
ss.saveSolvedBoard(tmpDir + "sudoku-board-ex-sol.txt", "Solution for the PUZZLE_EXAMPLE_001");
}
{
/*
* Puzzle modification - i.e. rotation
*/
SudokuStore.consolePrintln("----------------------------------------------------");
SudokuStore.consolePrintln(">>>>>>>> Puzzle modification");
int[,] puzzle = SudokuStore.getPuzzleExample(0);
int[,] puzzleRotated = SudokuStore.rotateClockWise(puzzle);
SudokuStore.consolePrintBoard(puzzle);
SudokuStore.consolePrintBoard(puzzleRotated);
}
/*
* And many other staff provided by the library :-)
*/
}
/**
* Generates puzzle based on current puzzle
* (different puzzle, same solution).
*
* @see SudokuGenerator
* @see SudokuGenerator#PARAM_DO_NOT_TRANSFORM
* @see SudokuGenerator#generate()
*/
private void generateFromCurrentPuzzle() {
generator = new SudokuGenerator(puzzle, SudokuGenerator.PARAM_DO_NOT_TRANSFORM);
setGeneratorOptions();
int[,] generated = generator.generate();
if (generator.getGeneratorState() == SudokuGenerator.GENERATOR_GEN_FINISHED) {
trackPuzzleUndo();
puzzle = generated;
} else {
JanetConsole.println(">>> !!! Error while generating puzzle !!! <<<");
JanetConsole.println(generator.getMessages());
}
}
/**
* Generates random puzzle with unique solution.
* Evaluates puzzle difficulty rating.
*
* @see SudokuGenerator
* @see SudokuGenerator#PARAM_GEN_RND_BOARD
* @see SudokuGenerator#generate()
* @see SudokuStore#calculatePuzzleRating(int[,])
*/
private void generateAndRateRandomPuzzle() {
generator = new SudokuGenerator(SudokuGenerator.PARAM_GEN_RND_BOARD);
setGeneratorOptions();
int[,] generated = generator.generate();
if (generator.getGeneratorState() == SudokuGenerator.GENERATOR_GEN_FINISHED) {
trackPuzzleUndo();
puzzle = generated;
ratePuzzleDifficulty();
} else {
JanetConsole.println(">>> !!! Error while generating random puzzle !!! <<<");
JanetConsole.println(generator.getMessages());
}
}