public static SudokuPlayer Create(Definition.Sudoku originSudoku, Definition.Sudoku playingSudoku)
{
if (playingSudoku == null)
{
throw new ArgumentNullException("playingSudoku");
}
return((SudokuPlayer)app.Dispatcher.Invoke((Func <SudokuPlayer>) delegate
{
return new SudokuPlayer(originSudoku, playingSudoku);
}));
}
public SudokuSolverPartternBase(Definition.Sudoku sudoku)
{
if (sudoku == null)
{
throw new ArgumentNullException("sudoku");
}
this.sudoku = sudoku;
this.observers = registerObservers(sudoku).ToArray();
this.validator = new SudokuValidator(sudoku);
this.name = this.GetType().Name;
}
public SudokuSolver(Definition.Sudoku sudoku)
{
if (sudoku == null)
{
throw new ArgumentNullException("sudoku");
}
if (!sudoku.Validate())
{
throw new ArgumentException("Invalid Sudoku. Duplicated element found");
}
this.sudoku = sudoku;
this.completionState = new Observers.CompletionStateObserver(sudoku);
}
public bool Build(Definition.Sudoku sudoku)
{
if (sudoku == null)
{
throw new ArgumentNullException("sudoku");
}
//Console.WriteLine("Grid 1, 5, 9");
fullRandomGrid(sudoku.Grid1, elementsInOrder.OrderBy(item => rnd.Next()));
fullRandomGrid(sudoku.Grid5, elementsInOrder.OrderBy(item => rnd.Next()));
fullRandomGrid(sudoku.Grid9, elementsInOrder.OrderBy(item => rnd.Next()));
//Console.WriteLine("Grid 3");
if (!randomGrid3(sudoku.Grid1, sudoku.Grid3, sudoku.Grid9))
{
return(false);
}
//Console.WriteLine("Grid 7");
if (!randomGrid7(sudoku.Grid1, sudoku.Grid7, sudoku.Grid9))
{
return(false);
}
//Console.WriteLine("Grid 2");
if (!randomGrid2(sudoku.Grid1, sudoku.Grid2, sudoku.Grid3, sudoku.Grid5))
{
return(false);
}
//Console.WriteLine("Grid 4");
if (!randomGrid4(sudoku.Grid1, sudoku.Grid4, sudoku.Grid5, sudoku.Grid7))
{
return(false);
}
//Console.WriteLine("Grid 6");
if (!randomGrid6(sudoku.Grid3, sudoku.Grid4, sudoku.Grid5, sudoku.Grid6, sudoku.Grid9))
{
return(false);
}
//Console.WriteLine("Grid 8");
if (!randomGrid8(sudoku.Grid2, sudoku.Grid5, sudoku.Grid7, sudoku.Grid8, sudoku.Grid9))
{
return(false);
}
return(true);
}
protected override IEnumerable <Observers.ObserverBase> registerObservers(Definition.Sudoku sudoku)
{
foreach (var lineObserver in sudoku.Rows.Concat(sudoku.Columns)
.Select(item => new Observers.LineObserver(item, Observers.SeatMode.Two)))
{
if (lineObserver.IsIdle)
{
lineObserver.Dispose();
}
else
{
lineObserver.Updated += onLineUpdated;
yield return(lineObserver);
}
}
}
protected override IEnumerable <Observers.ObserverBase> registerObservers(Definition.Sudoku sudoku)
{
foreach (var gridLineObserver in new GridEnumerable(sudoku)
.Select(item => new Observers.GridObserver(item, Observers.SeatMode.All)))
{
if (gridLineObserver.IsIdle)
{
gridLineObserver.Dispose();
}
else
{
gridLineObserver.Updated += onGridUpdated;
yield return(gridLineObserver);
}
}
}
public void InvalidSudoku()
{
var sudoku = new Definition.Sudoku();
foreach (var grid in sudoku.Grids)
{
for (int i = 0; i < 3; i++)
{
for (int j = 1; j <= 3; j++)
{
grid.Rows[i].Elements[j - 1].SetValue(3 * i + j);
}
}
}
Assert.IsFalse(sudoku.Validate());
}
private bool trySolveInBranch(out Definition.Sudoku completedSudoku)
{
foreach (var branchSolver in new Branch.SudokuSolveBranch(sudoku))
{
using (branchSolver)
{
if (branchSolver.TrySolve())
{
completedSudoku = branchSolver.sudoku;
return(true);
}
}
}
completedSudoku = null;
return(false);
}
public SudokuValueSyncBase(Definition.Sudoku defSudoku, Model.Sudoku sudoku)
{
if (defSudoku == null)
{
throw new ArgumentNullException("defSudoku");
}
if (sudoku == null)
{
throw new ArgumentNullException("sudoku");
}
this.defSudoku = defSudoku;
this.sudoku = sudoku;
foreach (var grid in defSudoku.Grids)
{
foreach (var element in grid.Elements)
{
element.ValueChanged += onElementValueChanged;
}
}
}
public CompletionStateObserver(Definition.Sudoku sudoku)
{
if (sudoku == null)
{
throw new ArgumentNullException("sudoku");
}
this.sudoku = sudoku;
foreach (var gridObserver in sudoku.Grids
.Select(item => new GridObserver(item, SeatMode.All)))
{
if (gridObserver.IsIdle)
{
gridObserver.Dispose();
this.completedGridCount++;
}
else
{
gridObserver.Updated += onGridUpdated;
this.gridObservers.Add(gridObserver);
}
}
}
public Definition.Sudoku Build(DifficultLevel difficultLevel)
{
if (difficultLevel == null)
{
throw new ArgumentNullException("difficultLevel");
}
Console.WriteLine("Difficulty: {0}", difficultLevel.Difficulty);
int level = difficultLevel.Level;
Definition.Sudoku targetSudoku = this.source.Copy();
int seatsCount = 0;
for (int i = 0; i < level; i++)
{
while (true)
{
var element = GetNextElement(targetSudoku);
if (element.HasValue)
{
element.ClearValue();
seatsCount++;
break;
}
}
}
if (seatsCount != level)
{
throw new Exception(
string.Format("Expected:\t{0} seats\r\nActually:\t{1} seats", level, seatsCount));
}
return(targetSudoku);
}
private IEnumerable <SudokuSolver> BranchSolverIterator(Definition.Sudoku sudoku)
{
int seatCount = -1;
IEnumerable <Definition.Element> branchBasedElements = null;
for (int i = 2; i <= SEAT_UPPER_BOUND; i++)
{
if (tryFindBranchBasedElements(sudoku, i, out branchBasedElements))
{
seatCount = i;
break;
}
}
if (seatCount < 0)
{
yield break;
}
var branchBasedEmptyElements = branchBasedElements.NotValued();
var remainderValues = branchBasedElements
.Values()
.SudokuExcept();
foreach (var values in new HeapFullPermutationEnumerable <int>(remainderValues))
{
var branchSudoku = sudoku.Copy();
var branchElements = branchBasedEmptyElements
.Select(item => branchSudoku.Grids[item.GridIndex].Elements[item.Index]);
using (var validator = new SudokuValidator(branchSudoku))
{
using (var valueIterator = values.GetEnumerator())
using (var elementIterator = branchElements.GetEnumerator())
{
while (valueIterator.MoveNext() && elementIterator.MoveNext())
{
var currentElement = elementIterator.Current;
var currentValue = valueIterator.Current;
//var fillingLog = string.Format("{0, -30}: ({1}, {2}) - {3}",
// "new branch",
// currentElement.GridIndex + 1,
// currentElement.Index + 1,
// currentValue);
currentElement.SetValue(currentValue);
if (validator.HasFailed)
{
break;
}
//else
// Console.WriteLine(fillingLog);
}
}
if (!validator.HasFailed)
{
yield return(new SudokuSolver(branchSudoku));
}
}
}
}
public TwoSeatsInLine(Definition.Sudoku sudoku)
: base(sudoku)
{
}
public AnySeatInGridLineType2(Definition.Sudoku sudoku)
: base(sudoku)
{
}
protected abstract IEnumerable <Observers.ObserverBase> registerObservers(Definition.Sudoku sudoku);
public SudokuStepSync(Definition.Sudoku defSudoku, Model.Sudoku sudoku)
: base(defSudoku, sudoku)
{
}
public OneSeatInNine(Definition.Sudoku sudoku)
: base(sudoku)
{
}
public SudokuPlayerController(Definition.Sudoku originSudoku, Definition.Sudoku playingSudoku)
{
this.window = SudokuPlayer.Create(originSudoku, playingSudoku);
}
protected override IEnumerable <Observers.ObserverBase> registerObservers(Definition.Sudoku sudoku)
{
//not observer in this parttern
yield break;
}
public bool TrySolve()
{
var sudoku = this.sudoku;
var completionState = this.completionState;
if (completionState.IsCompleted) //the sudoku might be already completed
{
return(true);
}
int lastSeatsRemainder = completionState.SeatsRemainder();
while (true)
{
using (var oneSeatInNineParttern = new Pattern.OneSeatInNine(sudoku))
using (var oneSeatInGridLinePattern = new Pattern.OneSeatInGridLine(sudoku))
using (var oneSearInGridLinePattern2 = new Pattern.OneSeatInGridLineType2(sudoku))
//using (var anySeatInGridLinePattern = new Pattern.AnySeatInGridLine(sudoku))
using (var twoSeatsInLinePattern = new Pattern.TwoSeatsInLine(sudoku))
using (var anySeatInGridLinePattern2 = new Pattern.AnySeatInGridLineType2(sudoku))
{
var patterns = new Pattern.SudokuSolverPartternBase[]
{
oneSeatInNineParttern,
oneSeatInGridLinePattern,
oneSearInGridLinePattern2,
//anySeatInGridLinePattern,
twoSeatsInLinePattern,
anySeatInGridLinePattern2
};
foreach (var pattern in patterns.OrderBy(item => item.Index))
{
pattern.Fill();
if (pattern.HasFailed)
{
return(false);
}
if (completionState.IsCompleted)
{
return(true);
}
}
}
int currentSeatsRemainder = completionState.SeatsRemainder();
if (currentSeatsRemainder != lastSeatsRemainder)
{
lastSeatsRemainder = currentSeatsRemainder;
}
else
{
break;
}
}
//still not solved, use branch
Definition.Sudoku completedSudoku = null;
if (trySolveInBranch(out completedSudoku))
{
sudoku.UpdateByValued(completedSudoku);
return(true);
}
return(false);
}
