private int Score()
{
int wood = yard.Cast <char>().Count(c => c == '|');
int lumber = yard.Cast <char>().Count(c => c == '#');
return(wood * lumber);
}
public static string Crap(char[,] x, int bags, int cap)
{
return(x.Cast <char>().Contains('D') ? "Dog!!" : x.Cast <char>().Count(c => c == '@') > bags * cap ? "Cr@p" : "Clean");
//return x.Cast<char>().Any(c => c == 'D') ? "Dog!!" : x.Cast<char>().Count(c => c == '@') > bags * cap ? "Cr@p" : "Clean";
//return x.Cast<char>().Count(y => y == 'D') > 0 ? "Dog!!" : x.Cast<char>().Count(y => y == '@') > bags * cap ? "Cr@p" : "Clean";
// int crap = 0;
// foreach (var item in x)
// {
// if (item == 'D')
// return "Dog!!";
// if (item == '@') crap++;
// }
// return crap <= bags * cap ? "Clean" : "Cr@p";
// int crap = 0;
// for (int i = 0; i < x.GetLength(0); ++i)
// {
// for (int j = 0; j < x.GetLength(1); ++j)
// {
// if (x[i, j] == 'D') return "Dog!!";
// if (x[i, j] == '@') crap++;
// }
// }
// return crap <= cap * bags ? "Clean" : "Cr@p";
}
/// <summary>
/// Debugger : j'ecrit les 2 tableaux pour les comparer
/// Problème : dans mon cas je n'arrivais pas comparer les 2 séquances avec le .SequenceEqual car elle ne permet pas de comparer les tableaux multi dimensional arrays
/// Solution : flatten les 2 tableaux et les comparer
/// Succès : oui
/// Optimisation : pas besoin c'est un debugger temporaire
/// </summary>
private static void Debug()
{
// reset couleur console pour eviter d'avoir un truck en bleu ou rouge illisible
Console.ForegroundColor = ConsoleColor.Gray;
// flatten le tableau qui permet de comparer si le joueur l'a rempli de 'O'
char[] tab_FlattenTblAnswer = G_Tab_charCavalierAnswer.Cast <char>().ToArray();
// crée une première version du tableau ou le pion se trouve
char[] tab_FlattenPion = G_Tab_charCavalier.Cast <char>().ToArray();
// boucle for qui va ecrire le cavalier en vertical
for (G_byteY = 0; G_byteY != G_sbyteUser; G_byteY++)
{
// boucle for qui va ecrire le cavalier en horizontal
for (G_byteX = 0; G_byteX != G_sbyteUser; G_byteX++)
{
// met le curseur en dessous du tableau
Console.SetCursorPosition(G_byteX, G_byteY + 10);
// ecrit le cavalier qui doit être obtenu pour finir le jeu
Console.Write(G_Tab_charCavalierAnswer[G_byteY, G_byteX]);
// met le curseur encore plus en dessous du tableau
Console.SetCursorPosition(G_byteX, G_byteY + 20);
// ecrit le cavalier qui doit être obtenu pour finir le jeu
Console.Write(G_Tab_charCavalier[G_byteY, G_byteX]);
}
}
// permet d'ecrire les tableaux flatten ( pas optimisé )
for (int i = 0; i < tab_FlattenPion.Length; i++)
{
// met le curseur encore plus en bas
Console.SetCursorPosition(i, 30);
// ecrit le caractère flatten en fonction de i
Console.Write(tab_FlattenPion[i]);
// met le curseur encore encore plus en bas
Console.SetCursorPosition(i, 40);
// ecrit le caractère flatten en fonction de i
Console.Write(tab_FlattenTblAnswer[i]);
}
// met le curseur a droite
Console.SetCursorPosition(G_byteX + 10, G_byteY + 10);
// ecrit la position X actuele du pion
Console.Write("X : " + G_sbyteXUser);
// met le curseur a droite et 1 en dessous du précédant
Console.SetCursorPosition(G_byteX + 10, G_byteY + 11);
// ecrit la position Y actuele du pion
Console.Write("Y : " + G_sbyteYUser);
}
} // fin static bool cavalier
/// <summary>
/// Main : Comme son nom l'indique, programme principale qui permet d'appeler les autres methodes pour le cavalier
/// Succès : Oui
/// Optimisation : je pense il y a moyen de faire mieux
/// </summary>
private static void Main(string[] agrs)
{
// permet de run mon cavalier en mode asynchrone
Task.Run(async() =>
{
// enlève la visibilité du curseur
Console.CursorVisible = false;
// call le programm InputUser, se réferer au static void InputUser() pour le code
InputUser();
// call le programm tableau, se réferer au static void Tableau() pour le code
Tableau();
// permet de décorer le pion
DecoPion();
// call le programm cavalier, se réferer au static void CavalierClean() pour le code
CavalierClean();
// flatten le tableau qui permet de comparer si le joueur l'a rempli de 'O'
// bug, n'arrive pas a reset le tableau flattent
char[] tab_FlattenTblAnswer = G_Tab_charCavalierAnswer.Cast <char>().ToArray();
// crée une première version du tableau ou le pion se trouve
char[] tab_FlattenPion = G_Tab_charCavalier.Cast <char>().ToArray();
// cavalier, recommence tant que le chat restart = o
for (; !tab_FlattenPion.SequenceEqual(tab_FlattenTblAnswer);)
{
// call le programm cavalier, se réferer au static void CavalierClean() pour le code
CavalierClean();
// call le programm cavalier, se réferer au static void Cavalier() pour le code
tab_FlattenTblAnswer = await Cavalier();
// reflaten le tableau a chaque fois vu que on se déplace
tab_FlattenPion = G_Tab_charCavalier.Cast <char>().ToArray();
}
// clear de la console
Console.Clear();
// change la couleur de la console en vert
Console.ForegroundColor = ConsoleColor.Green;
// ecrit que on a fini
Console.Write("Félicitation, vous avez gagné");
// sleep de 3 sec pour que l'user puisse voir que il a fini
Thread.Sleep(3000);
// je vais vous mentir mais j'ai 0 idée de ce que sa fait
}).GetAwaiter().GetResult();
} // fin static void Main ( jeu cavalier )
private char Map(char c)
{
char[] from = mapping.Cast <char>().Skip(26).Take(26).ToArray();
int index = FindInArray(abc, c);
return(mapping[1, index]);
}
public void Solve()
{
char[,] newLayout = (char[, ])layout.Clone();
do
{
layout = (char[, ])newLayout.Clone();
for (int i = 0; i < layout.GetLength(0); i++)
{
for (int j = 0; j < layout.GetLength(1); j++)
{
int occupiedAdjacentSeatsCount = seatCountBehaviour(i, j);
if (layout[i, j] == 'L' && occupiedAdjacentSeatsCount == 0)
{
newLayout[i, j] = '#';
}
else if (layout[i, j] == '#' && occupiedAdjacentSeatsCount >= occupiedSeatsThreeshold)
{
newLayout[i, j] = 'L';
}
}
}
}while (
(
Enumerable.Range(0, layout.Rank).All(dimension => layout.GetLength(dimension) == newLayout.GetLength(dimension)) &&
layout.Cast <char>().SequenceEqual(newLayout.Cast <char>())
) == false);
}
static char[,] RunGameOfSeats(char[,] seats, Func <char[, ], int, int, int> evaluateNeighbors, int decayFrom)
{
var next = (char[, ])seats.Clone();
for (; ;)
{
for (int y = 0; seats.GetLength(0) > y; ++y)
{
for (int x = 0; seats.GetLength(1) > x; ++x)
{
if ('L' == seats[y, x] && 0 == evaluateNeighbors(seats, y, x))
{
next[y, x] = '#';
}
else if ('#' == seats[y, x] && decayFrom <= evaluateNeighbors(seats, y, x))
{
next[y, x] = 'L';
}
else
{
next[y, x] = seats[y, x];
}
}
}
if (next.Cast <char>().SequenceEqual(seats.Cast <char>()))
{
return(seats);
}
var temp = next;
next = seats;
seats = temp;
}
}
} // fin static bool cavalier
/// <summary>
/// Main : Comme son nom l'indique, programme principale qui permet d'appeler les autres methodes pour le cavalier
/// Succès : Oui
/// Optimisation : je pense il y a moyen de faire mieux
/// </summary>
private static void Main(string[] agrs)
{
// variables
byte byteUser = 0;
// enlève la visibilité du curseur
Console.CursorVisible = false;
// call le programm InputUser, se réferer au static void InputUser() pour le code
byteUser = InputUser();
// call le programm tableau, se réferer au static void Tableau() pour le code
Tableau(byteUser);
// permet de décorer le pion
DecoPion(byteUser);
// call le programm cavalier, se réferer au static void CavalierClean() pour le code
CavalierClean(byteUser);
// crée une première version du tableau ou le pion se trouve
char[] tab_FlattenPion = G_Tab_charCavalier.Cast <char>().ToArray();
// cavalier, recommence tant que le chat restart = o
for (; !tab_FlattenPion.SequenceEqual(G_Tab_charCavalierAnswer);)
{
// call le programm cavalier, se réferer au static void CavalierClean() pour le code
CavalierClean(byteUser);
// call le programm cavalier, se réferer au static void Cavalier() pour le code
Cavalier(byteUser);
// reflaten le tableau a chaque fois vu que on se déplace
tab_FlattenPion = G_Tab_charCavalier.Cast <char>().ToArray();
}
// clear de la console
Console.Clear();
// change la couleur de la console en vert
Console.ForegroundColor = ConsoleColor.Green;
// ecrit que on a fini
Console.Write("Félicitation, vous avez gagné");
// sleep de 3 sec pour que l'user puisse voir que il a fini
Thread.Sleep(3000);
} // fin static void Main ( jeu cavalier )
protected override object SolvePartTwo()
{
InitBoard(Input.SplitByNewline());
//WriteConsole(input.Length, input.Length, 5, 5, (y, x) => (ConsoleColor.White, yard[y, x]));
StringBuilder sb = new StringBuilder();
Dictionary <string, int> gens = new Dictionary <string, int>();
bool skipped = false;
for (int i = 0; i < 1_000_000_000; i++)
{
yard = Advance(yard);
//WriteConsole(input.Length, input.Length, 5, 5, (y, x) => (ConsoleColor.White, yard[y, x]));
for (int y = 0; y < 50; y++)
{
for (int x = 0; x < 50; x++)
{
sb.Append(yard[y, x]);
}
}
string sYard = sb.ToString();
if (!skipped && gens.ContainsKey(sYard))
{
int id = gens[sYard];
int diff = i - id;
i += (int)(1e9 - i) / diff * diff;
skipped = true;
}
if (!skipped)
{
gens.Add(sYard, i);
}
sb.Clear();
}
int wood = yard.Cast <char>().Count(c => c == '|');
int lumber = yard.Cast <char>().Count(c => c == '#');
return(wood * lumber);
}
public bool Equals(Map other)
{
return(other != null &&
width == other.width &&
height == other.height &&
data.Cast <char>().SequenceEqual(other.data.Cast <char>()));
//EqualityComparer<char[,]>.Default.Equals(data, other.data);
}
protected override object SolvePartOne()
{
InitBoard(Input.SplitByNewline());
//WriteConsole(input.Length, input.Length, 5, 5, (y, x) => (ConsoleColor.White, yard[y, x]));
for (int i = 0; i < 10; i++)
{
yard = Advance(yard);
//WriteConsole(input.Length, input.Length, 5, 5, (y, x) => (ConsoleColor.White, yard[y, x]));
}
int wood = yard.Cast <char>().Count(c => c == '|');
int lumber = yard.Cast <char>().Count(c => c == '#');
return(wood * lumber);
}
public int SecondPart()
{
char[,] mat = BuildMatrix();
int numberOkay = mat.Cast <char>().ToArray().Where(i => i == '1').Count();
int[,] posicionUF = CalcularPositionUF(mat);
return(CalculateGroups(mat, numberOkay, posicionUF));
}
/// <summary>
/// Checks whether a certain board is in terminal state
/// </summary>
/// <param name="board">char matrix</param>
/// <returns>
/// -> YOU_PLAYER if you win
/// -> COMPUTER_PLAYER if computer wins
/// -> EMPTY_CELL if the state is not terminal
/// -> EQUAL if it is a draw and nobody wins
/// </returns>
private static char CheckForGameOver(this char[,] board)
{
char[,] boardTransposed = board.TransposeBoard();
for (int rowNumber = 0; rowNumber < board.GetLength(0); rowNumber++)
{
// check horizontals
if (board.TakeRow(rowNumber).SequenceEqual(Xwins) ||
boardTransposed.TakeRow(rowNumber).SequenceEqual(Xwins))
{
return(YOU_PLAYER);
}
// check verticals
if (board.TakeRow(rowNumber).SequenceEqual(Owins) ||
boardTransposed.TakeRow(rowNumber).SequenceEqual(Owins))
{
return(COMPUTER_PLAYER);
}
}
// check if you win in main diagonal
if (board.IsWinnerInMainDiagonal(YOU_PLAYER))
{
return(YOU_PLAYER);
}
// check if computer wins in main diagonal
if (board.IsWinnerInMainDiagonal(COMPUTER_PLAYER))
{
return(COMPUTER_PLAYER);
}
// check if you win in secondary diagonal
if (board.IsWinnerInSecondaryDiagonal(YOU_PLAYER))
{
return(YOU_PLAYER);
}
// check if computer wins in secondary diagonal
if (board.IsWinnerInSecondaryDiagonal(COMPUTER_PLAYER))
{
return(COMPUTER_PLAYER);
}
// check whether state is not terminal
char[] boardInArray = board.Cast <char>().ToArray();
for (int i = 0; i < board.Length; i++)
{
if (boardInArray[i] == EMPTY_CELL)
{
return(EMPTY_CELL);
}
}
// it's a draw
return(EQUAL);
}
/* Method to check if the population is stagnant*/
public static bool IsStagnant()
{
if (current.Rank == next.Rank &&
Enumerable.Range(0, current.Rank).All(dimension => current.GetLength(dimension) == next.GetLength(dimension)) &&
current.Cast <char>().SequenceEqual(next.Cast <char>()))
{
return(true);
}
return(false);
}
public static void GameShow()
{
for (int i = 0; i < 30; i++)
{
for (int j = 0; j < 120; j++)
{
playingField[i, j] = ' ';
}
}
GameIterating();
textImage = new string(playingField.Cast <Char>().ToArray());
Console.Clear();
Console.Write(textImage);
Thread.Sleep(1);
}
Node valueInTree(char[,] mov, Node root)
{
foreach (Node node in root.children)
{
if (mov.Cast <char>().SequenceEqual(node.value.Cast <char>()))
{
return(node);
}
else
{
return(valueInTree(mov, node));
}
}
return(null);
}
private static Dictionary <char, char> AssignTypeToEachRectangle(char[,] grid)
{
var rectangleType = 'A';
var ConvertTypeToChar = new Dictionary <string, char>();
return(grid.Cast <char>().Distinct()
.Select(rectangle =>
{
var dimP = GetRectangleDim(rectangle, grid);
var type = rectangle.Equals('A')
? rectangle.ToString()
: $"{dimP.XMax - dimP.XMin}{dimP.YMax - dimP.YMin}";
if (!ConvertTypeToChar.ContainsKey(type))
{
ConvertTypeToChar.Add(type, rectangleType++);
}
return (rectangle, ConvertTypeToChar[type]);
public static string Crap(char[,] x, int bags, int cap)
{
var doggy = x.Cast <char>().Select(d => d).Contains('D');
int whatICanPickUp = bags * cap;
if (doggy)
{
return("Dog!!");
}
foreach (char c in x)
{
if (c == '@')
{
whatICanPickUp--;
}
if (whatICanPickUp < 0)
{
return("Cr@p");
}
}
return("Clean");
}
static int CheckWin()
{
//checks win for player 2
if (board[0, 0] == playerID && board[0, 1] == playerID && board[0, 2] == playerID)
{
return(1);
}
else if (board[1, 0] == playerID && board[1, 1] == playerID && board[1, 2] == playerID)
{
return(1);
}
else if (board[2, 0] == playerID && board[2, 1] == playerID && board[2, 2] == playerID)
{
return(1);
}
else if (board[0, 0] == playerID && board[1, 1] == playerID && board[2, 2] == playerID)
{
return(1);
}
else if (board[2, 0] == playerID && board[1, 1] == playerID && board[0, 2] == playerID)
{
return(1);
}
else if (board[0, 1] == playerID && board[1, 1] == playerID && board[2, 1] == playerID)
{
return(1);
}
else if (board.Cast <char>().Any(c => c == '-'))
{
return(-1);
}
else
{
return(0);
}
}
static void Problem2(char[,] seats)
{
seats = RunGameOfSeats(seats, CountVisibleDiagonaly, 5);
Console.WriteLine("#2: " + seats.Cast <char>().Where(c => c == '#').Count());
}
/// <summary>
/// Tableau : Permet d'ecrire le tableau principal ou le joueur va se déplacer et le tableau ou il peut voir ce que il doit encore completer
/// Succès : Oui
/// Optimisation : peut faire mieux
/// </summary>
private static char[] Tableau()
{
// création du tableau answer avec l'input user
G_Tab_charCavalierAnswer = new char[G_sbyteUser, G_sbyteUser];
// création tableau user avec l'input user
G_Tab_charCavalier = new char[G_sbyteUser, G_sbyteUser];
// début boucle for Y, pour ecrire verticallement les cavalies
for (G_byteY = 0; G_byteY != G_sbyteUser; G_byteY++)
{
// début boucle for Y, pour ecrire honrizontallement les cavalies
for (G_byteX = 0; G_byteX != G_sbyteUser; G_byteX++)
{
// si G_byteX ou G_byteY = a 0 ou a sbyteUser -1, donc c'est une bordure
if (G_byteX == 0 || G_byteY == 0 || G_byteX == G_sbyteUser - 1 || G_byteY == G_sbyteUser - 1)
{
// regarde si la position actuelle de la boucle for est autre que la bordure tout en haut et tout en bas
if (G_byteX == 0 && G_byteY != 0 && G_byteY != G_sbyteUser - 1 || G_byteX == G_sbyteUser - 1 && G_byteY != 0 && G_byteY != G_sbyteUser - 1)
{
G_charTbl = '║';
}
// regarde si la position actuelle de la boucle for est autre que la bordure à gauche ou a droite
else if (G_byteY == 0 && G_byteX != 0 && G_byteX != G_sbyteUser - 1 || G_byteY == G_sbyteUser - 1 && G_byteX != 0 && G_byteX != G_sbyteUser - 1)
{
G_charTbl = '═';
}
// regarde si c'est le coin en haut a droite
else if (G_byteX == 0 && G_byteY == 0)
{
G_charTbl = '╔';
}
// regarde si c'est le coin en haut a gauche
else if (G_byteX == G_sbyteUser - 1 && G_byteY == 0)
{
G_charTbl = '╗';
}
// regarde si c'est le coin en bas a droite
else if (G_byteX == 0 && G_byteY == G_sbyteUser - 1)
{
G_charTbl = '╚';
}
// regarde si c'est le coin en bas a gauche
else if (G_byteX == G_sbyteUser - 1 && G_byteY == G_sbyteUser - 1)
{
G_charTbl = '╝';
}
// met la bordure en bleu vu que c'est une bordure
Console.ForegroundColor = ConsoleColor.Blue;
}
// si non alors c'est le millieu du tableau
else
{
// met la couleur des caratères a ecrire en rouge, car c'est une croix
Console.ForegroundColor = ConsoleColor.Red;
// change le caratère actuelle en croix
G_charTbl = 'x';
}
// ecrit le caratère actuelle dans le tableau principale
G_Tab_charCavalier[G_byteY, G_byteX] = G_charTbl;
// ecrit le caratère actuelle dans le tableau secondaire
G_Tab_charCavalierAnswer[G_byteY, G_byteX] = G_charTbl;
// si le caratère actuelle est un X, alors va ecrire dans le tableau de réponse un O, vu que on doit remplire le tableau user avec des O
if (G_charTbl == 'x')
{
// ecrit un O dans le tableau de réponse
G_Tab_charCavalierAnswer[G_byteY, G_byteX] = 'O';
}
// set le curseur pour ecrire le tableau principal
Console.SetCursorPosition(G_byteX, G_byteY);
// ecrit le caractère séléctionné par l'algoritme
Console.Write(G_charTbl);
// set le curseur pour ecrire le tableau secondaire
Console.SetCursorPosition(G_byteX + G_sbyteUser + 1, G_byteY);
// ecrit le caractère séléctionné par l'algoritme
Console.Write(G_charTbl);
} // fin boucle for X
} // fin boucle for Y
// initalisation pion
G_Tab_charCavalier[G_sbyteXUser, G_sbyteYUser] = 'O';
// change la couleur en gris
Console.ForegroundColor = ConsoleColor.Gray;
// met le curseur en dehor du tableau
Console.SetCursorPosition(5, G_sbyteYUser + G_sbyteUser);
// ecrit comment leave le jeu
Console.Write("Appuyze sur Escape pour quitter le jeu");
// met le curseur en dehor du tableau avec y + 1
Console.SetCursorPosition(5, G_sbyteYUser + G_sbyteUser + 1);
// ecrit comment reset le jeu
Console.Write("Appuyze sur 'r' pour reset le cavalier");
return(G_Tab_charCavalierAnswer.Cast <char>().ToArray());
} // fin void static Tableau()
} // fin static sbyte CheckTbl
/// <summary>
/// Cavalier : programme qui permet de déplacer le pion de l'user
/// Problème : je n'arrivais pas reset le tableau flatten, ducoup je l'ai transformé en bool, si le bool est true alors reset le tableau a flatten
/// Succès : Oui
/// Optimisation : je pense c'est pas mal
/// </summary>
private static async Task <char[]> Cavalier()
{
char[] Tab_CharFlatten = G_Tab_charCavalierAnswer.Cast <char>().ToArray();
// regarde si le pion se trouve vers une bordure
CheckChar();
// change l'ecriture des craratères en vert
Console.ForegroundColor = ConsoleColor.Green;
// met la position du curseur en fonction de la position de l'user
Console.SetCursorPosition(G_sbyteXUser, G_sbyteYUser);
// ecrit le pion en vert
Console.Write('O');
// variable utilisé dans le switch
ConsoleKey controle = Console.ReadKey().Key;
switch (controle)
{
// optimiser le code en faisant un void static pour les condition voir si le pion est en dehor du cavalier
case ConsoleKey.LeftArrow:
// décrémentation vu que il va a droite
--G_sbyteXUser;
// remet le pion ou il était avant et ecrit un message d'erreur
G_sbyteXUser += await checkTbl(1);
// sort du switch
break;
case ConsoleKey.RightArrow:
// incrémentation vu que il bouge a droite
++G_sbyteXUser;
// remet le pion ou il était avant et ecrit un message d'erreur
G_sbyteXUser += await checkTbl(-1);
// sort du switch
break;
case ConsoleKey.UpArrow:;
// décrémentaiton G_sbyteYUser vu que il se dirrige en haut
--G_sbyteYUser;
// remet le pion ou il était avant et ecrit un message d'erreur
G_sbyteYUser += await checkTbl(1);
// sort du switch
break;
case ConsoleKey.DownArrow:
// incrémentation G_sbyteYUser vu que il se dirrige en bas
++G_sbyteYUser;
// remet le pion ou il était avant et ecrit un message d'erreur
G_sbyteYUser += await checkTbl(-1);
// sort du switch
break;
case ConsoleKey.Escape:
// quitte le programme
Environment.Exit(0);
// sort du switch
break;
case ConsoleKey.R:
// reset le cavalier, se réferer au static void Reset() pour le code
// return le tableau flatten
Tab_CharFlatten = Reset();
// sort du switch
break;
// si aucune de ces actions on été effectuées, alors sa veut dire que l'user a appuuyé sur une touche autre du clavier
default:
// met le curseur en dehor du cavalier
Console.SetCursorPosition(G_sbyteUser - 2, G_sbyteUser + 4);
// set la console en rouge
Console.ForegroundColor = ConsoleColor.Red;
// averti l'user d'use les touches du clavier
Console.Write("Veuillez appuyer sur une des flèches du clavier");
// sort du switch
break;
} // fin du switch
// permet de décorer le pion
DecoPion();
// return le tableau flatten actuelle ou celui du reset
return(Tab_CharFlatten);
} // fin static bool cavalier
private static bool AreEqual(this char[,] x, char[,] y)
{
return(x.Cast <char>().SequenceEqual(y.Cast <char>()));
}
static bool Equal(char[,] a, char[,] b) => a.Cast <char>().SequenceEqual(b.Cast <char>());
public int GetRetainedWaterTiles() => _materials.Cast <char>().Count(c => c == '~');
private static HashSet <char> UniqueCharsIn(char[,] chars)
{
return(new HashSet <char>(chars.Cast <char>().Distinct()));
}
public static int ResourceValue(char[,] matrix)
{
var letters = matrix.Cast <char>();
return(letters.Where(c => c == TREE).Count() * letters.Where(c => c == LUMBERYARD).Count());
}
public IEnumerator <char> GetEnumerator()
{
return(_tile.Cast <char>().GetEnumerator());
}
public int CountAllWoodedAreas()
{
return(CountWoodedAreas(_acres.Cast <char>()));
}
private static char[] TakeRow(this char[,] board, int rowNumber)
{
return(board.Cast <char>().Skip(rowNumber * 3).Take(3).ToArray());
}