public BaseSudokuAction(SolutionsTree a_tree, SudokuSolutionNode a_selected) { m_selected = a_selected; m_tree_state = new SolutionsTreeState(a_tree); m_tree = a_tree; m_selected_tree = a_tree.SelectedSolutionNode; }
private bool IsSolvable(SudokuSolutionNode a_node) { if (a_node.Board.IsSolved) { return(true); } if (!a_node.Board.IsSolvable) { return(false); } a_node.StepAll(); SudokuSolutionNode node = a_node.Nodes.FirstOrDefault(); if (node == null) { return(true); } node.StepAll(); return(IsSolvable(node.Nodes.First())); }
private void RefreshBoard() { Cursor.Current = Cursors.WaitCursor; try { UndoRedoManager.Instance.Clear(); SudokuSolutionNode selected_node = solutionsTree.SelectedSolutionNode; SudokuSolution selected_sol = solutionsCheckedListBox.SelectedSolution; foreach (TreeNode node in solutionsTree.Nodes) { SudokuSolutionNode sol_node = solutionsTree.TreeNodeToSolutionNode(node); if (sol_node.State == SudokuSolutionNodeState.Solution) { sol_node.Parent.RemoveNodes(sol_node); } } SudokuSolutionNode last = solutionsTree.TreeNodeToSolutionNode(solutionsTree.Nodes.Cast <TreeNode>().Last()); last.RemoveNodes(); SudokuSolutionNode root = SudokuSolutionNode.CreateTree(solutionsTree.SelectedSolutionNode.Root); solutionsTree.UpdateTree(root, solutionsTree.SelectedSolutionNode); } finally { Cursor.Current = Cursors.Default; } }
private static void GenerateAllSolutionsTrees() { System.Console.WriteLine(); System.Console.WriteLine("Generating all solutions trees..."); System.Console.WriteLine(); FileInfo[] files = new DirectoryInfo(Directories.Examples).GetFiles(FileExtensions.XmlZipMask); ShowProgress(0, 70); new DirectoryInfo(Directories.SolutionTrees).CreateOrEmpty(); ConcurrentCounter counter = new ConcurrentCounter(); Parallel.ForEach(files, (file) => { SudokuBoard board = SudokuBoard.LoadFromFile(file.FullName); for (int i = 0; i < 4; i++) { SudokuSolutionNode node = SudokuSolutionNode.CreateRoot(board); node.SolveWithStepAll(); node.SaveToFile(Directories.SolutionTrees + Path.DirectorySeparatorChar + Path.GetFileNameWithoutExtension(Path.GetFileNameWithoutExtension(file.FullName)) + "_rotate_" + i + FileExtensions.XmlZipExt); board = board.Rotate(); } counter.Increment(); lock (counter) { ShowProgress(counter.Value * 70 / files.Length, 70); } }); }
private IEnumerable <SudokuSolutionNode> RemoveIfExistsElsewhere(IEnumerable <SudokuSolutionNode> a_enum, SudokuSolutionNode a_node) { List <SudokuSolutionNode> list = new List <SudokuSolutionNode>(a_enum); foreach (SudokuSolutionNode node in a_node.Root.GetAllNodesEnumerator()) { for (int i = list.Count - 1; i >= 0; i--) { if (list[i].Equals(node)) { if (!Object.ReferenceEquals(list[i], node)) { list.RemoveAt(i); } } } if (list.Count == 0) { break; } } return(list); }
public void Test_Solution_Tress_Verificator() { ProgressIndicator pi = new ProgressIndicator(System.Reflection.MethodBase.GetCurrentMethod().Name); FileInfo[] files = new DirectoryInfo(Directories.SolutionTrees).GetFiles(FileExtensions.XmlZipMask); string dir_diff = Directories.SolutionTrees + Path.DirectorySeparatorChar + "Verification_Failed"; new DirectoryInfo(dir_diff).CreateOrEmpty(); bool ok = true; ConcurrentCounter counter = new ConcurrentCounter(); int index = 0; Parallel.ForEach(files, (file) => { counter.Increment(); pi.AddLine((counter.Value * 100 / files.Length).ToString()); SudokuSolutionNode node = SudokuSolutionNode.LoadFromFile(file.FullName); foreach (SudokuSolutionNode n in node.GetAllNodesEnumerator()) { if (n.State == SudokuSolutionNodeState.Solution) { SudokuVerificator verificator = new SudokuVerificator(n.Board); foreach (SudokuNumber number in n.Solution.Removed) { bool b = verificator.IsImpossible(number.Col, number.Row, number.Number - 1); if (!b) { ok = false; string diff_file = String.Format( "{0}{1}{2}_index_{3}_sol_type_{4}_coords_{5}_number_{6}{7}", dir_diff, Path.DirectorySeparatorChar, Path.GetFileNameWithoutExtension(Path.GetFileNameWithoutExtension(file.FullName)), index, n.Solution.Type, number.Coords, number.Number, FileExtensions.XmlZipExt); new SudokuIntermediateSolution(n.Parent.Board, n.Board, n.Solution).SaveToFile(diff_file); index++; } } } } }); Assert.IsTrue(ok); }
public bool IsImpossible(int a_col, int a_row, int a_number_index) { SudokuBoard board = new SudokuBoard(m_board); board[a_col, a_row][a_number_index].State = SudokuNumberState.sudokucellstateSolved; SudokuSolutionNode node = SudokuSolutionNode.CreateRoot(board); return(!IsSolvable(node)); }
private TreeNode AddNextNode(TreeNode a_treeNode, SudokuSolutionNode a_solutionNode) { TreeNode node = null; node = GetParentCollection(a_treeNode).Insert(GetParentCollection(a_treeNode).IndexOf(a_treeNode) + 1, a_solutionNode.Info); node.Tag = a_solutionNode; ColorNode(node); return(node); }
public TreeNode SolutionNodeToTreeNode(SudokuSolutionNode a_node) { foreach (var node in Nodes.Cast <TreeNode>()) { if (TreeNodeToSolutionNode(node).Equals(a_node)) { return(node); } } return(null); }
private void ColorNode(TreeNode a_node) { SudokuSolutionNode node = TreeNodeToSolutionNode(a_node); if (node.State == SudokuSolutionNodeState.Solution) { if ((node.Solution.Type != SudokuSolutionType.MarkImpossibles) && (node.Solution.Type != SudokuSolutionType.MarkSolved) && (node.Solution.Type != SudokuSolutionType.SinglesInUnit)) { a_node.BackColor = Color.LightBlue; } } }
public void Step(SudokuSolutionNode a_node) { if (a_node == null) { a_node = SelectedSolutionNode.Step(); if (a_node == null) { return; } } a_node.Parent.RemoveNodes(a_node); UpdateTree(a_node.Root, a_node); }
public void Test_Unsolvable() { FileInfo[] files = new DirectoryInfo(Directories.TestExamples + Path.DirectorySeparatorChar + "Unsolvable").GetFiles(FileExtensions.XmlZipMask); foreach (FileInfo file in files) { SudokuBoard board = SudokuBoard.LoadFromFile(file.FullName); Assert.IsNotNull(board, file.FullName); SudokuSolutionNode root_node = SudokuSolutionNode.CreateRoot(board); SudokuSolutionNode node = root_node.Solve(); Assert.IsTrue(!node.Board.IsSolvable, file.Name); } }
public void Test_Examples_Solvable() { SudokuOptions.Current.ShowAllSolutions = false; SudokuOptions.Current.IncludeBoxes = true; ProgressIndicator pi = new ProgressIndicator(System.Reflection.MethodBase.GetCurrentMethod().Name); FileInfo[] files = new DirectoryInfo(Directories.Examples).GetFiles(FileExtensions.XmlZipMask); ConcurrentBag <string> unsolvable = new ConcurrentBag <string>(); ConcurrentCounter counter = new ConcurrentCounter(); Parallel.ForEach(files, (file) => { SudokuBoard board = SudokuBoard.LoadFromFile(file.FullName); Assert.IsNotNull(board, file.FullName); counter.Increment(); pi.AddLine((counter.Value * 100 / files.Length).ToString()); for (int i = 0; i < 4; i++) { SudokuSolutionNode root_node = SudokuSolutionNode.CreateRoot(board); SudokuSolutionNode node = root_node.Solve(); if (!node.Board.IsSolved) { unsolvable.Add("unsolvable; rotate_" + i + "; " + file.Name); } board = board.Rotate(); } }); if (unsolvable.Count > 0) { foreach (var file in unsolvable) { TestContext.WriteLine(file); } Assert.Fail(); } }
private static void MeasuringAvarageExampleSolvingTime() { System.Console.WriteLine("Measuring average example solving time:"); System.Console.WriteLine(""); FileInfo[] files = new DirectoryInfo(Directories.Examples).GetFiles(FileExtensions.XmlZipMask); SudokuBoard[] boards = new SudokuBoard[files.Length]; for (int i = 0; i < files.Length; i++) { boards[i] = SudokuBoard.LoadFromFile(files[i].FullName); } System.Diagnostics.Stopwatch stopwatch = new System.Diagnostics.Stopwatch(); stopwatch.Start(); for (int i = 0; i < boards.Length; i++) { System.Console.WriteLine(String.Format("Solving {0} from {1}: {2}", i + 1, boards.Length, files[i].Name)); SudokuSolutionNode node = SudokuSolutionNode.CreateRoot(boards[i]); node = node.Solve(); if (!node.NextBoard.IsSolved) { if (SudokuOptions.Current.IncludeBoxes) { System.Console.WriteLine(("ERROR: Can't solve: " + files[i])); } else { System.Console.WriteLine(("ERROR: Can't solve (recheck with boxes): " + files[i])); } } } stopwatch.Stop(); System.Console.WriteLine(""); System.Console.WriteLine(("Average solving time per sudoku: " + stopwatch.ElapsedMilliseconds / files.Length + " [ms]")); }
private void UpdateNode(SudokuSolutionNode a_node, TreeNode a_treeNode) { if (a_node == null) { return; } a_treeNode = AddNextNode(a_treeNode, a_node); if (a_node.Nodes.Any(n => n.Nodes.Any())) { a_node = a_node.Nodes.First(n => n.Nodes.Any()); } else { a_node = a_node.Nodes.FirstOrDefault(); } UpdateNode(a_node, a_treeNode); }
public void UpdateTree(SudokuSolutionNode a_root, SudokuSolutionNode a_select = null) { Debug.Assert(a_root.Parent == null); BeginUpdate(); Nodes.Clear(); UpdateNode(a_root, null); EndUpdate(); if ((a_select != null) && (SolutionNodeToTreeNode(a_select) != null)) { SelectedNode = SolutionNodeToTreeNode(a_select); } else { SelectedNode = Nodes.Cast <TreeNode>().Last(); } }
public void Solve(SudokuSolution a_solution = null) { if (a_solution == null) { a_solution = SelectedSolutionNode.Nodes.First().Solution; } SudokuSolutionNode solution_node = TreeNodeToSolutionNode(SelectedNode); solution_node = solution_node.Nodes.FirstOrDefault(n => Object.ReferenceEquals(n.Solution, a_solution)); if (solution_node != null) { solution_node.Parent.RemoveNodes(solution_node); } solution_node.Solve(); UpdateTree(solution_node.Root); }
public void Test_Examples_Unsolvable() { SudokuOptions.Current.ShowAllSolutions = false; SudokuOptions.Current.IncludeBoxes = true; FileInfo[] files = new DirectoryInfo(Directories.Examples + Path.DirectorySeparatorChar + "Unsolvable").GetFiles(FileExtensions.XmlZipMask); ProgressIndicator pi = new ProgressIndicator(System.Reflection.MethodBase.GetCurrentMethod().Name); ConcurrentBag <string> solvable = new ConcurrentBag <string>(); ConcurrentCounter counter = new ConcurrentCounter(); Parallel.ForEach(files, (file) => { counter.Increment(); pi.AddLine((counter.Value * 100 / files.Length).ToString()); SudokuBoard board = SudokuBoard.LoadFromFile(file.FullName); Assert.IsNotNull(board, file.FullName); SudokuSolutionNode root_node = SudokuSolutionNode.CreateRoot(board); SudokuSolutionNode node = root_node.Solve(); if (node.Board.IsSolved) { solvable.Add("solvable; " + file.FullName); } }); if (solvable.Count != 0) { foreach (var line in solvable) { TestContext.WriteLine(line); } Assert.Fail(); } }
public void Test_Solutions_Quantity() { SudokuOptions.Current.ShowAllSolutions = false; SudokuOptions.Current.IncludeBoxes = true; ProgressIndicator pi = new ProgressIndicator(System.Reflection.MethodBase.GetCurrentMethod().Name); FileInfo[] files = new DirectoryInfo(Directories.Solutions).GetFiles(FileExtensions.XmlZipMask); var solutions = (from file in files.AsParallel() select new { intermediate_solution = SudokuIntermediateSolution.LoadFromFile(file.FullName), fileName = file.FullName, }).ToArray(); solutions.ForEach(example => Assert.IsNotNull(example.intermediate_solution, example.fileName)); var solutions_gr = (from obj in solutions group obj by obj.intermediate_solution.Solution.Type into gr select(from obj in gr orderby obj.fileName select obj).ToArray()).ToArray(); ConcurrentBag <string> bad_quantities = new ConcurrentBag <string>(); Parallel.ForEach(solutions_gr, (solution_gr) => { pi.AddLine((solutions_gr.IndexOf(solution_gr) * 100 / solutions_gr.Count()).ToString()); if (new[] { SudokuSolutionType.XWing, SudokuSolutionType.JellyFish, SudokuSolutionType.SwordFish }.Contains( solution_gr.First().intermediate_solution.Solution.Type)) { if (solution_gr.Count() < 20) { bad_quantities.Add(solution_gr.First().intermediate_solution.Solution.Type + " - less then 20"); } else if (solution_gr.Count() > 20) { bad_quantities.Add(solution_gr.First().intermediate_solution.Solution.Type + " - more then 20"); } else { SudokuOptions.Current.IncludeBoxes = false; var gr1 = (from obj in solution_gr.Take(10) select obj.intermediate_solution.Solution).ToList(); int c1 = SudokuSolutionNode.FilterByOptions(gr1).Count(); if (c1 == 0) { bad_quantities.Add(solution_gr.First().intermediate_solution.Solution.Type + " - solutions from 1 to 10 doesn't contains any boxes"); } if (c1 == 10) { bad_quantities.Add(solution_gr.First().intermediate_solution.Solution.Type + " - solutions from 1 to 10 all contains boxes"); } SudokuOptions.Current.IncludeBoxes = false; var gr2 = (from obj in solution_gr.Skip(10).Take(10) select obj.intermediate_solution.Solution).ToList(); int c2 = SudokuSolutionNode.FilterByOptions(gr2).Count(); if (c2 != 10) { bad_quantities.Add(solution_gr.First().intermediate_solution.Solution.Type + " - solutions from 11 to 20 some contains boxes"); } } } else { if (solution_gr.Count() < 10) { bad_quantities.Add(solution_gr.First().intermediate_solution.Solution.Type + " - less then 10"); } if (solution_gr.Count() > 10) { bad_quantities.Add(solution_gr.First().intermediate_solution.Solution.Type + " - more then 10"); } } }); if (solutions_gr.Count() != Enum.GetValues(typeof(SudokuSolutionType)).Length) { bad_quantities.Add("Not all algorithms was tested"); } if (bad_quantities.Count != 0) { foreach (var line in bad_quantities) { TestContext.WriteLine(line); } } }
public void Test_Solution_Trees_vs_Examples() { ProgressIndicator pi = new ProgressIndicator(System.Reflection.MethodBase.GetCurrentMethod().Name); FileInfo[] files1 = new DirectoryInfo(Directories.Examples).GetFiles(FileExtensions.XmlZipMask); FileInfo[] files2 = new DirectoryInfo(Directories.SolutionTrees).GetFiles(FileExtensions.XmlZipMask); var not_all = (from file1 in files1 where files2.Count(fi => Directories.ConvertName(fi.FullName) == file1.Name) < 4 select file1).ToArray(); var too_much = (from file2 in files2 where files1.All(fi => fi.Name != Directories.ConvertName(file2.Name)) select file2).ToArray(); if (not_all.Count() > 0) { Assert.Fail("Is in 'Examples', but not in 'SolutionTrees' (run project 'SudokuGenerator'): " + not_all.First().FullName); } if (too_much.Count() > 0) { Assert.Fail("Is in 'SolutionTrees', but not in 'Examples': " + too_much.First().FullName); } string dir3 = Directories.SolutionTrees + Path.DirectorySeparatorChar + "Diffrencies"; new DirectoryInfo(dir3).CreateOrEmpty(); string dir4 = Directories.SolutionTrees + Path.DirectorySeparatorChar + "Diffrencies" + Path.DirectorySeparatorChar + "Added"; new DirectoryInfo(dir4).CreateOrEmpty(); string dir5 = Directories.SolutionTrees + Path.DirectorySeparatorChar + "Diffrencies" + Path.DirectorySeparatorChar + "Removed"; new DirectoryInfo(dir5).CreateOrEmpty(); bool b = false; ConcurrentBag <string> list = new ConcurrentBag <string>(); ConcurrentCounter counter = new ConcurrentCounter(); Parallel.ForEach(files2, (file2, state) => { counter.Increment(); pi.AddLine((counter.Value * 100 / files2.Length).ToString()); SudokuSolutionNode node2 = SudokuSolutionNode.LoadFromFile(file2.FullName); SudokuBoard board = SudokuBoard.LoadFromFile(files1.First(f => f.Name == Directories.ConvertName(file2.FullName)).FullName); board = board.Rotate(ExtractRotateNumber(file2.Name)); SudokuSolutionNode node1 = SudokuSolutionNode.CreateRoot(board); node1.SolveWithStepAll(); Assert.AreEqual(node1.State, node2.State, file2.FullName); Assert.AreEqual(node1.Board, node2.Board, file2.FullName); Assert.AreEqual(node1.Solution, node2.Solution, file2.FullName); b |= CompareNodes(node1, node2, file2, list, 1, 1); }); if (list.Count != 0) { string filename = dir3 + Path.DirectorySeparatorChar + "!Diffrencies.txt"; using (FileStream fs = new FileStream(filename, FileMode.Create)) { StreamWriter sw = new StreamWriter(fs); list.ForEach(s => sw.WriteLine(s)); sw.Flush(); } TestContext.AddResultFile(filename); } Assert.IsFalse(b); }
public EditAction(SolutionsTree a_tree, SudokuSolutionNode a_selected, bool a_edit, Action <bool> a_edit_func) : base(a_tree, a_selected) { m_edit = a_edit; m_edit_func = a_edit_func; }
public RotateAction(SolutionsTree a_tree, SolutionsCheckedListBox a_list, SudokuSolutionNode a_selected) : base(a_tree, a_selected) { m_list = a_list; }
public SolveAction(SolutionsTree a_tree, SudokuSolutionNode a_selected) : base(a_tree, a_selected) { }
public void InitTree(SudokuBoard a_board) { UpdateTree(SudokuSolutionNode.CreateRoot(a_board)); }
private bool CompareNodes(SudokuSolutionNode a_node, SudokuSolutionNode a_expected_node, FileInfo a_fileInfo, ConcurrentBag <string> a_list, int add_counter, int remove_counter) { bool b1 = false; IEnumerable <SudokuSolutionNode> solutions_added = null; IEnumerable <SudokuSolutionNode> solutions_removed = null; if (!a_node.Nodes.Exact(a_expected_node.Nodes)) { solutions_added = a_node.Nodes.Substract(a_expected_node.Nodes); solutions_removed = a_expected_node.Nodes.Substract(a_node.Nodes); if (solutions_removed.Count() > 0) { solutions_removed = RemoveIfExistsElsewhere(solutions_removed, a_node.Root); } else { solutions_removed = null; } if (solutions_added.Count() > 0) { solutions_added = RemoveIfExistsElsewhere(solutions_added, a_node.Root); } else { solutions_added = null; } } if (solutions_added != null) { foreach (var added in solutions_added) { if (added.Solution != null) { string dir = a_fileInfo.DirectoryName + Path.DirectorySeparatorChar + "Diffrencies" + Path.DirectorySeparatorChar + "Added"; SudokuIntermediateSolution intermediate_solution = new SudokuIntermediateSolution(added.Board, added.NextBoard, added.Solution); intermediate_solution.SaveToFile(dir + Path.DirectorySeparatorChar + Path.GetFileNameWithoutExtension(Path.GetFileNameWithoutExtension(a_fileInfo.FullName)) + "_added_" + add_counter + FileExtensions.XmlZipExt); a_list.Add(Path.GetFileNameWithoutExtension(Path.GetFileNameWithoutExtension(a_fileInfo.FullName)) + "_added_" + add_counter + ": " + intermediate_solution.Solution.ToString()); add_counter++; b1 = true; } } } if (solutions_removed != null) { foreach (var removed in solutions_removed) { if (removed.Solution != null) { string dir = a_fileInfo.DirectoryName + Path.DirectorySeparatorChar + "Diffrencies" + Path.DirectorySeparatorChar + "Removed"; SudokuIntermediateSolution intermediate_solution = new SudokuIntermediateSolution(removed.Board, removed.NextBoard, removed.Solution); intermediate_solution.SaveToFile(dir + Path.DirectorySeparatorChar + Path.GetFileNameWithoutExtension(Path.DirectorySeparatorChar + Path.GetFileNameWithoutExtension(a_fileInfo.FullName)) + "_removed_" + remove_counter + FileExtensions.XmlZipExt); a_list.Add(Path.GetFileNameWithoutExtension( Path.GetFileNameWithoutExtension(a_fileInfo.FullName)) + "_removed_" + remove_counter + ": " + intermediate_solution.Solution.ToString()); remove_counter++; b1 = true; } } } var node_next = ((a_node != null) && a_node.Nodes.Any()) ? a_node.Nodes.First() : null; var expected_next = ((a_expected_node != null) && a_expected_node.Nodes.Any()) ? a_expected_node.Nodes.First() : null; if ((node_next == null) || (expected_next == null)) { return(b1); } if (!node_next.Solution.Equals(expected_next.Solution)) { var next = a_node.Nodes.FirstOrDefault(n => n.Solution.Equals(expected_next.Solution)); if (next == null) { next = a_expected_node.Nodes.FirstOrDefault(n => n.Solution.Equals(node_next.Solution)); if (next != null) { expected_next = next; expected_next.SolveWithStepAll(); } else { return(b1); } } else { node_next = next; node_next.SolveWithStepAll(); } } if (node_next.Nodes.Any()) { node_next = node_next.Nodes.First(); } else { return(b1); } if (expected_next.Nodes.Any()) { expected_next = expected_next.Nodes.First(); } else { return(b1); } bool b2 = CompareNodes(node_next, expected_next, a_fileInfo, a_list, add_counter, remove_counter); return(b1 | b2); }
public void Test_Solution_Trees_Consolidate() { SudokuOptions.Current.ShowAllSolutions = false; ProgressIndicator pi = new ProgressIndicator(System.Reflection.MethodBase.GetCurrentMethod().Name); FileInfo[] files = new DirectoryInfo(Directories.SolutionTrees).GetFiles(FileExtensions.XmlZipMask); string dir = Directories.SolutionTrees + Path.DirectorySeparatorChar + "Consolidate"; new DirectoryInfo(dir).CreateOrEmpty(); int index = 0; ConcurrentCounter counter = new ConcurrentCounter(); Parallel.ForEach(files, (file) => { counter.Increment(); pi.AddLine((counter.Value * 100 / files.Length).ToString()); SudokuSolutionNode root = SudokuSolutionNode.LoadFromFile(file.FullName); foreach (SudokuSolutionNode node in root.GetAllNodesEnumerator()) { if (node.State != SudokuSolutionNodeState.State) { continue; } var filtered_sols = SudokuSolutionNode.FilterByOptions(node.Nodes.Select(n => n.Solution).ToList()); var filtered_nodes = (from n in node.Nodes where filtered_sols.Contains(n.Solution) select n).ToList(); var new_includes = (from n1 in filtered_nodes from n2 in filtered_nodes where SudokuSolutionNode.IsInclude(n1.Solution, n2.Solution, false) select new { n1, n2 }).ToList(); var ignore_pairs = new[] { new [] { SudokuSolutionType.NakedPair, SudokuSolutionType.BoxLineReduction }, new [] { SudokuSolutionType.NakedPair, SudokuSolutionType.PointingPair }, new [] { SudokuSolutionType.NakedPair, SudokuSolutionType.NakedTriple }, new [] { SudokuSolutionType.NakedPair, SudokuSolutionType.NakedQuad }, new [] { SudokuSolutionType.NakedTriple, SudokuSolutionType.BoxLineReduction }, new [] { SudokuSolutionType.NakedTriple, SudokuSolutionType.NakedQuad }, new [] { SudokuSolutionType.NakedTriple, SudokuSolutionType.PointingPair }, new [] { SudokuSolutionType.NakedTriple, SudokuSolutionType.PointingTriple }, new [] { SudokuSolutionType.NakedQuad, SudokuSolutionType.PointingPair }, new [] { SudokuSolutionType.HiddenPair, SudokuSolutionType.HiddenTriple }, new [] { SudokuSolutionType.HiddenPair, SudokuSolutionType.HiddenQuad }, new [] { SudokuSolutionType.HiddenTriple, SudokuSolutionType.HiddenQuad }, }; var ignore = from pair in new_includes from ignore_pair in ignore_pairs where (((pair.n1.Solution.Type == ignore_pair.First()) && (pair.n2.Solution.Type == ignore_pair.Last())) || ((pair.n1.Solution.Type == ignore_pair.Last()) && (pair.n2.Solution.Type == ignore_pair.First()))) select pair; new_includes = new_includes.Except(ignore).ToList(); var doubles = from p1 in new_includes from p2 in new_includes where (p1.n1 == p2.n2) && (p1.n2 == p2.n1) select p1; new_includes = new_includes.Except(doubles).ToList(); foreach (var pair in new_includes) { SudokuIntermediateSolution intermediate_solution_1 = new SudokuIntermediateSolution(pair.n1.Board, pair.n1.NextBoard, pair.n1.Solution); intermediate_solution_1.SaveToFile(dir + Path.DirectorySeparatorChar + index + "_" + Path.GetFileNameWithoutExtension(Path.GetFileNameWithoutExtension(file.FullName)) + "_" + pair.n1.Solution.Type + FileExtensions.XmlZipExt); SudokuIntermediateSolution intermediate_solution_2 = new SudokuIntermediateSolution(pair.n2.Board, pair.n2.NextBoard, pair.n2.Solution); intermediate_solution_2.SaveToFile(dir + Path.DirectorySeparatorChar + index + "_" + Path.GetFileNameWithoutExtension(Path.GetFileNameWithoutExtension(file.FullName)) + "_" + pair.n2.Solution.Type + FileExtensions.XmlZipExt); index++; } } }); Assert.IsTrue(index == 0); }
private static void GenerateAllSolutions(GenerationMethod a_method) { System.Console.WriteLine(); System.Console.WriteLine("Generating solutions..."); System.Console.WriteLine(); string dir = Directories.SolutionTrees + Path.DirectorySeparatorChar + "All"; new DirectoryInfo(dir).CreateOrEmpty(); FileInfo[] files1 = new DirectoryInfo(Directories.Examples).GetFiles(FileExtensions.XmlZipMask); FileInfo[] files2 = new DirectoryInfo(Directories.SolutionTrees).GetFiles(FileExtensions.XmlZipMask); var not_all = (from file1 in files1 where files2.Count(fi => Directories.ConvertName(fi.FullName) == file1.Name) < 4 select file1).ToArray(); var too_much = (from file2 in files2 where files1.All(fi => fi.Name != Directories.ConvertName(file2.Name)) select file2).ToArray(); if (not_all.Count() > 0) { System.Console.WriteLine("Is in 'Examples', but not in 'SolutionTrees' (run project 'SudokuGenerator'): " + not_all.First().FullName); System.Console.ReadKey(true); return; } if (too_much.Count() > 0) { System.Console.WriteLine("Is in 'SolutionTrees', but not in 'Examples': " + too_much.First().FullName); System.Console.ReadKey(true); return; } FileInfo[] files = (from file in new DirectoryInfo(Directories.SolutionTrees).GetFiles(FileExtensions.XmlZipMask) group file by Directories.ConvertName(file.Name) into gr select gr.First()).ToArray(); ShowProgress(0, 70); ConcurrentCounter counter = new ConcurrentCounter(); Parallel.ForEach(files, (file) => { SudokuSolutionNode root = SudokuSolutionNode.LoadFromFile(file.FullName); string file_name = Path.GetFileNameWithoutExtension(Directories.ConvertName(file.Name)); Dictionary <SudokuSolutionType, int> counters = new Dictionary <SudokuSolutionType, int>(); Dictionary <SudokuSolutionType, List <SudokuSolutionNode> > lists = new Dictionary <SudokuSolutionType, List <SudokuSolutionNode> >(); foreach (var type in Enum.GetValues(typeof(SudokuSolutionType)).Cast <SudokuSolutionType>()) { if (type == SudokuSolutionType.MarkImpossibles) { continue; } if (type == SudokuSolutionType.MarkSolved) { continue; } if (type == SudokuSolutionType.SinglesInUnit) { continue; } new DirectoryInfo(dir + Path.DirectorySeparatorChar + type).CreateOrEmpty(); lists[type] = new List <SudokuSolutionNode>(); counters[type] = 1; } foreach (var list in lists.Values) { list.Clear(); } foreach (SudokuSolutionNode node in root.GetAllNodesEnumerator()) { if (node.State != SudokuSolutionNodeState.State) { continue; } var nodes = (from n in node.Nodes where (n.Solution.Type != SudokuSolutionType.MarkImpossibles) && (n.Solution.Type != SudokuSolutionType.MarkSolved) && (n.Solution.Type != SudokuSolutionType.SinglesInUnit) select n).ToList(); var sols = SudokuSolutionNode.FilterByOptions(nodes.Select(n => n.Solution).ToList()); var nodes_gr = (from n in nodes where sols.Contains(n.Solution) group n by n.Solution.Type into gr select gr.ToList()).ToList(); if ((a_method == GenerationMethod.OneType) || (a_method == GenerationMethod.OneSolution)) { bool one_type = nodes_gr.Count(gr => gr.Any()) == 1; if (!one_type) { continue; } } if (a_method == GenerationMethod.OneSolution) { bool one_solution = nodes_gr.Count(gr => gr.Count == 1) == 1; if (!one_solution) { continue; } } foreach (var n in nodes) { lists[n.Solution.Type].Add(n); } } foreach (var list in lists.Values) { var uniques = from n in list group n by n.Solution into gr select gr.First(); var exclude = from n1 in uniques from n2 in uniques where !Object.ReferenceEquals(n1, n2) && n1.Solution.Removed.Contains(n2.Solution.Removed, Comparators.SudokuNumberRowColComparer.Instance) && n1.Solution.Stayed.Contains(n2.Solution.Stayed, Comparators.SudokuNumberRowColComparer.Instance) && n1.Solution.ColorUnits.Equals(n2.Solution.ColorUnits) select n2; var sols = uniques.Except(exclude); foreach (var n in sols) { SudokuIntermediateSolution intermediate_solution = new SudokuIntermediateSolution(n.Board, n.NextBoard, n.Solution); intermediate_solution.SaveToFile(dir + Path.DirectorySeparatorChar + n.Solution.Type + Path.DirectorySeparatorChar + file_name + " - " + counters[n.Solution.Type]++ + FileExtensions.XmlZipExt); } } counter.Increment(); lock (counter) { ShowProgress(counter.Value * 70 / files.Length, 70); } }); }
private static void MeasuringAverageAlgorithmSolvingTime() { const int REPEATS = 2; System.Console.WriteLine("Measuring average algorithm solving time:"); System.Console.WriteLine(""); FileInfo[] files = new DirectoryInfo(Directories.Solutions).GetFiles(FileExtensions.XmlZipMask); var solutions1 = from file in files.AsParallel() select new { intermediate_solution = SudokuIntermediateSolution.LoadFromFile(file.FullName), fileName = file.FullName }; var solutions2 = (from solution in solutions1 group solution by solution.intermediate_solution.Solution.Type into g select(from obj in g orderby obj.fileName select obj).ToArray()).ToArray(); foreach (var sols_gr in solutions2) { var sols = SudokuSolutionNode.FilterByOptions(sols_gr.Select(gr => gr.intermediate_solution.Solution).ToList()); if (sols_gr.Length == 20) { if (SudokuOptions.Current.IncludeBoxes) { sols = sols.Take(10).ToList(); } else { sols = sols.Skip(10).Take(10).ToList(); } } var sols_gr2 = (from gr in sols_gr where sols.Contains(gr.intermediate_solution.Solution) select gr).ToList(); System.Diagnostics.Stopwatch stopwatch = new System.Diagnostics.Stopwatch(); stopwatch.Start(); foreach (var solution in sols_gr2) { SudokuIntermediateSolution intermediate_solution = solution.intermediate_solution; bool bError = false; for (int i = 0; i < REPEATS; i++) { for (int j = 0; j < 4; j++) { if (!intermediate_solution.Test(false)) { bError = true; } intermediate_solution = intermediate_solution.Rotate(); } } if (bError) { System.Console.WriteLine("Can't solve: {0}", solution.fileName); } } stopwatch.Stop(); double time = stopwatch.ElapsedMilliseconds * 1.0 / sols_gr.Length / REPEATS / 4; s_algorithmToTime[sols_gr.First().intermediate_solution.Solution.Type] = time; System.Console.WriteLine("{0} ({1}): {2} [ms]", sols_gr.First().intermediate_solution.Solution.Type, sols_gr.Length, time.ToString("G4")); } }