merge

app/src/main/java/sudoku/structure/Sudoku.java

@@ -0,0 +1,248 @@
+package sudoku.structure;
+
+import sudoku.constraint.IConstraint;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @class Sudoku
+ * @brief Represents a sudoku
+ */
+public class Sudoku {
+
+	private final List<Block> blocks;
+	private final List<Cell> cells;
+	private final List<IConstraint> constraints;
+	private boolean isMutable;
+
+	public Sudoku(List<Cell> cells, List<Block> blocks, List<IConstraint> constraints) {
+		this.cells = cells;
+		this.blocks = blocks;
+		this.constraints = constraints;
+	}
+
+	/**
+	 * @return wether the coords are in the sudoku
+	 */
+	public boolean isValidCoords(int x, int y) {
+		int index = y * getSize() + x;
+		return index < getSize() * getSize();
+	}
+
+	/**
+	 * Try to place a cell at the given coordinate
+	 *
+	 * @return Cell created or null if it can't be done
+	 */
+	public Cell setCellSymbol(int x, int y, int value) {
+		assert (isValidCoords(x, y));
+		for (IConstraint constraint : this.constraints) {
+			if (!constraint.canBePlaced(this, x, y, value)) {
+				return null;
+			}
+		}
+		Cell cell = getCell(x, y);
+		cell.setSymbolIndex(value);
+		return cell;
+	}
+
+	public boolean setCellsSymbol(List<Integer> values) {
+		if (values.size() > this.cells.size()) {
+			return false;
+		}
+		for (int i = 0; i < values.size(); i++) {
+			int x = i % this.blocks.size();
+			int y = (i-x) / this.blocks.size();
+			int value = values.get(i);
+			this.setCellSymbol(x, y, value);
+		}
+		return true;
+	}
+
+	public boolean setImmutableCellsSymbol(List<Integer> values) {
+		if (values.size() > this.cells.size()) {
+			return false;
+		}
+		for (int i = 0; i < values.size(); i++) {
+			int x = i%this.blocks.size();
+			int y = (i-x)/this.blocks.size();
+			int value = values.get(i);
+			if (value != Cell.NOSYMBOL) {
+				Cell cellPlaced = this.setCellSymbol(x, y, value);
+				if (cellPlaced == null) {
+					continue;
+				}
+				cellPlaced.setImmutable();
+			}
+		}
+		return true;
+	}
+
+
+	public Cell getCell(int x, int y) {
+		int index = y * getSize() + x;
+		assert (isValidCoords(x, y));
+		try {
+            return this.cells.get(index);
+		} catch (IndexOutOfBoundsException e) {
+			return null;
+		}
+	}
+
+	public Cell getCell(int i) {
+		return this.cells.get(i);
+	}
+
+	public List<IConstraint> getConstraints() {
+		return constraints;
+	}
+
+	public int getSize() {
+		return this.blocks.size();
+	}
+
+	public List<Cell> getCells() {
+		return this.cells;
+	}
+
+	public List<Block> getBlocks() {
+		return this.blocks;
+	}
+
+	public boolean contains(Cell cell) {
+		return this.cells.contains(cell);
+	}
+
+	private Coordinate getCoordinateCell(Cell c) throws Exception {
+		int x = 0, y = 0;
+		int size = this.getSize();
+
+		if (!this.contains(c)) {
+			throw new Exception("The given cell is not in this sudoku.");
+		}
+
+		for (Cell cell : this.cells) {
+			if (cell == c) {
+				return new Coordinate(x, y);
+			}
+			if (x == size - 1) {
+				y += 1;
+				x = 0;
+			} else {
+				x += 1;
+			}
+		}
+		return new Coordinate(x, y);
+	}
+
+	public void updateSymbolsPossibilities() throws Exception {
+		for (IConstraint constraint : constraints) {
+			List<Cell> cells = this.getCells();
+			for (Cell cell : cells) {
+				Coordinate coord = null;
+				try {
+					coord = this.getCoordinateCell(cell);
+				} catch (Exception e) {
+					throw new RuntimeException(e);
+				}
+				List<Integer> newPossibleSymbols = cell.getPossibleSymbols();
+				newPossibleSymbols.retainAll(constraint.getPossibleSymbols(this, coord.getX(), coord.getY()));
+
+				cell.setPossibleSymbols(newPossibleSymbols);
+
+				if (cell.getPossibleSymbols().isEmpty()) {
+					throw new Exception("Rollback bitch");
+				}
+			}
+		}
+	}
+
+	public String toString() {
+		StringBuilder sb = new StringBuilder();
+		sb.append("Sudoku {");
+		for (int i = 0; i < getSize(); i++) {
+			sb.append("\n\t");
+			for (int j = 0; j < getSize(); j++) {
+				Cell cell = getCell(i, j);
+				sb.append(cell.toString()).append(" ");
+			}
+		}
+		sb.append("\n}");
+		return sb.toString();
+	}
+
+	public Cell getFirstEmptyCell() {
+		for (Cell cell : this.cells) {
+			if (cell.isEmpty()) {
+				return cell;
+			}
+		}
+		return null;
+	}
+
+	public List<Integer> getPossibleSymbolsOfCell(Cell cellToFill) {
+		List<Integer> result = new ArrayList<>();
+		Coordinate cellCoordinates;
+		try {
+			cellCoordinates = this.getCoordinateCell(cellToFill);
+		} catch (Exception e) {
+			return result;
+		}
+		for (IConstraint constraint : this.constraints) {
+			if (result.isEmpty()) {
+				result.addAll(constraint.getPossibleSymbols(this, cellCoordinates.getX(), cellCoordinates.getY()));
+			} else {
+				result.retainAll(constraint.getPossibleSymbols(this, cellCoordinates.getX(), cellCoordinates.getY()));
+			}
+		}
+		return result;
+	}
+
+	public boolean isValid() {
+		for (Cell cell : this.cells) {
+			if (cell.isMutable()) {
+				if (cell.isEmpty()) {
+					return false;
+				}
+				for (IConstraint constraint : this.constraints) {
+					Coordinate coords;
+					try {
+						int symbolPlaced = cell.getSymbolIndex();
+						coords = this.getCoordinateCell(cell);
+
+						cell.setSymbolIndex(Cell.NOSYMBOL);
+						List<Integer> possibleSymbols = constraint.getPossibleSymbols(this, coords.getX(), coords.getY());
+						cell.setSymbolIndex(symbolPlaced);
+						if (possibleSymbols.size() != 1 || possibleSymbols.get(0) != symbolPlaced) {
+							return false;
+						}
+
+					} catch (Exception e) {
+						throw new RuntimeException(e);
+					}
+				}
+			}
+		}
+		return true;
+	}
+
+	@Override
+	public boolean equals(Object object) {
+		if (!(object instanceof Sudoku)) {
+			return false;
+		}
+
+		if (this.getSize() != ((Sudoku) object).getSize()) {
+			return false;
+		}
+
+		for (int i = 0; i < this.getSize(); i++) {
+			if (this.getCell(i).getSymbolIndex() != ((Sudoku) object).getCell(i).getSymbolIndex()) {
+				return false;
+			}
+		}
+
+		return true;
+	}
+}