private void Fetch(uint value, SimpleList <int> intersection, SudokuRegion intersected, SudokuState state, ICollection <IEvent> events)
{
IEvent result = NoReduction.Instance;
var mask = ~value;
foreach (var index in intersected)
{
// items in the shared section should be skipped.
if (intersection.Contains(index))
{
continue;
}
var test = state.And <ReducePointingPairs>(index, mask);
if (test is ValueFound)
{
events.Add(test);
}
else if (test is ReducedOption)
{
result = test;
}
}
if (result is ReducedOption)
{
events.Add(ReducedOptions.Ctor <ReduceNakedPairs>());
}
}
private void Fetch(uint quad, SimpleList <int> buffer, SudokuRegion region, SudokuState state, ICollection <IEvent> events)
{
var reduced = false;
var mask = ~quad;
foreach (var index in region)
{
if (buffer.Contains(index))
{
continue;
}
var result = state.And <ReduceNakedTriples>(index, mask);
if (result is ValueFound)
{
events.Add(result);
}
else if (result is ReducedOption)
{
reduced = true;
}
}
if (reduced)
{
events.Add(ReducedOptions.Ctor <ReduceNakedTriples>());
}
}
private void Fetch(uint nakedPair, SudokuRegion region, SudokuState state, ICollection <IEvent> events)
{
IEvent result = NoReduction.Instance;
var mask = ~nakedPair;
foreach (var index in region)
{
var value = state[index];
if (value != nakedPair)
{
var test = state.And <ReduceNakedPairs>(index, mask);
if (test is ValueFound)
{
events.Add(test);
}
else if (test is ReducedOption)
{
result = test;
}
}
}
if (result is ReducedOption)
{
events.Add(ReducedOptions.Ctor <ReduceNakedPairs>());
}
}
public void Solve(uint value, SudokuRegion first, SudokuRegion second, SudokuRegionType otherType, SudokuState state, ICollection <IEvent> events)
{
buffer.Clear();
for (var index = 0; index < 9; index++)
{
var indexFirst = first[index];
var indexSecond = second[index];
var joinFirst = state[indexFirst] & value;
var joinSecond = state[indexSecond] & value;
if (joinFirst == 0)
{
if (joinSecond != 0)
{
return;
}
}
else
{
if (joinSecond == 0 || buffer.Count > 3)
{
return;
}
buffer.Add(indexFirst);
buffer.Add(indexSecond);
}
}
if (buffer.Count == 4)
{
var reducded = Fetch(
value,
first.Intersected.FirstOrDefault(r => r.RegionType == otherType),
state,
events);
reducded |= Fetch(
value,
second.Intersected.FirstOrDefault(r => r.RegionType == otherType),
state,
events);
if (reducded)
{
events.Add(ReducedOptions.Ctor <ReduceXWing>());
}
}
}
private void Fetch(uint pair, SimpleList <int> hiddenPairs, SudokuState state, ICollection <IEvent> events)
{
IEvent result = NoReduction.Instance;
foreach (var index in hiddenPairs)
{
var test = state.And <ReduceHiddenPairs>(index, pair);
if (test is ReducedOption)
{
result = test;
}
}
if (result is ReducedOption)
{
events.Add(ReducedOptions.Ctor <ReduceHiddenPairs>());
}
}
/// <inheritdoc />
public void Solve(SudokuPuzzle puzzle, SudokuState state, ICollection <IEvent> events)
{
var reduced = false;
for (var index = 0; index <= puzzle.MaximumIndex; index++)
{
// For known cells only.
if (state.IsKnown(index))
{
var mask = ~state[index];
// for all groups the cell belongs to.
foreach (var group in puzzle.Lookup[index])
{
foreach (var target in group)
{
if (target == index)
{
continue;
}
var result = state.And <ReduceNakedSingles>(target, mask);
if (result is ReducedOption)
{
reduced = true;
}
else if (result is ValueFound)
{
events.Add(result);
}
}
}
}
}
if (reduced)
{
events.Add(ReducedOptions.Ctor <ReduceNakedSingles>());
}
}
