public static void Main()
{
var hashtable = new HashTable<int, string>();
hashtable.Add(5, "five");
hashtable.Add(3, "tree");
hashtable.Add(-6, "minus six");
Console.WriteLine(hashtable.Find(-6));
Console.WriteLine("All elements");
foreach (var item in hashtable)
{
Console.WriteLine("Key: {0} => Value: {1}", item.Key, item.Value);
}
hashtable.Remove(3);
Console.WriteLine("3 removed from table");
try
{
Console.WriteLine("Searching for 3 in table");
hashtable.Find(3);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
Console.WriteLine("Hash table has {0} elements", hashtable.Count);
}
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("--------------------");
}
public void AddDuplicateKeyElementsTest()
{
HashTable<int, char> alphabet = new HashTable<int, char>();
alphabet.Add(1, 'A');
alphabet.Add(1, 'a');
}
public void InsertValueByDuplicatedKey_ExpectedException()
{
HashTable<int, int> hashTable = new HashTable<int, int>(10);
hashTable.Add(1, 1);
hashTable.Add(1, 2);
}
public void AddShouldThrowExceptionWhenTheSameKeyIsAlreadyPresent()
{
var hashtable = new HashTable<string, int>();
hashtable.Add("gosho", 12);
hashtable.Add("gosho", 2);
}
static void Main(string[] args)
{
HashTable<int, string> table = new HashTable<int, string>();
for (int i = 0; i < 17; i++)
{
table.Add(i, (i + 1).ToString());
}
Console.WriteLine(table[15]);
table.Clear();
for (int i = 0; i < 3000; i++)
{
table.Add(i, (i + 1).ToString());
}
Console.WriteLine(table[1457]);
//table.Add(1, "test");
//table.Add(2, "test");
////table.Remove(1);
//Console.WriteLine(table[1]);
}
internal static void Main()
{
string decorationLine = new string('-', Console.WindowWidth);
Console.Write(decorationLine);
Console.WriteLine("***Presenting the functionality of the data structure 'Hash table'***");
Console.Write(decorationLine);
HashTable<string, int> clubsPoints = new HashTable<string, int>();
Console.WriteLine("---Add operation---");
clubsPoints.Add("Rabbits-O!", 15);
clubsPoints.Add("Frogssy", 19);
clubsPoints.Add("Puma Runners", 17);
clubsPoints.Add("Lion Kings", 33);
Console.WriteLine("Count = " + clubsPoints.Count);
Console.WriteLine();
Console.WriteLine("---Iterator functionality---");
PrintClubsPoints(clubsPoints);
Console.WriteLine();
Console.WriteLine("---Remove operation---");
bool isRemoved = clubsPoints.Remove("Frogssy");
Console.WriteLine("Are 'Frogssy' removed: " + isRemoved);
Console.WriteLine("Count = " + clubsPoints.Count);
Console.WriteLine("Hash table after removal:");
PrintClubsPoints(clubsPoints);
Console.WriteLine();
Console.WriteLine("---Indexer---");
Console.WriteLine("'Lion Kings' points so far: " + clubsPoints["Lion Kings"]);
clubsPoints["Rabbits-O!"] += 3;
Console.WriteLine("'Rabbits-O!' points after a win: " + clubsPoints["Rabbits-O!"]);
Console.WriteLine();
Console.WriteLine("---Find operation---");
Console.WriteLine("Info about 'Puma Runners'" + clubsPoints.Find("Puma Runners"));
Console.WriteLine();
Console.WriteLine("---ContainsKey operation---");
Console.WriteLine("Is there a club 'Birdy'? - " + clubsPoints.ContainsKey("Birdy"));
Console.WriteLine("Is there a club 'Rabbits-O!'? - " + clubsPoints.ContainsKey("Rabbits-O!"));
Console.WriteLine();
Console.WriteLine("---Keys property---");
Console.Write("All clubs names are: ");
Console.WriteLine(string.Join(", ", clubsPoints.Keys));
Console.WriteLine();
Console.WriteLine("---Values property---");
Console.Write("All club's points are: ");
Console.WriteLine(string.Join(", ", clubsPoints.Values));
Console.WriteLine();
Console.WriteLine("---Clear operation---");
clubsPoints.Clear();
Console.WriteLine("Elements count after clearing: " + clubsPoints.Count);
}
public void SetNonExistingElementTest()
{
HashTable<int, char> alphabet = new HashTable<int, char>();
alphabet.Add(1, 'A');
alphabet.Add(2, 'B');
alphabet.Add(3, 'C');
alphabet[4] = 'D';
}
public void GetNonExistingElementTest()
{
HashTable<int, char> alphabet = new HashTable<int, char>();
alphabet.Add(1, 'A');
alphabet.Add(2, 'B');
alphabet.Add(3, 'C');
char dLetter = alphabet[4];
}
public void AddingNewKeyPairShouldCountCorrectly()
{
var hashTable = new HashTable<string, int>();
hashTable.Add("Ivan", 1);
hashTable.Add("Ivan1", 2);
hashTable.Add("Ivan2", 3);
Assert.AreEqual(hashTable.Count, 3);
}
public void TestIfAddingASameKeyThrows()
{
var table = new HashTable<int, int>();
table.Add(1, 11);
table.Add(1, 12);
var count = table.Count;
Assert.AreEqual(8, count);
}
private static void Main(string[] args)
{
HashTable<int, string> test = new HashTable<int, string>();
test.Add(5, "Pesho");
test.Add(45, "Gosho");
test.Add(18, "Mariika");
Console.WriteLine("Test: " + string.Join(", ", test));
}
public void Add_EmptyHashTable_Duplicates_ShouldThrowException()
{
// Arrange
var hashTable = new HashTable<string, string>();
// Act
hashTable.Add("Peter", "first");
hashTable.Add("Peter", "second");
}
public void HashTableTest()
{
HashTable<string, int> table = new HashTable<string, int>(100);
table.Add("brad", 100);
table.Add("rich", 200);
table.Remove("rich");
Assert.AreEqual(100, table.Find("brad"));
Assert.AreEqual(0, table.Find("rich"));
}
public void FindNonExistingEntryTest()
{
HashTable<string, int> studentMarks = new HashTable<string, int>();
studentMarks.Add("Ivan", 5);
studentMarks.Add("Pesho", 4);
studentMarks.Add("Lili", 6);
studentMarks.Add("Gosho", 3);
studentMarks.Find("Marin");
}
public void CountShouldReturnCorrectResult()
{
var table = new HashTable<string, int>();
table.Add("pesho", 2);
table.Add("gosho", 3);
table.Add("stamat", 3);
table.Remove("gosho");
Assert.AreEqual(2, table.Count);
}
public void Add_GivenKeyAndValue_PairInATable()
{
var hashTable = new HashTable<int, int>();
hashTable.Add(5, 2);
hashTable.Add(48, 30);
hashTable.Add(11, 7);
hashTable.Add(78, 25);
hashTable.Add(7, 58);
Assert.AreEqual(7, hashTable.SearchByKey(58));
}
public void Remove_GivenKey_ReturnedExpectedValue()
{
var hashTable = new HashTable<int, int>();
hashTable.Add(31, 2);
hashTable.Add(21, 30);
hashTable.Add(11, 7);
hashTable.Add(41, 25);
hashTable.Add(7, 58);
Assert.AreEqual(7, hashTable.Remove(11));
}
public void FindWithNullKeyTest()
{
HashTable<string, int> studentMarks = new HashTable<string, int>();
studentMarks.Add("Ivan", 5);
studentMarks.Add("Pesho", 4);
studentMarks.Add("Lili", 6);
studentMarks.Add("Gosho", 3);
studentMarks.Find(null);
}
public void Add_Get()
{
HashTable<int, string> table = new HashTable<int, string>();
table.Add(1, "Hello ");
table.Add(2, "to ");
table.Add(3, "Everyone");
string result = table.Get(1) + table.Get(2) + table.Get(3);
Assert.AreEqual("Hello to Everyone", result);
}
public void ContainsKeyFalseTest()
{
HashTable<string, int> studentMarks = new HashTable<string, int>();
studentMarks.Add("Pesho", 4);
studentMarks.Add("Lili", 6);
studentMarks.Add("Gosho", 3);
bool containsIvanStudent = studentMarks.ContainsKey("Ivan");
Assert.IsFalse(containsIvanStudent);
}
public void AddingValuesToHashTable()
{
HashTable<int, int> hashTable = new HashTable<int, int>(10);
hashTable.Add(1, 1);
hashTable.Add(11, 2);
hashTable.Add(2, 2);
hashTable.Add(3, 3);
Assert.AreEqual(hashTable.Count, 4);
}
public void HashTable_GetValue_Key_11_ExpectedValue_2()
{
HashTable<int, int> hashTable = new HashTable<int, int>(10);
hashTable.Add(1, 1);
hashTable.Add(11, 2);
hashTable.Add(2, 2);
hashTable.Add(3, 3);
Assert.AreEqual(hashTable.GetValue(11), 2);
}
public void Remove_GivenTheSameKeySecondTime_ThrownExpectedException()
{
var hashTable = new HashTable<int, int>();
hashTable.Add(31, 2);
hashTable.Add(21, 30);
hashTable.Add(11, 7);
hashTable.Add(41, 25);
hashTable.Add(7, 58);
hashTable.Remove(11);
hashTable.Remove(11);
}
public void Test_Add_ShouldIncreaseCapacityWhenNeeded()
{
hashTable = new HashTable<string, string>(4);
var initialCapacity = hashTable.Capacity;
hashTable.Add(key1, value1);
hashTable.Add(key2, value2);
hashTable.Add(key3, value3);
var currentCapacity = hashTable.Capacity;
var expectedCapacity = initialCapacity * 2;
Assert.AreEqual(expectedCapacity, currentCapacity, "Hash table should increase capacity when range exceeded!");
}
public void GetExistingElementTest()
{
HashTable<int, char> alphabet = new HashTable<int, char>();
alphabet.Add(1, 'A');
alphabet.Add(2, 'B');
alphabet.Add(3, 'C');
char bLetter = alphabet[2];
Assert.AreEqual(3, alphabet.Count);
Assert.AreEqual('B', bLetter);
}
public static void Main(string[] args)
{
var table = new HashTable<int, string>();
table.Add(1, "a");
table.Add(2, "b");
table.Add(3, "pesho");
foreach (var pair in table)
{
Console.WriteLine("{0} => {1}", pair.Key, pair.Value);
}
}
public void SetExistingElementTest()
{
HashTable<int, char> alphabet = new HashTable<int, char>();
alphabet.Add(1, 'A');
alphabet.Add(2, 'B');
alphabet.Add(3, 'C');
alphabet[2] = 'b';
Assert.AreEqual(3, alphabet.Count);
Assert.AreEqual('b', alphabet[2]);
}
static void Main(string[] args)
{
HashSet<int> p = new HashSet<int>();
HashTable<int, int> hashTable = new HashTable<int, int>(2);
hashTable.Add(3, 4);
hashTable.Add(7, 4);
Console.WriteLine(hashTable.Count);
hashTable.Remove(3);
Console.WriteLine(hashTable.Count);
hashTable.Add(3, 4);
hashTable.Add(8, 4);
hashTable.Add(13, 4);
hashTable.Add(3333, 4);
hashTable.Add(124, 4);
hashTable.Add(412412, 4);
hashTable[8] = 25;
hashTable[8] = -45;
Console.WriteLine(hashTable.Count);
foreach (var item in hashTable)
{
Console.WriteLine("Key {0}, Value {1}", item.Key, item.Value);
}
// Console.WriteLine(hashTable.Count);
// Console.WriteLine(hashTable.Find(3));
IEnumerable<int> keys = hashTable.Keys;
foreach (var key in keys)
{
Console.Write(key + ",");
}
Console.WriteLine();
hashTable.Add(17, 34);
hashTable.Remove(8);
hashTable.Remove(3333);
hashTable.Add(-4, 23);
keys = hashTable.Keys;
foreach (var key in keys)
{
Console.Write(key + ",");
}
Console.WriteLine();
hashTable.Clear();
Console.WriteLine(hashTable.Count);
foreach (var item in hashTable)
{
Console.WriteLine("Key {0}, Value {1}", item.Key, item.Value);
}
}
public void Enumerate()
{
HashTable<int, string> table = new HashTable<int, string>();
table.Add(1, "Hello ");
table.Add(2, "to ");
table.Add(3, "Everyone");
string result = string.Empty;
foreach (var value in table)
result += value;
Assert.AreEqual("Hello to Everyone", result);
}
private static void AddValuesToHashTable(HashTable <string, string> hashTable)
{
hashTable.Add("1", "item 1");
hashTable.Add("2", "item 2");
hashTable.Add("7", "item 7");
}
public void GetOneValue()
{
testTable.Add("Monday", "1");
Assert.Equal("1", testTable.Get("Monday"));
}
static void Main()
{
var badHashTable = new BadHashTable <int>(100);
badHashTable.Add(5);
badHashTable.Add(55);
badHashTable.Add(555);
badHashTable.DisplayHashTable();
Console.WriteLine();
Console.WriteLine($"Таблица содержит значение 555? {badHashTable.Search(555)}");
Console.WriteLine($"Таблица содержит значение 2? {badHashTable.Search(2)}");
Console.WriteLine();
var person1 = new Person("Коля", 20);
var person2 = new Person("Толя", 25);
var person3 = new Person("Оля", 22, 1);
var person4 = new Person("Валя", 20, 1);
var person5 = new Person("Валя", 20, 0);
var person6 = new Person("Витя", 20, 0);
var hashTable = new HashTable <int, Person>(10);
hashTable.Add(person1.Id, person1);
hashTable.Add(person2.Id, person2);
hashTable.Add(person3.Id, person3);
hashTable.Add(person4.Id, person4);
hashTable.Add(person5.Id, person5);
hashTable.Add(person6.Id, person6);
hashTable.DisplayHashTable();
Console.WriteLine();
Console.WriteLine($"Таблица содержит {person1} по ключу {person1.Id}? {hashTable.Search(person1.Id, person1)}");
Console.WriteLine($"Таблица содержит {person4} по ключу {person4.Id}? {hashTable.Search(person4.Id, person4)}");
Console.WriteLine();
var superHash = new SuperHash.SuperHash <Person>(100);
superHash.Add(person1);
superHash.Add(person2);
superHash.Add(person3);
superHash.Add(person4);
superHash.Add(person5);
superHash.Add(person6);
superHash.DisplayHashTable();
Console.WriteLine();
Console.WriteLine($"Таблица содержит значение {new Person("Коля", 20, 0)}? {superHash.Search(new Person("Коля", 20, 0))}");
Console.WriteLine($"Таблица содержит значение {new Person("Коля", 20, 1)}? {superHash.Search(new Person("Коля", 20, 1))}");
Console.WriteLine($"Таблица содержит значение {person5}? {superHash.Search(person5)}");
Console.WriteLine();
}
public void Add(T value)
{
hashTable.Add(value.GetHashCode(), value);
}
public void AddTest()
{
hashTable.Add("Alex");
Assert.IsTrue(hashTable.Contains("Alex"));
}
public void TestAdd_NullKey()
{
HashTable <string, int> hashTable = new HashTable <string, int>();
hashTable.Add(null, 5);
}
static void Main(string[] args)
{
HashTable <string, string> table = new HashTable <string, string>(10);
table.Add("testKey", "testValue");
table.Add("greetings", "Hello world !!!");
table.Add("phone", "0000000");
table.Add("testKey", "testValue");
table.Add("greetings", "Hello world !!!");
table.Add("phone", "0000000");
table.Add("testKey", "testValue");
table.Add("greetings", "Hello world !!!");
table.Add("phone", "0000000");
table.Add("testKey", "testValue");
table.Add("greetings", "Hello world !!!");
table.Add("phone", "0000000");
var test = table.GetValue("testKey");
System.Console.WriteLine($"before remove: {test}");
table.Remove("testKey");
var test2 = table.GetValue("testKey");
System.Console.WriteLine($"after remove: {test2}");
table.Clear();
System.Console.ReadKey();
}
public void Add(TKey key, TValue value)
{
table.Add(key, value);
}
public void TestHashTableClear()
{
HashTable <string, int> hashTable = new HashTable <string, int>(3, 0.9f);
hashTable.Add("m", 10);
hashTable.Add("b", 2000);
hashTable.Add("t", 0);
hashTable.Add("o", 33);
hashTable.Add("z", 0);
hashTable.Add("k", -812);
hashTable.Add("g", 0);
hashTable.Add("a5", 91);
hashTable.Add("c", 0);
hashTable.Add("a2", 22);
hashTable.Add("a7", 66);
hashTable.Add("i", 707);
hashTable.Add("h", -15);
hashTable.Clear();
Assert.IsFalse(hashTable.ContainsKey("m"));
Assert.IsFalse(hashTable.ContainsKey("b"));
Assert.IsFalse(hashTable.ContainsKey("t"));
Assert.IsFalse(hashTable.ContainsKey("o"));
Assert.IsFalse(hashTable.ContainsKey("z"));
Assert.IsFalse(hashTable.ContainsKey("k"));
Assert.IsFalse(hashTable.ContainsKey("g"));
Assert.IsFalse(hashTable.ContainsKey("a5"));
Assert.IsFalse(hashTable.ContainsKey("c"));
Assert.IsFalse(hashTable.ContainsKey("a2"));
Assert.IsFalse(hashTable.ContainsKey("a7"));
Assert.IsFalse(hashTable.ContainsKey("i"));
Assert.IsFalse(hashTable.ContainsKey("h"));
Assert.AreEqual(0, hashTable.Count);
}
static void Main()
{
//exercise 2
HashTable<string, string> phoneBook = new HashTable<string, string>();
string input = Console.ReadLine();
while (input != "search")
{
string[] splitted = input.Split(new[] { '-' }, StringSplitOptions.RemoveEmptyEntries).ToArray();
var name = splitted[0];
var phone = splitted[1];
if (!phoneBook.ContainsKey(name))
{
phoneBook.Add(name, phone);
}
input = Console.ReadLine();
if (input == "search")
{
string input2 = Console.ReadLine();
while (input2 != "")
{
if (!phoneBook.ContainsKey(input2))
{
Console.WriteLine("Contact {0} does not exist.", input2);
}
else
{
Console.Write(input2);
Console.WriteLine(" -> " + phoneBook[input2]);
}
input2 = Console.ReadLine();
}
}
//exercise 1;
/*HashTable<char, int> grades = new HashTable<char, int>();
string input = Console.ReadLine();
for (int i = 0; i < input.Length; i++)
{
var current = input[i];
if (!grades.ContainsKey(current))
{
grades.Add(current, 0);
}
grades[current]++;
}
foreach (var keyValue in grades.OrderBy(x=> x.Key))
{
Console.WriteLine(keyValue.Key + ": " + keyValue.Value + " time/s");
}*/
//Lab
/*HashTable<string, int> grades = new HashTable<string, int>();
Console.WriteLine("Grades:" + string.Join(",", grades));
Console.WriteLine("---------------");
grades.Add("Peter", 3);
var n = grades.Find("Peter");
Console.WriteLine("************" + n);
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("--------------------");*/
}
}
public void HashTable_Add_Method_Exception()
{
var ht = new HashTable();
Assert.Throws <ArgumentNullException>(() => ht.Add(null, "test"));
}
public void TestHashTable()
{
HashTable <string, int> hashTable = new HashTable <string, int>();
for (int i = 1; i < 700; i++)
{
hashTable.Add(i.ToString(), i);
}
if (hashTable.LookUp("643") != 643)
{
Assert.Equal(643, hashTable.LookUp("643"));
}
if (hashTable.LookUp("56") != 56)
{
Assert.Equal(56, hashTable.LookUp("56"));
}
if (hashTable.LookUp("275") != 275)
{
Assert.True(false);
}
if (hashTable.LookUp("477") != 477)
{
Assert.True(false);
}
ChainableHashTable <string, int> chainableHashTable = new ChainableHashTable <string, int>();
for (int i = 1; i < 1000; i++)
{
chainableHashTable.Add(i.ToString(), i);
}
if (hashTable.LookUp("643") != 643)
{
Assert.Equal(643, hashTable.LookUp("643"));
}
if (hashTable.LookUp("56") != 56)
{
Assert.Equal(56, hashTable.LookUp("56"));
}
if (hashTable.LookUp("275") != 275)
{
Assert.True(false);
}
if (hashTable.LookUp("477") != 477)
{
Assert.True(false);
}
TreeHashTable <string, int> treeHashTable = new TreeHashTable <string, int>();
for (int i = 1; i < 1000; i++)
{
treeHashTable.Add(i.ToString(), i);
}
if (treeHashTable.LookUp("643") != 643)
{
Assert.Equal(643, treeHashTable.LookUp("643"));
}
if (treeHashTable.LookUp("56") != 56)
{
Assert.Equal(56, treeHashTable.LookUp("56"));
}
if (treeHashTable.LookUp("275") != 275)
{
Assert.True(false);
}
if (treeHashTable.LookUp("477") != 477)
{
Assert.True(false);
}
}
public void AddItemThat_Is_Not_In_The_HashTable()
{
_hashTable.Add("42");
_hashTable.Should().BeEquivalentTo("42");
}
public ChartForm(int Num, DataGridView OutFileView, DataGridView ParametersView)
{
InitializeComponent();
double A, GoodA = 0;
int N, GoodMulN = 0, GoodDivN = 0;
int MinCollisMul = 0, MinCollisDiv = 0, MaxCollisMul = 0, MaxCollisDiv = 0;
for (int i = 1; i < Num; i++)
{
A = Convert.ToDouble(ParametersView[i, 0].Value);
N = Convert.ToInt32(ParametersView[i, 1].Value);
HashTable Division = new HashTable(N, A, "/");
HashTable Multiplication = new HashTable(N, A, "*");
for (int j = 0; j < OutFileView.Rows.Count; j++)
{
Auto autoM = new Auto(Convert.ToString(OutFileView[0, j].Value),
Convert.ToString(OutFileView[1, j].Value),
Convert.ToString(OutFileView[2, j].Value),
Convert.ToInt32(OutFileView[3, j].Value));
Auto autoD = new Auto(Convert.ToString(OutFileView[0, j].Value),
Convert.ToString(OutFileView[1, j].Value),
Convert.ToString(OutFileView[2, j].Value),
Convert.ToInt32(OutFileView[3, j].Value));
Multiplication.Add(autoM);
Division.Add(autoD);
}
int CollisMul = NumCollisions(Multiplication);
int CollisDiv = NumCollisions(Division);
if (i == 1)
{
MinCollisMul = CollisMul;
GoodMulN = N;
GoodA = A;
}
if (i == 1)
{
MinCollisDiv = CollisDiv;
GoodDivN = N;
}
if (CollisMul < MinCollisMul)
{
MinCollisMul = CollisMul;
GoodMulN = N;
GoodA = A;
}
if (CollisDiv < MinCollisDiv)
{
MinCollisDiv = CollisDiv;
GoodDivN = N;
}
if (CollisMul > MaxCollisMul)
{
MaxCollisMul = CollisMul;
}
if (CollisDiv > MaxCollisDiv)
{
MaxCollisDiv = CollisDiv;
}
this.chart1.Series["Division"].Points.AddXY("Количество\nколлизий\nN=" + N + " A=" + A, CollisDiv);
this.chart1.Series["Multiplication"].Points.AddXY("Количество\nколлизий\nN=" + N + " A=" + A, CollisMul);
}
BoxMinDiv.Text = Convert.ToString(MinCollisDiv);
BoxMinMul.Text = Convert.ToString(MinCollisMul);
BoxMaxDiv.Text = Convert.ToString(MaxCollisDiv);
BoxMaxMul.Text = Convert.ToString(MaxCollisMul);
BoxNDiv.Text = Convert.ToString(GoodDivN);
BoxNMul.Text = Convert.ToString(GoodMulN);
BoxAMul.Text = Convert.ToString(GoodA);
}
public void CreateTestHashTable()
{
hashTable = new HashTable(10);
hashTable.Add("1", "testString1");
}
public void Test_Add_ShouldIncreaseCount()
{
hashTable.Add(key1, value1);
var hashTableCount = hashTable.Count;
var expectedCount = 1;
Assert.AreEqual(expectedCount, hashTableCount, "Hash table should increase count when adding!");
}
public void AddTest()
{
for (int i = -2; i < 4; ++i)
{
hashTable.Add(i);
}
for (int i = -2; i < 4; ++i)
{
Assert.IsTrue(hashTable.Exists(i));
}
Assert.IsFalse(hashTable.Exists(9));
Assert.IsFalse(hashTable.Exists(-15));
}
public static void Main()
{
HashTable <string, int> marks = new HashTable <string, int>();
marks.Add("Pesho", 6);
marks.Add("Pesho", 2);
marks.Add("Gosho", 3);
marks.Add("Petranka", 2);
marks.Add("Stoqnka", 5);
marks.Add("Kirilka", 4);
marks.Remove("Stoqnka");
marks["Pesho"] = 3;
foreach (var item in marks)
{
Console.WriteLine("{0} -> {1}", item.Key, item.Value);
}
Console.WriteLine(marks.Find("Pesho"));
Console.WriteLine(marks["Pesho"]);
Console.WriteLine();
marks.Clear();
marks.Add("Pesho", 6);
marks.Add("Pesho", 2);
marks.Add("Gosho", 3);
marks.Add("George", 2);
marks.Add("Stanley", 5);
marks.Add("Kate", 4);
marks.Remove("Stanley");
marks["Pesho"] = 3;
foreach (var item in marks)
{
Console.WriteLine("{0} -> {1}", item.Key, item.Value);
}
Console.WriteLine(marks.Find("Pesho"));
Console.WriteLine(marks["Pesho"]);
}
static void Main(string[] args)
{
Console.WriteLine("*********Create new list*************");
var list = new LinkedList <string>()
{
"item1", "item2", "item3"
};
foreach (var element in list)
{
Console.Write($"{element} ");
}
Console.WriteLine("\n****Added item4****");
list.Add("item4");
foreach (var element in list)
{
Console.Write($"{element} ");
}
Console.WriteLine("\n****Added item0 to the begining****");
list.AddAt("item0", 0);
foreach (var element in list)
{
Console.Write($"{element} ");
}
Console.WriteLine("\n****Removed first item0 ****");
list.RemoveAt(0);
foreach (var element in list)
{
Console.Write($"{element} ");
}
Console.WriteLine("\n****Removed item2 ****");
list.Remove("item2");
foreach (var element in list)
{
Console.Write($"{element} ");
}
Console.WriteLine("\n****Element and their position****");
for (int i = 0; i < list.Length; i++)
{
Console.WriteLine($"{list.ElementAt(i)} at {i} position ");
}
Console.WriteLine("*********Create new hash table*************");
var hashtable = new HashTable(5);
hashtable.Add("1", "testString1");
hashtable.Add("2", "testString2");
hashtable.Add("3", "testString3");
for (int i = 0; i < hashtable.Size; i++)
{
Console.WriteLine(hashtable[i]);
}
Console.WriteLine($"Hashtable contains '2' key - {hashtable.Contains("2")}");
Console.WriteLine($"Hashtable contains '4' key - {hashtable.Contains("4")}");
object value;
var result = hashtable.TryGet("1", out value);
Console.WriteLine($"Hashtable contains '1' key - {hashtable.Contains("4")} with {value} value");
Console.ReadKey();
}
static void Main(string[] args)
{
Console.WriteLine("Задание №1" + "\r\n");
int[] MyArray = new int[10] {
1, 5, 8, 9, 34, 98, 23, 1, 45, 28
};
Console.Write("Исходный массив: ");
for (int i = 0; i < 10; i++)
{
Console.Write(Convert.ToString(MyArray[i]) + " ");
}
//демонстрация бинарного поиска
Console.WriteLine("\r\n" + "1.Нахождение индекса элемента 98 с помощью бинарного поиска: " + BinarySearch(MyArray, 98, 0, MyArray.Length).ToString());
//демонстрация поиска по бинарному дереву
var binaryTree = new BinaryTree();
Random rand = new Random();
for (int i = 0; i < 9; i++)
{
binaryTree.Add(new BinaryTreeNode(rand.Next(0, 50)));
}
Console.WriteLine("\r\n" + "2.Бинарное дерево, поиск элемента и его удаление");
binaryTree.PrintTree();
Console.WriteLine("Добавим новый элемент");
binaryTree.Add(new BinaryTreeNode(66));
binaryTree.PrintTree();
Console.WriteLine("Удалим его");
binaryTree.Remove(66);
binaryTree.PrintTree();
//демонстрация фиббоначиева поиска
Console.WriteLine("\r\n" + "3.Фиббоначиев поиск" + "\r\n");
FibonacciNumber fib = Fibonacci.find(21);
FibonacciNumber fib2 = new FibonacciNumber(8);
Console.WriteLine("Индекс числа 21 = " + fib.Index);
Console.WriteLine("Значение элемента с индексм 8 = " + fib2.Number);
Console.WriteLine("\r\n" + "4.Интерпаляционный поиск" + "\r\n");
Console.Write("Исходный массив: ");
for (int i = 0; i < 10; i++)
{
Console.Write(Convert.ToString(MyArray[i]) + " ");
}
Console.WriteLine("\r\n" + "Индекс числа 9 = " + InterpolationSearch(MyArray, 9));
Console.WriteLine("\r\n" + "Задание №2" + "\r\n");
Console.WriteLine("1.Поиск по map, в которой коллизии решаются простым рехэшированием");
Map <int, string> MyMap = new Map <int, string>();
MyMap.Add(new ItemMap <int, string>(1, "Один"));
MyMap.Add(new ItemMap <int, string>(1, "Один"));
MyMap.Add(new ItemMap <int, string>(2, "Два"));
MyMap.Add(new ItemMap <int, string>(3, "Три"));
MyMap.Add(new ItemMap <int, string>(4, "Четыре"));
MyMap.Add(new ItemMap <int, string>(5, "Пять"));
MyMap.Add(new ItemMap <int, string>(101, "Сто один"));
Console.WriteLine("Исходная карта:");
foreach (var item in MyMap)
{
Console.WriteLine(item);
}
Console.WriteLine("\r\n" + "Ищем число c ключем 7 " + (MyMap.Search(7) ?? "Не найдено"));
Console.WriteLine("Ищем число c ключем 101 " + (MyMap.Search(101) ?? "Не найдено"));
MyMap.Remove(1);
MyMap.Remove(101);
Console.WriteLine("\r\n" + "Удалили 1 и 101 ");
foreach (var item in MyMap)
{
Console.WriteLine(item);
}
Console.WriteLine("\r\n" + "2.Поиск по map, в которой коллизии решаются случайным рехэшированием");
Map <int, string> MyMap2 = new Map <int, string>();
MyMap2.Add(new ItemMap <int, string>(2, "Два"));
MyMap2.Add(new ItemMap <int, string>(2, "Два"));
MyMap2.Add(new ItemMap <int, string>(9, "Девять"));
MyMap2.Add(new ItemMap <int, string>(3, "Три"));
MyMap2.Add(new ItemMap <int, string>(4, "Четыре"));
MyMap2.Add(new ItemMap <int, string>(5, "Пять"));
MyMap2.Add(new ItemMap <int, string>(102, "Сто два"));
Console.WriteLine("Исходная карта:");
foreach (var item in MyMap2)
{
Console.WriteLine(item);
}
Console.WriteLine("\r\n" + "Ищем число c ключем 7 " + (MyMap2.Search(7) ?? "Не найдено"));
Console.WriteLine("Ищем число c ключем 102 " + (MyMap2.Search(102) ?? "Не найдено"));
MyMap2.Remove(2);
MyMap2.Remove(102);
Console.WriteLine("\r\n" + "Удалили 2 и 102 ");
foreach (var item in MyMap2)
{
Console.WriteLine(item);
}
Console.WriteLine("\r\n" + "3.Поиск по хэш таблице, в которой коллизии решаются методом цепочек");
Console.WriteLine("Исходная таблица:");
HashTable <int> MyHashTable = new HashTable <int>(5);
MyHashTable.Add(2);
MyHashTable.Add(24);
MyHashTable.Add(65);
MyHashTable.Add(8);
MyHashTable.Add(51);
MyHashTable.Add(61);
MyHashTable.PrintHashTable();
Console.WriteLine("\r\n" + "Содержит ли хэш таблица число 42 " + MyHashTable.Search(42));
Console.WriteLine("Содержит ли хэш таблица число 8 " + MyHashTable.Search(8));
MyHashTable.Delate(24);
MyHashTable.Delate(51);
Console.WriteLine("\r\n" + "Удалили 24 и 51 ");
MyHashTable.PrintHashTable();
Console.WriteLine("\r\n" + "Задание №3");
Console.WriteLine("Расстановка ферзей на поле : (ферзь = 1)" + "\r\n");
Chess MyChess = new Chess();
MyChess.Arrange();
Console.ReadLine();
}
static void Main(string[] args)
{
HashTable table = new HashTable();
//Add a set of key/value pairs
table.Add("Cat", 20);
table.Add("Zebra", 245);
table.Add("Tele", 3409);
table.Add("Frank", 6);
//Get Hash values of all added keys
Console.WriteLine("----HashTable-----");
Console.WriteLine(table.GetHash("Cat") + " is Cat");
Console.WriteLine(table.GetHash("Zebra") + " is Zebra");
Console.WriteLine(table.GetHash("Tele") + " is Tele");
Console.WriteLine(table.GetHash("Frank") + " is Frank");
Console.WriteLine("-----");
//Check if keys exist in the Hash table
Console.WriteLine(table.ContainsKey("Cat"));
Console.WriteLine(table.ContainsKey("Zebra"));
Console.WriteLine(table.ContainsKey("Tele"));
Console.WriteLine(table.ContainsKey("Frank"));
Console.WriteLine("Key Doe: currently isn't in the table");
Console.WriteLine(table.ContainsKey("Doe"));
Console.WriteLine("-----");
//Find the values of a given keys
Console.WriteLine(table.FindValue("Cat"));
Console.WriteLine(table.FindValue("Zebra"));
Console.WriteLine(table.FindValue("Tele"));
Console.WriteLine(table.FindValue("Frank"));
Console.WriteLine("-----");
//Add a key that creates collision
table.Add("Doe", 25);
Console.WriteLine(table.GetHash("Doe") + " is Doe");
Console.WriteLine(table.GetHash("Cat") + " is Cat");
Console.WriteLine(table.ContainsKey("Doe"));
Console.WriteLine("-----");
//Can still find a value even if the buckets are linked
Console.WriteLine(table.FindValue("Cat"));
Console.WriteLine(table.FindValue("Doe"));
Console.WriteLine(table.ContainsKey("Cat"));
Console.WriteLine(table.ContainsKey("Doe"));
Console.WriteLine("-----");
try
{
table.Add("Cat", 50);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
Console.WriteLine("----HashSet-----");
//HashSet
HashSet hashSet = new HashSet();
hashSet.Add("Cat", 20);
hashSet.Add("Zebra", 245);
Console.WriteLine(hashSet.ContainsKey("Cat"));
Console.WriteLine(hashSet.ContainsKey("Zebra"));
Console.WriteLine(hashSet.ContainsKey("Doe"));
Console.WriteLine("---");
//Throw error with collision
try
{
hashSet.Add("Doe", 5);
}
catch (Exception)
{
Console.WriteLine("Index already has a value");
}
Console.WriteLine(table.FindValue("Cat"));
Console.WriteLine(table.FindValue("Zebra"));
}
public void CanSaveValueByKey()
{
var hash = new HashTable();
hash.Add("Key1", "Value");
}
public void Initialize()
{
hashTable = new HashTable();
hashTable.Add("Jacob");
hashTable.Add("William");
hashTable.Add("Christopher");
hashTable.Add("Ryan");
hashTable.Add("David");
hashTable.Add("Alexander");
hashTable.Add("James");
hashTable.Add("Jonathan");
hashTable.Add("Jose");
hashTable.Add("Kevin");
hashTable.Add("Luke");
hashTable.Add("Cameron");
}
private void btnTest_Click(object sender, EventArgs e)
{
try
{
HashTable <string, string> ht = new HashTable <string, string>();
WriteMsg("HashTable Capacity: " + ht.Capacity);
WriteMsg("HashTable WhenEnlarge: " + ht.WhenEnlarge);
WriteMsg("HashTable EnlargeRatio: " + ht.EnlargeRatio);
WriteLine();
string key = "aa";
string value = "小明";
uint i = ht.Add(key, value);
WriteAddMsg(key, value, i);
key = "bb";
value = "小刚";
i = ht.Add(key, value);
WriteAddMsg(key, value, i);
key = "哈哈";
value = "小红";
i = ht.Add(key, value);
WriteAddMsg(key, value, i);
key = "ccc";
value = "小花";
i = ht.Add(key, value);
WriteAddMsg(key, value, i);
key = "ddd";
value = "小白";
i = ht.Add(key, value);
WriteAddMsg(key, value, i);
WriteLine();
key = "aa";
value = ht[key];
WriteGetMsg(key, value);
key = "bb";
value = ht[key];
WriteGetMsg(key, value);
key = "哈哈";
value = ht[key];
WriteGetMsg(key, value);
key = "ccc";
value = ht[key];
WriteGetMsg(key, value);
key = "ddd";
value = ht[key];
WriteGetMsg(key, value);
WriteLine();
}
catch (Exception ex)
{
WriteMsg(ex.ToString());
WriteLine();
}
}
static void Main(string[] args)
{
HashTable hashTable = new HashTable();
hashTable.Add("Qwerty");
}
//public int Capacity
//{
// get
// {
// return this.set.Capacity;
// }
//}
public void Add(T value)
{
set.Add(value, true);
}
public static void Main(string[] args)
{
HashTable <string, int> myHashTable = new HashTable <string, int>();
myHashTable.Add("one", 1);
myHashTable.Add("two", 2);
myHashTable.Add("three", 3);
myHashTable.Add("four", 4);
myHashTable.Add("five", 5);
myHashTable.Add("six", 6);
myHashTable.Add("seven", 7);
myHashTable.Add("eight", 8);
myHashTable.Add("nine", 9);
myHashTable.Add("ten", 10);
myHashTable.Add("eleven", 11);
myHashTable.Add("twelve", 12);
myHashTable.Add("thirteen", 13);
myHashTable.Add("fourteen", 14);
myHashTable.Add("fifteen", 15);
myHashTable.Add("sixteen", 16);
var searched = myHashTable.Find("nine");
myHashTable.Remove("nine");
myHashTable.Clear();
}
public void IsBelongsTrueInHashTableTest(HashTable hashTable)
{
hashTable.Add("999989");
Assert.IsTrue(hashTable.IsBelongs("999989"));
}
public void CanAddOneKeyValue()
{
hashtable.Add("A1", "pen");
Assert.True(hashtable.Contains("A1"));
}
public void Add_ThirdteenItems()
{
HashTable <string, int> hashTable = new HashTable <string, int>();
hashTable.Add("Pessfsho", 6);
hashTable.Add("Pesdfsho1", 6);
hashTable.Add("Peqeqwsho2", 6);
hashTable.Add("Peawsho3", 6);
hashTable.Add("Pesqddho4", 6);
hashTable.Add("Pwdesho5", 6);
hashTable.Add("Pescszho6", 6);
hashTable.Add("Pesaaho7", 6);
hashTable.Add("Pezxcsho8", 6);
hashTable.Add("Pesqwdho9", 6);
hashTable.Add("Pescscho10", 6);
hashTable.Add("Pescsaaho11", 6);
hashTable.Add("Pesadaho12", 6);
hashTable.Add("Pesadwho13", 6);
Assert.IsTrue(hashTable.Count == 14);
}