public static void Main(string [] args)
{
var numerBoardTokenizer = new NumberBoardTokenizer();
using (var streamReader = new StreamReader(new FileStream("./question.txt", FileMode.Open)))
{
using (var streamWriter = new StreamWriter(new FileStream("./answer.txt", FileMode.OpenOrCreate)))
{
var lines = streamReader.ReadToEnd().Split(new[] {Environment.NewLine},
StringSplitOptions.RemoveEmptyEntries);
for (var index = 0; index < lines.Length; index += 10)
{
var header = lines[index];
Console.WriteLine(header);
streamWriter.WriteLine(header);
var generate = numerBoardTokenizer.Generate(string.Join("", lines, index + 1, 9));
var sudokuBoard = new SudokuBoard();
sudokuBoard.Make(generate);
streamWriter.WriteLine(sudokuBoard.Answer);
sudokuBoard.Solve();
streamWriter.WriteLine(sudokuBoard.Answer);
}
}
}
}
void Awake()
{
sudokuBoard = GameObject.FindObjectOfType<SudokuBoard>();
modPanel = GameObject.FindObjectOfType<ModifierPanel>();
DontDestroyOnLoad(this.gameObject);
}
void Awake() {
int[,] boardArr;
var spaceArr = new ISpace<Tiles>[dims, dims];
board = new TileSudokuBoard((int) dims, spaceArr);
switch (SceneManager.GetActiveScene().name) {
case "Tutorial":
boardArr = tutorialBoard;
board.EndPos = new int[] {2, 2};
break;
case "MainGame":
default:
Debug.Log ("name is " + SceneManager.GetActiveScene().name);
boardArr = normalBoard;
break;
}
if (prefab==null)
throw new System.Exception("missing spacewrapper prefab");
//var spaceArr = new ISpace<Tiles>[dims, dims];
for (var i = 0; i < dims; ++i)
for (var j = 0; j < dims; ++j) {
spaceArr [i, j] = CreateSpaceWrapper (i, j, (Tiles)boardArr [i, j]);
Debug.Log ("Set Tile " + boardArr [i, j].ToString () + " at position" + i.ToString () + ", " + j.ToString());
}
}
void Awake()
{
if (prefab==null)
throw new System.Exception("missing spacewrapper prefab");
var spaceArr = new ISpace<Tiles>[dims, dims];
for (var i=0; i<dims; ++i)
for (var j=0; j<dims; ++j)
spaceArr[i,j] = CreateSpaceWrapper(i,j);
board = new TileSudokuBoard((int) dims, spaceArr);
}
public void startGame()
{
sudokuBoard = GameObject.FindObjectOfType<SudokuBoard>();
modPanel = GameObject.FindObjectOfType<ModifierPanel>();
modPanel.reset();
sudokuBoard.instantiateBoard();
populateBoard(level);
sudokuBoard.checkBoard();
}
/// <summary>
/// Finds the next position by finding the next blank character,
/// going from top to bottom, left to right
/// </summary>
/// <param name="sudokuBoard">SudokuBoard to find the next position for</param>
/// <returns>Position of the next blank character if one is found, null otherwise</returns>
protected override Position FindNextPosition(SudokuBoard sudokuBoard)
{
for (var row = 0; row < SudokuBoard.Rows; row++)
{
for (var col = 0; col < SudokuBoard.Columns; col++)
{
if (sudokuBoard[col, row] == '-')
{
return new Position(col, row);
}
}
}
return null;
}
// Use this for initialization
void Start()
{
sudokuBoard = GameObject.FindObjectOfType<SudokuBoard>();
modPanel = GameObject.FindObjectOfType<ModifierPanel>();
sudokuBoard.instantiateBoard();
int[] modifiers = createModifiers(4);
foreach (int mod in modifiers)
{
int x = Random.Range(0, 9);
int y = Random.Range(0, 9);
while (sudokuBoard.getValue(x, y) - mod < 0 || sudokuBoard.getValue(x, y) - mod > 8)
x = Random.Range(0, 9);
y = Random.Range(0, 9);
sudokuBoard.initializeMod(mod, x, y);
modPanel.addMod(mod);
}
}
public void Test_SolveBoardIterativelyWithQueue()
{
try
{
SudokuBoard board = new SudokuBoard();
if (Program.SolveBoardIterativelyWithQueue(ref board))
{
if (!board.VerifyBoard())
{
Assert.Fail("SolveBoardIterativelyWithQueue() returned true, but VerifyBoard() returned false afterwards.");
}
}
else
{
Assert.Fail("SolveBoardIterativelyWithQueue() returned false.");
}
}
catch (Exception e)
{
Assert.Fail("Test_SolveBoardIterativelyWithQueue() threw an exception. " + e.Message);
}
}
public void TestValidate()
{
SudokuBoard board = new SudokuBoard();
Validity valid1 = BoardValidation.Validate(board);
Assert.AreEqual(Validity.CONSISTENT, valid1);
BoardFactory.FillSequential(board);
Validity valid2 = BoardValidation.Validate(board);
Assert.AreEqual(Validity.INCONSISTENT, valid2);
BoardFactory.FillStriped(board);
Validity valid3 = BoardValidation.Validate(board);
Assert.AreEqual(Validity.COMPLETE, valid3);
board[3] = 15;
Validity valid4 = BoardValidation.Validate(board);
Assert.AreEqual(Validity.INVALID, valid4);
}
public static SudokuBoard CreateBoard(SudokuTestDifficulty difficulty)
{
string sudokuToParse;
switch (difficulty)
{
case SudokuTestDifficulty.VeryEasy:
sudokuToParse = _veryEasySudokuString;
break;
case SudokuTestDifficulty.Easy:
sudokuToParse = _easySudokuString;
break;
case SudokuTestDifficulty.Medium:
sudokuToParse = _mediumSudokuString;
break;
default:
throw new ArgumentOutOfRangeException(nameof(difficulty), difficulty, null);
}
return(SudokuBoard.Parse(sudokuToParse));
}
public void When_Board_Is_Valid_Then_Should_Get_Any_Cell(int row, int column, int value)
{
// arrange
var board = new[, ]
{
{ 1, 2, 3, 4, 5, 6, 7, 8, 9 },
{ 1, 2, 3, 4, 5, 6, 7, 8, 9 },
{ 1, 2, 3, 4, 5, 6, 7, 8, 9 },
{ 1, 2, 3, 4, 5, 6, 7, 8, 9 },
{ 1, 2, 3, 4, 5, 6, 7, 8, 9 },
{ 1, 2, 3, 4, 5, 6, 7, 8, 9 },
{ 1, 2, 3, 4, 5, 6, 7, 8, 9 },
{ 1, 2, 3, 4, 5, 6, 7, 8, 9 },
{ 1, 2, 3, 4, 5, 6, 7, 8, 9 },
};
var sudokuBoard = new SudokuBoard(board);
// act
var cell = sudokuBoard[row, column];
// assert
cell.Should().Be(value);
}
public void UnsolvedBoard_SolvedBoardReturned()
{
//arrange
int[] expectedResult = new int[]
{
8, 2, 7, 3, 1, 6, 5, 4, 9, 6, 4, 9, 7, 5, 2, 8, 3, 1, 5, 3, 1, 4, 8, 9, 6, 7, 2,
4, 9, 6, 2, 3, 8, 1, 5, 7, 2, 1, 8, 5, 4, 7, 3, 9, 6, 7, 5, 3, 6, 9, 1, 2, 8, 4,
3, 7, 4, 1, 6, 5, 9, 2, 8, 9, 6, 2, 8, 7, 3, 4, 1, 5, 1, 8, 5, 9, 2, 4, 7, 6, 3
};
SudokuBoard testBoard = new SudokuBoard(new int[] { 8, 2, 0, 3, 0, 0, 0, 0, 9, 0, 0, 9, 7, 5, 0, 8, 0, 0, 0, 3, 0, 0, 8, 0, 6, 0, 0,
0, 0, 6, 2, 3, 0, 0, 0, 7, 2, 1, 8, 5, 4, 7, 0, 0, 0, 7, 0, 0, 0, 9, 0, 0, 8, 0,
0, 0, 4, 1, 0, 5, 0, 0, 8, 0, 6, 0, 0, 7, 0, 4, 1, 0, 0, 0, 5, 9, 0, 4, 7, 6, 3 });
BacktrackBoardSolver solver = new BacktrackBoardSolver();
//act
Result <int[]> result = solver.Solve(testBoard);
//assert
Assert.IsTrue(result.IsSuccess);
bool areEqual = AreEqual(expectedResult, result.Data);
Assert.IsTrue(areEqual);
}
public static SudokuBoard LoadBoardFromText(string text)
{
var board = new SudokuBoard();
int row = 0;
foreach (var line in text.Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries))
{
int col = 0;
foreach (var c in line.Trim('\r').ToCharArray())
{
if (c != ' ' && c != '.')
{
board.SetValue(board[row, col], int.Parse(c.ToString()));
}
col++;
}
row++;
}
return(board);
}
public void SudokoBoard_Solve_ExtraZonesWithSolution()
{
// Arrange
// http://en.wikipedia.org/wiki/File:Oceans_Hypersudoku18_Puzzle.svg
SudokuBoard board = SudokuFactory.ClassicWith3x3BoxesAndHyperRegions(new[]
{
".......1.",
"..2....34",
"....51...",
".....65..",
".7.3...8.",
"..3......",
"....8....",
"58....9..",
"69......."
});
string[] tileDefinitions = new[]
{
"946832715",
"152697834",
"738451296",
"819726543",
"475319682",
"263548179",
"327985461",
"584163927",
"691274358"
};
// Act
IEnumerable <SudokuBoard> solutions = board.Solve();
// Assert
Assert.Single(solutions);
Assert.Equal(tileDefinitions, solutions.First().TileDefinitions);
}
public static double Eval(IChromosome sudokuChromosome, SudokuBoard sudokuBoard, int populationSize, double fitnessThreshold, int generationNb)
{
var fitness = new SudokuFitness(sudokuBoard);
var selection = new EliteSelection();
var crossover = new UniformCrossover();
var mutation = new UniformMutation();
var population = new Population(populationSize, populationSize, sudokuChromosome);
var ga = new GeneticAlgorithm(population, fitness, selection, crossover, mutation)
{
Termination = new OrTermination(new ITermination[]
{
new FitnessThresholdTermination(fitnessThreshold),
new GenerationNumberTermination(generationNb)
})
};
ga.Start();
var bestIndividual = ((ISudokuChromosome)ga.Population.BestChromosome);
var solutions = bestIndividual.GetSudokus();
return(solutions.Max(solutionSudoku => fitness.Evaluate(solutionSudoku)));
}
public void GuessMakeFirstGuessTest()
{
int[,] start =
{
{ 0, 0 },
{ 0, 0 }
};
int[,] endOne =
{
{ 1, 0 },
{ 0, 0 }
};
int[,] endTwo =
{
{ 2, 0 },
{ 0, 0 }
};
systemUnderTest = new SudokuBoard(start, SudokuBoard.BoardProperty.TwoByTwo);
systemUnderTest.MakeGuess();
int[,] outcome = systemUnderTest.GetAsMultidimentionalArray();
Assert.IsTrue(EqualTwoDimentionalArray(outcome, endOne) || EqualTwoDimentionalArray(outcome, endTwo));
}
public override void Draw()
{
var buffer = Context.Buffer;
var layout = Context.Layout;
var population = Context.Population;
SudokuBoard sudokuBoardToDraw = null;
if (population != null)
{
if ((population.BestChromosome is ISudokuChromosome bestChromosome))
{
if (population.CurrentGeneration != null)
{
var stats = population.CurrentGeneration.Chromosomes.GroupBy(c => c.Fitness).OrderByDescending(g => g.Key).Select(g => new { Fitness = g.Key, Count = g.Count(), First = ((ISudokuChromosome)g.First()).GetSudokus().First(), Last = ((ISudokuChromosome)g.Last()).GetSudokus().First() }).ToList();
Context.WriteText($"Fitness,Count:({stats[0].Fitness},{stats[0].Count})...({stats[stats.Count / 3].Fitness},{stats[stats.Count / 3].Count})...({stats[stats.Count * 2 / 3].Fitness},{stats[stats.Count * 2 / 3].Count})...({stats[stats.Count - 1].Fitness},{stats[stats.Count - 1].Count})");
Context.WriteText($"Top: [{string.Join(",", stats[0].First.Cells.Take(9).Select(i => i.ToString()).ToArray())}] [{string.Join(",", stats[0].Last.Cells.Take(9).Select(i => i.ToString()).ToArray())}]");
if (stats.Count > 1)
{
Context.WriteText($"Next: [{string.Join(",", stats[1].First.Cells.Take(9).Select(i => i.ToString()).ToArray())}] [{string.Join(",", stats[1].Last.Cells.Take(9).Select(i => i.ToString()).ToArray())}]");
}
}
sudokuBoardToDraw = bestChromosome.GetSudokus().First();
}
else
{
if (population.BestChromosome is MultipleChromosome multiChromosome)
{
var orderedSubChromosomes = multiChromosome.Chromosomes.OrderByDescending(c => c.Fitness).ToList();
bestChromosome = (ISudokuChromosome)orderedSubChromosomes.First();
var worstChromosome = (ISudokuChromosome)orderedSubChromosomes.Last();
sudokuBoardToDraw = bestChromosome.GetSudokus().First();
Context.WriteText($"Best Chromosome Best Sub-Fitness: {((IChromosome)bestChromosome).Fitness}");
Context.WriteText($"Best Chromosome Worst Sub-Fitness:: {((IChromosome)worstChromosome).Fitness}");
}
}
}
public void HorisontalExclusionOnOnlyPositionsThatFit()
{
int[,] start =
{
{ 1, 0, 0, 0 },
{ 0, 4, 0, 0 },
{ 3, 0, 0, 0 },
{ 0, 0, 0, 0 }
};
int[,] end =
{
{ 1, 3, 0, 0 },
{ 0, 4, 0, 0 },
{ 3, 0, 0, 0 },
{ 4, 0, 0, 0 }
};
systemUnderTest = new SudokuBoard(start, SudokuBoard.BoardProperty.FourByFour);
systemUnderTest.SimpleSquareExclusion();
systemUnderTest.HorizontalExclusionOnOnlyPositionsThatFit();
int[,] outcome = systemUnderTest.GetAsMultidimentionalArray();
Assert.IsTrue(EqualTwoDimentionalArray(outcome, end));
}
private void PasteFromClipboard()
{
if (!Clipboard.ContainsText())
{
return;
}
SudokuBoard board = new SudokuBoard(Clipboard.GetText());
if (board != null)
{
Cursor.Current = Cursors.WaitCursor;
try
{
solutionsTree.InitTree(board);
UndoRedoManager.Instance.Clear();
}
finally
{
Cursor.Current = Cursors.Default;
}
}
}
public void SudokuBoard_Solve_ClassicWithSolution()
{
// Arrange
SudokuBoard board = SudokuFactory.ClassicWith3x3Boxes(new[]
{
"...84...9",
"..1.....5",
"8...2146.",
"7.8....9.",
".........",
".5....3.1",
".2491...7",
"9.....5..",
"3...84..."
});
string[] tileDefinitions = new[]
{
"632845179",
"471369285",
"895721463",
"748153692",
"163492758",
"259678341",
"524916837",
"986237514",
"317584926",
};
// Act
IEnumerable <SudokuBoard> solutions = board.Solve();
// Assert
Assert.Single(solutions);
Assert.Equal(tileDefinitions, solutions.First().TileDefinitions);
}
public override void Undo()
{
SudokuBoard.ChangeText(Row, Column, PreviousValue);
SudokuBoard.SelectSquare(Row, Column);
}
public static SudokuBoard BacktrackingSearch(SudokuBoard sb)
{
return(RecursiveBacktracking(sb));
}
public SudokuBoard Solve(SudokuBoard sourceBoard)
{
var visited = new Stack <Cell>();
var toVisit = new Stack <Cell>();
sourceBoard.Where(cell => !cell.IsEmpty)
.ToList()
.ForEach(cell => visited.Push(cell));
var sudoku = new SudokuBoard(visited);
if (!sudoku.EmptyCells.Any())
{
return(sudoku);
}
var firstEmpty = sudoku.EmptyCells.First();
var start = Enumerable
.Range(1, 9)
.Shuffle()
.First(x => sudoku.IsValid(new Cell(firstEmpty.Row, firstEmpty.Col, x)));
toVisit.Push(new Cell(firstEmpty.Row, firstEmpty.Col, start));
while (toVisit.Any())
{
var current = toVisit.Pop();
visited.Push(current);
sudoku = new SudokuBoard(visited);
if (!sudoku.EmptyCells.Any())
{
return(sudoku);
}
current = sudoku.EmptyCells.First();
var neighbours = Enumerable.Range(1, 9)
.Shuffle()
.Where(x => sudoku.IsValid(new Cell(current.Row, current.Col, x)))
.Select(x => new Cell(current.Row, current.Col, x))
.ToList();
// Backtracking part
if (!neighbours.Any())
{
if (!toVisit.Any())
{
break;
}
var next = toVisit.Peek();
while (visited.Any(cell => cell.Row == next.Row && cell.Col == next.Col))
{
visited.Pop();
}
}
// Classic DFS
else
{
neighbours.ForEach(toVisit.Push);
}
}
return(sudoku);
}
private void LoadData()
{
sb = new SudokuBoard(Canvas1.Children);
Canvas1.Children.Clear();
}
public static bool ValidateSolution(int[][] board)
{
var sudoku = new SudokuBoard(board);
return(sudoku.IsValid());
}
/*
* For each cell value 1 - 9,
* Get All cells that have candidates for the current value.
* Start with Xwing of size one and continue up to 9
* - for each row/column
* - are the row/column candidates less than or equal to the XWing size we're looking for?
* - if yes, this row MIGHT be an XWing Set candidate.
* - Are there at least "setSize" row/column(s) that
* a) have less than or equal to the number of elements in our xwing set candidate
* b) every value in the row/column exist in the candidate row/column
* If yes, we have an Xwing!
* - out of all the rows that meet this criteria, skip the first "setSize", and take the rest
* - remove candidate values from the rest of the rows, ONLY IN THE SAME COLUMNS AS THE CANDIDATE ROW/Column
* */
protected override bool DoCrank(ref SudokuBoard board)
{
bool modified = false;
foreach (int currentValue in SudokuBoard.CELL_VALUES)
{
var candidateCells = board.Cells.Where(c => c.Candidates.Contains(currentValue)).ToList();
var boardRows = board.Cells.GroupBy(the => the.Row).ToArray();
var boardColumns = board.Cells.GroupBy(the => the.Column).ToArray();
var candidateRows = candidateCells.GroupBy(c => c.Row);
var candidateColumns = candidateCells.GroupBy(c => c.Column);
var uniqueColumns = candidateCells.Select(c => c.Column).Distinct().ToList();
var uniqueRows = candidateCells.Select(c => c.Row).Distinct().ToList();
//that is, the column values to test for the sudukoboard rows
var rowSets = this.GetPowerSet(uniqueColumns).Distinct();
//vice versa
var colSets = this.GetPowerSet(uniqueRows).Distinct();
foreach (int xWingSize in SudokuBoard.CELL_VALUES)
{
var xWingTestRows = rowSets.Where(r => r.Count() == xWingSize).ToArray();
foreach (var xWingValues in xWingTestRows)
{
int rowCount = xWingValues.Count();
var rowsToTest = candidateRows.Where(r => xWingValues.Contains(r.Key)).ToArray();
if (rowsToTest.Length < rowCount)
{
continue;
}
var setUnionOfCandidateColumns = rowsToTest.SelectMany(r => r.Select(c => c.Column)).Distinct().ToArray();
if (setUnionOfCandidateColumns.Length != rowCount)
{
continue;
}
var xWingTrimColumns = boardColumns.Where(clmn => setUnionOfCandidateColumns.Contains(clmn.Key)).ToArray();
foreach (var trimCol in xWingTrimColumns)
{
var trimCells = trimCol.Where(c => !xWingValues.Contains(c.Row) && c.Candidates.Contains(currentValue)).ToArray();
foreach (var cell in trimCells)
{
modified |= cell.Candidates.Remove(currentValue);
}
}
break;
}
//now do it for columns
var xWingTestCols = colSets.Where(clmn => clmn.Count() == xWingSize).ToArray();
foreach (var xWingValues in xWingTestCols)
{
int colCount = xWingValues.Count();
var columnsToTest = candidateColumns.Where(clmn => xWingValues.Contains(clmn.Key)).ToArray();
if (columnsToTest.Length < colCount)
{
continue;
}
var setUnionOfCandidateRows = columnsToTest.SelectMany(clmn => clmn.Select(c => c.Row)).Distinct().ToArray();
if (setUnionOfCandidateRows.Length != colCount)
{
continue;
}
var xWingTrimRows = boardRows.Where(r => setUnionOfCandidateRows.Contains(r.Key)).ToArray();
foreach (var trimRow in xWingTrimRows)
{
var trimCells = trimRow.Where(c => !xWingValues.Contains(c.Column) && c.Candidates.Contains(currentValue)).ToArray();
foreach (var cell in trimCells)
{
modified |= cell.Candidates.Remove(currentValue);
}
}
break;
}
}
}
return(modified);
}
public void SudokoBoard_Solve_SamuraiWithSolution()
{
// Arrange
// http://www.freesamuraisudoku.com/1001HardSamuraiSudokus.aspx?puzzle=42
SudokuBoard board = SudokuFactory.Samurai(new[]
{
"6..8..9..///.....38..",
"...79....///89..2.3..",
"..2..64.5///...1...7.",
".57.1.2..///..5....3.",
".....731.///.1.3..2..",
"...3...9.///.7..429.5",
"4..5..1...5....5.....",
"8.1...7...8.2..768...",
".......8.23...4...6..",
"//////.12.4..9.//////",
"//////......82.//////",
"//////.6.....1.//////",
".4...1....76...36..9.",
"2.....9..8..5.34...81",
".5.873......9.8..23..",
"...2....9///.25.4....",
"..3.64...///31.8.....",
"..75.8.12///...6.14..",
".......2.///.31...9..",
"..17.....///..7......",
".7.6...84///8...7..5."
});
string[] tileDefinitions = new[]
{
"674825931000142673859",
"513794862000897425361",
"982136475000563189472",
"357619248000425916738",
"298457316000918357246",
"146382597000376842915",
"469578123457689534127",
"821963754689231768594",
"735241689231754291683",
"000000512748396000000",
"000000497163825000000",
"000000368592417000000",
"746921835976142368597",
"238456971824563497281",
"159873246315978152346",
"815237469000625749813",
"923164758000314825769",
"467598312000789631425",
"694385127000431586972",
"581742693000257914638",
"372619584000896273154"
};
// Act
IEnumerable <SudokuBoard> solutions = board.Solve();
// Assert
Assert.Single(solutions);
Assert.Equal(tileDefinitions, solutions.First().TileDefinitions);
}
public SudokuEngine(SudokuBoard sudokuBoard, SudokuMapper sudokuMapper)
{
_sudokuBoard = sudokuBoard;
_sudokuMapper = sudokuMapper;
}
public void InitTree(SudokuBoard a_board)
{
UpdateTree(SudokuSolutionNode.CreateRoot(a_board));
}
public SudokuBoard BacktrackingSearch(SudokuBoard sb)
{
this.sudokuBoard = sb;
this.length = sb.Board.GetLength(0);
return(RecursiveBacktracking());
}
private static (SudokuBoard board, bool finish, bool deadEnd) generateBoardFromCell(int cellNumber, SudokuBoard board)
{
// var possibleValuesShuffled = Helpers.determinePossibleValuesx(cellNumber, board).Shuffle_knuthfisheryates2();
var possibleValuesShuffled = Helpers.determinePossibleValuesx(cellNumber, board).Shuffle_knuthfisheryates2();
// for (var index = 0; index < possibleValuesShuffled.Length; index++)
foreach (var possibleValue in possibleValuesShuffled)
{
var nextBoard = Helpers.sudokuBoardClone(board);
// nextBoard.cells[cellNumber].value = possibleValuesShuffled[index];
nextBoard.cells[cellNumber].value = possibleValue;
nextBoard.cells[cellNumber].expectedValue = nextBoard.cells[cellNumber].value;
nextBoard.cells[cellNumber].seed = true;
var nextCellNumber = cellNumber + 1;
if (nextCellNumber == board.cells.Length)
{
return(board : nextBoard, finish : true, deadEnd : false);
}
var(finishedBoard, finish, deadEnd) = generateBoardFromCell(nextCellNumber, nextBoard);
if (finish)
{
return(board : finishedBoard, finish : true, deadEnd : deadEnd);
}
}
// all cell values are wrong
return(board : null, finish : false, deadEnd : true);
}
public SudokuSolverTest()
{
this.boardInstance = new SudokuBoard();
this.boardReaderInstance = new StringBoardReaderStrategy(TestCaseInitial);
this.boardBruteForceSolver = new BruteForceSudokuSolver();
}
private async void button11_Click(object sender, EventArgs e)
{
bool labelValue = false;
// go through all labels and if there are no label values
// then cannot attempt solution
// got some value so attempt to solve
int[,] board = new int[Settings.BOARD_SIZE, Settings.BOARD_SIZE];
for (int j = 0; j < Settings.BOARD_SIZE; j++)
{
for (int i = 0; i < Settings.BOARD_SIZE; i++)
{
if (cellLabels[i, j].Text == string.Empty)
{
board[i, j] = 0;
}
else
{
labelValue = true;
board[i, j] = Convert.ToInt32(cellLabels[i, j].Text);
}
}
}
if (labelValue)
{
SudokuBoard sb = new SudokuBoard(board);
//MessageBox.Show( sb.Board.ToString() );
// set buttons to disabled
button11.Enabled = false;
this.Cursor = Cursors.WaitCursor;
bool result = false;
if (rdoBrute.Checked)
{
result = await Task.Run(() => sb.Solve(this, chkSingle.Checked));
}
else
{
result = await Task.Run(() => sb.TargettedSolve(this, chkSingle.Checked));
}
button11.Enabled = true;
this.Cursor = Cursors.Default;
if (result)
{
for (int j = 0; j < Settings.BOARD_SIZE; j++)
{
for (int i = 0; i < Settings.BOARD_SIZE; i++)
{
cellLabels[i, j].Text = String.Format("{0}", sb.Solution.Board[i, j]);
}
}
}
else
{
MessageBox.Show("No Solution Found");
}
labelValid.Text = sb.Valid.ToString();
labelAttempts.Text = sb.Attempts.ToString();
labelTime.Text = sb.TimeTaken.ToString();
}
}
public override Widget CreateConfigWidget()
{
var container = new VBox();
var fileHBox = new HBox();
container.Add(fileHBox);
// Sudoku index.
var indexHBox = new HBox();
fileHBox.Add(indexHBox);
var indexLabel = new Label {
Text = "Sudoku index"
};
indexHBox.Add(indexLabel);
var indexButton = new SpinButton(1, _sudokuList.Count, 1)
{
Value = 1
};
indexButton.ValueChanged += delegate
{
_sudokuIndex = (int)indexButton.Value - 1;
OnReconfigured();
};
indexHBox.Add(indexButton);
// File support
var selectImageButton = new Button {
Label = "Load sudoku(s) file"
};
selectImageButton.Clicked += delegate
{
Gtk.FileChooserDialog filechooser =
new Gtk.FileChooserDialog(
"Select the sudoku to use",
Context.GtkWindow,
FileChooserAction.Open,
"Cancel",
ResponseType.Cancel,
"Open",
ResponseType.Accept);
if (filechooser.Run() == (int)ResponseType.Accept)
{
_sudokuList = SudokuBoard.ParseFile(filechooser.Filename);
indexButton.SetRange(1, _sudokuList.Count);
}
filechooser.Destroy();
OnReconfigured();
};
fileHBox.Add(selectImageButton);
var helpImageButton = new Button {
Label = "?"
};
helpImageButton.Clicked += delegate
{
var msg = new MessageDialog(
Context.GtkWindow,
DialogFlags.Modal,
MessageType.Info,
ButtonsType.Ok,
"Accepted formats represent Sudokus on one or several lines," +
"\n with characters '.', '-', or 'X' for empty cells and digits otherwise." +
"\n Lines starting with other characters are ignored such as '#' for comments on the common sdk format.");
msg.Run();
msg.Destroy();
};
fileHBox.Add(helpImageButton);
// Genetics selector.
var geneticsHBox = new HBox();
geneticsHBox.Spacing += 2;
var geneticsLabel = new Label {
Text = "Genetics"
};
geneticsHBox.Add(geneticsLabel);
var chromosomeTypes = new string[] {
nameof(SudokuChromosomeType.RowsPermutations)
, nameof(SudokuChromosomeType.Cells)
, nameof(SudokuChromosomeType.RandomRowsPermutations)
, nameof(SudokuChromosomeType.RowsWithoutMask)
, nameof(SudokuChromosomeType.CellsWithoutMask)
};
_nbPermsHBox = new HBox
{
Visible = _ChromosomeType == nameof(SudokuChromosomeType.RandomRowsPermutations)
};
var nbPermsLabel = new Label {
Text = "Nb Permutations"
};
_nbPermsHBox.Add(nbPermsLabel);
var nbPermsButton = new SpinButton(1, 1000, 1);
_nbPermsHBox.Add(nbPermsButton);
nbPermsButton.Value = _nbPermutations;
nbPermsButton.ValueChanged += delegate
{
_nbPermutations = (int)nbPermsButton.Value;
OnReconfigured();
};
var nbSudokusLabel = new Label {
Text = "Nb Sudokus"
};
_nbPermsHBox.Add(nbSudokusLabel);
var nbSudokusButton = new SpinButton(1, 1000, 1);
_nbPermsHBox.Add(nbSudokusButton);
nbSudokusButton.Value = _nbSudokus;
nbSudokusButton.ValueChanged += delegate
{
_nbSudokus = (int)nbSudokusButton.Value;
OnReconfigured();
};
var selectorCombo = new ComboBox(chromosomeTypes)
{
Active = 0
};
selectorCombo.Changed += delegate
{
_ChromosomeType = selectorCombo.ActiveText;
_nbPermsHBox.Visible = _ChromosomeType == nameof(SudokuChromosomeType.RandomRowsPermutations);
OnReconfigured();
};
geneticsHBox.Add(selectorCombo);
container.Add(geneticsHBox);
container.Add(_nbPermsHBox);
//Multi check
var multiHBox = new HBox();
var multiCheck = new CheckButton("Multi-Solutions")
{
Active = _multipleChromosome
};
_nbChromosomesHBox = new HBox();
_nbChromosomesHBox.Spacing += 2;
_nbChromosomesHBox.Visible = _multipleChromosome;
var nbChromosomesLabel = new Label {
Text = "Nb Chrom."
};
_nbChromosomesHBox.Add(nbChromosomesLabel);
var nbChromosomesButton = new SpinButton(1, 1000, 1);
_nbChromosomesHBox.Add(nbChromosomesButton);
nbChromosomesButton.Value = _nbChromosomes;
nbChromosomesButton.ValueChanged += delegate
{
_nbChromosomes = (int)nbChromosomesButton.Value;
OnReconfigured();
};
multiCheck.Toggled += delegate
{
_multipleChromosome = multiCheck.Active;
_nbChromosomesHBox.Visible = _multipleChromosome;
OnReconfigured();
};
multiHBox.Add(multiCheck);
multiHBox.Add(_nbChromosomesHBox);
container.Add(multiHBox);
return(container);
}
public static (SudokuBoard board, bool finish, bool resolved) resolverWorkForce(int cellNumber, SudokuBoard board)
{
// console.log(`resolverWorkForce: cell:${cellNumber}`);
// sortir de la recurrence
if (cellNumber >= board.cells.Length)
{
return(board : board, finish : true, resolved : true);
}
// if (board.cells[cellNumber].value != null)
// TODO checkf this modification does not create problem
// TODO replace null by 0
// TODO
// TODO
// TODO
// TODO
// TODO
// TODO
// TODO
if (board.cells[cellNumber].value != 0)
{
// the cell is already filled we continue recurrence
// console.log(`resolverWorkForce: ALREADY FILLED - cell:${cellNumber} - value:${board.cells[cellNumber].value}`);
return(resolverWorkForce(cellNumber + 1, board));
}
else
{
// console.log(`resolverWorkForce: NO VALUE DEFINED cell:${cellNumber} - value:${board.cells[cellNumber].value}`);
// liste of potential values for the cell
var possibleValuesShuffled = Helpers.determinePossibleValuesx(cellNumber, board).Shuffle_knuthfisheryates2();
// parse all the potential values
// for (var index = 0; index < possibleValuesShuffled.Length; index++)
foreach (var possibleValue in possibleValuesShuffled)
{
var nextBoard = Helpers.sudokuBoardClone(board);
// nextBoard.cells[cellNumber].value = possibleValuesShuffled[index];
nextBoard.cells[cellNumber].value = possibleValue;
// console.log(`resolverWorkForce: PROPOSE VALUE cell:${cellNumber} - value:${nextBoard.cells[cellNumber].value}`);
var(finishedBoard, finish, resolved) = resolverWorkForce(cellNumber + 1, nextBoard);
if (finish)
{
return(board : finishedBoard, finish : finish, resolved : resolved);
}
}
// console.log(`resolverWorkForce: xxxxxxxxxxxxxxxxxxxxxxxxx !!! no possible value dead end: cell:${cellNumber}`, board)
// all cell values are wrong
return(board : null, finish : false, resolved : false);
}
}
public static void Solve(SudokuBoard board)
{
SudokuSolver.Solve(board, 0);
}
public IActionResult Sudoku()
{
var board = new SudokuBoard();
return(View(board.Board));
}
public void Test_VerifyBoard()
{
try
{
SudokuBoard board = new SudokuBoard();
//Test valid board
board.Board = new int[9, 9] {
{ 4, 3, 5, 2, 6, 9, 7, 8, 1 },
{ 6, 8, 2, 5, 7, 1, 4, 9, 3 },
{ 1, 9, 7, 8, 3, 4, 5, 6, 2 },
{ 8, 2, 6, 1, 9, 5, 3, 4, 7 },
{ 3, 7, 4, 6, 8, 2, 9, 1, 5 },
{ 9, 5, 1, 7, 4, 3, 6, 2, 8 },
{ 5, 1, 9, 3, 2, 6, 8, 7, 4 },
{ 2, 4, 8, 9, 5, 7, 1, 3, 6 },
{ 7, 6, 3, 4, 1, 8, 2, 5, 9 }
};
if (!board.VerifyBoard())
{
Assert.Fail("Valid board tested but failed VerifyBoard()");
}
//Test board with empty elements
board.Board = new int[9, 9] {
{ 4, 3, 5, 2, 6, 9, 7, 8, 1 },
{ 6, 8, 2, 5, 7, 1, 4, 9, 3 },
{ 1, 9, 0, 8, 3, 4, 0, 6, 2 },
{ 8, 2, 6, 1, 0, 5, 3, 4, 7 },
{ 3, 7, 4, 6, 8, 2, 0, 1, 5 },
{ 9, 0, 1, 7, 4, 3, 6, 2, 8 },
{ 5, 1, 9, 3, 2, 6, 8, 7, 4 },
{ 2, 4, 8, 0, 5, 7, 1, 3, 6 },
{ 7, 6, 3, 4, 1, 8, 2, 5, 9 }
};
if (board.VerifyBoard())
{
Assert.Fail("Board with missing elements passed VerifyBoard()");
}
//Test board that has invalid elements
board.Board = new int[9, 9] {
{ 4, 3, 5, 2, 6, 9, 7, 8, 1 },
{ 6, 8, 2, 5, 7, 1, 4, 9, 3 },
{ 9, 9, 7, 8, 3, 4, 5, 6, 2 },
{ 8, 2, 6, 1, 9, 5, 3, 4, 7 },
{ 3, 7, 4, 6, 8, 2, 9, 9, 5 },
{ 9, 5, 1, 7, 4, 3, 6, 2, 8 },
{ 5, 1, 9, 3, 2, 6, 8, 7, 4 },
{ 2, 4, 8, 9, 5, 9, 1, 3, 6 },
{ 7, 6, 3, 4, 1, 8, 2, 5, 9 }
};
if (board.VerifyBoard())
{
Assert.Fail("Invalid complete board passed VerifyBoard()");
}
}
catch (Exception e)
{
Assert.Fail("Test_VerifyBoard threw an exception. " + e.Message);
}
}