public void Changement(object sender, EventArgs e)
{
if ((Control)sender != this)
{
TextBox tb = ((TextBox)sender);
tb.LostFocus -= new EventHandler(Changement);
TableLayoutPanelCellPosition pos = this.Grid.GetCellPosition(tb);
grille.SetCaseValue(pos.Row, pos.Column, Int16.Parse(tb.Text));
if (grille.CheckSudoku())
{
string message = "Voulez-vous relancer une partie ?";
string caption = "Vous avez terminé !";
MessageBoxButtons buttons = MessageBoxButtons.YesNo;
DialogResult result;
result = MessageBox.Show(message, caption, buttons);
if (result == DialogResult.No)
{
this.Close();
}
else
{
grille = GenerateurGrille.GenererGrilleAléatoire(10);
this.initialisationLabel(grille);
}
}
}
}
/// <summary>
/// Méthode permettant de tester si une case d'une grille est nécessaire pour valider le principe d'unicité
/// </summary>
/// <param name="g"></param>
/// <param name="position"></param>
/// <returns></returns>
private static bool TesterCase(Grille g, int position)
{
int compteurReussite = 0;
int x = position / 9;
int y = position % 9;
for (int chiffre = 1; chiffre <= 9; chiffre++)
{
if (chiffre != g.GetCaseValue(x, y))
{
Grille aTester = new Grille(g);
aTester.SetCaseValue(x, y, chiffre);
if (CaseValide(aTester, 0) && aTester.CheckSudoku())
{
compteurReussite += 1;
if (compteurReussite == 1)
{
return(false);
}
}
}
}
if (compteurReussite == 0)
{
g.SetCaseValue(x, y, 0);
}
return(true);
}
private void Vérifier_Click(object sender, EventArgs e)
{
if ((Control)sender != this)
{
if (grille.CheckSudoku())
{
string message = "Voulez-vous relancer une partie ?";
string caption = "Vous avez terminé !";
MessageBoxButtons buttons = MessageBoxButtons.YesNo;
DialogResult result;
result = MessageBox.Show(message, caption, buttons);
if (result == DialogResult.No)
{
this.Close();
}
else
{
grille = GenerateurGrille.ViderGrilleUnique(50);
this.initialisationLabel(grille);
}
}
else
{
var mess = "Le sudoku n'est pas juste ! Corrigez-le";
var capt = "Dommage !";
var mb = MessageBoxButtons.OK;
var result = MessageBox.Show(mess, capt, mb);
}
}
}
/// <summary>
/// Méthode permettant de remplir la grille de sudoku
/// </summary>
/// <param name="grille">Grille</param>
/// <param name="coordonnee">Coordonnée de la case</param>
/// <returns>Grille rempli</returns>
private static bool CaseValide(Grille grille, int coordonnee)
{
if (coordonnee == 9 * 9)
{
return(true);
}
int i = coordonnee / 9;
int j = coordonnee % 9;
if (grille.GetCaseValue(i, j) != 0)
{
return(CaseValide(grille, coordonnee + 1));
}
for (int chiffre = 1; chiffre <= 9; chiffre++)
{
if (AbsentSurLigne(chiffre, grille, i) && AbsentSurColonne(chiffre, grille, j) && AbsentSurBloc(chiffre, grille, i, j))
{
grille.SetCaseValue(i, j, chiffre);
if (CaseValide(grille, coordonnee + 1))
{
return(true);
}
}
}
grille.SetCaseValue(i, j, 0);
return(false);
}
/// <summary>
/// Méthode permettant de générer une grille valide
/// On génère 3 carré aléatoire en diagonal.
/// On génère ensuite les autres grâce a un algorithme backward.
/// </summary>
/// <returns> Retourne une grille valide</returns>
private static Grille Generation()
{
Grille grille = new Grille();
GenerateurGrille.AddMiddleAnd2CornerSquare(grille);
CaseValide(grille, 0);
return(grille);
}
private bool isGrilleEgale(Grille g1, Grille g2)
{
for (var i = 0; i < 81; i++)
{
if (g1.GetCase(i % 9, i / 9).Value != g2.GetCase(i % 9, i / 9).Value)
{
return(false);
}
}
return(true);
}
/// <summary>
/// Méthode permettant de savoir si un chiffre un déjà présent sur une colonne donnée
/// </summary>
/// <param name="chiffre">Chiffre a vérifier</param>
/// <param name="g">Grille sur laquelle se trouve la colonne</param>
/// <param name="j">Colonne a vérifier</param>
/// <returns></returns>
private static bool AbsentSurColonne(int chiffre, Grille g, int j)
{
for (int i = 0; i < 9; i++)
{
if (g.GetCaseValue(i, j) == chiffre)
{
return(false);
}
}
return(true);
}
public Grille(Grille g)
{
InitialiserGrille();
for (int i = 0; i <= 8; i++)
{
for (int j = 0; j <= 8; j++)
{
SetCaseValue(i, j, g.GetCaseValue(i, j));
}
}
}
/// <summary>
/// Méthode permettant de savoir si un chiffre est présent sur la ligne donnée
/// </summary>
/// <param name="chiffre">Chiffre a vérifier</param>
/// <param name="g">Grille sur laquelle se trouve la ligne</param>
/// <param name="i">Ligne a vérifier</param>
/// <returns>True si absent, false sinon </returns>
private static bool AbsentSurLigne(int chiffre, Grille g, int i)
{
for (int j = 0; j < 9; j++)
{
if (g.GetCaseValue(i, j) == chiffre)
{
return(false);
}
}
return(true);
}
/// <summary>
/// Méthode permettant de vider la grille tout en respectant le principe d'unicité
/// </summary>
/// <returns>Une grille valide ayant une seule solution</returns>
public static Grille ViderGrilleUnique(int nbEssais)
{
Grille grille = GenerateurGrille.Generation();
grille.Solution = new Grille(grille);
for (int i = 1; i < nbEssais; i++)
{
Random rnd = new Random();
Thread.Sleep(10);
int nb = rnd.Next(1, 81);
TesterCase(grille, nb);
}
return(grille);
}
/// <summary>
/// Constructeur par défaut
/// </summary>
public F_Sudoku()
{
InitializeComponent();
grille = new Grille();
grille.generateGame();
grille.cacher(30);
// int[,] content = new int[9,9];
// FillContentTest(content);
FillGrille(Grille, grille.Partielle);
}
/// <summary>
/// Permet l'ajout d'un carré aléatoire
/// <param name="g">Grille g sur laquelle on ajoute le carré</param>
/// <param name="pos">position du carré</param>
private static void AddNormalSquarre(Grille g, int pos)
{
int ligne = (pos / 3) * 3;
int colonne = (pos % 3) * 3;
List <int> l = new List <int>();
l = GenerateurGrille.GénérerLigneValide();
for (int i = ligne; i < ligne + 3; i++)
{
for (int j = colonne; j < colonne + 3; j++)
{
g.SetCaseValue(i, j, l.First());
l.Remove(l.First());
}
}
}
/// <summary>
/// Méthode permettant de check si un chiffre est présent dans un carré
/// </summary>
/// <param name="chiffre">Chiffre a vérifier</param>
/// <param name="g">Grille sur laquelle se trouve le carré</param>
/// <param name="i">position en x</param>
/// <param name="j">position en y</param>
/// <returns></returns>
private static bool AbsentSurBloc(int chiffre, Grille g, int i, int j)
{
int _i = i - (i % 3), _j = j - (j % 3);
for (i = _i; i < _i + 3; i++)
{
for (j = _j; j < _j + 3; j++)
{
if (g.GetCaseValue(i, j) == chiffre)
{
return(false);
}
}
}
return(true);
}
/// <summary>
/// Permet de générer la grille et de mettre des cases vides
/// </summary>
/// <param name="nbCases">Nombre de cases à afficher</param>
/// <returns>Une grille avec des 0 sur les cases à deviner</returns>
public static Grille GenererGrilleAléatoire(int nbCases)
{
Grille grille = GenerateurGrille.Generation();
for (int i = 1; i <= 81 - nbCases; i++)
{
int x;
int y;
do
{
Random rnd = new Random();
x = rnd.Next(9);
y = rnd.Next(9);
} while (grille.GetCaseValue(x, y) == 0);
grille.SetCaseValue(x, y, 0);
grille.GetCase(x, y).IsChecked = true;
}
return(grille);
}
/// <summary>
///
/// </summary>
/// <param name="cases"></param>
void initialisationLabel(Grille g)
{
var liste = g.GetAllValues();
for (int i = 0; i < liste.Count; i++)
{
tabLabel[i].Text = liste[i].ToString();
if (tabLabel[i].Text != "0")
{
//tabLabel[i].BackColor = Color.Transparent;
tabLabel[i].Click -= new EventHandler(changeValueLabel);
}
else
{
tabLabel[i].Text = "";
//tabLabel[i].BackColor = Color.White;
}
GriserLabel(tabLabel[i], i / 9, i % 9);
}
}
public Sudoku()
{
InitializeComponent();
Console.Write("Intialisation");
grille = GenerateurGrille.ViderGrilleUnique(50);
tabLabel = new List <Label>();
for (int i = 0; i < 81; i++)
{
Label l = new Label();
l.Height = 50;
l.Width = 100;
l.TextAlign = ContentAlignment.MiddleCenter;
l.Font = new Font("Arial", 20);
l.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
l.Click += new EventHandler(changeValueLabel);
tabLabel.Add(l);
this.Grid.Controls.Add(l, i % 9, i / 9);
}
initialisationLabel(grille);
this.Invalidate();
}
public Search(CSP csp, Grille grille)
{
this.csp = csp;
this.nbInitialVariableNonAssigne = this.csp.GetVariableNonAssigne().Count;
this.grille = grille;
}
public Parser(String file)
{
this.file = file;
this.grille = new Grille();
this.variables = new List <Variable>();
}
static void Main(string[] args)
{
int choix = 0;
String fichier = "";
Grille g = new Grille();
Parser p = new Parser("");
Console.WriteLine("Bienvenue.\nVous êtes dans le Résolveur de Sudoku par CSP.");
Console.WriteLine("Tout d'abord, veuillez sélectionner un sudoku.\n");
do
{
Console.WriteLine("Vous avez le choix entre choisir un fichier qui contient le Sudoku (1) ou bien le rentrer dans la console (2).");
try
{
choix = int.Parse(Console.ReadLine());
}
catch (Exception e)
{
Console.WriteLine(e.StackTrace);
Console.WriteLine("Appuyez sur une touche pour quitter.");
Console.ReadKey();
return;
}
} while (choix != 1 && choix != 2);
if (choix == 1)
{
Console.WriteLine("Veuillez-vous assurez que le fichier est situé dans le dossier du projet.\nVeuillez entrer le nom du fichier texte contenant le Sudoku (sans l'extension):");
fichier = Console.ReadLine();
p = new Parser(String.Format("..//..//{0}.txt", fichier));
p.Lecture();
}
else if (choix == 2)
{
p.Saisie();
}
g = p.GetGrille();
Console.WriteLine("Voici la grille.");
g.Affiche();
GenerateurCB gcb = new GenerateurCB(g.GetCases());
gcb.Generer();
CSP csp = new CSP(p.GetVariables(), gcb.GetContraintes(), Grille.POSSIBILITE);
Search s = new Search(csp, g);
Func <Variable> firstUnassigned = new Func <Variable>(csp.GetFirstVariableNonAssigne);
Func <Variable> mrv = new Func <Variable>(s.MRV);
Func <Variable> mrvdh = new Func <Variable>(s.MRVSAndDH);
Func <Variable, List <int> > lcv = new Func <Variable, List <int> >(s.LCV);
Console.WriteLine("Nous allons maintenant choisir les différentes heuristiques.");
do
{
Console.WriteLine("Voulez-vous utilisez AC-3 ? (Oui - 1, Non - 2)");
try
{
choix = int.Parse(Console.ReadLine());
}
catch (Exception e)
{
Console.WriteLine(e.StackTrace);
Console.WriteLine("Appuyez sur une touche pour quitter.");
Console.ReadKey();
return;
}
} while(choix != 1 && choix != 2);
if (choix == 1)
{
s.AC3();
}
do
{
Console.WriteLine("Choissisez l'heuristique de variable que vous voulez utiliser :\n" +
" - Premère variable non assignée (1)\n - Minimum Remaining Value (2)\n - Minimum Remaining Value + Degree Heuristique (3)");
try
{
choix = int.Parse(Console.ReadLine());
}
catch (Exception e)
{
Console.WriteLine(e.StackTrace);
Console.WriteLine("Appuyez sur une touche pour quitter.");
Console.ReadKey();
return;
}
} while (choix != 1 && choix != 2 && choix != 3);
Func <Variable> hvb;
switch (choix)
{
case (1):
hvb = firstUnassigned;
break;
case (2):
hvb = mrv;
break;
case (3):
hvb = mrvdh;
break;
default:
hvb = firstUnassigned;
break;
}
do
{
Console.WriteLine("Voulez-vous utiliser Least Constraining Value ? (Oui - 1, Non - 2)");
try
{
choix = int.Parse(Console.ReadLine());
}
catch (Exception e)
{
Console.WriteLine(e.StackTrace);
Console.WriteLine("Appuyez sur une touche pour quitter.");
Console.ReadKey();
return;
}
} while (choix != 1 && choix != 2);
Func <Variable, List <int> > hva = null;
if (choix == 1)
{
hva = lcv;
}
Console.WriteLine("Tout est prêt.\nAppuyez sur une touche pour lancer la recherche.");
Console.ReadKey();
s.BacktrackingSearch(hvb, hva);
Console.WriteLine("Appuyez sur une touche pour quitter.");
Console.ReadKey();
}
/// <summary>
/// Permet d'ajouter 3 carré de 3*3 aléatoires
/// </summary>
/// <param name="g">Grille</param>
private static void AddMiddleAnd2CornerSquare(Grille g)
{
GenerateurGrille.AddNormalSquarre(g, 0);
GenerateurGrille.AddNormalSquarre(g, 4);
GenerateurGrille.AddNormalSquarre(g, 8);
}
