public void EnqueueDequeue_StableCheck_01()
{
var person1 = new Person()
{
Name = "p1", Age = 1
};
var person2 = new Person()
{
Name = "p1", Age = 2
};
Assert.AreEqual(person1.GetHashCode(), person2.GetHashCode());
Assert.AreNotEqual(person1, person2);
var hashq = new HashQueue <Person>();
hashq.Enqueue(person1);
hashq.Enqueue(person2);
Assert.AreEqual(2, hashq.Count());
Person temp;
temp = hashq.Dequeue();
Assert.AreSame(person1, temp);
Assert.AreNotSame(person2, temp);
Assert.AreEqual(1, hashq.Count());
temp = hashq.Dequeue();
Assert.AreSame(person2, temp);
Assert.AreNotSame(person1, temp);
Assert.AreEqual(0, hashq.Count());
}
private void UpdateVisibleChunks()
{
Vector3 playerPos = player.GetTranslation();
IntVector2 playerChunk = new IntVector2((int)(playerPos.x / (Chunk.SIZE.x * Block.SIZE)), (int)(playerPos.z / (Chunk.SIZE.z * Block.SIZE)));
List <IntVector2> chunksLoadedThisUpdate = new List <IntVector2>();
for (int r = 0; r < CHUNK_LOAD_RADIUS; r++)
{
foreach (IntVector2 v in chunkLoadIndices[r])
{
IntVector2 thisChunkIndex = playerChunk + v;
chunksLoadedThisUpdate.Add(thisChunkIndex);
CreateChunk(thisChunkIndex, true);
}
}
//Load an extra ring of chunks, but don't build meshes for them
for (int r = CHUNK_LOAD_RADIUS; r < CHUNK_LOAD_RADIUS + 1; r++)
{
foreach (IntVector2 v in chunkLoadIndices[r])
{
IntVector2 thisChunkIndex = playerChunk + v;
chunksLoadedThisUpdate.Add(thisChunkIndex);
CreateChunk(thisChunkIndex, false);
}
}
chunksToRemove = new HashQueue <IntVector2>(loadedChunks.Keys.Except(chunksLoadedThisUpdate));
}
private (int winner, long score) PlayRecursiveCombat_WithHashing(IEnumerable <int> deck1cards,
IEnumerable <int> deck2cards)
{
var deck1 = new HashQueue(deck1cards);
var deck2 = new HashQueue(deck2cards);
var cache = new HashSet <(long, long)>();
int GetRoundWinner(int card1, int card2)
{
if (card1 <= deck1.Count && card2 <= deck2.Count)
{
return(PlayRecursiveCombat_WithHashing(deck1.Take(card1), deck2.Take(card2)).winner);
}
return(card1 > card2 ? 1 : 2);
}
while (deck1.Any() && deck2.Any())
{
var state = (deck1.Hash, deck2.Hash);
if (!cache.Add(state))
{
return(1, GetWinnerScore(deck1, deck2));
}
var card1 = deck1.Dequeue();
var card2 = deck2.Dequeue();
var winner = GetRoundWinner(card1, card2);
var winnerDeck = winner == 1 ? deck1 : deck2;
winnerDeck.Enqueue(winner == 1 ? card1 : card2);
winnerDeck.Enqueue(winner == 1 ? card2 : card1);
}
return(winner: deck1.Any() ? 1 : 2, GetWinnerScore(deck1, deck2));
}
public void Enqueue01()
{
var hashq = new HashQueue <int>();
hashq.Enqueue(1);
hashq.Enqueue(1);
Assert.AreEqual(2, hashq.Count());
}
public void PeekPeekTail01()
{
var hashq = new HashQueue <int>();
hashq.Enqueue(1);
hashq.Enqueue(2);
hashq.Enqueue(3);
Assert.AreEqual(1, hashq.Peek());
Assert.AreEqual(3, hashq.PeekTail());
}
public void Delete_HeadTail_02()
{
var hashq = new HashQueue <int>();
Assert.AreEqual(0, hashq.Count());
hashq.Enqueue(1);
Assert.AreEqual(1, hashq.Peek());
Assert.AreEqual(1, hashq.PeekTail());
hashq.Delete(1);
Assert.IsTrue(hashq.IsEmpty());
}
public void IsEmpty01()
{
var hashq = new HashQueue <int>();
Assert.IsTrue(hashq.IsEmpty());
hashq.Enqueue(1);
Assert.IsFalse(hashq.IsEmpty());
hashq.Dequeue();
Assert.IsTrue(hashq.IsEmpty());
Assert.Throws <EmptyException>(() => hashq.Dequeue());
}
public void Delete_ReEnqueue_03()
{
var hashq = new HashQueue <int>();
Assert.AreEqual(0, hashq.Count());
hashq.Enqueue(1);
Assert.AreEqual(1, hashq.Count());
hashq.Delete(1);
Assert.AreEqual(0, hashq.Count());
hashq.Enqueue(1);
Assert.AreEqual(1, hashq.Count());
}
public void Clear01()
{
var hashq = new HashQueue <int>();
hashq.Enqueue(1);
hashq.Enqueue(2);
Assert.IsFalse(hashq.IsEmpty());
hashq.Clear();
Assert.IsTrue(hashq.IsEmpty());
hashq.Enqueue(1);
hashq.Enqueue(2);
Assert.IsFalse(hashq.IsEmpty());
}
public void Delete_Between_01()
{
var hashq = new HashQueue <int>();
Assert.AreEqual(0, hashq.Count());
hashq.Enqueue(1);
hashq.Enqueue(2);
hashq.Enqueue(3);
Assert.AreEqual(1, hashq.Peek());
Assert.AreEqual(3, hashq.PeekTail());
hashq.Delete(2);
Assert.AreEqual(1, hashq.Peek());
Assert.AreEqual(3, hashq.PeekTail());
}
public void EnqueueDequeue_StableCheck_02()
{
var hashq = new HashQueue <Person>();
var person1 = new Person()
{
Name = "p1", Age = 1
};
hashq.Enqueue(person1);
hashq.Enqueue(person1);
Assert.AreEqual(2, hashq.Count());
Assert.AreSame(person1, hashq.Dequeue());
Assert.AreEqual(1, hashq.Count());
Assert.AreSame(person1, hashq.Dequeue());
Assert.AreEqual(0, hashq.Count());
}
private static void Main(string[] args)
{
HashQueue <int> queue = new HashQueue <int>(5);
queue.Add(1);
queue.Add(2);
queue.Add(3);
queue.Add(4);
queue.Add(5);
queue.Add(6);
queue.ProcessItems((i) => Console.Write(i));
//foreach (int i in queue)
//{
// Console.Write("{0}", i);
//}
}
public void Enumerate01()
{
var count = 1000000;
var sw = new Stopwatch();
var hashq = new HashQueue <int>();
for (int i = 0; i < count; i++)
{
hashq.Enqueue(i);
}
sw.Start();
foreach (var item in hashq)
{
}
sw.Stop();
var hashqTime = sw.ElapsedMilliseconds;
Console.WriteLine($"hashqTime: {hashqTime}");
sw.Reset();
var q = new Queue <int>();
for (int i = 0; i < count; i++)
{
q.Enqueue(i);
}
sw.Start();
foreach (var item in q)
{
}
sw.Stop();
var qTime = sw.ElapsedMilliseconds;
Console.WriteLine($"qTime: {qTime}");
Assert.Less(hashqTime, qTime * 10);
Assert.Less(hashqTime, 50);
}
public void Delete_DuplicateHashCode_04()
{
var person1 = new Person()
{
Name = "p1", Age = 1
};
var person2 = new Person()
{
Name = "p1", Age = 2
};
Assert.AreEqual(person1.GetHashCode(), person2.GetHashCode());
Assert.AreNotEqual(person1, person2);
var hashq = new HashQueue <Person>();
Assert.AreEqual(0, hashq.Count());
hashq.Enqueue(person1);
hashq.Enqueue(person2);
Assert.AreEqual(2, hashq.Count());
Assert.IsTrue(hashq.Delete(person2));
Assert.AreEqual(1, hashq.Count());
Assert.AreSame(person1, hashq.Peek());
}
public void Find01()
{
var count = 1000000;
var sw = new Stopwatch();
var hashq = new HashQueue <int>();
for (int i = 0; i < count; i++)
{
hashq.Enqueue(i);
}
sw.Start();
Assert.IsTrue(hashq.Delete(count - 1));
sw.Stop();
var hashqTime = sw.ElapsedMilliseconds;
Console.WriteLine($"hashqTime: {hashqTime}");
sw.Reset();
var q = new Queue <int>();
for (int i = 0; i < count; i++)
{
q.Enqueue(i);
}
sw.Start();
// Queue<T>.Remove(x) and Where(x) are O(n).
q.Where(x => x == count - 1).ToList();
sw.Stop();
var qTime = sw.ElapsedMilliseconds;
Console.WriteLine($"qTime: {qTime}");
Assert.Less(hashqTime, qTime);
Assert.Less(hashqTime, 10);
}
