The Big Programming Thread - Page 814

package GUI;

import javafx.application.Application;
import javafx.collections.ObservableList;
import javafx.geometry.Insets;
import javafx.scene.*;
import javafx.scene.control.*;
import javafx.scene.layout.*;
import javafx.stage.*;
import org.apache.commons.lang3.math.NumberUtils;
import Sudoku.Solver;

public class Sudoku extends Application {
	public static void main(String[] args) {
		launch(args);
	}
	
	private Solver solver;
	private GridPane board;
	
	/*
	 * start creates a windows with a title, label in top area,
	 * Sudoku grid with 0 values in center and buttons to the right.
	 * It also creates a listener to catch when the user updates a value.
	 */
	@Override
	public void start(Stage primaryStage) throws Exception {
		solver = new Solver();
		board = new GridPane();

		for (int column = 0; column < 9; column++) {
			for (int row = 0; row < 9; row++) {

				int col = column;
				int r = row;

				TextField textField = new TextField("0");

				textField.setStyle("-fx-pref-width: 2em;");
				
				GridPane.setConstraints(textField, column, row);
				board.getChildren().add(textField);
				
				textField.textProperty().addListener((observable, oldValue, newValue) -> {
					// returns defaultValue if the string cannot be parsed.
					int newValueInt = NumberUtils.toInt(newValue, 0);
					if (!(newValueInt > 0 && newValueInt < 10)) {
						textField.setText("0");
					}
					solver.put(r, col, newValueInt);
				});
			}
		}

		BorderPane root = new BorderPane();

		HBox introText = new HBox();
		// create top box for intro text
		root.setTop(introText);
		root.setCenter(board);
		// create right area for box Vbox = vertical boxes
		VBox buttonBox = new VBox();
		root.setRight(buttonBox);
		

		Label topText = new Label("Welcome to a Sudoko solving program. \n" 
			+ "Enter numbers between 1 and 9 in the text fields. \n"
			+ "If you enter an incorrect input such as 'a' it will be changed to 0.\n");

		introText.getChildren().addAll(topText);

		// Buttons
		Button solveButton = new Button("Solve");
		solveButton.setOnAction(e -> solve());

		Button clearButton = new Button("Clear");
		clearButton.setOnAction(e -> clear());

		Button testCase5 = new Button("Test Case 5");
		testCase5.setOnAction(e -> testcase5());

		Button testCase3 = new Button("Test Case 3");
		testCase3.setOnAction(e -> testcase3());

		solveButton.setMaxWidth(Double.MAX_VALUE);
		clearButton.setMaxWidth(Double.MAX_VALUE);
		testCase5.setMaxWidth(Double.MAX_VALUE);
		testCase3.setMaxWidth(Double.MAX_VALUE);
		buttonBox.getChildren().addAll(solveButton, clearButton, testCase3, testCase5);
		
		//Stylesheets
		introText.setStyle("-fx-font-size: 20;");
		introText.setPadding(new Insets(10, 10, 10, 10));
		
		buttonBox.setSpacing(5);
		buttonBox.setPadding(new Insets(10, 10, 10, 10));
		buttonBox.setStyle("-fx-font-size: 20;");
		
		board.setPadding(new Insets(10, 10, 10, 10));
		board.setStyle("-fx-font-size: 20;");
		
		primaryStage.setTitle("Sudoku Solver");
		primaryStage.setScene(new Scene(root));
		primaryStage.show();
	}
	
	/*
	 * solve sends a request to Solver to solve the board.
	 * It then updates the GUI board with the content.
	 */
	private void solve() {
		// Reset counter for if solver is done or not
		Solver.resetSquaresFilled();

		// Does solver return true, then solved
		Boolean solved = Solver.solve();

		if(!solved){ 
			Dialogs.alert("Sudoko Solver Failure", "Sudoko not solved", 
			"Your sudoko was not possible to solve, please verify that you don't have duplicate numbers or other common errors.");
		}
		updateFromSolver();

	}
	
	/*
	 * updateFromSolver gets the content from the Solver board and updates the GUI.
	 */
	private void updateFromSolver() {
		for (int column = 0; column < 9; column++) {
			for (int row = 0; row < 9; row++) {
				String value = Integer.toString(solver.get(row, column));
				Node node = getNodeByRowColumnIndex(row, column, board);
				((TextField) node).setText(value);
			}
		}
	}
	
	/*
	 * getNodeByRowColumnIndex gets the node from the GUI board.
	 * This is used to get or update the content of a textfield in the grid.
	 * 
	 * @param int row, int column and GridPane name to check.
	 * @return node that matches the parameters.
	 */
	public Node getNodeByRowColumnIndex(final int row, final int column, GridPane gridPane) {
		Node result = null;
		ObservableList<Node> childrens = gridPane.getChildren();

		for (Node node : childrens) {
			if (GridPane.getRowIndex(node) == row && GridPane.getColumnIndex(node) == column) {
				result = node;
				break;
			}
		}

		return result;
	}

