Merge branch 'master' of git.ale-pri.com:Ryuk/Sudoku

app/src/main/java/sudoku/solver/Solver.java

@@ -4,16 +4,79 @@ import sudoku.structure.MultiDoku;
 import sudoku.structure.Cell;
 
 import java.util.List;
+import java.util.Random;
+import java.util.concurrent.CancellationException;
 
 public class Solver {
 
     /**
      * Résout le multidoku passé en paramètre si c'est possible.
-     * En testant toutes les possibilités avec un algorithme de backtracking.
+     * En testant toutes les possibilités, de manière aléatoire, avec un algorithme de backtracking.
+     *
      * @param doku Multidoku, à résoudre
-     * @return boolean, true s'il est résolut ou false s'il ne l'est pas.
+     * @param rand Random, pour tester aléatoirement les symboles
+     * @return boolean, true s'il est résolu ou false s'il ne l'est pas.
      */
+    public static boolean solveRandom(MultiDoku doku, Random rand) {
+        if (Thread.interrupted())
+			throw new CancellationException("User wants to stop the solver");
+
+        if (doku.isValid()) {
+            return true;
+        }
+
+        Cell cellToFill = doku.getFirstEmptyCell();
+        if (cellToFill == null) {
+            return false;
+        }
+
+        List<Integer> possibleSymbols = doku.getPossibleSymbolsOfCell(cellToFill);
+
+        while (!possibleSymbols.isEmpty()){
+            int nextPossibleSymbolIndex = rand.nextInt(possibleSymbols.size());
+            int nextSymbol = possibleSymbols.get(nextPossibleSymbolIndex);
+
+            cellToFill.setSymbolIndex(nextSymbol);
+            if (Solver.solveRandom(doku, rand)) {
+                return true;
+            }
+            cellToFill.setSymbolIndex(Cell.NOSYMBOL);
+            possibleSymbols.remove(nextPossibleSymbolIndex);
+
+        }
+        return false;
+    }
+
+    public static int countSolution(MultiDoku doku) {
+        int result = 0;
+
+        if (doku.isValid()) {
+            return 1;
+        }
+
+        Cell cellToFill = doku.getFirstEmptyCell();
+        if (cellToFill == null) {
+            return 0;
+        }
+
+        List<Integer> possibleSymbols = doku.getPossibleSymbolsOfCell(cellToFill);
+
+        for (int symbol : possibleSymbols) {
+
+            cellToFill.setSymbolIndex(symbol);
+            if (Solver.solve(doku)) {
+                result++;
+            }
+            cellToFill.setSymbolIndex(Cell.NOSYMBOL);
+        }
+
+        return result;
+    }
+
     public static boolean solve(MultiDoku doku) {
+        if (Thread.interrupted())
+			throw new CancellationException("User wants to stop the solver");
+
         if (doku.isValid()) {
             return true;
         }
@@ -28,46 +91,16 @@ public class Solver {
             return false;
         }
 
-        for (int symbol : possibleSymbols) {
+        for (int symbol : possibleSymbols){
+
             cellToFill.setSymbolIndex(symbol);
             if (Solver.solve(doku)) {
                 return true;
             } else {
                 cellToFill.setSymbolIndex(Cell.NOSYMBOL);
             }
+
         }
         return false;
     }
-
-    /*
-    Ancien algo abandonné pour le moment
-
-    private void rollBack() {
-        stack.pop();
-    }
-
-
-    public MultiDoku solve(MultiDoku doku, List<IConstraint> constraints) throws Exception {
-        List<MutableCell> allMutableCells = doku.getMutableCells();
-        List<MutableCell> remainingCellsToCheck = new ArrayList<>(allMutableCells);
-        Random rand = new Random();
-        while (!remainingCellsToCheck.isEmpty()) {
-            int indexCurrentCell = rand.nextInt(remainingCellsToCheck.size());
-            MutableCell currentCell = remainingCellsToCheck.get(indexCurrentCell);
-
-            int symbol = currentCell.getPossibleSymbols().get(0);
-            currentCell.setSymbolIndex(symbol);
-            // stack.push(new MutableCell(currentCell));
-            try {
-                doku.updateSymbolsPossibilities();
-            } catch (Exception e) {
-                this.rollBack();
-                System.out.println(this.stack);
-            }
-            remainingCellsToCheck.remove(indexCurrentCell);
-        }
-        return doku;
-    }
-
-     */
 }

app/src/main/java/sudoku/solver/StupidSolver.java

@@ -5,6 +5,9 @@ import java.util.concurrent.CancellationException;
 import sudoku.structure.MultiDoku;
 import sudoku.structure.Sudoku;
 
+/**
+ * Class de test non utilisé
+ */
 public class StupidSolver {
 
 	private static boolean solve(Sudoku sudoku, int index) {

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

@@ -77,4 +77,10 @@ public class Cell {
 	public boolean isMutable() {
 		return this.isMutable;
 	}
+
+    public int empty() {
+		int oldSymbol = this.symbolIndex;
+		this.symbolIndex = Cell.NOSYMBOL;
+		return oldSymbol;
+    }
 }

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

@@ -98,5 +98,21 @@ public class MultiDoku {
 
 		return true;
 	}
+
+	public List<Cell> getFilledCells() {
+		List<Cell> result = new ArrayList<>();
+		for (Cell c : this.getCells()){
+			if (!c.isEmpty()) {
+				result.add(c);
+			}
+		}
+		return result;
+	}
+
+	public void empty(Cell cell) {
+		List<Cell> cells = getCells();
+		Cell cellToEmpty = cells.get(cells.indexOf(cell));
+		cellToEmpty.setSymbolIndex(Cell.NOSYMBOL);
+	}
 }
 

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

@@ -242,8 +242,9 @@ public class Sudoku {
 		} catch (Exception e) {
 			return result;
 		}
-		for (IConstraint constraint : this.constraints) {
-			if (result.isEmpty()) {
+		for (int i = 0; i < this.constraints.size(); i++) {
+			IConstraint constraint = this.constraints.get(i);
+			if (i == 0) {
 				result.addAll(constraint.getPossibleSymbols(this, cellCoordinates.getX(), cellCoordinates.getY()));
 			} else {
 				result.retainAll(constraint.getPossibleSymbols(this, cellCoordinates.getX(), cellCoordinates.getY()));

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

@@ -4,14 +4,17 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
+import java.util.Random;
 
 import sudoku.constraint.BlockConstraint;
 import sudoku.constraint.ColumnConstraint;
 import sudoku.constraint.IConstraint;
 import sudoku.constraint.LineConstraint;
+import sudoku.solver.Solver;
 
 public class SudokuFactory {
 
+	private static final Random random = new Random();
 	public static List<IConstraint> DEFAULT_CONSTRAINTS = Arrays.asList(new BlockConstraint(), new LineConstraint(), new ColumnConstraint());
 
 	private static List<Cell> initCells(int size) {
@@ -66,6 +69,37 @@ public class SudokuFactory {
 		});
 	}
 
+	public static boolean newDokuFromFilledOne (MultiDoku doku, int difficulty) throws Exception {
+
+		if (difficulty > doku.getCells().size()) {
+			throw new Exception();
+		}
+
+		if (difficulty == 0) {
+			return true;
+		}
+
+		List<Cell> cellsThatCanBeEmptied = doku.getFilledCells();
+
+		while (!cellsThatCanBeEmptied.isEmpty()) {
+			int index = random.nextInt(cellsThatCanBeEmptied.size());
+			Cell cellToEmpty = cellsThatCanBeEmptied.get(index);
+
+			int oldSymbol = cellToEmpty.empty();
+
+			if (Solver.countSolution(doku) == 1) {
+				if (newDokuFromFilledOne(doku, --difficulty)) {
+					return true;
+				}
+			}
+
+			cellToEmpty.setSymbolIndex(oldSymbol);
+			cellsThatCanBeEmptied.remove(cellToEmpty);
+		}
+
+		return false;
+    }
+
 	private static Sudoku createRectangleSudoku(int width, int height) {
 		int symbolCount = width * height;
 		List<Cell> cases = initCells(symbolCount);