public void Part1(string numbers, long expected)
{
var sut = new MemoryGame(numbers, 2020);
var actual = sut.Play();
Assert.Equal(expected, actual);
}
public void CalculateTheNthElement_WhenItsNoLongerInTheInitializationArray(int order, int expectedResult)
{
int[] numbers = { 0, 3, 6 };
var sut = new MemoryGame(numbers);
Assert.Equal(expectedResult, sut.CalculateFor(order));
}
public void SolveSecondPuzzle()
{
int[] numbers = { 2, 20, 0, 4, 1, 17 };
var sut = new MemoryGame(numbers);
Assert.Equal(814, sut.CalculateFor(30000000));
}
public void SolveFirstPuzzle()
{
int[] numbers = { 2, 20, 0, 4, 1, 17 };
var sut = new MemoryGame(numbers);
Assert.Equal(758, sut.CalculateFor(2020));
}
public void PartOne()
{
int target = 2020;
int word = MemoryGame.FindWordAtTurn(Input, target);
Assert.IsTrue(word == 1085);
}
public RunGame()
{
FormSettings formSettings = new FormSettings();
bool playGame = true;
m_RulesSTR = string.Format(@"Memory Game Rules:
Each player chooses two cards from the closed cards in his turn.
If both cards have the same picture, the player gets a point and his turn continues.
The game ends when all the cards are open.
The player with the most points is the winner
Enjoy!.");
while (playGame)
{
while (formSettings.DialogResult != DialogResult.Cancel && formSettings._FirstPlayerName == string.Empty || formSettings._SecondPlayerName == string.Empty)
{
formSettings.ShowDialog();
}
if (formSettings.DialogResult == DialogResult.OK)
{
m_MemoryGame = new MemoryGame(formSettings.gameType, formSettings.BoardRows, formSettings.BoardCals,
formSettings._FirstPlayerName, formSettings._SecondPlayerName);
BoardForm boardForm = new BoardForm(m_MemoryGame);
MessageBox.Show(m_RulesSTR, "Memory Game - Rules", MessageBoxButtons.OK);
Thread.Sleep(1000);
boardForm.ShowDialog();
if (boardForm.DialogResult != DialogResult.Yes)
{
playGame = false;
}
}
}
}
// GET: Admin/MemoryGames/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
MemoryGame MemoryGame = db.MemoryGames.Find(id);
if (MemoryGame == null)
{
return(HttpNotFound());
}
if (MemoryGame.UrlImagen != null)
{
var fullPath = Request.MapPath("~/media/upload/MemoryGame/" + MemoryGame.UrlImagen);
if (System.IO.File.Exists(fullPath))
{
System.IO.File.Delete(fullPath);
}
}
db.MemoryGames.Remove(MemoryGame);
db.SaveChanges();
return(RedirectToAction("Create", "MemoryGames", new { id = MemoryGame.JuegoOnlineId }));
}
public void Example1()
{
var game = new MemoryGame(new[] { 0, 3, 6 }).PlayUntil(10);
Assert.AreEqual(new[] { 0, 3, 6, 0, 3, 3, 1, 0, 4, 0 }, game.SpokenNumbers);
Assert.AreEqual(10, game.LastTurn);
}
public BoardForm(MemoryGame i_MemoryGame)
{
m_MemoryGame = i_MemoryGame;
firstPos = new Position(-1, -1);
secondPos = new Position(-1, -1);
m_CardsButtons = new MemoryGameCardButton[m_MemoryGame.GameBoard.Rows, m_MemoryGame.GameBoard.Cols];
initializeComponent();
}
public JsonResult Contestar(int id, int respuesta)
{
MemoryGame MemoryGame = db.MemoryGames.Find(id);
ResultadoMemoryGame resultado = new ResultadoMemoryGame();
return(Json(resultado, JsonRequestBehavior.AllowGet));
}
public void PartTwo()
{
int target = 30000000;
int word = MemoryGame.FindWordAtTurn(Input, target);
//< ~2s run time, not ideal but functional for the day
Assert.IsTrue(word == 10652);
}
public MainWindowViewModel()
{
_Game = new MemoryGame();
OpenCardCommand = new RelayCommand(CanOpenCard, DoOpenCard);
//StartCommand krijgt géén CanStart methode want dat enabled de button niet utomatisch; wordt nu geregeld door binding in
//de xaml van de button
StartCommand = new RelayCommand(null, DoStart);
}
// Algorithm to compare two revealed cards for match
public void CompareRevealedCard(MemoryGame revealedCard)
{
// Get references to two revealed cards
if (this.revealedCardCounter == 0)
{
this.firstRevealedCard = revealedCard;
this.revealedCardCounter += 1;
}
else
{
this.secondRevealedCard = revealedCard;
this.revealedCardCounter += 1;
}
// Compare the two revealed cards for match
if (this.revealedCardCounter == 2)
{
// If the two cards match...
if (firstRevealedCard.ID == secondRevealedCard.ID)
{
// Score
this.score += 1;
this.scoreLabel.GetComponent <TextMeshPro>().text = "SCORE " + this.score;
// Dim the colors
firstRevealedCard.Animate();
secondRevealedCard.Animate();
// Reset references
firstRevealedCard = null;
secondRevealedCard = null;
// Reset counter
this.revealedCardCounter = 0;
}
else
{
// Punish
if (this.score > 0)
{
this.score -= 1;
this.scoreLabel.GetComponent <TextMeshPro>().text = "SCORE " + this.score;
}
// After a second, unreveal the first card
StartCoroutine(Wait(firstRevealedCard));
// First card is now the second card
firstRevealedCard = secondRevealedCard;
// Reset second card for reuse
secondRevealedCard = null;
this.revealedCardCounter = 1;
}
}
}
static void Main(string[] args)
{
var memoryGame = new MemoryGame(File.ReadAllLines("../input.txt").First());
//Part One
Console.WriteLine(memoryGame.GetNumberAtTurn(2020));
//Part Two
Console.WriteLine(memoryGame.GetNumberAtTurn(30000000));
}
void OnEnable()
{
memoryGame = (target as MemoryGame).gameObject.GetComponent <MemoryGame>();
switchOn = (Texture2D)Resources.Load("switch on") as Texture2D;
switchOff = (Texture2D)Resources.Load("switch off") as Texture2D;
viewImages = new AnimBool(false);
viewImages.valueChanged.AddListener(Repaint);
}
public void Test_KnownResults_2020()
{
int target = 2020;
foreach (var tup in KnownResults_2020)
{
var word = MemoryGame.FindWordAtTurn(tup.Item1, target);
Assert.IsTrue(word == tup.Item2);
}
}
static void Main(string[] args)
{
var game = new MemoryGame();
game.Init("input.txt");
while (game.Turn <= 30000000)
{
game.NextTurn();
}
}
public void Part2_WithOtherSamples_ShouldReturnExpected(string sampleInput, long expected)
{
string[] input = sampleInput.Split(',',
StringSplitOptions.TrimEntries |
StringSplitOptions.RemoveEmptyEntries
);
List <long> numbers = input.Select(long.Parse).ToList();
MemoryGame game = new MemoryGame(numbers);
long total = game.Play(30000000);
Assert.Equal(expected, total);
}
public void ValidateMemoryGeneration()
{
//Arrange
var game = new MemoryGame();
short numberOfPairs = 5;
//Act
var r = game.GenerateCards(numberOfPairs);
//Assert
Assert.Equal(numberOfPairs * 2, r.Count());
}
public void CardRevealed(MemoryGame card)
{
if (_firstRevealed == null)
{
_firstRevealed = card;
}
else
{
_secondRevealed = card;
StartCoroutine(CheckMatch());
}
}
public void Part2Test(int n1, int n2, int n3, int value)
{
// Given
var start = new[] { n1, n2, n3 };
var game = new MemoryGame(start);
// When
var actual = game.Play().Take(30000000).Last();
// Then
Assert.Equal(value, actual);
}
public void ValidateMemoryGeneration2()
{
//Arrange
var game = new MemoryGame();
short numberOfPairs = short.MaxValue;
//Act
var r = game.GenerateCards(numberOfPairs);
var groupBy = r.GroupBy(a => a).Select(g => g.Count());
//Assert
Assert.All(groupBy, g => Assert.True(g == 2));
}
public void Part1_WithSampleInput_ShouldReturn436()
{
string sampleInput = @"0,3,6";
string[] input = sampleInput.Split(',',
StringSplitOptions.TrimEntries |
StringSplitOptions.RemoveEmptyEntries
);
List <long> numbers = input.Select(long.Parse).ToList();
MemoryGame game = new MemoryGame(numbers);
long total = game.Play(2020);
Assert.Equal(436, total);
}
public void ValidateMemoryGeneration3()
{
//Arrange
var game = new MemoryGame();
short numberOfPairs = 3;
//Act
var r1 = game.GenerateCards(numberOfPairs).ToArray();
var r2 = game.GenerateCards(numberOfPairs).ToArray();
var r3 = game.GenerateCards(numberOfPairs).ToArray();
//Assert
Assert.NotEqual(r1, r2);
Assert.NotEqual(r2, r3);
}
public void Part1Test()
{
// Given
var start = new[] { 0, 3, 6 };
var game = new MemoryGame(start);
// When
var play = game.Play().Take(10);
// Then
Assert.Equal(
new[] { 0, 3, 6, 0, 3, 3, 1, 0, 4, 0 },
play
);
}
private IEnumerator CheckMatch()
{
if (_firstRevealed.id == _secondRevealed.id)
{
_score++;
scoreLabel.text = "Score: " + _score;
}
else
{
yield return(new WaitForSeconds(0.5f));
_firstRevealed.Unreveal();
_secondRevealed.Unreveal();
}
_firstRevealed = null;
_secondRevealed = null;
}
private void MemoryGame_Click(object sender, EventArgs e)
{
try
{
//MessageBox.Show("Work In Progress!!!", "<3 Not Ready <3");
m_SoundsYesAndNo.controls.stop();
m_Musicplayer.controls.stop();
this.Close();
MemoryGame m_MemoryGameForm = new MemoryGame();
m_MemoryGameForm.Show();
GarbageCollector();
}
catch
{
}
}
private void initializeGameSettings()
{
GameSettingsForm settingsForm = new GameSettingsForm();
settingsForm.ShowDialog();
string firstPlayerName = settingsForm.FirstPlayerName;
string secondPlayerName = settingsForm.SecondPlayerName;
firstPlayerName = firstPlayerName.Equals(string.Empty) ? "First Player" : settingsForm.FirstPlayerName;
secondPlayerName = secondPlayerName.Equals(string.Empty) ? "Second Player" : settingsForm.SecondPlayerName;
int heightOfBoard = int.Parse(settingsForm.HeightAndWidthOfBoard[k_IndexOfHeight].ToString());
int widthOfBoard = int.Parse(settingsForm.HeightAndWidthOfBoard[k_IndexOfWidth].ToString());
this.m_LogicMemoryGame = new MemoryGame(
firstPlayerName,
settingsForm.IsAgainstAFriend,
secondPlayerName,
heightOfBoard,
widthOfBoard);
this.m_GameBoard = new PictureBox[m_LogicMemoryGame.GameBoard.Height, m_LogicMemoryGame.GameBoard.Width];
this.m_BoardContainingTheHiddenImages = new PictureBox[m_LogicMemoryGame.GameBoard.Height, m_LogicMemoryGame.GameBoard.Width];
}
public void ValidateStateConcepts()
{
//Arrange
var game = new MemoryGame();
//Act / assert
//Start
game.Start();
Assert.Equal(typeof(StartedState), game.MyState.GetType());
//Stop
game.Stop();
Assert.Equal(typeof(StoppedState), game.MyState.GetType());
//Paused
game.Start();
game.Pause();
Assert.Equal(typeof(PausedState), game.MyState.GetType());
//Resume
game.Resume();
Assert.Equal(typeof(StartedState), game.MyState.GetType());
}
private static string PartX(string input, int iterations)
{
var digits = input.Split(',').ToInts()
.ToList();
var data = new MemoryGame();
var nextNumber = -1;
for (var i = 0; i < iterations; i++)
{
if (i < digits.Count)
{
nextNumber = data.Say(digits[i], i);
}
else
{
nextNumber = data.Say(nextNumber, i);
}
}
return(data.LastNumber.ToString());
}