	/*
	 * clear sets the GUI board and the solver board to all 0 values.
	 */
	private void clear() {
		// Clear Solver board
		for (int column = 0; column < 9; column++) {
			for (int row = 0; row < 9; row++) {
				solver.put(row, column, 0);
			}
		}
		// Clear visual board
		for (Node node : board.getChildren()) {
			if (node instanceof TextField) {
				((TextField) node).setText("0");
			}
		}
	}

	/*
	 * testcase3 inputs a few values to solver board and then updates it to the GUI board.
	 * Used to test a case that isn't possible to solve.
	 */
	public void testcase3() {
		clear();
		solver.put(0, 0, 1);
		solver.put(0, 1, 2);
		solver.put(0, 2, 3);
		solver.put(1, 0, 4);
		solver.put(1, 1, 5);
		solver.put(1, 2, 6);
		solver.put(2, 3, 7);
		updateFromSolver();
	}

	/*
	 * testcase5 inputs a few values to solver board and then updates it to the GUI board.
	 * Used to test a case that is possible to solve.
	 */
	public void testcase5() {
		clear();
		solver.put(0, 2, 8);
		solver.put(0, 5, 9);
		solver.put(0, 7, 6);
		solver.put(0, 8, 2);
		solver.put(1, 8, 5);
		solver.put(2, 0, 1);
		solver.put(2, 2, 2);
		solver.put(2, 3, 5);
		solver.put(3, 3, 2);
		solver.put(3, 4, 1);
		solver.put(3, 7, 9);
		solver.put(4, 1, 5);
		solver.put(4, 6, 6);
		solver.put(5, 0, 6);
		solver.put(5, 7, 2);
		solver.put(5, 8, 8);
		solver.put(6, 0, 4);
		solver.put(6, 1, 1);
		solver.put(6, 3, 6);
		solver.put(6, 5, 8);
		solver.put(7, 0, 8);
		solver.put(7, 1, 6);
		solver.put(7, 4, 3);
		solver.put(7, 6, 1);
		solver.put(8, 6, 4);
		updateFromSolver();
	}
}

package Sudoku;

public class Solver {
	// Board with cell content
	private static int[][] board;
	// Number of squaresfilled, counts to know when done
	static int numSquaresFilled;

	/*
	 * Solver creates a board.
	 * 
	 * @return creates a Sudoku board
	 */
	public Solver() {
		board = new int[9][9];
	}

	/*
	 * solve solves the board that has been put in previously.
	 * 
	 * @return true if the board is solved
	 */
	public static boolean solve() {
		// If all squares filled return true
		if (81 == numSquaresFilled) {
			return true;
		}

		boolean findCell = true;
		// booleanCondition ? executeThisPartIfBooleanConditionIsTrue :
		// executeThisPartIfBooleanConditionIsFalse
		RowColoumn rc = findCell ? getConstrained() : findFirstOpenCell();
		// get row and cell from rc
		int r = rc.row;
		int c = rc.col;
		for (int i = 1; i <= 9; i++) {
			numSquaresFilled++;
			// fill cell with i value
			board[r][c] = i;
			// if board is legal start the search for next cell
			if (isBoardLegal(r, c)) {
				if (solve()) {
					return true;
				}
			}
			// else set cell to 0 and remove the squares filled to previous
			// value.
			board[r][c] = 0;
			numSquaresFilled--;
		}
		// return false if not possible
		return false;
	}

	/*
	 * RowColoumn creates a simple row and column state that can be used
	 */
	static class RowColoumn {
		int row;
		int col;

		RowColoumn(int r, int c) {
			row = r;
			col = c;
		}
	}

	/*
	 * put adds a value to a cell.
	 * 
	 * @param int row, int column, int value
	 * 
	 * @return true if the cell value is added to board
	 */
	public boolean put(int row, int col, int value) {
		board[row][col] = value;
		if (board[row][col] == value) {
			return true;
		}
		return false;
	}

	/*
	 * get Returns a value of a cell.
	 * 
	 * @param int row, int column
	 * @return value of cell
	 */
	public int get(int row, int col) {
		int returnValue = board[row][col];
		return returnValue;
	}

	/*
	 * isLegal tests if the entire board is valid. It does this by testing if
	 * there is a duplicate number in the row, column or 3x3 square. It is not a
	 * test to see if it is possible to solve.
	 * 
	 * @return true if the board follows sudoku rules
	 */
	public static boolean isLegal() {
		for (int i = 0; i < 9; i++) {
			for (int j = 0; j < 9; j++) {
				if (!isBoardLegal(i, j)) {
					return false;
				}
			}
		}
		return true;
	}

