## Summary

Describes a “sandwich” constraint that does not imply uniqueness of all digits. The digits

LittleSandwichConstraint.**Digit1**
and

LittleSandwichConstraint.**Digit2** must occur exactly once each (in any order) and form the edges of the sandwich. The
numbers sandwiched between them must sum up to

LittleSandwichConstraint.**Sum**.

## Remarks

Warning: This constraint is very memory-intensive. It is implemented as a

CombinationsConstraint
with all of the possible number combinations for the specified set of cells. Avoid using this on oversized
puzzles.

## Constructors

**LittleSandwichConstraint**(IEnumerable<int> **affectedCells**, int **sum**, int **digit1** = 1, int **digit2** = 9, int **minValue** = 1, int **maxValue** = 9) |
Constructor. |

## Instance methods

ConstraintResult | | *Refer to the documentation for Constraint.***Process**. |

string | | *Refer to the documentation for object.***ToString**. |

## Static methods

int | |
Converts a convenient coordinate notation into a puzzle-grid index. |

IEnumerable<int> | |
Converts a convenient coordinate notation into puzzle-grid indices. |

## Instance properties

int[] | | The group of cells affected by this constraint, or `null` if it affects all of them. |

bool | |
By default, a constraint is only evaluated once for every digit placed in the grid, but not when another
constraint merely rules out a possibility. Derived types can override this and return `true` to indicate
to the solver that the constraint should be reevaluated (meaning: have Constraint.**Process**(SolverState) called on it
again) when another constraint rules out a value in one of the affected cells of this constraint. |

int | | One of the numbers that form the edges of the sandwich (the other is LittleSandwichConstraint.**Digit2**). |

int | | One of the numbers that form the edges of the sandwich (the other is LittleSandwichConstraint.**Digit1**). |

int? | |
Indicates an approximate number of possible combinations of digits this constraint can still accommodate. This
will help the solver prioritize cells when multiple cells have the same number of combinations individually. |

int | | The total that the sandwiched numbers must sum up to. |