public void assign(GrilleSudoku s, int cell, int value, List <int> assignment, List <List <int> > possibilites, List <List <int> > pruned)
{
assignment.Add(cell);
s.SetCell(cell / 9, cell % 9, value);
if (possibilites[cell].Contains(value))
{
possibilites[cell].Remove(value);
}
if (!pruned[cell].Contains(value))
{
pruned[cell].Add(value);
}
if (possibilites[cell].Count == 0)
{
possibilites[cell].Add(10);
}
// supp la Valeur des Possibilités des Voisins de la Cellule
foreach (int neighboor_value in Cell_Neighboor(s, cell))
{
if (possibilites[neighboor_value].Contains(value))
{
possibilites[neighboor_value].Remove(value);
}
if (!pruned[neighboor_value].Contains(value))
{
pruned[neighboor_value].Add(value);
}
}
}
public void Solve(GrilleSudoku s)
{
Console.WriteLine("Begin solving Sudoku");
Console.WriteLine("The problem is: ");
int[][] problem = new int[9][];
for (int row = 0; row <= 8; row++)
{
problem[row] = new int[9];
for (int column = 0; column <= 8; column++)
{
problem[row][column] = s.GetCellule(row, column);
}
}
int[,] tab = new int[9, 9];
for (int row = 0; row <= 8; row++)
{
problem[row] = new int[9];
for (int column = 0; column <= 8; column++)
{
tab[row, column] = s.GetCellule(row, column);
}
}
//DisplayMatrix(problem);
int numOrganisms = 200;
int maxEpochs = 5000;
int maxRestarts = 20;
Sudoku sudo = Sudoku.New(tab);
Sudoku soln = Solvette(sudo, numOrganisms, maxEpochs, maxRestarts);
Console.WriteLine("Best solution found: ");
//DisplayMatrix(soln);
//affichage du sudoku
Console.WriteLine(soln.ToString());
//Reconversion depuis int[,]
for (int row = 0; row < 9; row++)
{
for (int column = 0; column < 9; column++)
{
s.Cellules[row * 9 + column] = soln.CellValues[row, column];
}
}
int err = Error(soln);
if (err == 0)
{
Console.WriteLine("Success \n");
}
else
{
Console.WriteLine("Did not find optimal solution \n");
}
Console.WriteLine("End Sudoku demo");
Console.ReadLine();
}
public void AC3(GrilleSudoku s, List <List <int> > possibilites)
{
bool test = true;
int CaseCheck;
while (test)
{
test = false;
for (int i = 0; i < 81; i++)
{
if (possibilites[i].Count == 1 && possibilites[i][0] != 10)
{
test = true;
}
}
if (test == true)
{
CaseCheck = getNextMRV(possibilites);
//AC3 ETAPE : 1
//Nb Possibilites = 1
if (possibilites[CaseCheck].Count == 1)
{
s.SetCell(CaseCheck / 9, CaseCheck % 9, possibilites[CaseCheck][0]);
DeletePossibilites(s, possibilites, CaseCheck, possibilites[CaseCheck][0]);
}
}
}
}
void ISudokuSolver.Solve(GrilleSudoku s)
{
var suudokuResolu = this.Solve(s);
Enumerable.Range(0, 81).ToList().ForEach(i => s.Cellules[i] = suudokuResolu.Cellules[i]);
//throw new NotImplementedException();
}
public bool Resolve(GrilleSudoku s) // La fonction solve va pemettre de choisir la solution valide satsifaisant les contraintes de sodoku
{
for (int ligne = 0; ligne < Size; ligne++) // parcourt les lignes
{
for (int col = 0; col < Size; col++) // parcourt les colonnes
{
// Ce double for parcourt chaque colonne pour une ligne donnée
if (s.GetCellule(ligne, col) == 0) // empty: si la cellule est vide alors on va rentrer dans la boucle for
{
for (int value = 1; value <= 9; value++) // qui va tester les valeur de 1 à 9
{
if (IsValid(s, ligne, col, value)) // Si la valeur est valide avec les conditions de validité qu'on va définirapres dans le code
{
s.SetCell(ligne, col, value); // Alors on remplie la case vide avec la valeur valide
if (Resolve(s)) // Et on appelle la fonction elle-meme pour la récursivité : Principe de backtracking
{
return(true); // On on valide la solution
}
else
{
s.SetCell(ligne, col, 0); // Sinon on réinitialise la valeur à 0
}
}
}
return(false); // On refait le même processus
}
}
}
return(true); // Jusqu'à ce qu'on trouve une solution valide et on la garde
}
public void Solve(GrilleSudoku s)
{
List <List <int> > list_cell = new List <List <int> >();
foreach (var i in System.Linq.Enumerable.Range(0, 9))
{
var ligne = new List <int>(9);
list_cell.Add(ligne);
foreach (var j in System.Linq.Enumerable.Range(0, 9))
{
ligne.Add(s.GetCellule(j, i));
}
}
var monTableau = list_cell.Select(l => l.ToArray()).ToArray();
var monPuzzle = new Puzzle(monTableau, false);
var monSolver = new Solver(monPuzzle);
monSolver.DoWork(this, new System.ComponentModel.DoWorkEventArgs(null));
foreach (var i in System.Linq.Enumerable.Range(0, 9))
{
foreach (var j in System.Linq.Enumerable.Range(0, 9))
{
s.SetCell(i, j, monPuzzle.Rows[i][j].Value);
}
}
}
private bool IsValid(GrilleSudoku s, int ligne, int col, int value)
//appel les trois fonctions
{
return(IsLigneValid(s, ligne, value) &&
IsCarreValid(s, ligne, col, value) &&
IsColValid(s, col, value));
}
public virtual void SolveSudoku(GrilleSudoku s)
{
Dirichlet[] dirArray = Enumerable.Repeat(Dirichlet.Uniform(CellDomain.Count), CellIndices.Count).ToArray();
//On affecte les valeurs fournies par le masque à résoudre en affectant les distributions de probabilités initiales
foreach (var cellIndex in GrilleSudoku.IndicesCellules)
{
if (s.Cellules[cellIndex] > 0)
{
//Vector v = Vector.Zero(CellDomain.Count);
//v[s.Cellules[cellIndex] - 1] = 1.0;
//Todo: Alternative: le fait de mettre une proba non nulle permet d'éviter l'erreur "zero probability" du Sudoku Easy-n°2, mais le Easy#3 n'est plus résolu
//tentative de changer la probabilite pour solver le sudoku 3 infructueuse
Vector v = Vector.Constant(CellDomain.Count, EpsilonProba);
v[s.Cellules[cellIndex] - 1] = FixedValueProba;
dirArray[cellIndex] = Dirichlet.PointMass(v);
}
}
CellsPrior.ObservedValue = dirArray;
// Todo: tester en inférant sur d'autres variables aléatoire,
// et/ou en ayant une approche itérative: On conserve uniquement les cellules dont les valeurs ont les meilleures probabilités
//et on réinjecte ces valeurs dans CellsPrior comme c'est également fait dans le projet neural nets.
//
// IFunction draw_categorical(n)// where n is the number of samples to draw from the categorical distribution
// {
//
// r = 1
/* for (i=0; i<9; i++)
* for (j=0; j<9; j++)
* for (k=0; k<9; k++)
* ps[i][j][k] = probs[i][j][k].p; */
//DistributionRefArray<Discrete, int> cellsPosterior = (DistributionRefArray<Discrete, int>)InferenceEngine.Infer(Cells);
//var cellValues = cellsPosterior.Point.Select(i => i + 1).ToList();
//Autre possibilité de variable d'inférence (bis)
Dirichlet[] cellsProbsPosterior = InferenceEngine.Infer <Dirichlet[]>(ProbCells);
foreach (var cellIndex in GrilleSudoku.IndicesCellules)
{
if (s.Cellules[cellIndex] == 0)
{
//s.Cellules[cellIndex] = cellValues[cellIndex];
var mode = cellsProbsPosterior[cellIndex].GetMode();
var value = mode.IndexOf(mode.Max()) + 1;
s.Cellules[cellIndex] = value;
}
}
}
// Méthode qui est appelé au start du script Jeu afin d'initialiser les objets
public void Init()
{
tileReference = GameObject.Find("TilePrefab");
grille = GameObject.Find("Jeu").GetComponent <Jeu>().getGrille();
colonne = grille.getCols();
ligne = grille.getRows();
generateNumberSelection();
}
public void Solve(GrilleSudoku s)
{
int[][] sJaggedTableau = Enumerable.Range(0, 9).Select(i => Enumerable.Range(0, 9).Select(j => s.GetCellule(i, j)).ToArray()).ToArray();
var sTableau = To2D(sJaggedTableau);
Program.estValide(sTableau, 0);
Enumerable.Range(0, 9).ToList().ForEach(i => Enumerable.Range(0, 9).ToList().ForEach(j => s.SetCell(i, j, sTableau[i, j])));
}
/// <summary>
/// Constructor that accepts a Sudoku to solve
/// </summary>
/// <param name="targetCore.Sudoku">the target sudoku to solve</param>
public SudokuCellsChromosome(GrilleSudoku targetSudoku) : base(81)
{
_targetSudoku = targetSudoku;
for (int i = 0; i < Length; i++)
{
ReplaceGene(i, GenerateGene(i));
}
}
public void IterationSetup()
{
IterationPuzzles = new List <Core.GrilleSudoku>(NbPuzzles);
for (int i = 0; i < NbPuzzles; i++)
{
IterationPuzzles.Add(AllPuzzles[Difficulty][i].CloneSudoku());
}
SolverPresenter.Solver.Solve(GrilleSudoku.Parse("483921657967345001001806400008102900700000008006708200002609500800203009005010300"));
}
/// <summary>
/// Constructor with a mask and a number of genes
/// </summary>
/// <param name="targetCore.Sudoku">the target sudoku to solve</param>
/// <param name="length">the number of genes</param>
public SudokuPermutationsChromosome(GrilleSudoku targetSudoku, int length) : base(length)
{
TargetSudoku = targetSudoku;
TargetRowsPermutations = GetRowsPermutations(TargetSudoku);
for (int i = 0; i < Length; i++)
{
ReplaceGene(i, GenerateGene(i));
}
}
public void Solve(GrilleSudoku s)
{
// SolveWithSubstitutions(s);
// SolveWithScope(s);
// SolveWithAsumptions(s);
// SolveOriginalVersion(s);
SolveOriginalCleanup(s);
// z3Context.MkTactic("smt");
}
private GameObject infos; // Référence à l'object Infos pour afficher dans son élément texte les informations de la partie
void Start()
{
grille = new GrilleSudoku(9, 9); // Définition de la grille de 9 par 9
grille.initVal(0); // Toutes les cases sont à 0
GameObject diffManager = GameObject.Find("DifficultyManager");
if (diffManager) // Vérification que la scène SudokuMenu a fait son travail
{
if (diffManager.GetComponent <sceneManager>().resumeGame)
{
// Cas où l'on veut reprendre la partie du fichier sauvegardeSudoku
var loadedData = JSON.Parse(File.ReadAllText(defineSudoku.cheminSauvegarde));
numGrille = loadedData["num"].ToString();
difficulte = loadedData["difficulte"];
temps = float.Parse(loadedData["timer"]);
affichageTemps = loadedData["timerString"];
grille.chargementGrilleSauvegarde();
Destroy(diffManager);
}
else
{
difficulte = diffManager.GetComponent <sceneManager>().difficulty; // Récupération de la difficulté choisit dans la scène SudokuMenu
Destroy(diffManager);
//Choix d'un niveau au hasard selon la difficulté précedement choisie
int cpt = 0;
string directoryPath = defineSudoku.getCheminDifficulte(difficulte);
var info = new DirectoryInfo(directoryPath);
var fileInfo = info.GetFiles();
foreach (FileInfo f in fileInfo)
{
if (f.Extension == ".json")
{
cpt++;
}
}
int level = UnityEngine.Random.Range(1, cpt + 1);
numGrille = level.ToString();
}
}
else // Afin de pouvoir lancer la scène Sudoku sans problème
{
string[] level = SelectionNiveauAleatoire(); // Chaine de caractères avec la difficulté et le numéro de grille
difficulte = level[0];
numGrille = level[1]; // Numéro de grille choisit au hasard
}
infos = GameObject.Find("Infos");
infos.GetComponent <TextMeshProUGUI>().text = "Difficulty : " + difficulte + " Level : " + numGrille + "\nTimer : " + affichageTemps; // Changement du texte des infos
grille.chargementGrille(numGrille, difficulte); // Chargement de la grille avec la difficulté et son numéro de grille
UIManager = GameObject.Find("Jeu").GetComponent <UIManager>();
UIManager.Init(); // Initialisation des objets visuels
parent = GameObject.Find("GridManager").transform;
UIManager.GenerateGrid(0f, 0f, parent); // Génération de la grille sur la scène
grille.sauvegardeGrille(); // Sauvegarde de la grille dès le lancement
}
private bool IsColValid(GrilleSudoku s, int col, int value)
{
for (var ligne = 0; ligne < Size; ligne++)
{
if (s.GetCellule(ligne, col) == value)
{
return(false);
}
}
return(true);
}
private bool IsLigneValid(GrilleSudoku s, int ligne, int value)
{
for (var col = 0; col < Size; col++)
{
if (s.GetCellule(ligne, col) == value)
{
return(false);
}
}
return(true);
}
/// <summary>
/// Evaluates a single Sudoku board by counting the duplicates in rows, boxes
/// and the digits differing from the target mask.
/// </summary>
/// <param name="testSudoku">the board to evaluate</param>
/// <returns>the number of mistakes the Sudoku contains.</returns>
public double Evaluate(GrilleSudoku testSudoku)
{
// We use a large lambda expression to count duplicates in rows, columns and boxes
var cells = testSudoku.Cellules.Select((c, i) => new { index = i, cell = c }).ToList();
var toTest = cells.GroupBy(x => x.index / 9).Select(g => g.Select(c => c.cell)) // rows
.Concat(cells.GroupBy(x => x.index % 9).Select(g => g.Select(c => c.cell))) //columns
.Concat(cells.GroupBy(x => x.index / 27 * 27 + x.index % 9 / 3 * 3).Select(g => g.Select(c => c.cell))); //boxes
var toReturn = -toTest.Sum(test => test.GroupBy(x => x).Select(g => g.Count() - 1).Sum()); // Summing over duplicates
toReturn -= cells.Count(x => _targetSudoku.Cellules[x.index] > 0 && _targetSudoku.Cellules[x.index] != x.cell); // Mask
return(toReturn);
}
// FONCTION POUR BACKTRACKING
public int Nombre_de_conflits(GrilleSudoku s, int cellule, int valeur, List <List <int> > possibilites)
{
int count = 0;
foreach (int cell in Cell_Neighboor(s, cellule))
{
if (possibilites[cell].Count > 1 && possibilites[cell].Contains(valeur))
{
count = count + 1;
}
}
return(count);
}
/// <summary>
/// builds a single Sudoku from the given row permutation genes
/// </summary>
/// <returns>a list with the single Sudoku built from the genes</returns>
public virtual IList <GrilleSudoku> GetSudokus()
{
var listInt = new List <int>(81);
for (int i = 0; i < 9; i++)
{
var perm = GetPermutation(i);
listInt.AddRange(perm);
}
var sudoku = new GrilleSudoku(listInt);
return(new List <GrilleSudoku>(new[] { sudoku }));
}
static void AddDataConstraints(GrilleSudoku data, Model model, Decision[][] grid)
{
for (int r = 0; r < 9; ++r)
{
for (int c = 0; c < 9; ++c)
{
if (data.GetCellule(r, c) != 0)
{
model.AddConstraint("v" + r + c, grid[r][c] == data.GetCellule(r, c));
}
}
}
}
public int[][] ConvertToMatrix(GrilleSudoku grille) // conversion de grillesudoku en int[][]
{
int[][] sud = new int[9][];
for (int i = 0; i < 9; i++)
{
sud[i] = new int[9];
for (int j = 0; j < 9; j++)
{
sud[i][j] = grille.GetCellule(i, j);
}
}
return(sud);
}
private bool IsColValid(GrilleSudoku s, int col, int value)
//Vérifie que chaque nombre n'apparait qu'une fois sur la colonne
{
for (var ligne = 0; ligne < Size; ligne++)
{
if (s.GetCellule(ligne, col) == value)
{
return(false);
}
}
return(true);
}
private bool IsLigneValid(GrilleSudoku s, int ligne, int value)
//Vérifie que chaque nombre n'apparait qu'une fois sur la ligne
{
for (var col = 0; col < Size; col++)
{
if (s.GetCellule(ligne, col) == value)
{
return(false);
}
}
return(true);
}
public bool Is_present(GrilleSudoku s, List <List <int> > possibilites, int poss, int position)
{
foreach (int voisin in Cell_Neighboor(s, position))
{
int ligne = voisin / 9;
int colonne = voisin % 9;
if (s.GetCellule(ligne, colonne) == poss)
{
return(false);
}
}
return(true);
}
public void Solve(GrilleSudoku grid)
{
Sud = new Sudoku(grid);
s.sudoku = Sud;
s.Solve();
Sud = s.sudoku;
for (int i = 0; i < 9; i++)
{
for (int j = 0; j < 9; j++)
{
grid.SetCell(i, j, Sud.getCaseSudoku(i, j));
}
}
}
public virtual void SolveSudoku(GrilleSudoku s)
{
Dirichlet[] dirArray = Enumerable.Repeat(Dirichlet.Uniform(CellDomain.Count), CellIndices.Count).ToArray();
//On affecte les valeurs fournies par le masque à résoudre en affectant les distributions de probabilités initiales
foreach (var cellIndex in GrilleSudoku.IndicesCellules)
{
if (s.Cellules[cellIndex] > 0)
{
Vector v = Vector.Zero(CellDomain.Count);
v[s.Cellules[cellIndex] - 1] = 1.0;
//Todo: Alternative: le fait de mettre une proba non nulle permet d'éviter l'erreur "zero probability" du Sudoku Easy-n°2, mais le Easy#3 n'est plus résolu
//Vector v = Vector.Constant(CellDomain.Count, EpsilonProba);
//v[s.Cellules[cellIndex] - 1] = FixedValueProba;
dirArray[cellIndex] = Dirichlet.PointMass(v);
}
}
CellsPrior.ObservedValue = dirArray;
// Todo: tester en inférant sur d'autres variables aléatoire,
// et/ou en ayant une approche itérative: On conserve uniquement les cellules dont les valeurs ont les meilleures probabilités et on réinjecte ces valeurs dans CellsPrior comme c'est également fait dans le projet neural nets.
DistributionRefArray <Discrete, int> cellsPosterior = (DistributionRefArray <Discrete, int>)InferenceEngine.Infer(Cells);
var cellValues = cellsPosterior.Point.Select(i => i + 1).ToList();
//Autre possibilité de variable d'inférence (bis)
//Dirichlet[] cellsProbsPosterior = InferenceEngine.Infer<Dirichlet[]>(ProbCells);
foreach (var cellIndex in GrilleSudoku.IndicesCellules)
{
if (s.Cellules[cellIndex] == 0)
{
s.Cellules[cellIndex] = cellValues[cellIndex];
//Autre possibilité de variable d'inférence (bis)
//var mode = cellsProbsPosterior[cellIndex].GetMode();
//var value = mode.IndexOf(1.0) + 1;
//s.Cellules[cellIndex] = value;
}
}
}
public void Solve(GrilleSudoku s)
{
string game = string.Concat(s.Cellules.Select(c => (c == 0) ? "." : c.ToString()));
Dictionary <string, string> solution = LinqSudokuSolver.Search(LinqSudokuSolver.Parse_grid(game));
for (int r = 0; r < cellIndices.Count(); r++)
{
for (int c = 0; c < cellIndices.Count(); c++)
{
var cellules = Int32.Parse(solution[LinqSudokuSolver.Rows[r].ToString() + LinqSudokuSolver.Cols[c].ToString()]);
s.SetCell(r, c, cellules);
}
}
}
public void Solve(GrilleSudoku s)
{
var game = String.Concat(s.Cellules.Select(c => (c == 0) ? "." : c.ToString()));
var solution = LinqSudokuSolver.search(LinqSudokuSolver.parse_grid(game));
foreach (var r in Enumerable.Range(0, 9))
{
foreach (var c in Enumerable.Range(0, 9))
{
var cellules = Int32.Parse(solution[LinqSudokuSolver.rows[r].ToString() + LinqSudokuSolver.cols[c].ToString()]);
s.SetCell(r, c, cellules);
}
}
}
public void Solve(GrilleSudoku s)
{
//Création d'un solver Or-tools
Solver solver = new Solver("Sudoku");
//Création de la grille de variables
IntVar[,] grid = solver.MakeIntVarMatrix(9, 9, 1, 9, "grid");
IntVar[] grid_flat = grid.Flatten();
//Masque de résolution
foreach (int i in cellIndices)
{
foreach (int j in cellIndices)
{
if (s.GetCellule(i, j) > 0)
{
solver.Add(grid[i, j] == s.GetCellule(i, j));
}
}
}
//Un chiffre ne figure qu'une seule fois par ligne/colonne/cellule
foreach (int i in cellIndices)
{
// Lignes
solver.Add((from j in cellIndices
select grid[i, j]).ToArray().AllDifferent());
// Colonnes
}
//Cellules
//Début de la résolution
DecisionBuilder db = solver.MakePhase(grid_flat,
Solver.INT_VAR_SIMPLE,
Solver.INT_VALUE_SIMPLE);
solver.NewSearch(db);
//Mise à jour du sudoku
}
