public void Test54SeatsError()
{
string source = @"7 9 5 1 4 2 3 6 8
1 2 4 8 6 3 7 9 5
8 3 6 7 _ _ 2 1 4
_ 4 1 _ _ _ 5 8 7
_ 5 9 _ _ 8 6 4 1
_ 8 _ _ _ _ 9 2 3
9 _ 8 5 _ _ 4 3 6
4 _ _ _ _ _ 8 5 2
5 _ _ _ 8 _ 1 7 9";
Definition.Sudoku sudoku;
Assert.IsTrue(SudokuHelper.TryParse(source, out sudoku));
Assert.IsTrue(sudoku.Validate(), "Invalid sudoku");
var sourceSudoku = sudoku.Copy();
var guiController = new GUI.SudokuPlayerController(sourceSudoku, sudoku);
using (var solver = new Core.SudokuSolver(sudoku))
{
Assert.IsTrue(solver.TrySolve());
}
guiController.ShowAndWaitForClose();
}
public void solve_puzzle_test_true(string puzzle, string test_message)
{
SudokuGrid result = SudokuHelper.solve_puzzle(puzzle);
Assert.True(result.is_grid_solved(), $"{test_message} grid not solved. {System.Environment.NewLine}{result.ToStringFormatted()}");
Assert.True(result.is_grid_valid(), $"{test_message} grid is invalid. {System.Environment.NewLine}{result.ToStringFormatted()}");
}
public void Test_SolveBoard_Solved()
{
int[,] array = new int[9, 9]
{
{ 0, 0, 9, 0, 0, 0, 0, 0, 0, },
{ 3, 0, 4, 0, 8, 1, 0, 2, 0, },
{ 0, 8, 6, 5, 0, 0, 0, 0, 0, },
{ 9, 0, 1, 3, 0, 0, 0, 0, 2, },
{ 0, 0, 0, 0, 4, 0, 0, 0, 0, },
{ 6, 0, 0, 0, 0, 2, 4, 0, 1 },
{ 0, 0, 0, 0, 0, 3, 2, 6, 0 },
{ 0, 3, 0, 4, 1, 0, 5, 0, 8 },
{ 0, 0, 0, 0, 0, 0, 1, 0, 0, },
};
SudokoBoard board = SudokoBoard.CreateBoard(array);
ISudokoSolver solver = new SudokoSolver(board);
solver.SolveBoard();
board = solver.GetBoard();
bool isSolved = SudokuHelper.IsBoardSolved(board);
Assert.IsTrue(isSolved);
}
public void get_values_for_coordinates_test(string puzzle, CoordinateList coords, List <int> expected_values, string message)
{
SudokuGrid grid = new SudokuGrid(puzzle);
//List<int> values_found = SudokuGrid.get_values_for_coordinates(coords, grid._grid_cells);
//var firstNotSecond = values_found.Except(expected_values).ToList();
//var secondNotFirst = expected_values.Except(values_found).ToList();
Assert.True(SudokuHelper.are_int_lists_equal(SudokuGrid.get_values_for_coordinates(coords, grid._grid_cells), expected_values), message);
}
public void get_possible_values_for_cell_test(string puzzle, int x, int y, List <int> expected_values, string message)
{
SudokuGrid grid = new SudokuGrid(puzzle);
//List<int> values_found = SudokuGrid.calculate_possible_values_for_cell(x, y, grid._grid_cells);
//var firstNotSecond = values_found.Except(expected_values).ToList();
//var secondNotFirst = expected_values.Except(values_found).ToList();
//Assert.True(values_found.Count == expected_values.Count && !firstNotSecond.Any() && !secondNotFirst.Any(), message);
Assert.True(SudokuHelper.are_int_lists_equal(SudokuGrid.calculate_possible_values_for_cell(x, y, grid._grid_cells), expected_values), message);
}
public void set_possible_values_of_all_cells_test(string puzzle, int x, int y, List <int> expected_values, string message)
{
SudokuGrid grid = new SudokuGrid(puzzle);
grid.set_possible_values_of_all_cells();
//List<int> target_possibles = grid._grid_cells[x, y]._possible_values;
//var firstNotSecond = target_possibles.Except(expected_values).ToList();
//var secondNotFirst = expected_values.Except(target_possibles).ToList();
//Assert.True(target_possibles.Count == expected_values.Count && !firstNotSecond.Any() && !secondNotFirst.Any(), message);
Assert.True(SudokuHelper.are_int_lists_equal(grid._grid_cells[x, y]._possible_values, expected_values), message);
}
public void find_pointing_pair_test()
{
SudokuGrid grid = new SudokuGrid("306000000|000070000|405000000||000000000|000000000|000000000||000000000|000000000|000000000");
grid.set_possible_values_of_all_cells();
HashSet <(int, int, int)> results = SudokuHelper.find_pointing_pairs(grid._grid_cells);
HashSet <(int, int, int)> expected_results = new HashSet <(int, int, int)> {
(1, 3, 7), (1, 4, 7), (1, 5, 7), (1, 6, 7), (1, 7, 7), (1, 8, 7)
};
int a_not_b = results.Except(expected_results).Count();
int b_not_a = expected_results.Except(results).Count();
Assert.True(results.Count == expected_results.Count && a_not_b == 0 && b_not_a == 0);
}
protected override ValidationResult IsValid(object value, ValidationContext validationContext)
{
// The model properties are already checked. We can cast without any problem "value" param.
var sudokuGrid = (SudokuGrid)value;
var helper = new SudokuHelper(sudokuGrid.Values);
if (helper.ValidateGridValues())
{
return(ValidationResult.Success);
}
else
{
return(new ValidationResult("The grid is not valid. Some values filled in are not correct."));
}
}
public void find_hidden_singles_test()
{
SudokuGrid grid = new SudokuGrid("000000000|000200000|000000000||000060000|000000000|000080000||000000000|000000000|000002000");
grid.set_possible_values_of_all_cells();
HashSet <(int, int, int)> results = SudokuHelper.find_hidden_singles(grid._grid_cells);
HashSet <(int, int, int)> expected_results = new HashSet <(int, int, int)> {
(4, 4, 2)
};
int a_not_b = results.Except(expected_results).Count();
int b_not_a = expected_results.Except(results).Count();
Assert.True(results.Count == expected_results.Count && a_not_b == 0 && b_not_a == 0);
}
public void ParseFromString()
{
string source = @"7 9 5 1 2 4 3 6 8
1 2 4 8 6 3 7 9 5
3 6 8 7 5 9 2 1 4
6 4 1 _ _ _ _ 8 7
2 5 9 _ 7 8 6 4 _
_ 8 7 _ _ _ _ 2 _
_ 1 _ 5 _ 7 _ 3 6
_ 7 _ _ _ _ _ 5 _
5 3 _ _ 8 _ 1 7 _";
Definition.Sudoku sudoku;
Assert.IsTrue(SudokuHelper.TryParse(source, out sudoku));
Assert.AreEqual(source, sudoku.ToString());
}
static void Main(string[] args)
{
//var map = new int[9, 9]
//{
// { 0,8,0,0,0,0,6,0,0},
// { 0,0,0,4,0,0,0,0,9},
// { 0,7,0,0,0,0,8,0,5},
// { 4,0,0,0,0,0,0,0,0},
// { 0,3,0,0,6,0,0,9,0},
// { 0,0,0,7,2,0,1,0,0},
// { 0,9,3,2,0,0,0,6,4},
// { 8,1,0,3,0,0,0,0,0},
// { 0,0,0,0,0,5,0,0,0}
//};
var map = new string[]
{
"800074000",
"050600003",
"000200000",
"900500040",
"000140060",
"000006800",
"000902056",
"062000900",
"070001200"
};
var numMap = new int[9, 9];
for (int i = 0; i < 9; i++)
{
for (int k = 0; k < 9; k++)
{
numMap[i, k] = Convert.ToInt32(map[i][k].ToString());
}
}
var sudoku = new SudokuHelper(numMap);
sudoku.Run();
for (int i = 0; i < 9; i++)
{
for (int k = 0; k < 9; k++)
{
Console.Write($"{sudoku.Map[i, k]}\t");
}
Console.WriteLine();
}
}
static void Main(string[] args)
{
var services = new ServiceCollection();
ConfigureServices(services);
using (ServiceProvider serviceProvider = services.BuildServiceProvider())
{
SudokuHelper helper = serviceProvider.GetService <SudokuHelper>();
//MyApplication app = serviceProvider.GetService<MyApplication>();
//app.Run();
SudokuGrid grid = new SudokuGrid("010809300000506028007003001300601804004200500070090060700048000620130000081000950");
Console.WriteLine(grid.ToStringFormatted());
SudokuHelper.solve_grid(grid);
Console.WriteLine(grid.ToStringFormatted());
}
}
public void Test_IsBoardValid_Invalid()
{
int[,] array = new int[9, 9]
{
{ 5, 1, 1, 2, 3, 7, 8, 4, 6 },
{ 5, 7, 4, 6, 8, 1, 9, 2, 5 },
{ 2, 8, 6, 5, 9, 4, 3, 1, 7 },
{ 9, 4, 1, 3, 6, 8, 7, 5, 2 },
{ 8, 2, 7, 1, 4, 5, 6, 3, 9 },
{ 6, 5, 3, 9, 7, 2, 4, 8, 1 },
{ 1, 9, 8, 7, 5, 3, 2, 6, 4 },
{ 7, 3, 2, 4, 1, 6, 5, 9, 8 },
{ 4, 6, 5, 8, 2, 9, 1, 7, 3 }
};
SudokoBoard board = SudokoBoard.CreateBoard(array);
bool isSolved = SudokuHelper.IsBoardValid(board);
Assert.IsFalse(isSolved);
}
private static void Main()
{
List <SudokuWithLegalValues> results = SudokuHelper.Solve(originalSudoku16, 2, null, out _);
int counter = 1;
if (results == null)
{
return;
}
foreach (var sudokuSolution in results)
{
Console.WriteLine($"Solution {counter}/{results.Count}:");
SudokuHelper.LogSudoku(sudokuSolution, true);
Console.WriteLine();
Console.WriteLine();
string compact = SudokuHelper.GenerateDisplayStringCompact(sudokuSolution);
Console.WriteLine(compact);
counter++;
}
}
public void are_lists_equal_false(List <int> a, List <int> b, string message)
{
Assert.False(SudokuHelper.are_int_lists_equal(a, b), message);
}
public IActionResult GenerateGrid()
{
var helper = new SudokuHelper();
return(Ok(helper.GenerateValidGrid()));
}
private void Btn_Click(object sender, EventArgs e)
{
sudokuHelper = new SudokuHelper(sudokuTable.DataSource);
sudokuTable.DataSource = sudokuHelper.Run().Map;
}
static void Main(string[] args)
{
//int[,] array = new int[9, 9]
//{
// {6, 5, 0, 0, 0, 0, 0, 9, 7},
// {0, 0, 4, 0, 2, 0, 0, 0, 0},
// {0, 0, 0, 6, 5, 7, 4, 0, 0},
// {0, 9, 0, 8, 0, 0, 0, 2, 3},
// {0, 0, 6, 3, 0, 9, 1, 0, 0},
// {3, 1, 0, 0, 0, 2, 0, 7, 0},
// {0, 0, 3, 2, 8, 4, 0, 0, 0},
// {0, 0, 0, 0, 9, 0, 8, 0, 0},
// {9, 8, 0, 0, 0, 0, 0, 4, 1},
//};
int[,] array = new int[9, 9]
{
{ 0, 0, 9, 0, 0, 0, 0, 0, 0, },
{ 3, 0, 4, 0, 8, 1, 0, 2, 0, },
{ 0, 8, 6, 5, 0, 0, 0, 0, 0, },
{ 9, 0, 1, 3, 0, 0, 0, 0, 2, },
{ 0, 0, 0, 0, 4, 0, 0, 0, 0, },
{ 6, 0, 0, 0, 0, 2, 4, 0, 1 },
{ 0, 0, 0, 0, 0, 3, 2, 6, 0 },
{ 0, 3, 0, 4, 1, 0, 5, 0, 8 },
{ 0, 0, 0, 0, 0, 0, 1, 0, 0, },
};
SudokoBoard board = SudokoBoard.CreateBoard(array);
Console.WriteLine(" ************ Before solution ************ ");
Console.WriteLine();
PrintBoard(board);
//PrintRows(board);
//PrintColumns(board);
if (SudokuHelper.IsBoardValid(board))
{
ISudokoSolver solver = new SudokoSolver(board);
solver.SolveBoard();
board = solver.GetBoard();
Console.WriteLine();
Console.WriteLine(" ************ After solution ************ ");
Console.WriteLine();
PrintBoard(board);
//board.PrintPossibleValues(false);
Console.WriteLine();
}
else
{
//throw new InvalidOperationException("The sudoku board has some invalid cells");
Console.WriteLine("Error: The sudoku board has some invalid cells");
}
List <int> lstA = new List <int> {
1, 2, 3, 4,
};
List <int> lstB = new List <int> {
4, 3, 2, 1,
};
var dups = lstA.Intersect(lstB).ToList();
var distinct = lstA.Except(lstB).ToList();
Console.Read();
}