	/*
	 * isBoardLegal tests if the cell on the board is valid. It does this by
	 * testing if there is a duplicate number in the row, column or 3x3 square.
	 * 
	 * @param int row and int column to check.
	 * @return true if the cell follows sudoku rules
	 */
	static boolean isBoardLegal(int row, int col) {
		return (isRowLegal(row) && isColLegal(col) && isSquareLegal(row, col));
	}

	/*
	 * isRowLegal tests if the cell in the row is valid. It does this by testing
	 * if there is a duplicate number in the row.
	 * 
	 * @param int row to check.
	 * @return true if the row follows sudoku rules
	 */
	static boolean isRowLegal(int row) {
		int[] count = new int[9];
		for (int col = 0; col < 9; col++) {
			int n = board[row][col] - 1;
			if (n == -1) 
				continue; 
			count[n]++;
			if (count[n] > 1)
				return false;
		}
		return true;
	}

	/*
	 * isRowLegal tests if the cell in the column is valid. It does this by
	 * testing if there is a duplicate number in the row.
	 * 
	 * @param int col to check.
	 * @return true if the column follows sudoku rules
	 */
	static boolean isColLegal(int col) {
		int[] count = new int[9];
		for (int row = 0; row < 9; row++) {
			int n = board[row][col] - 1;
			if (n == -1) 
				continue; 
			count[n]++;
			if (count[n] > 1)
				return false;
		}
		return true;
	}

	/*
	 * isRowLegal tests if the cell in the square is valid. It does this by
	 * testing if there is a duplicate number in the square.
	 * 
	 * @param int row and int column to check.
	 * @return true if the square follows sudoku rules
	 */
	static boolean isSquareLegal(int row, int col) {
		int r = (row / 3) * 3; 
		int c = (col / 3) * 3; 
		int[] count = new int[9];
		for (int i = 0; i < 3; i++) {
			for (int j = 0; j < 3; j++) {
				int n = board[r + i][c + j] - 1;
				if (n == -1)
					continue;
				count[n]++;
				if (count[n] > 1)
					return false;
			}
		}
		return true;
	}

	/*
	 * findFirstOpenCell looks for the first empty cell and returns it.
	 * 
	 * @return RowColoumn that can be called internally.
	 */
	static RowColoumn findFirstOpenCell() {
		for (int i = 0; i < 9; i++) {
			for (int j = 0; j < 9; j++) {
				if (board[i][j] == 0) { 
					return new RowColoumn(i, j);
				}
			}
		}
		return new RowColoumn(0, 0);
	}
	/*
	 * findFirstOpenCell looks for the cell with most variables to fill in with.
	 * So a cell with more data is used before one with no conditions.
	 * 
	 * @return RowColoumn that can be called internally.
	 */
	static RowColoumn getConstrained() {

		int r = 0, c = 0, max = 0;
		
		int[] rowCounts = new int[9];
		int[] colCounts = new int[9];
		for (int i = 0; i < 9; i++) {
			for (int j = 0; j < 9; j++) {
				if (board[i][j] != 0)
					rowCounts[i]++;
				if (board[j][i] != 0)
					colCounts[i]++;
			}
		}

		int[][] squareCounts = new int[3][3];
		
		for (int i = 0; i < 3; i++) {
			for (int j = 0; j < 3; j++) {
				int count = 0;
				for (int m = 0; m < 3; m++) {
					for (int n = 0; n < 3; n++) {
						
						if (board[(i * 3) + m][(j * 3) + n] != 0)
							count++;
					}
				}
				squareCounts[i][j] = count;
			}
		}

		for (int i = 0; i < 9; i++) {
			for (int j = 0; j < 9; j++) {
								if (board[i][j] == 0) {
					if (rowCounts[i] > max) {
						max = rowCounts[i];
						r = i;
						c = j;
					}
					if (colCounts[j] > max) {
						max = rowCounts[j];
						r = i;
						c = j;
					}
				}
			}
		}
		return new RowColoumn(r, c);
	}

	/*
	 * printBoard prints the current board state to console.
	 * Used for testing to see if the situation matches the expected.
	 */
	public static void printBoard() {
		for (int i = 0; i < 9; i++) {
			for (int j = 0; j < 9; j++) {
				System.out.print(" " + (board[i][j] == 0 ? " " : board[i][j]) + " ");
				if (j % 3 == 2 && j < 8)
					System.out.print("|");
			}
			System.out.println();
			if (i % 3 == 2 && i < 8)
				System.out.println("---------|---------|---------");
		}
		System.out.println();
	}
	
	/*
	 * resetSquaresFilled resets the numSquaresFilled to 0 for repeated usage of board.
	 */
	public static void resetSquaresFilled() {
		numSquaresFilled = 0;
	}

}

...
public class Dialogs {
	public static void alert(String title, String headerText, String infoText) {
		Alert alert = new Alert(AlertType.INFORMATION);
		alert.setTitle(title);
		alert.setHeaderText(headerText);
		alert.setContentText(infoText);
		alert.showAndWait();
	}
...
}