public void CanGetRowForCell()
{
int[,] data = {
{9,0,0, 0,0,5, 6,8,1 },
{0,6,0, 2,8,0, 7,0,0 },
{0,0,0, 0,0,6, 9,0,5 },
{0,8,0, 0,0,2, 0,4,6 },
{0,0,5, 0,0,0, 3,0,0 },
{1,9,0, 5,0,0, 0,7,0 },
{8,0,2, 9,0,0, 0,0,0 },
{0,0,9, 0,2,7, 0,6,0 },
{6,7,4, 8,0,0, 0,0,3 }
};
IBoardCells boardCells = new BoardCells(new Board(data));
var row1 = boardCells.GetRowForCell(0, 0);
var row2 = boardCells.GetRowForCell(8, 8);
var row3 = boardCells.GetRowForCell(3, 5);
Assert.True(row1.SequenceEqual(new int[] { 9, 0, 0, 0, 0, 5, 6, 8, 1 }));
Assert.True(row2.SequenceEqual(new int[] { 6, 7, 4, 8, 0, 0, 0, 0, 3 }));
Assert.True(row3.SequenceEqual(new int[] { 0, 8, 0, 0, 0, 2, 0, 4, 6 }));
}
public string SerialiseBoardToPuzzleString()
{
var rowPosition = 1;
var puzzleString = "";
while (rowPosition <= this.MaxRows)
{
var colPosition = 1;
while (colPosition <= this.MaxColumns)
{
var cell = BoardCells.Where(x => x.CellRow == rowPosition && x.CellColumn == colPosition).FirstOrDefault();
if (cell == null)
{
puzzleString = $"{puzzleString}0";
}
else
{
puzzleString = $"{puzzleString}{cell.CurrentValue}";
}
colPosition++;
}
rowPosition++;
}
return(puzzleString);
}
public void CanGetColsForCell()
{
int[,] data = {
{9,0,0, 0,0,5, 6,8,1 },
{0,6,0, 2,8,0, 7,0,0 },
{0,0,0, 0,0,6, 9,0,5 },
{0,8,0, 0,0,2, 0,4,6 },
{0,0,5, 0,0,0, 3,0,0 },
{1,9,0, 5,0,0, 0,7,0 },
{8,0,2, 9,0,0, 0,0,0 },
{0,0,9, 0,2,7, 0,6,0 },
{6,7,4, 8,0,0, 0,0,3 }
};
IBoardCells boardCells = new BoardCells(new Board(data));
var col1 = boardCells.GetColumnForCell(0, 0);
var col2 = boardCells.GetColumnForCell(8, 8);
var col3 = boardCells.GetColumnForCell(3, 5);
Assert.True(col1.SequenceEqual(new int[] { 9, 0, 0, 0, 0, 1, 8, 0, 6 }));
Assert.True(col2.SequenceEqual(new int[] { 1, 0, 5, 6, 0, 0, 0, 0, 3 }));
Assert.True(col3.SequenceEqual(new int[] { 0, 2, 0, 0, 0, 5, 9, 0, 8 }));
}
public IEnumerable <Coordonnate> DeadNeighborhood(BoardCells livingCells)
{
return
(new NoMatchingCoordonnates(
this.neighborhoodCoords,
livingCells
).Coordonnates());
}
public Cell Evolve(BoardCells livingCells)
{
return
(new Cell(
this.rules.IsAlive(livingCells),
this.coordonnate,
this.neighborhoodCoords
));
}
public void PrintBoard()
{
var currentRow = 1;
Console.WriteLine("___________________________________________________________________________________________________________");
while (currentRow <= MaxRows)
{
foreach (var box in BoardCells.Where(x => x.CellRow == currentRow).GroupBy(x => x.CellBox))
{
foreach (var cell in box)
{
if (cell.CellColumn == 1)
{
Console.Write("||");
}
if (cell.CurrentValue == 0)
{
Console.Write($" ");
var values = "";
foreach (var value in cell.PossibleValues)
{
values = $"{values}{value}";
}
var valueToWrite = PadBoth(values, 9);
Console.ForegroundColor = ConsoleColor.DarkCyan;
Console.Write(valueToWrite);
Console.Write($" ");
Console.ForegroundColor = ConsoleColor.White;
}
else
{
Console.Write($" {cell.CurrentValue} ");
}
}
Console.Write("||");
}
Console.WriteLine();
if (currentRow == 9)
{
Console.Write("-----------------------------------------------------------------------------------------------------------");
Console.WriteLine();
}
else if (currentRow % 3 == 0)
{
Console.Write("||_________________________________||_________________________________||_________________________________||");
Console.WriteLine();
}
currentRow++;
}
}
public void CanGetSquareForCell()
{
int[,] data = {
{9,0,0, 0,0,5, 6,8,1 },
{0,6,0, 2,8,0, 7,0,0 },
{0,0,0, 0,0,6, 9,0,5 },
{0,8,0, 0,0,2, 0,4,6 },
{0,0,5, 0,0,0, 3,0,0 },
{1,9,0, 5,0,0, 0,7,0 },
{8,0,2, 9,0,0, 0,0,0 },
{0,0,9, 0,2,7, 0,6,0 },
{6,7,4, 8,0,0, 0,0,3 }
};
IBoardCells boardCells = new BoardCells(new Board(data));
var sq1 = boardCells.GetSquareForCell(0, 0);
var sq2 = boardCells.GetSquareForCell(8, 8);
var sq3 = boardCells.GetSquareForCell(3, 5);
Assert.Equal(9, sq1[0, 0]);
Assert.Equal(0, sq1[0, 1]);
Assert.Equal(0, sq1[0, 2]);
Assert.Equal(0, sq1[1, 0]);
Assert.Equal(6, sq1[1, 1]);
Assert.Equal(0, sq1[1, 2]);
Assert.Equal(0, sq1[2, 0]);
Assert.Equal(0, sq1[2, 1]);
Assert.Equal(0, sq1[2, 2]);
Assert.Equal(0, sq2[0, 0]);
Assert.Equal(0, sq2[0, 1]);
Assert.Equal(0, sq2[0, 2]);
Assert.Equal(0, sq2[1, 0]);
Assert.Equal(6, sq2[1, 1]);
Assert.Equal(0, sq2[1, 2]);
Assert.Equal(0, sq2[2, 0]);
Assert.Equal(0, sq2[2, 1]);
Assert.Equal(3, sq2[2, 2]);
Assert.Equal(0, sq3[0, 0]);
Assert.Equal(0, sq3[0, 1]);
Assert.Equal(2, sq3[0, 2]);
Assert.Equal(0, sq3[1, 0]);
Assert.Equal(0, sq3[1, 1]);
Assert.Equal(0, sq3[1, 2]);
Assert.Equal(5, sq3[2, 0]);
Assert.Equal(0, sq3[2, 1]);
Assert.Equal(0, sq3[2, 2]);
}
public void PrintBoard()
{
var currentRow = 1;
Console.WriteLine("___________________________________");
while (currentRow <= MaxRows)
{
foreach (var box in BoardCells.Where(x => x.CellRow == currentRow).GroupBy(x => x.CellBox))
{
foreach (var cell in box)
{
if (cell.CellColumn == 1)
{
Console.Write("||");
}
if (cell.CurrentValue == 0)
{
Console.Write(" ");
}
else
{
Console.Write($" {cell.CurrentValue} ");
}
}
Console.Write("||");
}
Console.WriteLine();
if (currentRow == 9)
{
Console.Write("-----------------------------------");
Console.WriteLine();
}
else if (currentRow % 3 == 0)
{
Console.Write("||_________||_________||_________||");
Console.WriteLine();
}
currentRow++;
}
}
public PseudoBoard(int rows, int cols, string inputValues)
{
MaxRows = rows;
MaxColumns = cols;
AllowedValues = Enumerable.Range(1, Math.Max(MaxRows, MaxColumns)).Select(x => x).ToList();
PuzzleString = inputValues;
var currentRow = 1;
var currentColumn = 1;
var currentIndex = 0;
var values = inputValues.ToList();
while (currentRow <= MaxRows)
{
while (currentColumn <= MaxColumns)
{
var cellValue = Convert.ToInt32(values[currentIndex] - 48); //char of 0 enters as 48
var pseudoCell = new PseudoCell
{
CellRow = currentRow,
CellColumn = currentColumn,
CurrentValue = cellValue,
PossibleValues = cellValue == 0 ? Enumerable.Range(1, Math.Max(MaxRows, MaxColumns)).Select(x => x).ToList() : new List <int>(),
SolvedCell = cellValue == 0 ? false : true
};
pseudoCell.FindBox();
BoardCells.Add(pseudoCell);
currentIndex++;
currentColumn++;
}
currentColumn = 1;
currentRow++;
}
}
public NoMatchingCoordonnates(BoardCoordonnates coordonnates, BoardCells cells)
{
this.coordonnates = coordonnates;
this.cells = new CacheCells(cells);
}
public bool IsPositionOffGrid(Vertex2D pos)
{
return(pos.X < 0 || pos.X >= BoardCells.GetLength(0) || pos.Y < 0 || pos.Y >= BoardCells.GetLength(1));
}
public void WillReturnEmptyListCellHasAValue()
{
int[,] data = {
{9,0,0, 0,0,5, 6,8,1 },
{0,6,0, 2,8,0, 7,0,0 },
{0,0,0, 0,0,6, 9,0,5 },
{0,8,0, 0,0,2, 0,4,6 },
{0,0,5, 0,0,0, 3,0,0 },
{1,9,0, 5,0,0, 0,7,0 },
{8,0,2, 9,0,0, 0,0,0 },
{0,0,9, 0,2,7, 0,6,0 },
{6,7,4, 8,0,0, 0,0,3 }
};
IBoardCells boardCells = new BoardCells(new Board(data));
SimpleMoveFinder moveFinder = new SimpleMoveFinder();
var cellMoves = moveFinder.GetMovesForCell(boardCells, 0, 0);
Assert.Equal(0, cellMoves.Moves.Count);
cellMoves = moveFinder.GetMovesForCell(boardCells, 8, 8);
Assert.Equal(0, cellMoves.Moves.Count);
}
public void WilLReturnMoves()
{
int[,] data = {
{9,0,0, 0,0,5, 6,8,1 },
{0,6,0, 2,8,0, 7,0,0 },
{0,0,0, 0,0,6, 9,0,5 },
{0,8,0, 0,0,2, 0,4,6 },
{0,0,5, 0,0,0, 3,0,0 },
{1,9,0, 5,0,0, 0,7,0 },
{8,0,2, 9,0,0, 0,0,0 },
{0,0,9, 0,2,7, 0,6,0 },
{6,7,4, 8,0,0, 0,0,3 }
};
IBoardCells boardCells = new BoardCells(new Board(data));
SimpleMoveFinder moveFinder = new SimpleMoveFinder();
var cellMoves = moveFinder.GetMovesForCell(boardCells, 0, 1);
// 2,3,4
int[] expectedValues = new int[] { 2, 3, 4 };
Assert.Equal(expectedValues.Length, cellMoves.Moves.Count);
foreach (IMove move in cellMoves.Moves) {
Assert.True(expectedValues.Contains(move.Value));
}
cellMoves = moveFinder.GetMovesForCell(boardCells, 8, 7);
expectedValues = new int[] { 1, 2, 5, 9 };
// 1,2,5,9
Assert.Equal(4, cellMoves.Moves.Count);
foreach (IMove move in cellMoves.Moves) {
Assert.True(expectedValues.Contains(move.Value));
}
}
public CacheCells(BoardCells cells)
{
this.cells = cells;
this.cache = new List <Cell>();
}
public CellsToCoordonnates(BoardCells cellsToConvert)
{
this.cellsToConvert = cellsToConvert;
}
public MatchingCells(BoardCoordonnates neighborhood, BoardCells cellsToMatch)
{
this.neighborhood = neighborhood;
this.cellsToMatch = new CacheCells(cellsToMatch);
}
public bool IsAlive(BoardCells livingCells)
{
return(this.neighborhoodCells.MatchingCells(livingCells).Cells().Count() == 3);
}
public DeadCells(BoardCells cells)
{
this.cells = cells;
}
public void WillReturnSquares()
{
int[,] data = {
{9,0,0, 0,0,5, 6,8,1 },
{0,6,0, 2,8,0, 7,0,0 },
{0,0,0, 0,0,6, 9,0,5 },
{0,8,0, 0,0,2, 0,4,6 },
{0,0,5, 0,0,0, 3,0,0 },
{1,9,0, 5,0,0, 0,7,0 },
{8,0,2, 9,0,0, 0,0,0 },
{0,0,9, 0,2,7, 0,6,0 },
{6,7,4, 8,0,0, 0,0,3 }
};
IBoardCells boardCells = new BoardCells(new Board(data));
var squares = boardCells.Squares;
Assert.Equal(9, squares.Count);
Assert.Equal(9, squares.ElementAt(0)[0, 0]);
Assert.Equal(0, squares.ElementAt(0)[0, 1]);
Assert.Equal(0, squares.ElementAt(0)[0, 2]);
Assert.Equal(0, squares.ElementAt(0)[1, 0]);
Assert.Equal(6, squares.ElementAt(0)[1, 1]);
Assert.Equal(0, squares.ElementAt(0)[1, 2]);
Assert.Equal(0, squares.ElementAt(0)[2, 0]);
Assert.Equal(0, squares.ElementAt(0)[2, 1]);
Assert.Equal(0, squares.ElementAt(0)[2, 2]);
Assert.Equal(0, squares.ElementAt(1)[0, 0]);
Assert.Equal(0, squares.ElementAt(1)[0, 1]);
Assert.Equal(5, squares.ElementAt(1)[0, 2]);
Assert.Equal(2, squares.ElementAt(1)[1, 0]);
Assert.Equal(8, squares.ElementAt(1)[1, 1]);
Assert.Equal(0, squares.ElementAt(1)[1, 2]);
Assert.Equal(0, squares.ElementAt(1)[2, 0]);
Assert.Equal(0, squares.ElementAt(1)[2, 1]);
Assert.Equal(6, squares.ElementAt(1)[2, 2]);
Assert.Equal(6, squares.ElementAt(2)[0, 0]);
Assert.Equal(8, squares.ElementAt(2)[0, 1]);
Assert.Equal(1, squares.ElementAt(2)[0, 2]);
Assert.Equal(7, squares.ElementAt(2)[1, 0]);
Assert.Equal(0, squares.ElementAt(2)[1, 1]);
Assert.Equal(0, squares.ElementAt(2)[1, 2]);
Assert.Equal(9, squares.ElementAt(2)[2, 0]);
Assert.Equal(0, squares.ElementAt(2)[2, 1]);
Assert.Equal(5, squares.ElementAt(2)[2, 2]);
Assert.Equal(0, squares.ElementAt(3)[0, 0]);
Assert.Equal(8, squares.ElementAt(3)[0, 1]);
Assert.Equal(0, squares.ElementAt(3)[0, 2]);
Assert.Equal(0, squares.ElementAt(3)[1, 0]);
Assert.Equal(0, squares.ElementAt(3)[1, 1]);
Assert.Equal(5, squares.ElementAt(3)[1, 2]);
Assert.Equal(1, squares.ElementAt(3)[2, 0]);
Assert.Equal(9, squares.ElementAt(3)[2, 1]);
Assert.Equal(0, squares.ElementAt(3)[2, 2]);
Assert.Equal(0, squares.ElementAt(4)[0, 0]);
Assert.Equal(0, squares.ElementAt(4)[0, 1]);
Assert.Equal(2, squares.ElementAt(4)[0, 2]);
Assert.Equal(0, squares.ElementAt(4)[1, 0]);
Assert.Equal(0, squares.ElementAt(4)[1, 1]);
Assert.Equal(0, squares.ElementAt(4)[1, 2]);
Assert.Equal(5, squares.ElementAt(4)[2, 0]);
Assert.Equal(0, squares.ElementAt(4)[2, 1]);
Assert.Equal(0, squares.ElementAt(4)[2, 2]);
Assert.Equal(0, squares.ElementAt(5)[0, 0]);
Assert.Equal(4, squares.ElementAt(5)[0, 1]);
Assert.Equal(6, squares.ElementAt(5)[0, 2]);
Assert.Equal(3, squares.ElementAt(5)[1, 0]);
Assert.Equal(0, squares.ElementAt(5)[1, 1]);
Assert.Equal(0, squares.ElementAt(5)[1, 2]);
Assert.Equal(0, squares.ElementAt(5)[2, 0]);
Assert.Equal(7, squares.ElementAt(5)[2, 1]);
Assert.Equal(0, squares.ElementAt(5)[2, 2]);
Assert.Equal(8, squares.ElementAt(6)[0, 0]);
Assert.Equal(0, squares.ElementAt(6)[0, 1]);
Assert.Equal(2, squares.ElementAt(6)[0, 2]);
Assert.Equal(0, squares.ElementAt(6)[1, 0]);
Assert.Equal(0, squares.ElementAt(6)[1, 1]);
Assert.Equal(9, squares.ElementAt(6)[1, 2]);
Assert.Equal(6, squares.ElementAt(6)[2, 0]);
Assert.Equal(7, squares.ElementAt(6)[2, 1]);
Assert.Equal(4, squares.ElementAt(6)[2, 2]);
Assert.Equal(9, squares.ElementAt(7)[0, 0]);
Assert.Equal(0, squares.ElementAt(7)[0, 1]);
Assert.Equal(0, squares.ElementAt(7)[0, 2]);
Assert.Equal(0, squares.ElementAt(7)[1, 0]);
Assert.Equal(2, squares.ElementAt(7)[1, 1]);
Assert.Equal(7, squares.ElementAt(7)[1, 2]);
Assert.Equal(8, squares.ElementAt(7)[2, 0]);
Assert.Equal(0, squares.ElementAt(7)[2, 1]);
Assert.Equal(0, squares.ElementAt(7)[2, 2]);
Assert.Equal(0, squares.ElementAt(8)[0, 0]);
Assert.Equal(0, squares.ElementAt(8)[0, 1]);
Assert.Equal(0, squares.ElementAt(8)[0, 2]);
Assert.Equal(0, squares.ElementAt(8)[1, 0]);
Assert.Equal(6, squares.ElementAt(8)[1, 1]);
Assert.Equal(0, squares.ElementAt(8)[1, 2]);
Assert.Equal(0, squares.ElementAt(8)[2, 0]);
Assert.Equal(0, squares.ElementAt(8)[2, 1]);
Assert.Equal(3, squares.ElementAt(8)[2, 2]);
}
public void WillReturnRows()
{
int[,] data = {
{9,0,0, 0,0,5, 6,8,1 },
{0,6,0, 2,8,0, 7,0,0 },
{0,0,0, 0,0,6, 9,0,5 },
{0,8,0, 0,0,2, 0,4,6 },
{0,0,5, 0,0,0, 3,0,0 },
{1,9,0, 5,0,0, 0,7,0 },
{8,0,2, 9,0,0, 0,0,0 },
{0,0,9, 0,2,7, 0,6,0 },
{6,7,4, 8,0,0, 0,0,3 }
};
IBoardCells boardCells = new BoardCells(new Board(data));
var rows = boardCells.Rows;
Assert.Equal(9, rows.Count);
Assert.True(rows[0].SequenceEqual(new int[] { 9, 0, 0, 0, 0, 5, 6, 8, 1 }));
Assert.True(rows[1].SequenceEqual(new int[] { 0, 6, 0, 2, 8, 0, 7, 0, 0 }));
Assert.True(rows[2].SequenceEqual(new int[] { 0, 0, 0, 0, 0, 6, 9, 0, 5 }));
Assert.True(rows[3].SequenceEqual(new int[] { 0, 8, 0, 0, 0, 2, 0, 4, 6 }));
Assert.True(rows[4].SequenceEqual(new int[] { 0, 0, 5, 0, 0, 0, 3, 0, 0 }));
Assert.True(rows[5].SequenceEqual(new int[] { 1, 9, 0, 5, 0, 0, 0, 7, 0 }));
Assert.True(rows[6].SequenceEqual(new int[] { 8, 0, 2, 9, 0, 0, 0, 0, 0 }));
Assert.True(rows[7].SequenceEqual(new int[] { 0, 0, 9, 0, 2, 7, 0, 6, 0 }));
Assert.True(rows[8].SequenceEqual(new int[] { 6, 7, 4, 8, 0, 0, 0, 0, 3 }));
}
public void WillReturnColumns()
{
int[,] data = {
{9,0,0, 0,0,5, 6,8,1 },
{0,6,0, 2,8,0, 7,0,0 },
{0,0,0, 0,0,6, 9,0,5 },
{0,8,0, 0,0,2, 0,4,6 },
{0,0,5, 0,0,0, 3,0,0 },
{1,9,0, 5,0,0, 0,7,0 },
{8,0,2, 9,0,0, 0,0,0 },
{0,0,9, 0,2,7, 0,6,0 },
{6,7,4, 8,0,0, 0,0,3 }
};
IBoardCells boardCells = new BoardCells(new Board(data));
var columns = boardCells.Columns;
Assert.Equal(9, columns.Count);
Assert.True(columns[0].SequenceEqual(new int[] { 9, 0, 0, 0, 0, 1, 8, 0, 6 }));
Assert.True(columns[1].SequenceEqual(new int[] { 0, 6, 0, 8, 0, 9, 0, 0, 7 }));
Assert.True(columns[2].SequenceEqual(new int[] { 0, 0, 0, 0, 5, 0, 2, 9, 4 }));
Assert.True(columns[3].SequenceEqual(new int[] { 0, 2, 0, 0, 0, 5, 9, 0, 8 }));
Assert.True(columns[4].SequenceEqual(new int[] { 0, 8, 0, 0, 0, 0, 0, 2, 0 }));
Assert.True(columns[5].SequenceEqual(new int[] { 5, 0, 6, 2, 0, 0, 0, 7, 0 }));
Assert.True(columns[6].SequenceEqual(new int[] { 6, 7, 9, 0, 3, 0, 0, 0, 0 }));
Assert.True(columns[7].SequenceEqual(new int[] { 8, 0, 0, 4, 0, 7, 0, 6, 0 }));
Assert.True(columns[8].SequenceEqual(new int[] { 1, 0, 5, 6, 0, 0, 0, 0, 3 }));
}
public bool IsAlive(BoardCells livingCells)
{
var matchingCells = neighborhoodCells.MatchingCells(livingCells);
return(matchingCells.Cells().Count() >= 2 && matchingCells.Cells().Count() <= 3);
}
public BoardCells MatchingCells(BoardCells livingCells)
{
return(new MatchingCells(neighborhoodCells, livingCells.Cells()));
}
public DeadNeighborhood(BoardCells livingCells)
{
this.livingCells = new CacheCells(livingCells);
}
public LivingCells(BoardCells cells)
{
this.cells = cells;
}
public bool IsAlive(BoardCells livingCells)
{
return(this.isCellAlive ? this.stayAlive.IsAlive(livingCells) : this.becomeAlive.IsAlive(livingCells));
}
public EngagedCells(IEnumerable <Coordonnate> livingCoords)
{
this.deadCells = new CoordonnatesToCells(false, new Distinct(new DeadNeighborhood(livingCoords)));
this.livingCells = new CoordonnatesToCells(true, livingCoords);
}
