From 0277a1f8b6de596a0695cb50b945548815aec1df Mon Sep 17 00:00:00 2001 From: Imbus Date: Tue, 5 Dec 2023 17:31:17 +0100 Subject: [PATCH] New interface --- app/src/main/java/sudoku/Solver.java | 28 +++++++++++-------- app/src/main/java/sudoku/SudokuSolver.java | 32 ++++++++++++++++++++-- app/src/test/java/sudoku/SolverTest.java | 30 ++++++++++---------- 3 files changed, 61 insertions(+), 29 deletions(-) diff --git a/app/src/main/java/sudoku/Solver.java b/app/src/main/java/sudoku/Solver.java index 304b97e..4eb977c 100644 --- a/app/src/main/java/sudoku/Solver.java +++ b/app/src/main/java/sudoku/Solver.java @@ -24,7 +24,7 @@ public class Solver implements SudokuSolver { /** * Resets the board to all zeros */ - public void reset() { + public void clear() { board = new int[9][9]; } @@ -63,7 +63,7 @@ public class Solver implements SudokuSolver { // Check for legal values in the current cell for (int val = 1; val <= 9; ++val) { - if (legal(row, col, val)) { + if (isLegal(row, col, val)) { board[row][col] = val; // When we find a legal value, recursively call solve() on the next cell if (solve(row + 1, col)) { @@ -80,25 +80,21 @@ public class Solver implements SudokuSolver { * Randomizes the board. This guarantees a solvable board. */ public void randomizeBoard() { - this.reset(); + this.clear(); for (int i = 0; i < 9; ++i) { int row = (int) (Math.random() * 9); int col = (int) (Math.random() * 9); int val = (int) (Math.random() * 9) + 1; - if (legal(row, col, val)) { + if (isLegal(row, col, val)) { board[row][col] = val; } } } /** - * Sets the value of the board at the given position - * - * @param row row to set - * @param col column to set - * @param val value to set + * {@inheritDoc} */ - public void setPos(int row, int col, int val) { + public void set(int row, int col, int val) { if (row < 9 && col < 9) { board[row][col] = val; } @@ -107,7 +103,17 @@ public class Solver implements SudokuSolver { /** * {@inheritDoc} */ - public boolean legal(int row, int col, int val) { + public int get(int row, int col) { + if (row < 9 && col < 9) { + return board[row][col]; + } + return 0; + } + + /** + * {@inheritDoc} + */ + public boolean isLegal(int row, int col, int val) { if (row < 0 || row >= 9 || col < 0 || col >= 9 || val < 1 || val > 9) { return false; } diff --git a/app/src/main/java/sudoku/SudokuSolver.java b/app/src/main/java/sudoku/SudokuSolver.java index 2500328..e77ecdd 100644 --- a/app/src/main/java/sudoku/SudokuSolver.java +++ b/app/src/main/java/sudoku/SudokuSolver.java @@ -3,11 +3,14 @@ package sudoku; public interface SudokuSolver { /** * Set sudoku board, numbers 1-9 are fixed values, 0 is unsolved. + * + * @param board a board to copy values from + * @throws IllegalArgumentException if board is invalid, e.g. not 9x9 */ void setBoard(int[][] board); /** - * Get the sudoku board + * Get a copy of the sudoku board */ int[][] getBoard(); @@ -26,5 +29,28 @@ public interface SudokuSolver { * @param nbr * @return true if legal */ - boolean legal(int row, int col, int nbr); -} \ No newline at end of file + boolean isLegal(int row, int col, int nbr); + + /** + * Get number on board + * + * @param row + * @param col + * @return number on board + */ + int get(int row, int col); + + /** + * Set number on board, numbers 1-9 are fixed values, 0 is unsolved. + * + * @param row + * @param col + * @param nbr + */ + void set(int row, int col, int nbr); + + /** + * Clear the board + */ + void clear(); +} diff --git a/app/src/test/java/sudoku/SolverTest.java b/app/src/test/java/sudoku/SolverTest.java index 618f20a..7089fc8 100644 --- a/app/src/test/java/sudoku/SolverTest.java +++ b/app/src/test/java/sudoku/SolverTest.java @@ -31,17 +31,17 @@ class SolverTest { @Test void legalTest() { Solver solver = new Solver(); - assertTrue(solver.legal(0, 0, 1)); - solver.setPos(0, 0, 1); + assertTrue(solver.isLegal(0, 0, 1)); + solver.set(0, 0, 1); IntStream.range(0, 9).forEach(i -> { - assertFalse(solver.legal(0, i, 1)); - assertFalse(solver.legal(i, 0, 1)); + assertFalse(solver.isLegal(0, i, 1)); + assertFalse(solver.isLegal(i, 0, 1)); }); - assertTrue(solver.legal(5, 5, 1)); - assertTrue(solver.legal(8, 8, 9)); - assertTrue(solver.legal(8, 8, 1)); + assertTrue(solver.isLegal(5, 5, 1)); + assertTrue(solver.isLegal(8, 8, 9)); + assertTrue(solver.isLegal(8, 8, 1)); } @Test @@ -51,7 +51,7 @@ class SolverTest { assertTrue(solver.solve()); assertTrue(solver.isSolved()); - solver.reset(); + solver.clear(); solver.randomizeBoard(); assertFalse(solver.isSolved()); assertTrue(solver.solve()); @@ -62,25 +62,25 @@ class SolverTest { Solver solver = new Solver(); assertTrue(solver.solve()); solver.randomizeBoard(); - solver.reset(); + solver.clear(); assertFalse(solver.isSolved()); } @Test void legalWithInvalidInputsTest() { Solver solver = new Solver(); - assertFalse(solver.legal(-1, 0, 1)); - assertFalse(solver.legal(0, -1, 1)); - assertFalse(solver.legal(0, 0, -1)); - assertFalse(solver.legal(0, 0, 10)); + assertFalse(solver.isLegal(-1, 0, 1)); + assertFalse(solver.isLegal(0, -1, 1)); + assertFalse(solver.isLegal(0, 0, -1)); + assertFalse(solver.isLegal(0, 0, 10)); } @Test @Disabled void unsolvableTest() { Solver solver = new Solver(); - solver.setPos(0, 0, 1); - solver.setPos(0, 1, 1); + solver.set(0, 0, 1); + solver.set(0, 1, 1); assertFalse(solver.solve()); } }