public void ButtonClicked()
{
GameObject selectedObject = EventSystem.current.currentSelectedGameObject;
if (selectedObject != null)
{
//Selektovali smo dugme
Debug.Log("Clicked on : " + selectedObject.name);
if (selectedObject.tag == "SudokuButton")
{
selectedField = selectedObject;
}
else if (selectedObject.tag == "NumericButton")
{
selectedNumber = selectedObject;
//Logika
if (selectedField != null)
{
int number;
SudokuField fieldInfo = selectedField.GetComponent <SudokuField>();
bool parseOk = int.TryParse(selectedNumber.name, out number);
if (parseOk)
{
sudoku.SetNewNumber(fieldInfo.rowIndex, fieldInfo.columnIndex, number);
}
}
}
}
}
public SudokuPuzzle Deserialize()
{
var sudokufields = new SudokuField[9, 9];
fields.ForEach(x => sudokufields[x.row, x.column] = new SudokuField(x.value));
return(new SudokuPuzzle(sudokufields));
}
private void button1_Click(object sender, EventArgs e)
{
byte[] nums = ParseNums();
long ctr1 = 0, ctr2 = 0, freq = 0;
Utils.QueryPerformanceFrequency(ref freq);
if (Utils.QueryPerformanceCounter(ref ctr1) != 0) // Begin timing.
{
var solves = new SudokuField().Solve(nums).Take(100).ToList();
Utils.QueryPerformanceCounter(ref ctr2); // Finish timing.
if (solves.Count >= 100)
{
textBox2.Text = solves[0];
label1.Text = $"Всего решений более{solves.Count} за {(ctr2 - ctr1) * 1.0 / freq:0.0000}";
}
else if (solves.Count > 0)
{
textBox2.Text = solves[0];
label1.Text = $"Всего решений {solves.Count} за {(ctr2 - ctr1) * 1.0 / freq:0.0000}";
}
else
{
textBox2.Text = "";
label1.Text = $"Решений нет за {(ctr2 - ctr1) * 1.0 / freq:0.0000}";
}
}
}
private Result Analyze(SudokuField sudokuField, KeyValuePair <Position, SudokuElement> entry)
{
var row = entry.Key.Row;
var column = entry.Key.Column;
var result = base.Process(sudokuField, row, column);
if (result != Result.None)
{
return(result);
}
HashSet <int> existngNumbers = GetNumbersFromSudokuSection(sudokuField, row, column);
if (AddUniqueFromExisting(sudokuField.GetRow(row), entry.Value, existngNumbers))
{
return(Result.Added);
}
if (AddUniqueFromExisting(sudokuField.GetColumn(column), entry.Value, existngNumbers))
{
return(Result.Added);
}
if (AddUniqueFromExisting(sudokuField.GetSection(row, column), entry.Value, existngNumbers))
{
return(Result.Added);
}
return(Result.None);
}
public void Load(TextReader reader)
{
Status("Saving puzzle");
field = new SudokuField();
field.LoadNewPuzzle(reader);
Status("Puzzle saved");
}
public void CreateNewSudoku(int rows, int columns)
{
Status("Creating puzzle");
field = SudokuField.CreateNewField(rows, columns);
DataBind();
Status("Puzzle created");
}
protected SudokuPuzzle guessNextField(SudokuPuzzle sudoku, SudokuField field)
{
SudokuPuzzle result = null;
foreach (int value in field.GetPossibleValues().Shuffle())
{
// make copy of sudoku and try out possibility
var copy = (SudokuPuzzle)sudoku.Clone();
copy.Fields[field.RowIndex, field.ColumnIndex].SetValue(value);
if (copy.IsValid())
{
// go to next recursion level
result = solveSudokuRecursive(copy);
// pass correct solution to lower recursion levels
if (result != null)
{
break;
}
}
}
return(result);
}
private static void CheckCollision(SudokuField sudoku)
{
if (Validator.IsCollision(sudoku))
{
throw new SudokuCollisionNumberException("There are the same numbers in row/column/section");
}
}
static void Main(string[] args)
{
SudokuField sudoku = new SudokuField();
MainSolver solver = new MainSolver();
sudoku = solver.Process(sudoku);
Console.WriteLine(sudoku);
}
private SudokuElement FindFirstEmpty(SudokuField sudokuField)
{
return(sudokuField.Field
.Select(n => n.Value)
.Where(n => n.Number == Data.Empty)
.DefaultIfEmpty(null)
.FirstOrDefault());
}
public HashSet <int> GetNumbersFromSudokuSection(SudokuField sudokuField, int row, int column)
{
return(sudokuField.GetSudokuSection(row, column)
.Select(n => n.Value)
.Select(n => n.Number)
.Where(n => n != Data.Empty)
.ToHashSet());
}
static void Main(string[] args)
{
Console.Clear();
SudokuField field = new SudokuField(Difficulty.Easy);
Console.WriteLine(field.Solved);
Console.WriteLine(field.ToString());
}
private Result SolveElement(SudokuField sudokuField, KeyValuePair <Position, SudokuElement> entry) // SudokuElement sudokuElement)
{
if (entry.Value.Number == Data.Empty)
{
return(Analyze(sudokuField, entry));
}
return(Result.None);
}
public new SolverResult Process(SudokuField sudokuField)
{
_sudokuFieldCopy = sudokuField;
Stack <StackElement> stackElements = new Stack <StackElement>();
StackElement stackElement;
Result result = Result.None;
int index;
while (true)
{
switch (result)
{
case Result.FullFilled:
return(new SolverResult(Result.FullFilled, _sudokuFieldCopy));
case Result.Error:
bool loop = true;
do
{
if (stackElements.Count == 0)
{
return(new SolverResult(Result.Error));
}
stackElement = stackElements.Pop();
index = stackElement.Index + 1;
if (index < stackElement.GetCandidateSize())
{
_sudokuFieldCopy = stackElement.SudokuField;
_sudokuElement = stackElement.SudokuElement;
if (PutOnStack(stackElements, index) == Result.Error)
{
return(new SolverResult(Result.Error));
}
loop = false;
}
else
{
loop = true;
}
} while (loop);
break;
default:
_sudokuElement = FindFirstEmpty(_sudokuFieldCopy);
if (PutOnStack(stackElements, 0) == Result.Error)
{
return(new SolverResult(Result.Error));
}
break;
}
result = base.Process(_sudokuFieldCopy);
}
}
protected Result Process(SudokuField sudokuField, int row, int column)
{
SudokuElement sudokuElement = sudokuField.GetSudokuElement(row, column);
HashSet <int> existingNumbers = GetNumbersFromSudokuSection(sudokuField, row, column);
foreach (int number in existingNumbers)
{
_ = sudokuElement.RemoveCandidate(number);
}
return(AddNumber(sudokuElement));
}
protected bool isFieldDetermined(SudokuPuzzle sudoku, SudokuPuzzle solution, SudokuField field)
{
// get value from the first solution
int solutionValue = solution.Fields[field.RowIndex, field.ColumnIndex].Value;
// try to solve the sudoku again, but now without the value from the first solution
field.Possibilities[solutionValue - 1] = false;
var secondSolution = guessNextField(sudoku, field);
// if there is no second solution, the sudoku has definitely a unique solution
return(secondSolution == null || solution.Equals(secondSolution));
}
public void HandlePuzzleLoading(SudokuField field)
{
Status("loading puzzle");
this.ContentType = field.ContentType;
this._rows = field.NumRows;
this._columns = field.NumColumns;
field.AutoOutput = true;
LayoutRoot.Children.Clear();
InitCanvas(field.NumRows, field.NumColumns);
DataBind();
ShowValues();
field.Updated += new SudokuField.UpdateEvent(field_Updated);
this.Height = field.NumRows * (cellHeight + CellSpacing) + CellSpacing;
this.Width = field.NumColumns * (cellWidth + CellSpacing) + CellSpacing;
Status("Puzzle loaded");
}
private bool removeField(SudokuPuzzle sudoku, SudokuPuzzle solution)
{
foreach (SudokuField field in sudoku.GetSetFields().Shuffle())
{
// clone sudoku and set the field value to 0
SudokuPuzzle temp = (SudokuPuzzle)sudoku.Clone();
SudokuField tempField = temp.Fields[field.RowIndex, field.ColumnIndex];
tempField.SetValue(0);
if (HasSudokuUniqueSolution(temp))
{
field.SetValue(0);
return(true);
}
}
return(false);
}
private Result PutOnStack(Stack <StackElement> stack, int index)
{
StackElement stackElement = new StackElement(_sudokuFieldCopy, _sudokuElement, index);
stack.Push(stackElement);
_sudokuFieldCopy = _sudokuFieldCopy.DeepCopy();
_sudokuElement = FindFirstEmpty(_sudokuFieldCopy);
if (_sudokuElement == null)
{
return(Result.Error);
}
int number = _sudokuElement.GetCandidate(index);
_sudokuElement.Number = number;
_sudokuElement.FontColor = Data.BackTrackColor;
return(Result.None);
}
public SudokuField Process(SudokuField sudoku)
{
CheckCollision(sudoku);
_ = _solverUnique.Process(sudoku);
if (_solverUnique.Process(sudoku) != Result.FullFilled)
{
SolverResult solverResult = _solverBackTrack.Process(sudoku);
if (solverResult.Result == Result.Error)
{
throw new SudokuUnsolvableException("There is no solution for this Sudoku.");
}
else
{
sudoku = solverResult.Sudoku;
}
}
return(sudoku);
}
private void button2_Click(object sender, EventArgs e)
{
byte[] nums = ParseNums();
long ctr1 = 0, ctr2 = 0, freq = 0;
Utils.QueryPerformanceFrequency(ref freq);
if (Utils.QueryPerformanceCounter(ref ctr1) != 0) // Begin timing.
{
var solve = new SudokuField().Solve(nums).FirstOrDefault();
Utils.QueryPerformanceCounter(ref ctr2); // Finish timing.
if (solve != null)
{
textBox2.Text = solve;
label1.Text = $"Всего решений 1 за {(ctr2 - ctr1) * 1.0 / freq:0.0000}";
}
else
{
textBox2.Text = "";
label1.Text = $"Решений нет за {(ctr2 - ctr1) * 1.0 / freq:0.0000}";
}
}
}
public Result Process(SudokuField sudokuField)
{
bool loop;
do
{
loop = false;
foreach (KeyValuePair <Position, SudokuElement> entry in sudokuField.Field) //.Values)
{
Result result = SolveElement(sudokuField, entry);
switch (result)
{
case Result.Error:
return(Result.Error);
case Result.Added:
loop = true;
break;
}
}
} while (loop);
return(Validator.IsFilled(sudokuField) ? Result.FullFilled : Result.None);
}
public StackElement(SudokuField sudokuField, SudokuElement sudokuElement, int index)
{
SudokuField = sudokuField;
SudokuElement = sudokuElement;
Index = index;
}
public void LoadNewPuzzle(string path)
{
field = new SudokuField();
field.LoadNewPuzzle(path);
HandlePuzzleLoading(field);
}
public void LoadNewPuzzle(TextReader reader)
{
field = new SudokuField();
field.LoadNewPuzzle(reader);
HandlePuzzleLoading(field);
}
public SolverResult(Result result, SudokuField sudokuField)
{
Result = result;
Sudoku = sudokuField;
}
