This commit is contained in:
@@ -2,7 +2,7 @@ package gui;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
import sudoku.constraint.Constraint;
|
||||
import sudoku.constraint.IConstraint;
|
||||
import sudoku.structure.MultiDoku;
|
||||
import sudoku.structure.SudokuFactory;;
|
||||
|
||||
@@ -33,7 +33,7 @@ public enum SudokuType {
|
||||
return this.displayName;
|
||||
}
|
||||
|
||||
public MultiDoku createDoku(List<Constraint> constraints, int... params) {
|
||||
public MultiDoku createDoku(List<IConstraint> constraints, int... params) {
|
||||
return maker.makeSudoku(constraints, params);
|
||||
}
|
||||
|
||||
@@ -43,7 +43,7 @@ public enum SudokuType {
|
||||
|
||||
@FunctionalInterface
|
||||
private static interface SudokuMaker {
|
||||
MultiDoku makeSudoku(List<Constraint> constraints, int... params);
|
||||
MultiDoku makeSudoku(List<IConstraint> constraints, int... params);
|
||||
}
|
||||
|
||||
private static final String[] dokuNames;
|
||||
|
||||
@@ -11,6 +11,7 @@ import imgui.extension.imguifiledialog.flag.ImGuiFileDialogFlags;
|
||||
import imgui.type.ImBoolean;
|
||||
import imgui.type.ImInt;
|
||||
import sudoku.constraint.Constraint;
|
||||
import sudoku.constraint.IConstraint;
|
||||
import sudoku.structure.Difficulty;
|
||||
import sudoku.structure.MultiDoku;
|
||||
import sudoku.structure.SudokuFactory;
|
||||
@@ -40,18 +41,18 @@ public class SudokuSelector {
|
||||
initConstraints();
|
||||
}
|
||||
|
||||
private List<Constraint> getConstraints() {
|
||||
List<Constraint> constraints = new ArrayList<>();
|
||||
private List<IConstraint> getConstraints() {
|
||||
List<IConstraint> constraints = new ArrayList<>();
|
||||
for (int i = 0; i < this.contraints.size(); i++) {
|
||||
if (this.contraints.get(i).get())
|
||||
constraints.add(Constraint.values()[i]);
|
||||
constraints.add(Constraint.values()[i].getConstraint());
|
||||
}
|
||||
return constraints;
|
||||
}
|
||||
|
||||
private void initConstraints() {
|
||||
for (Constraint cons : Constraint.values()) {
|
||||
contraints.add(new ImBoolean(SudokuFactory.DEFAULT_CONSTRAINTS.contains(cons)));
|
||||
contraints.add(new ImBoolean(SudokuFactory.DEFAULT_CONSTRAINTS.contains(cons.getConstraint())));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -1,12 +1,12 @@
|
||||
package sudoku.constraint;
|
||||
|
||||
import java.io.Serializable;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
import sudoku.structure.Sudoku;
|
||||
|
||||
public interface IConstraint {
|
||||
|
||||
public interface IConstraint extends Serializable {
|
||||
boolean canBePlaced(final Sudoku s, int x, int y, int newSymbolIndex);
|
||||
|
||||
default List<Integer> getPossibleSymbols(final Sudoku s, int x, int y) {
|
||||
|
||||
@@ -15,14 +15,13 @@ import java.util.Scanner;
|
||||
public class ConsoleInterface {
|
||||
public Scanner reader = new Scanner(System.in);
|
||||
|
||||
public void welcome(){
|
||||
public void welcome() {
|
||||
System.out.println("Welcome to our Sudoku Solver!");
|
||||
System.out.println("This is the project of Melvyn Bauvent, Lilas Grenier and Simon Priblyski.");
|
||||
System.out.println("Do you have a save sudoku you would like to continue? (y/n, default n)");
|
||||
if (reader.next().equalsIgnoreCase("y")){
|
||||
if (reader.next().equalsIgnoreCase("y")) {
|
||||
useSavedDoku();
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
createDoku();
|
||||
}
|
||||
}
|
||||
@@ -32,27 +31,26 @@ public class ConsoleInterface {
|
||||
MultiDoku md = saveChoice();
|
||||
int blockWidth = md.getSubGrid(0).getBlockWidth();
|
||||
int blockHeight = md.getSubGrid(0).getBlocks().getFirst().getCells().size() / blockWidth;
|
||||
List<String> listSymbols = pickSymbols(blockWidth*blockHeight);
|
||||
List<String> listSymbols = pickSymbols(blockWidth * blockHeight);
|
||||
System.out.println("This is the saved sudoku:");
|
||||
showMultidoku(md, listSymbols, blockWidth, blockHeight);
|
||||
}
|
||||
|
||||
public void createDoku(){
|
||||
public void createDoku() {
|
||||
System.out.println("First of all, you need to tell me the size of the sudoku you want to generate.");
|
||||
int width = getBlockWidth();
|
||||
int height = getBlockHeight();
|
||||
System.out.println("Your sudoku will have blocks of a " + width + " x " + height + " format.");
|
||||
int numberOfSymbols = width * height;
|
||||
List<String> listSymbols = pickSymbols(numberOfSymbols);
|
||||
List<Constraint> listConstraints = getListConstraints();
|
||||
List<IConstraint> listConstraints = getListConstraints();
|
||||
System.out.println("Now that we have the size of our sudoku, " +
|
||||
"would you rather have a single grid ('one', default), " +
|
||||
"or a a multidoku composed of 5 subgrids ('multi') ?");
|
||||
MultiDoku doku;
|
||||
if (reader.next().equalsIgnoreCase("multi")) {
|
||||
doku = SudokuFactory.createBasicXShapedMultidoku(width, height, listConstraints);
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
doku = SudokuFactory.createBasicEmptyRectangleDoku(width, height, listConstraints);
|
||||
}
|
||||
System.out.println("Your sudoku will look like this:");
|
||||
@@ -63,8 +61,7 @@ public class ConsoleInterface {
|
||||
String difficulty = reader.next().toLowerCase();
|
||||
if (difficulty.equals("full")) {
|
||||
generateFullDoku(doku);
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
generatePartialDoku(doku, difficulty);
|
||||
}
|
||||
System.out.println("Here's your sudoku !");
|
||||
@@ -116,7 +113,8 @@ public class ConsoleInterface {
|
||||
}
|
||||
|
||||
private List<String> pickSymbols(int numberOfSymbols) {
|
||||
System.out.println("Would you like to pick the " + numberOfSymbols + " symbols from the sudoku? (y/n, default 'no' will use numbers)");
|
||||
System.out.println("Would you like to pick the " + numberOfSymbols
|
||||
+ " symbols from the sudoku? (y/n, default 'no' will use numbers)");
|
||||
if (reader.next().equalsIgnoreCase("y")) {
|
||||
List<String> listSymbols = new ArrayList<>();
|
||||
System.out.println("You have chosen to pick your own symbols.");
|
||||
@@ -132,7 +130,8 @@ public class ConsoleInterface {
|
||||
System.out.println("You chose the symbols: " + listSymbols.toString());
|
||||
return listSymbols;
|
||||
} else {
|
||||
System.out.println("What existing sets of symbols do you want to use? Numbers ('n', default), letters ('l'), or emojis ('e')?");
|
||||
System.out.println(
|
||||
"What existing sets of symbols do you want to use? Numbers ('n', default), letters ('l'), or emojis ('e')?");
|
||||
return switch (reader.next().toLowerCase()) {
|
||||
case "l" -> Symbols.Letters.getSymbols();
|
||||
case "e" -> Symbols.Emojis.getSymbols();
|
||||
@@ -141,22 +140,27 @@ public class ConsoleInterface {
|
||||
}
|
||||
}
|
||||
|
||||
private List<Constraint> getListConstraints() {
|
||||
List<Constraint> listConstraints = SudokuFactory.DEFAULT_CONSTRAINTS;
|
||||
System.out.println("The sudoku have constraints of blocks, lines and columns. Would you like to add the diagonal constraints ? (y/n, default 'no')");
|
||||
if(reader.next().equalsIgnoreCase("y")){
|
||||
listConstraints.add(Constraint.Diagonal);
|
||||
private List<IConstraint> getListConstraints() {
|
||||
List<IConstraint> listConstraints = SudokuFactory.DEFAULT_CONSTRAINTS;
|
||||
System.out.println(
|
||||
"The sudoku have constraints of blocks, lines and columns. Would you like to add the diagonal constraints ? (y/n, default 'no')");
|
||||
if (reader.next().equalsIgnoreCase("y")) {
|
||||
listConstraints.add(Constraint.Diagonal.getConstraint());
|
||||
}
|
||||
return listConstraints;
|
||||
}
|
||||
|
||||
private void generatePartialDoku(MultiDoku doku, String difficultyName) {
|
||||
Difficulty difficulty;
|
||||
switch (difficultyName){
|
||||
case "very easy": difficulty = Difficulty.VeryEasy;
|
||||
case "easy": difficulty = Difficulty.Easy;
|
||||
case "hard": difficulty = Difficulty.Hard;
|
||||
default: difficulty = Difficulty.Medium;
|
||||
switch (difficultyName) {
|
||||
case "very easy":
|
||||
difficulty = Difficulty.VeryEasy;
|
||||
case "easy":
|
||||
difficulty = Difficulty.Easy;
|
||||
case "hard":
|
||||
difficulty = Difficulty.Hard;
|
||||
default:
|
||||
difficulty = Difficulty.Medium;
|
||||
}
|
||||
try {
|
||||
SudokuFactory.fillDoku(doku, difficulty);
|
||||
@@ -169,15 +173,15 @@ public class ConsoleInterface {
|
||||
new RandomSolver().solve(doku);
|
||||
}
|
||||
|
||||
private void showMultidoku(MultiDoku doku, List<String> listSymbols, int width, int height){
|
||||
private void showMultidoku(MultiDoku doku, List<String> listSymbols, int width, int height) {
|
||||
showMultiDoku(RenderableMultidoku.fromMultidoku(doku), listSymbols, width, height);
|
||||
}
|
||||
|
||||
private void showMultiDoku(RenderableMultidoku doku, List<String> listSymbols, int width, int height){
|
||||
private void showMultiDoku(RenderableMultidoku doku, List<String> listSymbols, int width, int height) {
|
||||
SudokuPrinter.printMultiDoku(doku, listSymbols, width, height);
|
||||
}
|
||||
|
||||
private void saveMultiDoku(MultiDoku doku){
|
||||
private void saveMultiDoku(MultiDoku doku) {
|
||||
System.out.println("Number of the file to overwrite ('-1' or unused save file number to create a new save) :");
|
||||
int n = reader.nextInt();
|
||||
String path = SudokuSerializer.saveMultiDoku(doku, n);
|
||||
|
||||
@@ -12,6 +12,7 @@ import org.json.JSONArray;
|
||||
import org.json.JSONObject;
|
||||
|
||||
import sudoku.constraint.Constraint;
|
||||
import sudoku.constraint.IConstraint;
|
||||
import sudoku.structure.Block;
|
||||
import sudoku.structure.Cell;
|
||||
import sudoku.structure.MultiDoku;
|
||||
@@ -44,7 +45,7 @@ public class SudokuSerializer {
|
||||
}
|
||||
|
||||
int blockID = blockIds.indexOf(block);
|
||||
assert(blockID >= 0);
|
||||
assert (blockID >= 0);
|
||||
int symbolIndex = cell.getSymbolIndex();
|
||||
|
||||
JSONObject cellJsonObject = new JSONObject();
|
||||
@@ -99,8 +100,17 @@ public class SudokuSerializer {
|
||||
|
||||
// serialize constraints
|
||||
|
||||
for (Constraint cons : sudoku.getConstraints()) {
|
||||
constraintsJsonArray.put(cons.ordinal());
|
||||
for (IConstraint cons : sudoku.getConstraints()) {
|
||||
boolean constraintSerialized = false;
|
||||
for (Constraint enumCons : Constraint.values()) {
|
||||
if (cons.getClass().isAssignableFrom(enumCons.getConstraint().getClass())) {
|
||||
constraintSerialized = true;
|
||||
constraintsJsonArray.put(enumCons.ordinal());
|
||||
}
|
||||
}
|
||||
if (!constraintSerialized) {
|
||||
System.out.println("La contrainte " + cons.getClass() + " n'a pas pu être sérialisé !");
|
||||
}
|
||||
}
|
||||
|
||||
jsonSudoku.put("constraints", constraintsJsonArray);
|
||||
@@ -125,6 +135,7 @@ public class SudokuSerializer {
|
||||
*/
|
||||
public static String saveMultiDoku(final MultiDoku doku) {
|
||||
JSONObject jsonRoot = serializeSudoku(doku);
|
||||
|
||||
File f = new File("save", "save.json");
|
||||
int i = 0;
|
||||
while (f.exists()) {
|
||||
@@ -143,14 +154,12 @@ public class SudokuSerializer {
|
||||
File f;
|
||||
if (saveToOverwrite == 0) {
|
||||
f = new File("save", "save.json");
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
f = new File("save", "save-" + saveToOverwrite + ".json");
|
||||
}
|
||||
if (!f.exists()) {
|
||||
return saveMultiDoku(doku);
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
try (FileWriter file = new FileWriter(f)) {
|
||||
file.write(serializeSudoku(doku).toString(3));
|
||||
} catch (IOException e) {
|
||||
@@ -234,7 +243,7 @@ public class SudokuSerializer {
|
||||
|
||||
List<Cell> sudokuCells = new ArrayList<>();
|
||||
List<Block> sudokuBlocks = new ArrayList<>();
|
||||
List<Constraint> sudokuConstraints = new ArrayList<>();
|
||||
List<IConstraint> sudokuConstraints = new ArrayList<>();
|
||||
|
||||
for (int j = 0; j < sudokuCellsJsonArray.length(); j++) {
|
||||
int cellID = sudokuCellsJsonArray.getInt(j);
|
||||
@@ -248,7 +257,7 @@ public class SudokuSerializer {
|
||||
|
||||
for (int j = 0; j < sudokuConstraintsJsonArray.length(); j++) {
|
||||
int constraintID = sudokuConstraintsJsonArray.getInt(j);
|
||||
sudokuConstraints.add(Constraint.values()[constraintID]);
|
||||
sudokuConstraints.add(Constraint.values()[constraintID].getConstraint());
|
||||
}
|
||||
|
||||
Sudoku s = new Sudoku(sudokuCells, sudokuBlocks, sudokuConstraints);
|
||||
|
||||
@@ -193,7 +193,7 @@ public class MultiDoku {
|
||||
}
|
||||
|
||||
public MultiDoku clone() {
|
||||
//TODO: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaah
|
||||
// TODO: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaah
|
||||
return SudokuSerializer.deserializeSudoku(SudokuSerializer.serializeSudoku(this));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -25,13 +25,14 @@ public class Sudoku {
|
||||
/**
|
||||
* Liste des contraintes (TODO) du Sudoku.
|
||||
*/
|
||||
private final List<Constraint> constraints;
|
||||
private final List<IConstraint> constraints;
|
||||
/**
|
||||
* Largeur des Blocks s'ils sont rectangulaires, valant 0 si ce n'est pas le cas.
|
||||
* Largeur des Blocks s'ils sont rectangulaires, valant 0 si ce n'est pas le
|
||||
* cas.
|
||||
*/
|
||||
private int blockWidth;
|
||||
|
||||
public Sudoku(List<Cell> cells, List<Block> blocks, List<Constraint> constraints) {
|
||||
public Sudoku(List<Cell> cells, List<Block> blocks, List<IConstraint> constraints) {
|
||||
this.cells = cells;
|
||||
this.blocks = blocks;
|
||||
this.constraints = constraints;
|
||||
@@ -49,6 +50,7 @@ public class Sudoku {
|
||||
|
||||
/**
|
||||
* Transforme des coordonées d'une Cell en index.
|
||||
*
|
||||
* @param x int, abscisse.
|
||||
* @param y int, ordonnée.
|
||||
* @return int, index correspondant.
|
||||
@@ -59,7 +61,9 @@ public class Sudoku {
|
||||
|
||||
/**
|
||||
* Vérifie que des coordonnées correspondent bien à une Cell dans le Sudoku.
|
||||
* @return boolean, valant true si les coordonnées sont dans les bornes du Sudoku, false sinon.
|
||||
*
|
||||
* @return boolean, valant true si les coordonnées sont dans les bornes du
|
||||
* Sudoku, false sinon.
|
||||
*/
|
||||
public boolean isValidCoords(int x, int y) {
|
||||
int index = toIndex(x, y);
|
||||
@@ -68,21 +72,25 @@ public class Sudoku {
|
||||
|
||||
/**
|
||||
* Vérifie que l'index correspond bien à une Cell dans le Sudoku.
|
||||
* @return boolean, valant true si l'index est dans les bornes du Sudoku, false sinon.
|
||||
*
|
||||
* @return boolean, valant true si l'index est dans les bornes du Sudoku, false
|
||||
* sinon.
|
||||
*/
|
||||
public boolean isValidCoords(int index) {
|
||||
return index < getSize() * getSize();
|
||||
}
|
||||
|
||||
/**
|
||||
* Teste si on peut placer la value dans la Cell aux coordonnées x, y d'après les contraintes du Sudoku.
|
||||
* Teste si on peut placer la value dans la Cell aux coordonnées x, y d'après
|
||||
* les contraintes du Sudoku.
|
||||
*
|
||||
* @param x int, abscisse de la Cell voulue.
|
||||
* @param y int, ordonnée de la Cell voulue.
|
||||
* @param value int, index du symbole qu'on veut placer.
|
||||
* @return boolean, true si on peut la placer et false sinon.
|
||||
*/
|
||||
public boolean canBePlaced(int x, int y, int value) {
|
||||
for (Constraint constraint : this.constraints) {
|
||||
for (IConstraint constraint : this.constraints) {
|
||||
if (!constraint.canBePlaced(this, x, y, value)) {
|
||||
return false;
|
||||
}
|
||||
@@ -92,6 +100,7 @@ public class Sudoku {
|
||||
|
||||
/**
|
||||
* Vide la Cell dotn les coordonnées sont renseignées de son symbole.
|
||||
*
|
||||
* @param x int, abscisse de la Cell voulue.
|
||||
* @param y int, coordonnée de la Cell voulue.
|
||||
*/
|
||||
@@ -119,6 +128,7 @@ public class Sudoku {
|
||||
|
||||
/**
|
||||
* Place le symbole d'index value dans la Cell de coordonnées précisées.
|
||||
*
|
||||
* @param x int, abscisse de la Cell voulue.
|
||||
* @param y int, coordonnée de la Cell voulue.
|
||||
* @param value int, index du symbole à placer.
|
||||
@@ -126,7 +136,7 @@ public class Sudoku {
|
||||
*/
|
||||
public Cell setCellSymbol(int x, int y, int value) {
|
||||
assert (isValidCoords(x, y));
|
||||
for (Constraint constraint : this.constraints) {
|
||||
for (IConstraint constraint : this.constraints) {
|
||||
if (!constraint.canBePlaced(this, x, y, value)) {
|
||||
return null;
|
||||
}
|
||||
@@ -138,6 +148,7 @@ public class Sudoku {
|
||||
|
||||
/**
|
||||
* Place les symboles d'index contenus dans values dans les cases du Sudoku.
|
||||
*
|
||||
* @param values List<Integer>, liste des index des symboles à placer.
|
||||
* @return boolean, vaut true si les symboles ont été placés, false sinon.
|
||||
*/
|
||||
@@ -155,7 +166,9 @@ public class Sudoku {
|
||||
}
|
||||
|
||||
/**
|
||||
* Place les symboles d'index contenus dans values dans les cases du Sudoku et rend ces cases immuables.
|
||||
* Place les symboles d'index contenus dans values dans les cases du Sudoku et
|
||||
* rend ces cases immuables.
|
||||
*
|
||||
* @param values List<Integer>, liste des index des symboles à placer.
|
||||
* @return boolean, vaut true si les symboles ont été placés, false sinon.
|
||||
*/
|
||||
@@ -192,7 +205,7 @@ public class Sudoku {
|
||||
return this.cells.get(i);
|
||||
}
|
||||
|
||||
public List<Constraint> getConstraints() {
|
||||
public List<IConstraint> getConstraints() {
|
||||
return constraints;
|
||||
}
|
||||
|
||||
@@ -210,6 +223,7 @@ public class Sudoku {
|
||||
|
||||
/**
|
||||
* Vérifie si une Cell appartient au Sudoku.
|
||||
*
|
||||
* @param cell Cell, cellule dont on veut vérifier l'appartenance au Sudoku.
|
||||
* @return boolean, vaut true si la Cell appartient au Sudoku.
|
||||
*/
|
||||
@@ -233,6 +247,7 @@ public class Sudoku {
|
||||
|
||||
/**
|
||||
* Renvoie la 1re Cell vide du Sudoku.
|
||||
*
|
||||
* @return Cell, une Cell vide, ou null s'il n'y en a pas.
|
||||
*/
|
||||
public Cell getFirstEmptyCell() {
|
||||
@@ -245,7 +260,9 @@ public class Sudoku {
|
||||
}
|
||||
|
||||
/**
|
||||
* Vérifie si le Sudoku est résolue, soit complet et cohérent avec ses contraintes.
|
||||
* Vérifie si le Sudoku est résolue, soit complet et cohérent avec ses
|
||||
* contraintes.
|
||||
*
|
||||
* @return boolean, valant true si le Sudoku est résolu, false sinon.
|
||||
*/
|
||||
public boolean isSolved() {
|
||||
@@ -256,6 +273,7 @@ public class Sudoku {
|
||||
|
||||
/**
|
||||
* Vérifie que le Sudoku est complet, soit qu'il n'y ait aucune case vide.
|
||||
*
|
||||
* @return boolean, true si le Sudoku est complet, false sinon.
|
||||
*/
|
||||
private boolean isComplete() {
|
||||
@@ -263,7 +281,9 @@ public class Sudoku {
|
||||
}
|
||||
|
||||
/**
|
||||
* Vérifie si le Sudoku est valide, soit qu'il est cohérent avec ses contraintes.
|
||||
* Vérifie si le Sudoku est valide, soit qu'il est cohérent avec ses
|
||||
* contraintes.
|
||||
*
|
||||
* @return bollean, true si le Sudoku est valide, false sinon
|
||||
*/
|
||||
private boolean isValid() {
|
||||
|
||||
@@ -10,6 +10,7 @@ import java.util.Map;
|
||||
import java.util.Random;
|
||||
|
||||
import sudoku.constraint.Constraint;
|
||||
import sudoku.constraint.IConstraint;
|
||||
import sudoku.io.SudokuSerializer;
|
||||
import sudoku.solver.RandomSolver;
|
||||
import sudoku.solver.Solver;
|
||||
@@ -25,11 +26,13 @@ public class SudokuFactory {
|
||||
* Liste des contraintes par défaut d'un Multi- ou Sudoku.
|
||||
* Comprend les contraintes de blocs, de lignes, et de colonnes.
|
||||
*/
|
||||
public static List<Constraint> DEFAULT_CONSTRAINTS = Arrays.asList(Constraint.Block, Constraint.Column,
|
||||
Constraint.Line);
|
||||
public static List<IConstraint> DEFAULT_CONSTRAINTS = SudokuFactory
|
||||
.fromConstraints(Arrays.asList(Constraint.Block, Constraint.Column,
|
||||
Constraint.Line));
|
||||
|
||||
/**
|
||||
* Créée des Cells et les met dans une liste de taille size.
|
||||
*
|
||||
* @param size int, nombre de Cells à initialiser.
|
||||
* @return List<Cell>, liste des Cells initialisées.
|
||||
*/
|
||||
@@ -42,7 +45,9 @@ public class SudokuFactory {
|
||||
}
|
||||
|
||||
/**
|
||||
* Créée des Blocks de taille width par height à partir des cellules données, et les met dans une liste.
|
||||
* Créée des Blocks de taille width par height à partir des cellules données, et
|
||||
* les met dans une liste.
|
||||
*
|
||||
* @param cells List<Cell>, liste des Cells à découper en Blocks.
|
||||
* @param width int, largeur des Blocks à créer.
|
||||
* @param height int, hauteur des Blocks à créer.
|
||||
@@ -72,29 +77,36 @@ public class SudokuFactory {
|
||||
}
|
||||
|
||||
/**
|
||||
* Créée un MultiDoku vide dont les Blocks sont de taille widthBlock par heightBlock.
|
||||
* Créée un MultiDoku vide dont les Blocks sont de taille widthBlock par
|
||||
* heightBlock.
|
||||
*
|
||||
* @param widthBlock int, largeur des Blocks.
|
||||
* @param heightBlock int, hauteur des Blocks.
|
||||
* @return MultiDoku, MultiDoku vide.
|
||||
*/
|
||||
public static MultiDoku createBasicEmptyRectangleDoku(int widthBlock, int heightBlock,
|
||||
List<Constraint> constraints) {
|
||||
List<IConstraint> constraints) {
|
||||
return new MultiDoku(Arrays.asList(createRectangleSudoku(widthBlock, heightBlock, constraints)));
|
||||
}
|
||||
|
||||
/**
|
||||
* Créée un MultiDoku vide dont les Blocks sont carrés de longueur size.
|
||||
*
|
||||
* @param size int, taille des Blocks.
|
||||
* @return MultiDoku, MultiDoku vide.
|
||||
*/
|
||||
public static MultiDoku createBasicEmptySquareDoku(int size, List<Constraint> constraints) {
|
||||
public static MultiDoku createBasicEmptySquareDoku(int size, List<IConstraint> constraints) {
|
||||
return new MultiDoku(Arrays.asList(createSquareSudoku(size, constraints)));
|
||||
}
|
||||
|
||||
/**
|
||||
* Place des Cells immutables de valeurs fournies, aux Coordinate fournies dans le MultiDoku doku fourni.
|
||||
* Place des Cells immutables de valeurs fournies, aux Coordinate fournies dans
|
||||
* le MultiDoku doku fourni.
|
||||
*
|
||||
* @param doku MultiDoku, MultiDoku à remplir.
|
||||
* @param immutableCells Map<Coordinate, Integer>, association de Coordinate coordonnées et Integer valeurs, correspondant aux cases à remplir.
|
||||
* @param immutableCells Map<Coordinate, Integer>, association de Coordinate
|
||||
* coordonnées et Integer valeurs, correspondant aux cases
|
||||
* à remplir.
|
||||
*/
|
||||
public static void setImmutableCells(MultiDoku doku, Map<Coordinate, Integer> immutableCells) {
|
||||
immutableCells.forEach((coordinate, symbol) -> {
|
||||
@@ -113,8 +125,10 @@ public class SudokuFactory {
|
||||
*
|
||||
* @param doku MultiDoku, MultiDoku dont on doit vider des Cells.
|
||||
* @param nbCellsToEmpty int, nombre de cases à retirer.
|
||||
* @return boolean, valant true si un MultiDoku de difficulté donnée peut être créée, false sinon.
|
||||
* @throws Exception si la difficulté n'est pas compatible avec la taille du MultiDoku.
|
||||
* @return boolean, valant true si un MultiDoku de difficulté donnée peut être
|
||||
* créée, false sinon.
|
||||
* @throws Exception si la difficulté n'est pas compatible avec la taille du
|
||||
* MultiDoku.
|
||||
*/
|
||||
public static boolean newDokuFromFilledOne(MultiDoku doku, int nbCellsToEmpty, Solver solver) throws Exception {
|
||||
|
||||
@@ -149,12 +163,14 @@ public class SudokuFactory {
|
||||
}
|
||||
|
||||
/**
|
||||
* Créée un Sudoku vide dont les Blocks sont de taille widthBlock par heightBlock.
|
||||
* Créée un Sudoku vide dont les Blocks sont de taille widthBlock par
|
||||
* heightBlock.
|
||||
*
|
||||
* @param widthBlock int, largeur des Blocks.
|
||||
* @param heightBlock int, hauteur des Blocks.
|
||||
* @return Sudoku, Sudoku vide.
|
||||
*/
|
||||
private static Sudoku createRectangleSudoku(int widthBlock, int heightBlock, List<Constraint> constraints) {
|
||||
private static Sudoku createRectangleSudoku(int widthBlock, int heightBlock, List<IConstraint> constraints) {
|
||||
int symbolCount = widthBlock * heightBlock;
|
||||
List<Cell> cases = initCells(symbolCount);
|
||||
List<Block> blocs = initRectangleBlocs(cases, widthBlock, heightBlock);
|
||||
@@ -168,15 +184,17 @@ public class SudokuFactory {
|
||||
|
||||
/**
|
||||
* Créée un Sudoku vide dont les Blocks sont carrés de longueur size.
|
||||
*
|
||||
* @param size int, taille des Blocks.
|
||||
* @return Sudoku, Sudoku vide.
|
||||
*/
|
||||
private static Sudoku createSquareSudoku(int size, List<Constraint> constraints) {
|
||||
private static Sudoku createSquareSudoku(int size, List<IConstraint> constraints) {
|
||||
return createRectangleSudoku(size, size, constraints);
|
||||
}
|
||||
|
||||
/**
|
||||
* Connecte deux Sudokus selon la décalage offset fourni.
|
||||
*
|
||||
* @param sudoku1 Sudoku, premier sudoku à connecter.
|
||||
* @param sudoku2 Sudoku, second sudoku à connecter.
|
||||
* @param offset Coordinate, décalage entre les deux Sudokus.
|
||||
@@ -213,11 +231,14 @@ public class SudokuFactory {
|
||||
}
|
||||
|
||||
/**
|
||||
* Créée un MultiDoku de Blocks carrés de taille size composé de cinq Sudokus, dont un central qui partage chacun de ses Blockss d'angle avec un autre Sudoku.
|
||||
* Créée un MultiDoku de Blocks carrés de taille size composé de cinq Sudokus,
|
||||
* dont un central qui partage chacun de ses Blockss d'angle avec un autre
|
||||
* Sudoku.
|
||||
*
|
||||
* @param size int, largeur des Blocks unitraires des Sudokus à crééer.
|
||||
* @return MultiDoku, MultiDoku de forme X.
|
||||
*/
|
||||
public static MultiDoku createBasicXShapedMultidoku(int size, List<Constraint> constraints) {
|
||||
public static MultiDoku createBasicXShapedMultidoku(int size, List<IConstraint> constraints) {
|
||||
assert (size > 1);
|
||||
|
||||
/*
|
||||
@@ -241,7 +262,8 @@ public class SudokuFactory {
|
||||
}
|
||||
|
||||
/**
|
||||
* Créée un MultiDoku de Blocks rectangulaires de forme width par height composé de cinq Sudokus,
|
||||
* Créée un MultiDoku de Blocks rectangulaires de forme width par height composé
|
||||
* de cinq Sudokus,
|
||||
* dont un central qui partage chacun de ses Blocks d'angle avec un autre
|
||||
* Sudoku.
|
||||
*
|
||||
@@ -249,7 +271,7 @@ public class SudokuFactory {
|
||||
* @param height int, hauteur des Blocks unitraires des Sudokus à crééer.
|
||||
* @return MultiDoku, MultiDoku de forme X.
|
||||
*/
|
||||
public static MultiDoku createBasicXShapedMultidoku(int width, int height, List<Constraint> constraints) {
|
||||
public static MultiDoku createBasicXShapedMultidoku(int width, int height, List<IConstraint> constraints) {
|
||||
assert (width > 1 && height > 1);
|
||||
|
||||
/*
|
||||
@@ -291,14 +313,14 @@ public class SudokuFactory {
|
||||
}
|
||||
}
|
||||
|
||||
public static MultiDoku createBasicEmptyRandomBlockDoku(int blockSize, List<Constraint> constraints) {
|
||||
public static MultiDoku createBasicEmptyRandomBlockDoku(int blockSize, List<IConstraint> constraints) {
|
||||
int blockCellCount = blockSize * blockSize;
|
||||
List<Cell> cells = initCells(blockCellCount);
|
||||
List<Cell> homeLessCells = new ArrayList<>();
|
||||
homeLessCells.addAll(cells);
|
||||
List<Block> blocks = new ArrayList<>();
|
||||
Random r = new Random();
|
||||
for (int i = 0 ; i < blockCellCount; i++) {
|
||||
for (int i = 0; i < blockCellCount; i++) {
|
||||
Block b = new Block();
|
||||
for (int j = 0; j < blockCellCount; j++) {
|
||||
int cellIndex = r.nextInt(homeLessCells.size());
|
||||
@@ -314,4 +336,12 @@ public class SudokuFactory {
|
||||
}
|
||||
return new MultiDoku(Arrays.asList(sudoku));
|
||||
}
|
||||
|
||||
public static List<IConstraint> fromConstraints(List<Constraint> constraints) {
|
||||
List<IConstraint> iconstraints = new ArrayList<>();
|
||||
for (Constraint cons : constraints) {
|
||||
iconstraints.add(cons.getConstraint());
|
||||
}
|
||||
return iconstraints;
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user