Beispiel #1
0
        public void Revert_RevertsSpecifiedColumn()
        {
            var puzzle = new PuzzleWithPossibleValues(new int?[][] {
                new int?[] { 1, null /* 4 */, null /* 3 */, 2 },
                new int?[] { null /* 2 */, null /* 3 */, null /* 1 */, 4 },
                new int?[] { null /* 4 */, 1, null /* 2 */, 3 },
                new int?[] { 3, null /* 2 */, null /* 4 */, 1 }
            });
            var rule = new ColumnUniquenessRule();

            Assert.True(rule.TryInit(puzzle, puzzle.UniquePossibleValues));
            IList <BitVector> initialPossibleValuesByColumn = _GetPossibleValuesByColumn(puzzle.Size, rule);
            var updatedCoordTracker = new CoordinateTracker(puzzle.Size);
            var coord = new Coordinate(1, 1);
            int val   = 3;

            rule.Update(coord, val, updatedCoordTracker);

            var revertedCoordTracker = new CoordinateTracker(puzzle.Size);

            rule.Revert(coord, val, revertedCoordTracker);

            Assert.Equal(
                updatedCoordTracker.TrackedCoords.ToArray(),
                revertedCoordTracker.TrackedCoords.ToArray());
            for (int column = 0; column < initialPossibleValuesByColumn.Count; column++)
            {
                Assert.Equal(
                    initialPossibleValuesByColumn[column],
                    rule.GetMissingValuesForColumn(column));
            }
        }
Beispiel #2
0
        private IList <BitVector> _GetPossibleValuesByColumn(int numColumns, ColumnUniquenessRule rule)
        {
            var possibleColumnValues = new List <BitVector>();

            for (int column = 0; column < numColumns; column++)
            {
                possibleColumnValues.Add(rule.GetMissingValuesForColumn(column));
            }
            return(possibleColumnValues);
        }
        public void Revert_WithoutAffectedCoordsList_RevertsSpecifiedColumn()
        {
            var puzzle = new Puzzle(new int?[, ] {
                { 1, null /* 4 */, null /* 3 */, 2 },
                { null /* 2 */, null /* 3 */, null /* 1 */, 4 },
                { null /* 4 */, 1, null /* 2 */, 3 },
                { 3, null /* 2 */, null /* 4 */, 1 }
            });
            var rule = new ColumnUniquenessRule(puzzle, _GetAllPossibleValues(puzzle.Size));
            IList <BitVector> initialPossibleValuesByColumn = _GetPossibleValuesByColumn(puzzle.Size, rule);
            var coord = new Coordinate(1, 1);
            int val   = 3;

            rule.Update(coord, val, new CoordinateTracker(puzzle.Size));

            rule.Revert(coord, val);

            for (int column = 0; column < initialPossibleValuesByColumn.Count; column++)
            {
                Assert.Equal(
                    initialPossibleValuesByColumn[column],
                    rule.GetMissingValuesForColumn(column));
            }
        }