public void Get_Missing()
{
HashTable<string, int> table = new HashTable<string, int>();
table.Add("100", 100);
int value = table["missing"];
}
static public void Main()
{
IHash hash;
HashTable.HashTable hashTable;
Console.WriteLine("Type:\n -0 to use first function,\n -1 to use second function.");
ushort command = Convert.ToUInt16(Console.ReadLine());
while (command > 1)
{
Console.WriteLine("Wrong input! Try again.");
command = Convert.ToUInt16(Console.ReadLine());
}
if (command == 1)
{
hash = new Hash2();
}
else
{
hash = new Hash1();
}
hashTable = new HashTable.HashTable(hash);
hashTable.Add(1);
for (int i = 0; i < 1000; ++i)
{
hashTable.Add(51 * i);
}
Console.WriteLine(hashTable.Search(33));
Console.WriteLine(hashTable.Search(102));
hashTable.DeleteElement(51);
hashTable.DeleteElement(0);
Console.WriteLine(hashTable.Search(0));
// hash.Print();
}
public static void Main(string[] args)
{
var hashTable = new HashTable<int,string>();
hashTable.Add(1, "Test")
.Add(2, "Test 2")
.Add(3, "Test 3")
.Add(0, "Test 4")
.Add(16, "Test 5")
.Add(19, "Test 37")
.Add(19, "Test 200")
.Remove(3);
for (int i = 20; i < 50; i++)
{
hashTable.Add(i, "String " + i);
}
Console.WriteLine(string.Join(" ", hashTable.Keys));
Console.WriteLine(hashTable[2]);
foreach (var pair in hashTable)
{
Console.WriteLine(pair);
}
}
public void Add_Unique_Adds()
{
HashTable<string, int> table = new HashTable<string, int>();
List<int> added = new List<int>();
for (int i = 0; i < 100; i++)
{
Assert.AreEqual(i, table.Count, "The count was incorrect");
int value = _rng.Next();
string key = value.ToString();
// this ensure we should never throw on Add
while (table.ContainsKey(key))
{
value = _rng.Next();
key = value.ToString();
}
table.Add(key, value);
added.Add(value);
}
// now make sure all the keys and values are there
foreach (int value in added)
{
Assert.IsTrue(table.ContainsKey(value.ToString()), "ContainsKey returned false?");
Assert.IsTrue(table.ContainsValue(value), "ContainsValue returned false?");
int found = table[value.ToString()];
Assert.AreEqual(value, found, "The indexed value was incorrect");
}
}
public static void Main(string[] args)
{
Console.WriteLine ("Phonebook. Available commands:");
Console.WriteLine ("");
Console.WriteLine ("- a [name]|[phone] : Adds new contact.");
Console.WriteLine ("- s [name] : Searches for specific name.");
Console.WriteLine ("- q : quit.");
Console.WriteLine ("");
var phoneBook = new HashTable<string, string> (50);
char command;
do {
string input = Console.ReadLine();
command = input[0];
if(input.Length<=2) {
continue;
}
var arguments = input.Substring(2);
switch(command) {
case 'a':
var pair = arguments.Split('|');
phoneBook[pair[0]] = pair[1];
break;
case 's':
if( phoneBook.ContainsKey(arguments)) {
Console.WriteLine("{0} -> {1}", arguments, phoneBook[arguments]);
} else {
Console.WriteLine("Contact {0} does not exist.", arguments);
}
break;
}
} while ('q' != command);
}
public void TryGet_From_Empty()
{
HashTable<string, int> table = new HashTable<string, int>();
int value;
Assert.IsFalse(table.TryGetValue("missing", out value));
}
public void Remove_Missing()
{
HashTable<string, int> table = new HashTable<string, int>();
table.Add("100", 100);
Assert.IsFalse(table.Remove("missing"), "Remove on an empty collection should return false");
}
static void Main()
{
string stringText = Console.ReadLine();
var symbolsColection = new HashTable<char, int>();
for (int i = 0; i < stringText.Length; i++)
{
char symbol = stringText[i];
if (!symbolsColection.ContainsKey(symbol))
{
symbolsColection.Add(symbol, 1);
}
else
{
symbolsColection[symbol]++;
}
}
var sortedSymbolsColection = symbolsColection.OrderBy(s => s.Key);
foreach (var symbol in sortedSymbolsColection)
{
Console.WriteLine("{0}: {1} time/s", symbol.Key, symbol.Value);
}
}
static void Main(string[] args)
{
var ht = new HashTable<int, int>();
var ll = new MyLinkedList<int>();
var stackLL = new StackLL<int>();
var stackArr = new StackArray<int>();
var queueArr = new QueueArr<int>();
}
static void Main()
{
var test = new HashTable<int, string>();
test.Add(1, "a");
test.Add(2, "b");
test.Add(1, "c");
test.Add(2, "d");
}
public void DeleteElement_2()
{
hashTable = new HashTable.HashTable(new Hash2());
hashTable.DeleteElement(1);
hashTable.Add(1);
hashTable.DeleteElement(1);
Assert.AreEqual(false, hashTable.Search(1));
}
public void TryGet_Missing()
{
HashTable<string, int> table = new HashTable<string, int>();
table.Add("100", 100);
int value;
Assert.IsFalse(table.TryGetValue("missing", out value));
}
public void DeleteElement_2()
{
hashTable = new HashTable.HashTable(new Hash2());
hashTable.DeleteElement(1);
hashTable.Add(1);
hashTable.DeleteElement(1);
Assert.AreEqual(false, hashTable.Search(1));
}
public void SameKeyTest()
{
var check = new HashTable.HashTable(3);
check.PutPair(1, 1);
check.PutPair(1, 2);
Assert.AreEqual(2, check.GetValueByKey(1));
}
public void TwoEquialsElementsTest()
{
var h = new HashTable.HashTable(3);
h.PutPair("a", 3232);
h.PutPair("a", 342);
Assert.AreEqual(h.GetValueByKey("a"), 342);
}
static void Main()
{
HashFunction1 ooo = new HashFunction1();
HashTable myTable = new HashTable(2, ooo);
myTable.Add("ololo");
myTable.Add("olololo");
myTable.PrintTable();
Console.Read();
}
public void AddAndSearch_2()
{
hashTable = new HashTable.HashTable(new Hash1());
hashTable.Add(1);
hashTable.Add(2);
Assert.AreEqual(true, hashTable.Search(1));
Assert.AreEqual(true, hashTable.Search(2));
Assert.AreEqual(false, hashTable.Search(3));
}
public void TwoEquialsElementsTest()
{
var h = new HashTable.HashTable(3);
h.PutPair("mirage", 123);
h.PutPair("mirage", 321);
Assert.AreEqual(h.GetValueByKey("mirage"), 321);
}
public void TestGetValueMethodShouldThrowException()
{
var hashTable = new HashTable<int, int>();
hashTable.Add(1, 2);
hashTable[2] = 3;
hashTable.GetValue(3);
}
public void TestAddMethod()
{
var hashTable = new HashTable<int, int>();
hashTable.Add(1, 2);
hashTable[2] = 3;
Assert.AreEqual(2, hashTable.Count);
}
public void TwoEquialsElementsTest()
{
var t = new HashTable.HashTable(3);
t.PutPair("один", 1);
t.PutPair("один", 2);
Assert.AreEqual(t.GetValueByKey("один"), 2);
}
public void TwoEquialsElementsTest()
{
var HashT = new HashTable.HashTable(3);
HashT.PutPair("a", 1);
HashT.PutPair("a", 2);
Assert.AreEqual(HashT.GetValueByKey("a"), 2);
}
public void AddAndSearch_2()
{
hashTable = new HashTable.HashTable(new Hash1());
hashTable.Add(1);
hashTable.Add(2);
Assert.AreEqual(true, hashTable.Search(1));
Assert.AreEqual(true, hashTable.Search(2));
Assert.AreEqual(false, hashTable.Search(3));
}
public void Enumerate_Values_Empty()
{
HashTable<string, string> table = new HashTable<string, string>();
foreach (string key in table.Values)
{
Assert.Fail("There should be nothing in the Values collection");
}
}
public static void Main()
{
var HashTable = new HashTable<int, string> { { 3, "ar" } };
HashTable[2] = "asd";
string indexCheck = HashTable[2];
Console.WriteLine("toString:");
Console.WriteLine(HashTable);
Console.WriteLine("indexer:");
Console.WriteLine(HashTable[2]);
Console.WriteLine(indexCheck);
Console.WriteLine("keys:");
var keysChecker = HashTable.Keys;
foreach (int key in keysChecker)
{
Console.WriteLine(key);
}
Console.WriteLine("count:");
Console.WriteLine(HashTable.Count);
Console.WriteLine("remove:");
HashTable.Remove(4);
Console.WriteLine(HashTable[2]);
HashTable.Remove(2);
Console.WriteLine(HashTable[2]);
Console.WriteLine("count:");
Console.WriteLine(HashTable.Count);
string res;
bool findChecker = HashTable.Find(3, out res);
Console.WriteLine("Find value by key 3:");
Console.WriteLine(res);
Console.WriteLine(findChecker);
Console.WriteLine(HashTable);
Console.WriteLine("clear");
HashTable.Clear();
Console.WriteLine(HashTable);
Console.WriteLine("----");
Console.WriteLine("resize");
for (int i = 0; i < 100; i++)
{
HashTable.Add(i, i.ToString());
}
Console.WriteLine(HashTable);
}
public void SimpleTest()
{
var check = new HashTable.HashTable(3);
for (var i = 0; i < 3; i++)
{
check.PutPair(i, i + 1);
Assert.AreEqual(i + 1, check.GetValueByKey(i));
}
}
public void TestRemoveMethod()
{
var hashTable = new HashTable<int, int>();
hashTable.Add(1, 2);
hashTable[2] = 3;
Assert.IsTrue(hashTable.Remove(2));
Assert.IsFalse(hashTable.Remove(-1));
}
public void TestEqualElements()
{
string[] value = new string[] { "Раз", "Два" };
var table = new HashTable.HashTable(3);
table.PutPair(1, value[0]);
table.PutPair(1, value[1]);
Assert.AreEqual(table.GetValueByKey(1), value[0]);
Assert.AreEqual(table.GetValueByKey(1), value[1]);
}
public void Elements1000Test()
{
var HashT = new HashTable.HashTable(10000);
for (int i = 0; i < 10000; i++)
{
HashT.PutPair(i, i + 100);
}
Assert.AreEqual(HashT.GetValueByKey(15), 115);
}
public void OneInTenThousandsTest()
{
var dict = new HashTable.HashTable(10000);
for (var i = 0; i < 10000; i++)
{
dict.PutPair(i, i);
}
Assert.AreEqual(42, dict.GetValueByKey(42));
}
public void ElementsTest2()
{
var h = new HashTable.HashTable(10000);
for (int i = 1; i < 10000; i++)
{
h.PutPair(i, i + 1);
}
Assert.AreEqual(h.GetValueByKey(15), 16);
}
public void TestManyElements()
{
int size = 100000;
var table = new HashTable.HashTable(size);
for (int i = 0; i < size; i++)
{
table.PutPair(i, i++);
}
Assert.AreEqual(table.GetValueByKey(920), 921);
}
public void BigElementsTest()
{
var t = new HashTable.HashTable(10000);
for (int i = 1; i < 10000; i++)
{
t.PutPair(i, i + 1);
}
Assert.AreEqual(t.GetValueByKey(45), 46);
}
public void AddToHashTableMustWork()
{
var hashTable = new HashTable<string, int>();
var key = "testkey";
var testValue = 100;
hashTable.Add(key, testValue);
Assert.AreEqual(hashTable[key], testValue);
}
public void ElementsTest()
{
var t = new HashTable.HashTable(3);
t.PutPair("dd", 231);
t.PutPair("dfg", 3224);
t.PutPair("aaas", 4422);
Assert.AreEqual(t.GetValueByKey("dd"), 231);
Assert.AreEqual(t.GetValueByKey("dfg"), 3224);
Assert.AreEqual(t.GetValueByKey("aaas"), 4422);
}
public void ElementsTest()
{
var HashT = new HashTable.HashTable(3);
HashT.PutPair("HI", 1337);
HashT.PutPair("I`M", 1488);
HashT.PutPair("OLDMEN", 228);
Assert.AreEqual(HashT.GetValueByKey("HI"), 1337);
Assert.AreEqual(HashT.GetValueByKey("I`M"), 1488);
Assert.AreEqual(HashT.GetValueByKey("OLDMEN"), 228);
}
public void TestExpandMethod()
{
var hashTable = new HashTable<int, int>();
Assert.AreEqual(0, hashTable.Count);
for (int i = 1; i <= 12; i++)
{
hashTable.Add(i, 12 - i + 1);
}
Assert.AreEqual(12, hashTable.Count);
}
public void ElementsTest()
{
var t = new HashTable.HashTable(3);
t.PutPair("no", 57);
t.PutPair("yes", 666);
t.PutPair("yeah", 89);
Assert.AreEqual(t.GetValueByKey("no"), 57);
Assert.AreEqual(t.GetValueByKey("yes"), 666);
Assert.AreEqual(t.GetValueByKey("yeah"), 89);
}
public void ThreeElementsTest()
{
var table = new HashTable.HashTable(3);
table.PutPair("один", 1);
table.PutPair("два", 2);
table.PutPair("три", 3);
Assert.AreEqual(table.GetValueByKey("один"), 1);
Assert.AreEqual(table.GetValueByKey("два"), 2);
Assert.AreEqual(table.GetValueByKey("три"), 3);
}
public void RemoveFromHashTableMustWork()
{
var hashTable = new HashTable<string, int>();
var key = "testkey";
var testValue = 100;
hashTable.Add(key, testValue);
hashTable.Remove(key);
Assert.AreEqual(hashTable.Count, 0);
}
static void Main(string[] args)
{
var table = new HashTable.HashTable();
table.Insert(1, 143);
table.Insert(15, 156);
table.Insert(8, 12);
table.Print();
Console.ReadKey();
}
public void ThousandInTenThousandsTest()
{
var dict = new HashTable.HashTable(10000);
for (var i = 1001; i < 11001; i++)
{
dict.PutPair(i, i);
}
for (var i = 0; i < 1000; i++)
{
Assert.IsNull(dict.GetValueByKey(i));
}
}
public void HashTableCountWorksCorectWithAddOfElements()
{
var hashTable = new HashTable<int, string>();
var expectedCount = 50;
for (int i = 0; i < expectedCount; i++)
{
hashTable.Add(i * 2, "Test text " + i);
}
Assert.AreEqual(expectedCount, hashTable.Count);
}
public void ElementsSearchTest()
{
var ht = new HashTable.HashTable(11000);
for (int i = 0; i < 10000; i++)
{
ht.PutPair(i, i + "Один");
}
for (int i = 10000; i < 11000; i++)
{
Assert.AreEqual(ht.GetValueByKey(i), null);
}
}
public void ElementsSearchTests()
{
var h = new HashTable.HashTable(150000);
for (int i = 1; i < 10000; i++)
{
h.PutPair(i, i + 1);
}
for (int j = 10000; j <= 11000; j++)
{
Assert.AreEqual(h.GetValueByKey(j), null);
}
}
public void TestThreeElements()
{
string[] value = new string[] { "Компьютер", "Чайник", "Микроволновка" };
var table = new HashTable.HashTable(3);
for (int i = 0; i < value.Length; i++)
{
table.PutPair(i + 1, value[i]);
}
for (int i = 0; i < value.Length; i++)
{
Assert.AreEqual(table.GetValueByKey(i + 1), value[i]);
}
}
public void TestThreeElements()
{
string[] value = new string[] { "Раз", "Два", "Три" };
var table = new HashTable.HashTable(3);
for (int i = 0; i < value.Length; i++)
{
table.PutPair(i + 1, value[i]);
}
for (int i = 0; i < value.Length; i++)
{
Assert.AreEqual(table.GetValueByKey(i + 1), value[i]);
}
}
public static void Main()
{
var grades = new HashTable<string, int>();
Console.WriteLine("Grades:" + string.Join(",", grades));
Console.WriteLine("--------------------");
grades.Add("Peter", 3);
grades.Add("Maria", 6);
grades["George"] = 5;
Console.WriteLine("Grades:" + string.Join(",", grades));
Console.WriteLine("--------------------");
grades.AddOrReplace("Peter", 33);
grades.AddOrReplace("Tanya", 4);
grades["George"] = 55;
Console.WriteLine("Grades:" + string.Join(",", grades));
Console.WriteLine("--------------------");
Console.WriteLine("Keys: " + string.Join(", ", grades.Keys));
Console.WriteLine("Values: " + string.Join(", ", grades.Values));
Console.WriteLine("Count = " + string.Join(", ", grades.Count));
Console.WriteLine("--------------------");
grades.Remove("Peter");
grades.Remove("George");
grades.Remove("George");
Console.WriteLine("Grades:" + string.Join(",", grades));
Console.WriteLine("--------------------");
Console.WriteLine("ContainsKey[\"Tanya\"] = " + grades.ContainsKey("Tanya"));
Console.WriteLine("ContainsKey[\"George\"] = " + grades.ContainsKey("George"));
Console.WriteLine("Grades[\"Tanya\"] = " + grades["Tanya"]);
Console.WriteLine("--------------------");
grades.Add("Maria1", 5);
grades.Add("Maria12", 6);
grades.Add("Peter 13", 5);
grades.Add("Peter 14", 5);
grades.Add("George 1", 6);
grades.Add("George 11", 6);
grades.Add("George 12", 5);
grades.Add("George 2", 5);
grades.Add("George 3", 5);
grades.Add("Maria 3", 5);
//grades.Add("Maria 2", 5);
Console.WriteLine("\nCollisions deep: {0}\n--------------------", grades.CalculateCollisionsDeep());
Console.WriteLine("\nHashTable preview: \n--------------------\n{0}", grades);
}
public void CollisionTest()
{
var table2 = new HashTable<double, string>();
table2[273476.4000081323] = "You're beautiful";
table2[273606.9000081021] = "Hands up!";
table2.Remove(273476.4000081323);
Assert.That(table2[273606.9000081021], Is.EqualTo("Hands up!"));
Assert.That(table2.Count, Is.EqualTo(1));
table2.Remove(273606.9000081021);
Assert.That(table2.Count, Is.EqualTo(0));
}
public void Remove_Found()
{
HashTable<string, int> table = new HashTable<string, int>();
for (int i = 0; i < 100; i++)
{
table.Add(i.ToString(), i);
}
for (int i = 0; i < 100; i++)
{
Assert.IsTrue(table.ContainsKey(i.ToString()), "The key was not found in the collection");
Assert.IsTrue(table.Remove(i.ToString()), "The value was not removed (or remove returned false)");
Assert.IsFalse(table.ContainsKey(i.ToString()), "The key should not have been found in the collection");
}
}
static void Main(string[] args)
{
HashTable<string, int> people = new HashTable<string, int>();
people.Add("gosho", 14);
people.Add("tosho", 15);
people.Add("pesho", 16);
people.Add("ivan", 20);
people.Add("stoqn", 40);
Console.WriteLine("Count {0}", people.Count);
Console.WriteLine("Gosho is {0} years old.", people["gosho"]);
people.Remove("gosho");
Console.WriteLine("Count {0}", people.Count);
Console.WriteLine(people.Contain("gosho"));
}
public void TestGetValueMethod()
{
var hashTable = new HashTable<int, int>();
hashTable.Add(1, 2);
hashTable[2] = 3;
Assert.AreEqual(2, hashTable.Count);
Assert.AreEqual(2, hashTable[1]);
Assert.AreEqual(2, hashTable.GetValue(1));
Assert.AreEqual(3, hashTable[2]);
Assert.AreEqual(3, hashTable.GetValue(2));
}
public static void Main()
{
HashTable hash = new HashTable();
hash.Add(1);
for (int i = 0; i < 1000; ++i)
{
hash.Add(51 * i);
}
Console.WriteLine(hash.Search(33));
Console.WriteLine(hash.Search(102));
hash.DeleteElement(51);
hash.DeleteElement(0);
Console.WriteLine(hash.Search(0));
hash.Print();
}
public void Get_Succeeds()
{
HashTable<string, int> table = new HashTable<string, int>();
table.Add("100", 100);
int value = table["100"];
Assert.AreEqual(100, value, "The returned value was incorrect");
for (int i = 0; i < 100; i++)
{
table.Add(i.ToString(), i);
value = table["100"];
Assert.AreEqual(100, value, "The returned value was incorrect");
}
}
public void TryGet_Succeeds()
{
HashTable<string, int> table = new HashTable<string, int>();
table.Add("100", 100);
int value;
Assert.IsTrue(table.TryGetValue("100", out value));
Assert.AreEqual(100, value, "The returned value was incorrect");
for (int i = 0; i < 100; i++)
{
table.Add(i.ToString(), i);
Assert.IsTrue(table.TryGetValue("100", out value));
Assert.AreEqual(100, value, "The returned value was incorrect");
}
}
static void Main(string[] args)
{
HashTable hashTable = new HashTable(7);
Emp tom = new Emp(1, "tom");
Emp zhangshan = new Emp(2, "zhangsan");
Emp lisi = new Emp(8, "lisi");
//添加
hashTable.Add(tom);
hashTable.Add(zhangshan);
hashTable.Add(lisi);
//hashTable.ShowHashTable();
//查找
hashTable.FindEmpById(8);
Console.ReadLine();
}
public void FindingAlienKeys()
{
int flag;
var size = 10000;
var rnd = new Random(270005);
flag = rnd.Next(size);
var ht = new HashTable(size);
for (var i = 0; i < size; i++)
{
var element = rnd.Next();
ht.PutPair(i, element);
}
for (var i = 0; i < 1000; i++)
{
Assert.AreEqual(null, ht.GetValueByKey(rnd.Next(1000) + 10000));
}
}
public void ElementsSearchTests()
{
var h = new HashTable.HashTable(10000);
for (int i = 1; i < 10000; i++)
{
h.PutPair(i, i + 1);
}
string [] s = new string [1000];
for (int i = 1; i < 1000; i++)
{
s[i] = Convert.ToString(i);
}
foreach (string e in s)
{
Assert.AreEqual(h.GetValueByKey(e), null);
}
}
static void Main(string[] args)
{
HashTable <int> hashTable = new HashTable <int>();
hashTable.Add(31);
hashTable.Add(72);
hashTable.Add(17);
hashTable.Add(3);
hashTable.Add(8);
hashTable.Add(14);
Console.Write("HashTable before changes={ ");
foreach (int element in hashTable)
{
Console.Write(element + " ");
}
Console.Write(" }");
Console.WriteLine();
HashTable <string> hashTable1 = new HashTable <string>();
hashTable1.Add("s");
hashTable1.Add("b");
hashTable1.Add("c");
hashTable1.Add("de");
hashTable1.Add("e");
Console.WriteLine(hashTable1.Contains(null));
Console.WriteLine(hashTable1.Remove(null));
hashTable1.Clear();
Hashtable qwe = new Hashtable();
qwe.Add(0, "A");
qwe.Add(1, "B");
qwe.Add(2, null);
Console.WriteLine(qwe.Contains(2));
qwe.Remove(2);
}
public static void Main()
{
var j = 1002;
var hashTable = new HashTable(10000);
var rand = new Random();
var massiveOfValue = new char[10000];
for (int i = 0; i < 10000; i++)
{
massiveOfValue[i] = (char)rand.Next(0x00A1, 0x27B2);
}
foreach (var e in massiveOfValue)
{
hashTable.PutPair(j++, e);
}
for (int k = 0; k < 1000; k++)
{
hashTable.GetValueByKey(k);
}
}
