public void SolveSecondPuzzle()
{
var sut = new RecursiveCombat(PuzzleData.PUZZLE_DATA);
sut.Play();
sut.CalculatePointsForWinner();
Assert.Equal(32665, sut.WinnerPoints);
}
public void PlayRecursiveGameCorrectly()
{
var sut = new RecursiveCombat(PuzzleData.SAMPLE_DATA);
sut.Play();
sut.CalculatePointsForWinner();
Assert.Equal(291, sut.WinnerPoints);
}
public void ReturnPoints_WhenCalculatingWinnerPointsAfterTheRecursiveGame()
{
var sut = new RecursiveCombat(PuzzleData.SAMPLE_DATA);
sut.PlayTurns(17);
sut.CalculatePointsForWinner();
Assert.Equal(291, sut.WinnerPoints);
}
public object PartB(string input)
{
(Player player1, Player player2) = ParseInput(input);
Player winner = new RecursiveCombat(player1, player2).Play();
int handSize = winner.Hand.Count;
return(winner.Hand
.Select((card, index) => (Card: card, Index: handSize - index))
.Aggregate(0, (score, pair) => score + pair.Card * pair.Index));
}
public override string Second()
{
string filename = GetFilename();
List <string> input = System.IO.File.ReadAllLines(filename).ToList();
PRINT = false;
RecursiveCombat game = new RecursiveCombat(input);
game.PlayGame();
var result = game.Score();
return(result.ToString());
}
protected override void SetResultOfRound()
{
// CHECK IF A RECURSIVE GAME SHOULD HAPPEN
// If both players have at least as many cards remaining
// in their deck as the value of the card they just drew,
// the winner of the round is determined by playing a new game of Recursive Combat.
Player playerWon;
bool playSubgame = Players.All(p => p.NrOfCards >= p.PlayedCard);
if (playSubgame)
{
if (PRINT)
{
Console.WriteLine("Playing a sub-game to determine the winner...");
}
var playersWithNewCards = Players.Select(p => new Player(p.Name, p.Cards.ToList().Take(p.PlayedCard).ToList())).ToList();
SubGame++;
var newGame = new RecursiveCombat(playersWithNewCards, SubGame);
var playerWonRecursiceGame = newGame.PlayGame();
playerWon = Players.FirstOrDefault(p => p.Name == playerWonRecursiceGame.Name);
var otherPlayer = Players.FirstOrDefault(p => p.Name != playerWonRecursiceGame.Name);
// note that the winner's card might be the lower-valued of the two cards
playerWon.WonCards(playerWon.PlayedCard, otherPlayer.PlayedCard);
if (PRINT)
{
Console.WriteLine($"...anyway, back to game {GameNr}.");
}
}
else
{
// find player with the highest card!
playerWon = Players.OrderBy(p => p.PlayedCard).Reverse().FirstOrDefault();
CardsOnTable.Sort();
CardsOnTable.Reverse();
playerWon.WonCards(CardsOnTable);
}
if (PRINT)
{
Console.WriteLine($"{playerWon.Name} wins round {Round} of game {GameNr}!");
}
// reset round!
Players.ForEach(p => p.ResetRound());
CardsOnTable = new List <int>();
}
public void TestInfiniteGame()
{
var input = @"Player 1:|43|19||Player 2:|2|29|14".Replace("|", Environment.NewLine); var(player1, player2) = DeckParser.Parse(input);
var game = new RecursiveCombat(new List <Player> {
player1, player2
});
while (!game.Complete())
{
game.PlayRound();
}
Assert.Equal(78, player2.CalculateScore());
}
public override bool Test2()
{
string filename = GetTestFilename();
List <string> input = System.IO.File.ReadAllLines(filename).ToList();
PRINT = false;
RecursiveCombat game = new RecursiveCombat(input);
game.PlayGame();
var result = game.Score();
bool testSucceeded = result == 291;
return(testSucceeded);
}
public void ScoreCalcTestPuzzle2()
{
var input = @"Player 1:|9|2|6|3|1||Player 2:|5|8|4|7|10".Replace("|", Environment.NewLine);
var(player1, player2) = DeckParser.Parse(input);
var game = new RecursiveCombat(new List <Player> {
player1, player2
});
while (!game.Complete())
{
game.PlayRound();
}
Assert.Equal(291, player2.CalculateScore());
}
public Player Play()
{
while (Player1.Hand.Count > 0 && Player2.Hand.Count > 0)
{
int player1HandHash = HashHand(Player1.Hand);
int player2HandHash = HashHand(Player2.Hand);
// Avoid infinite recursion
if (player1History.Contains(player1HandHash) && player2History.Contains(player2HandHash))
{
return(Player1);
}
// Add the current state
player1History.Add(player1HandHash);
player2History.Add(player2HandHash);
int player1Card = Player1.Hand.Dequeue();
int player2Card = Player2.Hand.Dequeue();
Player winner;
// Recursive game
if (player1Card <= Player1.Hand.Count && player2Card <= Player2.Hand.Count)
{
RecursiveCombat nextGame = new RecursiveCombat(new Player(Player1, player1Card), new Player(Player2, player2Card));
winner = nextGame.Play();
}
else
{
winner = player1Card > player2Card ? Player1 : Player2;
}
if (winner.Id == Player1.Id)
{
Player1.Hand.Enqueue(player1Card);
Player1.Hand.Enqueue(player2Card);
}
else
{
Player2.Hand.Enqueue(player2Card);
Player2.Hand.Enqueue(player1Card);
}
}
return(Player1.Hand.Count == 0 ? Player2 : Player1);
}
public void PreventInfiniteRecursion()
{
const string decks = @"Player 1:
43
19
Player 2:
2
29
14";
var sut = new RecursiveCombat(decks);
sut.Play();
sut.CalculatePointsForWinner();
Assert.Equal(105, sut.WinnerPoints);
}
public void CorrectlyModifyPlayerCards_AfterPlayingFiveRecursiveTurns()
{
var sut = new RecursiveCombat(PuzzleData.SAMPLE_DATA);
sut.PlayTurns(5);
Assert.Collection(sut.Players[0],
p1 => Assert.Equal(9, p1),
p2 => Assert.Equal(5, p2),
p3 => Assert.Equal(6, p3),
p4 => Assert.Equal(4, p4));
Assert.Collection(sut.Players[1],
p1 => Assert.Equal(8, p1),
p2 => Assert.Equal(2, p2),
p3 => Assert.Equal(7, p3),
p4 => Assert.Equal(3, p4),
p5 => Assert.Equal(10, p5),
p6 => Assert.Equal(1, p6));
}
public void CorrectlyModifyPlayerCards_AfterPlayingSeventeenRecursiveTurns()
{
var sut = new RecursiveCombat(PuzzleData.SAMPLE_DATA);
sut.PlayTurns(17);
Assert.Empty(sut.Players[0]);
Assert.Collection(sut.Players[1],
p1 => Assert.Equal(7, p1),
p2 => Assert.Equal(5, p2),
p3 => Assert.Equal(6, p3),
p4 => Assert.Equal(2, p4),
p5 => Assert.Equal(4, p5),
p6 => Assert.Equal(1, p6),
p7 => Assert.Equal(10, p7),
p8 => Assert.Equal(8, p8),
p9 => Assert.Equal(9, p9),
p10 => Assert.Equal(3, p10));
}
public void Puzzle2()
{
var input = new FileReader()
.GetResource("AdventOfCode2020.Tests.Day22.PuzzleInput.txt");
var(player1, player2) = DeckParser.Parse(input);
var game = new RecursiveCombat(new List <Player> {
player1, player2
});
while (!game.Complete())
{
game.PlayRound();
}
Assert.Equal(1800, game.Rounds);
Assert.Equal(9833, game.GetWinner().CalculateScore());
}
