Example #1
0
        public static bool IsInclude(SudokuSolution a_stayed, SudokuSolution a_toremoved, bool a_use_includes_list)
        {
            if (Object.ReferenceEquals(a_stayed, a_toremoved))
            {
                return(false);
            }

            if (a_use_includes_list)
            {
                if (!SudokuSolution.Includes.Any(pair => (a_toremoved.Type == pair.First()) && (a_stayed.Type == pair.Last())))
                {
                    return(false);
                }
            }

            if (a_stayed.Type == a_toremoved.Type)
            {
                if (!a_stayed.ColorUnits.Equals(a_toremoved.ColorUnits))
                {
                    return(false);
                }
            }

            return(a_stayed.Removed.Contains(a_toremoved.Removed) &&
                   a_toremoved.Stayed.Contains(a_stayed.Stayed) &&
                   !a_stayed.Removed.ContainsAny(a_toremoved.Stayed) &&
                   !a_stayed.Stayed.ContainsAny(a_toremoved.Removed));
        }
Example #2
0
 internal void Apply(SudokuSolution a_solution)
 {
     a_solution.Removed.ForEach(num =>
                                m_board[num.Col, num.Row][num.Number - 1].State = SudokuNumberState.sudokucellstateImpossible);
     a_solution.Solved.ForEach(num =>
                               m_board[num.Col, num.Row][num.Number - 1].State = SudokuNumberState.sudokucellstateSolved);
 }
Example #3
0
 internal SudokuSolutionNode(SudokuBoard a_board, SudokuSolutionNodeState a_state, SudokuSolution a_solution = null)
 {
     m_state = a_state;
     m_board = a_board;
     m_board.BoardChanged += num => m_nextBoard = null;
     m_solution            = a_solution;
 }
        public SudokuIntermediateSolution(SudokuBoard a_before, SudokuBoard a_after, SudokuSolution a_solution)
        {
            Debug.Assert(a_before != null);

            m_before   = a_before;
            m_after    = a_after;
            m_solution = a_solution;
        }
Example #5
0
        private static void LoadNodesFromXML(XElement a_element, SudokuSolutionNode a_parent)
        {
            a_element.Element("solution_nodes").Elements().ForEach(child_element =>
            {
                SudokuBoard board             = SudokuBoard.LoadFromXML(child_element.Element("board"));
                SudokuSolutionNode child_node = a_parent.AddNode(
                    board,
                    (SudokuSolutionNodeState)Enum.Parse(typeof(SudokuSolutionNodeState), child_element.Attribute("state").Value),
                    SudokuSolution.LoadFromXML(child_element.Element("solution"), board)
                    );

                LoadNodesFromXML(child_element, child_node);
            });
        }
        private static SudokuIntermediateSolution LoadFromXML(XElement a_element)
        {
            try
            {
                SudokuBoard    before   = SudokuBoard.LoadFromXML(a_element.Element("board_before"));
                SudokuBoard    after    = SudokuBoard.LoadFromXML(a_element.Element("board_after"));
                SudokuSolution solution = SudokuSolution.LoadFromXML(a_element.Element("solution"), before);

                SudokuIntermediateSolution intermediate_solution = new SudokuIntermediateSolution(before, after, solution);

                return(intermediate_solution);
            }
            catch
            {
                return(null);
            }
        }
Example #7
0
        public override bool Equals(object a_obj)
        {
            if (a_obj == null)
            {
                return(false);
            }
            if (ReferenceEquals(this, a_obj))
            {
                return(true);
            }
            SudokuSolution solution = a_obj as SudokuSolution;

            if (solution == null)
            {
                return(false);
            }

            return((m_type == solution.m_type) &&
                   m_removed.Exact(solution.m_removed) &&
                   m_solved.Exact(solution.m_solved) &&
                   m_stayed.Exact(solution.m_stayed) &&
                   m_colorUnits.SelectMany().Exact(solution.m_colorUnits.SelectMany()));
        }
Example #8
0
 internal SudokuSolutionNode AddNode(SudokuBoard a_board, SudokuSolutionNodeState a_state, SudokuSolution a_solution)
 {
     return(AddNode(new SudokuSolutionNode(a_board, a_state, a_solution)));
 }
Example #9
0
 public static SudokuSolution Rotate(this SudokuSolution a_sol, SudokuBoard a_board)
 {
     return(new SudokuSolution(a_sol.Type, Rotate(a_sol.Removed, a_board), Rotate(a_sol.Stayed, a_board),
                               Rotate(a_sol.Solved, a_board), from unit in a_sol.ColorUnits
                               select Rotate(unit, a_board)));
 }