public void NumbersAreOrderedByColumn()
{
var columns = string.Join("", BingoCard.GetCard().ToList()
.Select(x => x.Substring(0, 1)).ToArray());
Assert.IsTrue(Regex.IsMatch(columns, "^[B]*[I]*[N]*[G]*[O]*$"));
}
private static List <BingoCard> GetCards()
{
List <BingoCard> cards = new();
int rowNumber = 0;
BingoCard card = null;
for (int i = 1; i < Input.Count; i++)
{
if (Input[i] == "")
{
if (card == null)
{
card = new BingoCard();
rowNumber = 0;
}
else
{
cards.Add(card);
card = new BingoCard();
rowNumber = 0;
}
}
else
{
card.AddRow(rowNumber, Input[i]);
rowNumber++;
}
}
cards.Add(card);
return(cards);
}
public void ProblemTwo()
{
var cards = ParseInput(Input, out List <int> drawNumbers);
BingoCard lastWinner = null;
var lastWinnerLastDrawnNumber = 0;
for (int i = 0; i < drawNumbers.Count; i++)
{
var number = drawNumbers[i];
List <BingoCard> winners = new List <BingoCard>();
foreach (var card in cards)
{
if (card.DrawNumber(number))
{
winners.Add(card);
//Asume only 1 end winner
lastWinner = card;
lastWinnerLastDrawnNumber = number;
}
}
winners.ForEach(i => cards.Remove(i));
}
//19000 too high
var score = lastWinner.CalculateScore(lastWinnerLastDrawnNumber);
Console.WriteLine(score);
}
private static int Part2()
{
string bingoBalls = Input[0];
List <BingoCard> cards = GetCards();
string[] draws = bingoBalls.Split(',');
for (int i = 0; i < draws.Length; i++)
{
foreach (BingoCard card in cards)
{
if (!card.HasBingo)
{
if (int.TryParse(draws[i], out int ball))
{
card.CheckNumber(ball, i);
}
}
}
if (!cards.Any(card => !card.HasBingo))
{
break;
}
}
BingoCard lastToWin = cards.Where(card => card.WonAtDraw == cards.Max(card => card.WonAtDraw)).FirstOrDefault();
return(lastToWin.Score);
}
public void GetCard_Twice_Should_Be_Different_Set()
{
var card1 = BingoCard.GetCard().ToExpectedObject();
var card2 = BingoCard.GetCard();
card1.ShouldNotEqual(card2);
}
public static void Main()
{
// Your code here!
Console.Write("nを代入してください");
int n = int.Parse(Console.ReadLine());
Console.Write("mを代入してください");
int m = int.Parse(Console.ReadLine());
BingoCard A = new BingoCard();
Console.WriteLine("---------宿題２－1---------");
var bingo = A.ReturnCard(n, m);
for (int i = 0; i < bingo.Length; i++)
{
for (int j = 0; j < bingo[i].Length; j++)
{
Console.Write("|" + bingo[i][j]);
}
Console.WriteLine("|");
}
Console.WriteLine("---------宿題２－4---------");
Console.WriteLine(A.BingoAve(3, 5, 10000));
Console.WriteLine("---------宿題２－５---------");
A.Graph();
}
public void Part1(string[] lines)
{
var numCards = (lines.Length - 1) / 6;
var bingoCards = new List <BingoCard>();
for (int i = 0; i < numCards; i++)
{
var cardLines = new ArraySegment <string>(lines, 2 + (6 * i), 5);
var card = new BingoCard(cardLines.ToArray());
bingoCards.Add(card);
}
var numbers = lines[0].Split(",").Select(x => long.Parse(x)).ToList();
foreach (var number in numbers)
{
foreach (var card in bingoCards)
{
if (card.CallNumber(number))
{
var uncalledValue = card.GetUncalledCardValue();
Console.WriteLine($"Card has bingo. Uncalled value is {uncalledValue}. Last number called is: {number}. Score is: {uncalledValue * number}.");
return;
}
}
}
}
public IActionResult Index()
{
// Make the Bingo grid
var grid = Enumerable.Range(0, 5)
.Select((c, i) => Enumerable.Range(0, 19).Select(d => d + i * 20 + 1).Shuffle().ToArray().Take(5).ToArray())
.ToArray();
// Flatten the grid for storage in the DB
var flattenedGrid = Enumerable.Range(0, 5).SelectMany(c => Enumerable.Range(0, 5).Select(d => grid[d][c]))
.ToList();
// Remove the free space
flattenedGrid.RemoveAt(12);
// Generate the card
var card = new BingoCard {
DateCreated = DateTime.Now,
Numbers = flattenedGrid
.Select((c, i) => new BingoNumber {
Number = c,
Order = i
})
.ToArray()
};
_context.Cards.Add(card);
_context.SaveChanges();
return(RedirectToAction("Show", "Cards", new { id = card.CardNumber }));
}
public void OneTimeSetUp()
{
_card = new BingoCard(5, 3);
_numbers = _card.GetNumbers();
_numbers[2, 0] = 0;
_numbers[2, 1] = 0;
_numbers[2, 2] = 0;
}
public void When_GetCard_Should_Return_Start_With_BINGO_And_Number()
{
var bingoCard = BingoCard.GetCard();
foreach (var number in bingoCard.ToList())
{
Assert.IsTrue(Regex.IsMatch(number, "^[BINGO][0-9]*$"));
}
}
public void VerticalBingo()
{
BingoCard card = new BingoCard();
for (int column = 0; column < BingoCard.MaxColumns - 1; column++)
{
Assert.IsFalse(card.Mark(card.GetCard()[0, column].Number));
}
Assert.IsTrue(card.Mark(card.GetCard()[0, BingoCard.MaxColumns - 1].Number));
}
public void HorizontalBingo()
{
BingoCard card = new BingoCard();
for (int row = 0; row < BingoCard.MaxColumns - 1; row++)
{
Assert.IsFalse(card.Mark(card.GetCard()[row, 0].Number));
}
Assert.IsTrue(card.Mark(card.GetCard()[BingoCard.MaxRows - 1, 0].Number));
}
public void TopRightDiagonalBingo()
{
BingoCard card = new BingoCard();
for (int n = 0; n < BingoCard.MaxColumns - 1; n++)
{
Assert.IsFalse(card.Mark(card.GetCard()[n, BingoCard.MaxColumns - n - 1].Number));
}
Assert.IsTrue(card.Mark(card.GetCard()[BingoCard.MaxRows - 1, 0].Number));
}
public void T14GoldenTest()
{
for (int j = 0; j < 500; j++)
{
Bingo bingo = new Bingo(20);
BingoCard bc = bingo.bingoCard;
bingo.CommenceGame();
Assert.True(bc.card == bingo.bingoCard.card);
Assert.True(bingo.status == "win" || bingo.status == "lose");
}
}
private string getRandomID(BingoCard card, Random rnd, int caprnd)
{
int rndnumber = (byte)rnd.Next(caprnd, caprnd+_jump_random_number);
string id = rndnumber.ToString();
if (!card.Contains(id))
{
addUniqueId(id);
return id;
}
else return getRandomID(card, rnd, caprnd);
}
public void NumbersWithinColumnAreAllInTheCorrectRange(string column, int start, int end)
{
var numbers = BingoCard.GetCard().Where(x => x.StartsWith(column)).ToList();
foreach (var number in numbers)
{
var n = Convert.ToInt32(number.Substring(1));
Assert.GreaterOrEqual(n, start, "Column {0} should be in the range between {1} and {2}, found: {3}", column, start, end, number);
Assert.LessOrEqual(n, end, "Column {0} should be in the range between {1} and {2}, found: {3}", column, start, end, number);
}
}
/**
* @method Cause a bingo card's information to be copied into our singleton UI
* @param card - The card whose information we wish to copy.
* @returns None; the information held in the bingo card UI will be overwritten with the contents of this card.
*/
private void LoadBingoCardIntoUI(BingoCard card)
{
// Find our UI object.
BingoCardUI ui = FindObjectOfType <BingoCardUI>();
if (ui != null)
{
// If we found it, load this card into the UI.
ui.LoadBingoCard(card);
EditorUtility.SetDirty(ui);
}
}
private static BingoState CardDaubNumber(BingoState state, CardDaubNumberAction action)
{
BingoCard card = state.Cards[action.CardIndex];
int attemptedNumber = card.Numbers[action.NumberIndex];
if (state.CalledNumbers.Contains(attemptedNumber))
{
card.DaubedIndexes.Add(action.NumberIndex);
}
return(state);
}
public void When_GetCard_Should_contain_Char_Below_B_I_N_G_O()
{
var expecteds = new List <string>()
{
"B", "I", "N", "G", "O"
};
var bingoCard = BingoCard.GetCard();
foreach (var expected in expecteds)
{
Assert.IsTrue(new List <string>(bingoCard).Any(x => x.Contains(expected)));
}
}
private static void Main(string[] args)
{
var a = ReadIntsLinesAsList(3);
var n = ReadInt();
var b = ReadIntLinesAsList(n);
var card = new BingoCard(a);
b.ForEach((number) => card.Mark(number));
var answer = (card.HasBingo()) ? "Yes" : "No";
Console.WriteLine(answer);
}
private BingoCard scrambleACard()
{
BingoCard card = new BingoCard();
byte caprndnumber = _min_random_number;
for(byte ci = 0; ci < _max_cols; ci++)
{
for (byte ri = 0; ri < _max_rows; ri++)
{
string id = getRandomID(card, rnd, caprndnumber);
card.Add(id);
}
caprndnumber += _jump_random_number;
}
return card;
}
public void NumbersWithinColumnAreInRandomOrder()
{
var card = BingoCard.GetCard().Select(x => Convert.ToInt32(x.Substring(1))).ToArray();
var isRandom = false;
for (var i = 1; i < card.Length; i++)
{
if (card[i - 1] > card[i])
{
isRandom = true;
break;
}
}
Assert.IsTrue(isRandom, "Unlikely result, is the list ordered?");
}
//public Transform mpfBingoNumber;
// Use this for initialization
void Start()
{
string[] bingoChar = { "B", "I", "N", "G", "O" };
Rect rtCanvas = this.GetComponent <RectTransform>().rect;
myBingoCards = new BingoCard[2];
myBingoCards[0] = new BingoCard();
myBingoCards[0].initialize("Panigale1", "images/bingoCard", new Vector2(rtCanvas.min.x, rtCanvas.max.y), 150.0f, this.transform);
myBingoCards[1] = new BingoCard();
myBingoCards[1].initialize("Panigale2", "images/bingoCard", new Vector2(rtCanvas.min.x, rtCanvas.max.y - 180.0f), 150.0f, this.transform);
resetBingoNumber(mBingoNumbers);
StartCoroutine(callNumber());
Debug.Log("Start end");
}
public void RandomnessTest()
{
var card = BingoCard.GetCard();
var cardNumberCount = (new int[24]).ToList();
for (var i = 0; i < 100; i++)
{
var c = BingoCard.GetCard();
for (var j = 0; j < 24; j++)
{
if (card[j] == c[j])
{
cardNumberCount[j]++;
}
}
}
Assert.IsFalse(cardNumberCount.Any(x => x > 30), "The same number appeared on more than 30 of the 100 cards on the same spot, are the cards random?");
}
public override void OnInspectorGUI()
{
BingoCard card = target as BingoCard;
int validContentCount = card.ValidContentCount;
if (validContentCount < 24)
{
EditorGUILayout.LabelField(validContentCount.ToString() + " / 24 Pieces of Valid Content Entered");
}
else
{
if (GUILayout.Button("Load Into UI"))
{
LoadBingoCardIntoUI(card);
}
}
GUILayout.Space(20);
base.OnInspectorGUI();
}
private void resetBingoNumber(BingoNumber [] bingoNumber)//게임 진행시 번호호출순서를 섞는다.
{
string[] bingoChar = { "B", "I", "N", "G", "O" };
int count = 0;
for (int n = 0; n < 5; n++)
{
for (int i = 0; i < 15; i++)
{
count = i + (n * 15);
bingoNumber[count].number = count + 1;
bingoNumber[count].bingoChar = bingoChar[n];
}
}
//shuffle(ref bingoNumber);
BingoCard.shuffle(ref bingoNumber);
mBingoCounter = 0;
}
private static List <BingoCard> ParseCards(IEnumerable <string> game)
{
var lines = new List <string>();
var cards = new List <BingoCard>();
foreach (string line in game.Skip(2))
{
if (string.IsNullOrEmpty(line))
{
cards.Add(BingoCard.Create(lines));
lines.Clear();
continue;
}
lines.Add(line);
}
cards.Add(BingoCard.Create(lines));
return(cards);
}
private static int Part1()
{
string bingoBalls = Input[0];
List <BingoCard> cards = GetCards();
string[] draws = bingoBalls.Split(',');
bool stop = false;
for (int i = 0; i < draws.Length; i++)
{
foreach (BingoCard card in cards)
{
if (int.TryParse(draws[i], out int ball))
{
card.CheckNumber(ball, i);
}
if (card.HasBingo)
{
stop = true;
break;
}
}
if (stop)
{
break;
}
}
int countWinningBoards = cards.Count(card => card.HasBingo);
BingoCard bingoCard = cards.Where(card => card.Score == cards.Max(card => card.Score)).FirstOrDefault();
return(bingoCard.Score);
}
private bool containsCard(BingoCard card)
{
if (_cards.Count == 0) return false;
return _cards.Contains(card);
}
public void OneTimeSetUp()
{
_card = new BingoCard(5, 3);
_drawnNumber = _card.GetRandomNumber();
_card.MarkNumberAsDrawn(_drawnNumber);
}
public void OneTimeSetUp()
{
_card = new BingoCard(5, 3);
}
/**
* @method Cause a bingo card's information to be copied intothis UI
* @param card - The card whose information we wish to copy.
* @returns None; the information held in the bingo card UI will be overwritten with the contents of this card.
*/
public void LoadBingoCard(BingoCard card)
{
// Set colors.
ScreenBackground.color = card.ScreenBackgroundColor;
CardBackground.color = card.CardBackgroundColor;
TileBackground.color = card.TileBackgroundColor;
TitleText.text = card.Title;
TitleText.color = card.TitleTextColor;
if (card.TitleFont != null)
{
TitleText.font = card.TitleFont;
}
// Obtain all tiles.
BingoCardTileUI[] tiles = TileBackground.gameObject.GetComponentsInChildren <BingoCardTileUI>();
// Obtain all usable content and create a sorted list of content to place into the card.
List <BingoCard.Content> validContent = card.GetValidContent();
List <RandomizedTileContent> randomizedContent = new List <RandomizedTileContent>();
foreach (BingoCard.Content content in validContent)
{
randomizedContent.Add(new RandomizedTileContent(content));
}
// Sort our content.
randomizedContent.Sort();
// Place content into all of our tiles.
int count = 0;
foreach (BingoCardTileUI tile in tiles)
{
// Is this tile the free space?
if (tile.IsFreeSpace)
{
tile.Background.color = card.FreeSpaceLiningColor;
tile.Interior.color = card.FreeSpaceInteriorColor;
tile.ContentText.color = card.FreeSpaceTextColor;
if (card.FreeSpaceFont != null)
{
tile.ContentText.font = card.FreeSpaceFont;
}
if (card.CustomFreeSpaceContent.IsValid)
{
tile.ContentText.text = card.CustomFreeSpaceContent.Text;
}
else
{
tile.ContentText.text = "FREE SPACE";
}
}
else
{
tile.Background.color = card.ContentLiningColor;
tile.Interior.color = card.ContentInteriorColor;
tile.ContentText.color = card.ContentTextColor;
if (card.ContentFont != null)
{
tile.ContentText.font = card.ContentFont;
}
tile.ContentText.text = randomizedContent[count].Text;
++count;
}
}
}
public void ColumnContainsCorrectNumberOfItems(string column, int count)
{
var numbers = BingoCard.GetCard().Where(x => x.StartsWith(column)).ToList();
Assert.AreEqual(count, numbers.Count);
}
