added samples; added MRV strategy

sample/00.txt

+462831957
+795426183
+381795426
+173984265
+659312748
+248567319
+926178534
+834259671
+517643890

sample/04.txt

+.......12........3..23..4....18....5.6..7.8.......9.....85.....9...4.5..47...6...

uqac-ia-sudoku-csp/Board.cs

 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using uqac_ia_sudoku_csp.Interfaces;
 
 namespace uqac_ia_sudoku_csp
 {
             return !Game.Any(line => line.Any(cell => cell == null));
         }
 
+        public bool IsConsistent(int x, int y, IList<IConstraint> constraints)
+        {
+            return constraints.All(constraint => constraint.Check(this, x, y));
+        }
+
         public void Print(TextWriter stream)
         {
             stream.WriteLine(Characters);

uqac-ia-sudoku-csp/Interfaces/INextValueChooser.cs

-namespace uqac_ia_sudoku_csp.Interfaces
+using System.Collections.Generic;
+
+namespace uqac_ia_sudoku_csp.Interfaces
 {
     public interface INextValueChooser
     {
-        void SelectVariable(Board board, out int x, out int y);
+        void SelectVariable(Board board, out int x, out int y, IList<IConstraint> constraints);
     }
 }

uqac-ia-sudoku-csp/Program.cs

 using System;
 using uqac_ia_sudoku_csp.Solver;
 using uqac_ia_sudoku_csp.Solver.Generators;
+using uqac_ia_sudoku_csp.Solver.NextValueChoosers;
 
 namespace uqac_ia_sudoku_csp
 {
             var generator = new FileGenerator();
             generator.Generate(board, new FileGeneratorDbo
             {
-                EmptyCharacters = "0 ",
-                FilePath = "../sample/03.txt"
+                EmptyCharacters = "0 .",
+                FilePath = "../sample/04.txt"
             });
             board.Print(Console.Out);
 
-            var solver = new BacktrackSearch();
+            var solver = new BacktrackSearch(new MRVNextValueChooser());
+            var start = DateTime.Now;
             var resolved = solver.Resolve(board);
+            var end = DateTime.Now;
 
             if (resolved.Success)
             {
                 Console.WriteLine("Not resolved");
             }
             Console.WriteLine($"{resolved.TryCount} tries");
+            Console.WriteLine($"{(end - start).TotalMilliseconds} ms");
         }
     }
 }

uqac-ia-sudoku-csp/Solver/BacktrackSearch.cs

-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Linq;
 using uqac_ia_sudoku_csp.Interfaces;
 using uqac_ia_sudoku_csp.Solver.Constraints;
 {
     public class BacktrackSearch : ISolver
     {
+        private readonly INextValueChooser _nextValueChooser;
         protected IList<IConstraint> Constraints;
 
-        public BacktrackSearch()
+        public BacktrackSearch(INextValueChooser nextValueChooser)
         {
+            _nextValueChooser = nextValueChooser;
             Constraints = new List<IConstraint>
             {
                 new LineContraint(),
 
         public SolverResult Resolve(Board board)
         {
+            var domain = Enumerable.Range(0, board.Size).ToList();
             var result = new SolverResult();
-            result.Success = RecursiveResolve(board, result);
+            result.Success = RecursiveResolve(board, result, domain);
             return result;
         }
 
-        protected bool RecursiveResolve(Board board, SolverResult result)
+        protected bool RecursiveResolve(Board board, SolverResult result, IList<int> domain)
         {
             if (board.IsComplete())
             {
                 return true;
             }
             int x, y;
-            SelectVariable(board, out x, out y);
-            foreach (var value in GetDomainValues(board))
+            _nextValueChooser.SelectVariable(board, out x, out y, Constraints);
+            if (x != -1 && y != -1)
             {
-                ++result.TryCount;
-                board.SetNumber(x, y, value);
-                if (IsConsistent(board, x, y))
+                foreach (var value in domain)
                 {
-                    if (RecursiveResolve(board, result))
+                    ++result.TryCount;
+                    board.SetNumber(x, y, value);
+                    if (board.IsConsistent(x, y, Constraints))
                     {
-                        return true;
+                        if (RecursiveResolve(board, result, domain))
+                        {
+                            return true;
+                        }
                     }
                 }
+                board.ClearNumber(x, y);
             }
-            board.ClearNumber(x, y);
             return false;
         }
-
-        protected void SelectVariable(Board board, out int x, out int y)
-        {
-            for (var xx = 0; xx < board.Size; ++xx)
-            {
-                for (var yy = 0; yy < board.Size; ++yy)
-                {
-                    if (board.GetNumber(xx, yy) == null)
-                    {
-                        x = xx;
-                        y = yy;
-                        return;
-                    }
-                }
-            }
-            x = -1;
-            y = -1;
-        }
-
-        protected IEnumerable<int> GetDomainValues(Board board)
-        {
-            return Enumerable.Range(0, board.Size);
-        }
-
-        protected bool IsConsistent(Board board, int x, int y)
-        {
-            return Constraints.All(constraint => constraint.Check(board, x, y));
-        }
     }
 }

uqac-ia-sudoku-csp/Solver/NextValueChoosers/BasicValueChooser.cs

+using System.Collections.Generic;
+using uqac_ia_sudoku_csp.Interfaces;
+
+namespace uqac_ia_sudoku_csp.Solver.NextValueChoosers
+{
+    public class BasicValueChooser : INextValueChooser
+    {
+        public void SelectVariable(Board board, out int x, out int y, IList<IConstraint> constraints)
+        {
+            for (var xx = 0; xx < board.Size; ++xx)
+            {
+                for (var yy = 0; yy < board.Size; ++yy)
+                {
+                    if (board.GetNumber(xx, yy) == null)
+                    {
+                        x = xx;
+                        y = yy;
+                        return;
+                    }
+                }
+            }
+            x = -1;
+            y = -1;
+        }
+    }
+}

uqac-ia-sudoku-csp/Solver/NextValueChoosers/MRVNextValueChooser.cs

+using System.Collections.Generic;
+using uqac_ia_sudoku_csp.Interfaces;
+
+namespace uqac_ia_sudoku_csp.Solver.NextValueChoosers
+{
+    public class MRVNextValueChooser : INextValueChooser
+    {
+        public void SelectVariable(Board board, out int x, out int y, IList<IConstraint> constraints)
+        {
+            var avail = 1;
+            while (avail < board.Size)
+            {
+                for (var xx = 0; xx < board.Size; ++xx)
+                {
+                    for (var yy = 0; yy < board.Size; ++yy)
+                    {
+                        if (board.GetNumber(xx, yy) == null)
+                        {
+                            var remaining = GetRemainingValue(board, xx, yy, constraints);
+                            if (remaining == avail)
+                            {
+                                x = xx;
+                                y = yy;
+                                return;
+                            }
+                        }
+                    }
+                }
+                ++avail;
+            }
+            x = -1;
+            y = -1;
+        }
+
+        protected int GetRemainingValue(Board board, int x, int y, IList<IConstraint> constraints)
+        {
+            var c = 0;
+            for (var i = 0; i < board.Size; ++i)
+            {
+                board.SetNumber(x, y, i);
+                if (board.IsConsistent(x, y, constraints))
+                {
+                    ++c;
+                }
+            }
+            board.ClearNumber(x, y);
+            return c;
+        }
+    }
+}