private long GetTopSide(IDefinedSizeGrid <bool> grid)
{
var size = grid.Region().Width;
var region = new GridRegion(GridPoint.Origin, size, 1);
return(Binary.FromBools(grid.Windowed(region).AllCells()));
}
private static IDefinedSizeGrid <char> StepPart2(IDefinedSizeGrid <char> chars)
{
return(CommonGrids.CoordinateGrid
.Map(coord => (chars.Get(coord), SurroundingEightSightlines(chars, coord)))
.Map(x => StepFunction(x.Item2, x.Item1, 5))
.Windowed(chars.Region()));
}
/// <summary>
/// Finds the basin that some point is sitting in.
/// </summary>
private HashSet <GridPoint> ExpandBasin(IDefinedSizeGrid <int> grid, GridPoint lowestPoint)
{
var pointsInBasin = new HashSet <GridPoint> {
lowestPoint
};
// Let's do a sort of breadth first search starting from the lowest point
var pointsToInvestigate = new Queue <GridPoint>();
pointsToInvestigate.Enqueue(lowestPoint);
while (pointsToInvestigate.Any())
{
// Choose a point we haven't investigated and try expanding the basin around it.
var expandedPoints = pointsToInvestigate
.Dequeue()
.Adjacent4
.Where(p =>
grid.GetOrDefault(p, 9) != 9 &&
// But let's not expand backwards.
!pointsInBasin.Contains(p));
foreach (var candidatePoint in expandedPoints)
{
pointsInBasin.Add(candidatePoint);
pointsToInvestigate.Enqueue(candidatePoint);
}
}
return(pointsInBasin);
}
public DefinedSizeMappedGrid(IDefinedSizeGrid <TOld> baseGrid, Func <TOld, TNew> func)
{
_baseGrid = baseGrid;
_func = func;
Width = baseGrid.Width;
Height = baseGrid.Height;
}
private static IEnumerable <GridPoint> FindLowestPoints(IDefinedSizeGrid <int> grid) =>
grid
.Region()
.AllPoints()
.Where(point =>
{
var height = grid.Get(point);
// A point is the lowest point if all points around it are higher.
return(point
.Adjacent4
.All(adjacentPoint => grid.GetOrDefault(adjacentPoint, 9) > height));
});
private IEnumerable <IDefinedSizeGrid <bool> > AllRotationsAndMirrorings(IDefinedSizeGrid <bool> grid)
{
for (var i = 0; i < 4; i++)
{
yield return(grid);
yield return(grid.FlipHorizontally());
yield return(grid.FlipVertically());
grid = grid.RotateClockwise();
}
}
/// <summary>
/// Perform some operations on a grid, but keep the outline of the original.
/// </summary>
public static WindowGrid <TOut> KeepingRegion <TIn, TOut>(
this IDefinedSizeGrid <TIn> grid,
Func <IDefinedSizeGrid <TIn>, IGrid <TOut> > func)
{
var region = grid.Region();
var result = func(grid);
if (result is IDefinedSizeGrid <TOut> definedResult)
{
if (!definedResult.Region().ContainsRegion(region))
{
throw new InvalidOperationException(
$"KeepingRegion() function returned a defined size grid that changes the region of the grid");
}
}
return(new WindowGrid <TOut>(result, region));
}
public SolidGrid(IDefinedSizeGrid <T> grid)
{
Width = grid.Width;
Height = grid.Height;
_grid = new T[grid.Height][];
for (var y = 0; y < grid.Height; y++)
{
var row = new T[grid.Width];
for (var x = 0; x < grid.Width; x++)
{
var pos = new GridPoint(x, y);
row[x] = grid.Get(pos);
}
_grid[y] = row;
}
}
private (IDefinedSizeGrid <int>, int) Step(IDefinedSizeGrid <int> grid)
{
// Increment
var nextState = grid.Map(x => x + 1).Solidify();
// Flash
var haveFlashed = new HashSet <GridPoint>();
var didFlash = true;
while (didFlash)
{
didFlash = false;
var flashing = nextState
.AllEntries()
.Where2(i => i > 9)
.Where1(x => !haveFlashed.Contains(x));
foreach (var(point, _) in flashing)
{
didFlash = true;
haveFlashed.Add(point);
foreach (var flashPoint in point.Adjacent8)
{
if (!nextState.Region().ContainsPoint(flashPoint))
{
continue;
}
nextState.Set(flashPoint, nextState.Get(flashPoint) + 1);
}
}
}
// Reset flashers
foreach (var flashPoint in haveFlashed)
{
nextState.Set(flashPoint, 0);
}
return(nextState, haveFlashed.Count);
}
private IEnumerable <bool[]> GetSides(IDefinedSizeGrid <bool> grid)
{
var size = grid.Region().Width;
var region = new GridRegion(GridPoint.Origin, size, 1);
yield return(grid.Windowed(region).AllCells().ToArray());
yield return(grid.Windowed(region).AllCells().Reverse().ToArray());
grid = grid.RotateClockwise();
yield return(grid.Windowed(region).AllCells().ToArray());
yield return(grid.Windowed(region).AllCells().Reverse().ToArray());
grid = grid.RotateClockwise();
yield return(grid.Windowed(region).AllCells().ToArray());
yield return(grid.Windowed(region).AllCells().Reverse().ToArray());
grid = grid.RotateClockwise();
yield return(grid.Windowed(region).AllCells().ToArray());
yield return(grid.Windowed(region).AllCells().Reverse().ToArray());
}
public static IDefinedSizeGrid <TNew> Map <TOld, TNew>(this IDefinedSizeGrid <TOld> grid, Func <TOld, TNew> func)
{
return(new DefinedSizeMappedGrid <TOld, TNew>(grid, func));
}
public static T GetOrDefault <T>(this IDefinedSizeGrid <T> grid, GridPoint p, T defaultValue = default)
{
return(grid.Region().ContainsPoint(p) ? grid.Get(p) : defaultValue);
}
/// <summary>
/// Maps points inside the inner grid to the inner grid, but everything outside comes from the outer grid.
/// </summary>
public static IGrid <T> EmbedInside <T>(this IDefinedSizeGrid <T> innerGrid, IGrid <T> outerGrid)
{
return(new GeneratedGrid <T>(p => innerGrid.Region().ContainsPoint(p) ? innerGrid.Get(p) : outerGrid.Get(p)));
}
public static string Dump <T>(this IDefinedSizeGrid <T> grid)
{
return(string.Join("\n", Enumerable.Range(0, grid.Height).Select(y =>
string.Join("", Enumerable.Range(0, grid.Width).Select(x => CellChar(grid.Get(new GridPoint(x, y))))))));
}
// I literally added .Rows() and .Columns() to my grid library right before I saw the problem. private bool BoardHasWon(IDefinedSizeGrid <int> board, HashSet <int> balls) => board.Columns().Any(col => col.All(balls.Contains)) || board.Rows().Any(row => row.All(balls.Contains));
public static GridRegion Region <T>(this IDefinedSizeGrid <T> grid)
{
return(new GridRegion(GridPoint.Origin, grid.Width, grid.Height));
}
public static SolidGrid <T> Solidify <T>(this IDefinedSizeGrid <T> grid)
{
return(new SolidGrid <T>(grid));
}
public static WrappingGrid <T> Wrapping <T>(this IDefinedSizeGrid <T> grid)
{
return(new WrappingGrid <T>(grid));
}
public WrappingGrid(IDefinedSizeGrid <T> baseGrid)
{
_baseGrid = baseGrid;
}
