From 4bd55d4ce4a71e0dd7ae7735ec0a56698bcdfe11 Mon Sep 17 00:00:00 2001 From: Janet-Doe Date: Tue, 21 Jan 2025 19:10:06 +0100 Subject: [PATCH] merge --- app/src/main/java/sudoku/Cell.java | 48 +++++++++++++++- app/src/main/java/sudoku/ImmutableCell.java | 4 +- app/src/main/java/sudoku/Main.java | 56 +++++++++++++++++++ app/src/main/java/sudoku/MutableCell.java | 12 +++- app/src/main/java/sudoku/Sudoku.java | 12 ++-- app/src/main/java/sudoku/SudokuFactory.java | 4 +- .../sudoku/constraint/BlockConstraint.java | 11 +++- .../main/java/sudoku/io/SudokuPrinter.java | 10 ++-- app/src/main/java/sudoku/solver/Solver.java | 31 ++++------ 9 files changed, 151 insertions(+), 37 deletions(-) diff --git a/app/src/main/java/sudoku/Cell.java b/app/src/main/java/sudoku/Cell.java index 74dd9b7..32be9b7 100644 --- a/app/src/main/java/sudoku/Cell.java +++ b/app/src/main/java/sudoku/Cell.java @@ -1,10 +1,17 @@ package sudoku; +import org.checkerframework.checker.units.qual.C; + +import java.util.ArrayList; +import java.util.List; + public abstract class Cell { - protected static int NOSYMBOLE = -1; + protected static int NOSYMBOL = -1; protected int symbolIndex; protected Block block = null; + //protected List blockContainers = null; + //protected List sudokuContainers = null; public Cell(int symbolIndex) { this.symbolIndex = symbolIndex; @@ -14,9 +21,25 @@ public abstract class Cell { * @brief Default constructor, empty square */ public Cell() { - this(NOSYMBOLE); + this(NOSYMBOL); } + /* + + public Cell(Cell cell) { + this.symbolIndex = cell.symbolIndex; + this.sudokuContainers = cell.sudokuContainers; + this.blockContainers = cell.blockContainers; + } + + public Cell(List sudokuContainers, List blockContainers) { + super(); + this.sudokuContainers = new ArrayList<>(sudokuContainers); + this.blockContainers = new ArrayList<>(blockContainers); + } + + */ + public int getSymbolIndex() { return symbolIndex; } @@ -25,11 +48,30 @@ public abstract class Cell { return this.block; } + /* + public List getBlockContainers() { + return this.blockContainers; + } + + public void setBlockContainers(List block) { + this.blockContainers = block; + } + + public List getSudokuContainers() { + return this.sudokuContainers; + } +*/ // only SudokuFactory and SudokuSerializer should access this public void setBlock(Block block) { this.block = block; } + /* + public void setSudokuContainers(List sudoku) { + this.sudokuContainers = sudoku; + } + */ + public boolean equalsValue(Cell otherCell) { return otherCell.getSymbolIndex() == this.getSymbolIndex(); } @@ -38,7 +80,7 @@ public abstract class Cell { public String toString() { StringBuilder sb = new StringBuilder(); sb.append("| "); - if (this.symbolIndex != NOSYMBOLE){ + if (this.symbolIndex != NOSYMBOL){ sb.append(this.symbolIndex); } else { diff --git a/app/src/main/java/sudoku/ImmutableCell.java b/app/src/main/java/sudoku/ImmutableCell.java index 828c4b1..3442562 100644 --- a/app/src/main/java/sudoku/ImmutableCell.java +++ b/app/src/main/java/sudoku/ImmutableCell.java @@ -2,8 +2,8 @@ package sudoku; public class ImmutableCell extends Cell { - public ImmutableCell(int symboleIndex) { - super(symboleIndex); + public ImmutableCell(int symbolIndex) { + super(symbolIndex); } } diff --git a/app/src/main/java/sudoku/Main.java b/app/src/main/java/sudoku/Main.java index fb8efe2..b5ae811 100644 --- a/app/src/main/java/sudoku/Main.java +++ b/app/src/main/java/sudoku/Main.java @@ -3,8 +3,15 @@ */ package sudoku; +import sudoku.constraint.BlockConstraint; +import sudoku.constraint.ColumnConstraint; +import sudoku.constraint.IConstraint; +import sudoku.constraint.LineConstraint; import sudoku.io.SudokuPrinter; import sudoku.io.SudokuSerializer; +import sudoku.solver.Solver; + +import java.util.ArrayList; public class Main { public String getGreeting() { @@ -13,5 +20,54 @@ public class Main { public static void main(String[] args) { System.out.println(new Main().getGreeting()); + int blockWidth = 2; + int blockHeight = 2; + var multidoku = SudokuFactory.createBasicEmptyRectangleSudoku(blockWidth, blockHeight); + var sudoku = multidoku.getSubGrid(0); + //SudokuPrinter.printRectangleSudoku(sudoku, blockWidth , blockHeight); + //Line 1: + ((MutableCell)sudoku.getCell(0)).setSymbolIndex(0); + ((MutableCell)sudoku.getCell(1)).setSymbolIndex(1); + ((MutableCell)sudoku.getCell(2)).setSymbolIndex(2); + ((MutableCell)sudoku.getCell(3)).setSymbolIndex(3); + //Line 2: + ((MutableCell)sudoku.getCell(4)).setSymbolIndex(2); + ((MutableCell)sudoku.getCell(5)).setSymbolIndex(3); + ((MutableCell)sudoku.getCell(6)).setSymbolIndex(0); + ((MutableCell)sudoku.getCell(7)).setSymbolIndex(1); + //Line 3: + ((MutableCell)sudoku.getCell(8)).setSymbolIndex(1); + ((MutableCell)sudoku.getCell(9)).setSymbolIndex(0); + ((MutableCell)sudoku.getCell(10)).setSymbolIndex(3); + ((MutableCell)sudoku.getCell(11)).setSymbolIndex(2); + // Line 4 + ((MutableCell)sudoku.getCell(12)).setSymbolIndex(3); + ((MutableCell)sudoku.getCell(13)).setSymbolIndex(2); + ((MutableCell)sudoku.getCell(14)).setSymbolIndex(1); + ((MutableCell)sudoku.getCell(15)).setSymbolIndex(0); + + SudokuPrinter.printRectangleSudoku(multidoku.getSubGrid(0), blockWidth , blockHeight); + + ArrayList constraints = new ArrayList<>(); + constraints.add(new LineConstraint()); + constraints.add(new ColumnConstraint()); + constraints.add(new BlockConstraint()); + + System.out.println(sudoku.isValid(constraints)); + + /* + Solver solver = new Solver(); + ArrayList constraints = new ArrayList<>(); + constraints.add(new LineConstraint()); + constraints.add(new ColumnConstraint()); + constraints.add(new BlockConstraint()); + try { + solver.solve(multidoku, constraints); + } catch (Exception e) { + System.out.println(e); + } + */ + + } } diff --git a/app/src/main/java/sudoku/MutableCell.java b/app/src/main/java/sudoku/MutableCell.java index 7994627..0270564 100644 --- a/app/src/main/java/sudoku/MutableCell.java +++ b/app/src/main/java/sudoku/MutableCell.java @@ -17,17 +17,27 @@ public class MutableCell extends Cell{ this.possibleSymbols = new ArrayList<>(); } + public MutableCell(MutableCell currentCell) { + super(currentCell); + this.possibleSymbols = currentCell.getPossibleSymbols(); + } + public void setSymbolIndex(int symbolIndex) { this.symbolIndex = symbolIndex; } + public void setPossibleSymbols(List possibleSymbols) { + this.possibleSymbols.clear(); + this.possibleSymbols.addAll(possibleSymbols); + } + /** * Remove the current symbolIndex and returns it * @return integer symbolIndex cleared */ public int clearCurrentSymbol() { int i = this.symbolIndex; - setSymbolIndex(NOSYMBOLE); + setSymbolIndex(NOSYMBOL); return i; } diff --git a/app/src/main/java/sudoku/Sudoku.java b/app/src/main/java/sudoku/Sudoku.java index 590ed81..e43350f 100644 --- a/app/src/main/java/sudoku/Sudoku.java +++ b/app/src/main/java/sudoku/Sudoku.java @@ -7,7 +7,7 @@ import java.util.List; /** * @class Sudoku - * @brief Représente une grille de sudoku avec N symboles + * @brief Represents a sudoku */ public class Sudoku { @@ -39,10 +39,10 @@ public class Sudoku { return this.blocks.size(); } - public Boolean isValid(List constraints) { + public boolean isValid(List constraints) { //not implemented //for eachcase check contraintes - throw new Error("Function isValid() not implemented"); + return false; } public List getCells() { @@ -100,7 +100,11 @@ public class Sudoku { } catch (Exception e) { throw new RuntimeException(e); } - constraint.getPossibleSymbols(this, coord.getX(), coord.getY()); + List newPossibleSymbols = cell.getPossibleSymbols(); + newPossibleSymbols.retainAll(constraint.getPossibleSymbols(this, coord.getX(), coord.getY())); + + cell.setPossibleSymbols(newPossibleSymbols); + if (cell.getPossibleSymbols().isEmpty()){ throw new Exception("Rollback bitch"); } diff --git a/app/src/main/java/sudoku/SudokuFactory.java b/app/src/main/java/sudoku/SudokuFactory.java index dfb0222..d6ca071 100644 --- a/app/src/main/java/sudoku/SudokuFactory.java +++ b/app/src/main/java/sudoku/SudokuFactory.java @@ -29,7 +29,9 @@ public class SudokuFactory { for (int x = 0; x < width; x++) { int index = ((y + blockY * height) * size + (x + blockX * width)); Cell blockCell = cells.get(index); - blockCell.setBlock(newBlock); + List blockContainers = new ArrayList<>(); + blockContainers.add(newBlock); + blockCell.setBlockContainers(blockContainers); newBlock.addCell(blockCell); } } diff --git a/app/src/main/java/sudoku/constraint/BlockConstraint.java b/app/src/main/java/sudoku/constraint/BlockConstraint.java index c6adec3..67556d2 100644 --- a/app/src/main/java/sudoku/constraint/BlockConstraint.java +++ b/app/src/main/java/sudoku/constraint/BlockConstraint.java @@ -8,8 +8,15 @@ public class BlockConstraint implements IConstraint{ @Override public boolean canBePlaced(final Sudoku s, int x, int y, int newSymbolIndex) { - Block bloc = s.getCell(x, y).getBlock(); - return !bloc.getCells().contains(new MutableCell(newSymbolIndex)); + + /* + boolean result = true; + for (Block block : s.getCell(x, y).getBlockContainers()) { + result = result && (!block.getCells().contains(new MutableCell(newSymbolIndex))); + } + */ + return !s.getBlocks().getCells().contains(new MutableCell(newSymbolIndex)); + } } diff --git a/app/src/main/java/sudoku/io/SudokuPrinter.java b/app/src/main/java/sudoku/io/SudokuPrinter.java index ced7bff..30bd607 100644 --- a/app/src/main/java/sudoku/io/SudokuPrinter.java +++ b/app/src/main/java/sudoku/io/SudokuPrinter.java @@ -7,16 +7,16 @@ public class SudokuPrinter { public static void printRectangleSudoku(final Sudoku s, int blockWidth, int blockHeight) { for (int y = 0; y < s.getSize(); y++) { if (y % blockHeight == 0 && y > 0) { - System.out.println(""); + System.out.println(); } - String line = "[ "; + StringBuilder line = new StringBuilder("[ "); for (int x = 0; x < s.getSize(); x++) { - line += (s.getCell(x, y).getSymbolIndex() + 1) + " "; + line.append((s.getCell(x, y).getSymbolIndex() + 1)).append(" "); if (x % blockWidth == blockWidth - 1 && x != blockWidth * blockHeight - 1) { - line += "| "; + line.append("| "); } } - line += "]"; + line.append("]"); System.out.println(line); } } diff --git a/app/src/main/java/sudoku/solver/Solver.java b/app/src/main/java/sudoku/solver/Solver.java index b87425c..63bc00a 100644 --- a/app/src/main/java/sudoku/solver/Solver.java +++ b/app/src/main/java/sudoku/solver/Solver.java @@ -12,7 +12,10 @@ import java.util.Stack; public class Solver { Stack stack; - public Solver() { + public Solver() {} + + private void rollBack() { + stack.pop(); } public MultiDoku solve(MultiDoku doku, List constraints) throws Exception { @@ -25,26 +28,16 @@ public class Solver { while (!remainingCellsToCheck.isEmpty()) { int indexCurrentCell = rand.nextInt(remainingCellsToCheck.size()); MutableCell currentCell = remainingCellsToCheck.get(indexCurrentCell); - if (currentCell.getPossibleSymbols().isEmpty()){ - MutableCell modify = stack.pop(); - modify.removeSymbolFromPossibilities(modify.clearCurrentSymbol()); - } else { - int symbol = currentCell.getPossibleSymbols().get(0); - currentCell.setSymbolIndex(symbol); - stack.push(currentCell); - try { - doku.updateSymbolsPossibilities(); - } catch (Exception e) { - //TODO rollback - } - //TODO check constraints integrity in sudoku - + 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;