public void AddShouldThrowExceptionWhenTheSameKeyIsAlreadyPresent() { var hashtable = new HashTable<string, int>(); hashtable.Add("gosho", 12); hashtable.Add("gosho", 2); }
public void RemoveNullKeyElementTest() { HashTable<Point, int> pointsCounts = new HashTable<Point, int>(); pointsCounts.Add(new Point(3, 2), 11); pointsCounts.Remove(null); }
private static void Main() { const int elementsCount = 30000; var rand = new Random(); var beforeHash = GC.GetTotalMemory(true); var hashTest = new HashTable<int, int>(); var stopWatch = new Stopwatch(); stopWatch.Start(); for (var i = 0; i < elementsCount; i++) { var currentNum = rand.Next(); hashTest.Add(currentNum, currentNum); hashTest.Contains(currentNum); } stopWatch.Stop(); var afterHash = GC.GetTotalMemory(true); Console.WriteLine( "The time needed to add {0} items in the HashTalbe was {1}", hashTest.Count, stopWatch.Elapsed); Console.WriteLine("Current capacity is {0} items", hashTest.Capacity); Console.WriteLine("{0} kb used", (afterHash - beforeHash) / 1024); }
public void AddDuplicateKeyElementsTest() { HashTable<int, char> alphabet = new HashTable<int, char>(); alphabet.Add(1, 'A'); alphabet.Add(1, 'a'); }
static void Main() { string input = Console.ReadLine(); var phonebook = new HashTable<string, string>(); while (input != "search") { string[] record = input.Split( new char[] {'-'}, StringSplitOptions.RemoveEmptyEntries); phonebook.AddOrReplace(record[0], record[1]); input = Console.ReadLine(); } input = Console.ReadLine(); while (input != "") { if (phonebook.ContainsKey(input)) { Console.WriteLine("{0} -> {1}", input, phonebook[input]); } else { Console.WriteLine("Contact {0} does not exist.", input); } input = Console.ReadLine(); } }
public void RemoveShouldReturnTrueIfTheKeyIsFoundAndRemovedFromTheHashTable() { var testHashTable = new HashTable<int, int>(); testHashTable.Set(1, 1); var removed = testHashTable.Remove(1); Assert.AreEqual(true, removed); }
public static void Main() { var table = new HashTable<int, int>(); table.Add(1, 11); table.Add(2, 12); table.Add(3, 13); table.Add(4, 14); table.Add(5, 15); table.Add(6, 16); table.Add(7, 17); table.Add(8, 18); //var four = table.Find(4); Console.WriteLine(); Console.WriteLine(table.Count); table.Remove(4); table.Remove(4); Console.WriteLine(); Console.WriteLine(table.Count); Console.WriteLine(); var secondfour = table.Find(4); Console.WriteLine(table.Count); Console.WriteLine(secondfour); Console.WriteLine(table[1]); table[1] = 15; Console.WriteLine(table[1]); Console.WriteLine(string.Join(", ", table.Keys)); }
public void Add_OneItem() { HashTable<string, int> hashTable = new HashTable<string, int>(); hashTable.Add("Pesho", 6); Assert.IsTrue(hashTable.Count == 1); }
static void Main(string[] args) { var hash = new HashTable<string, int>(); for (int i = 0; i < 50; i++) { var name = "Pesho"; hash.Add(name + i, i); Console.WriteLine("Count: " + hash.Count); Console.WriteLine("Length: " + hash.Length); } var result = hash.Find("Pesho4"); Console.WriteLine(result); Console.WriteLine(); Console.WriteLine("Count is " + hash.Count); hash.Remove("Pesho2"); Console.WriteLine("Now count is " + hash.Count); Console.WriteLine("-------"); foreach (var item in hash) { Console.WriteLine(item); } }
public void RemoveShouldReturnFalseIfTheKeyIsNotFound() { var testHashTable = new HashTable<int, int>(); testHashTable.Set(1, 1); var removed = testHashTable.Remove(2); Assert.AreEqual(false, removed); }
public void IndexerShouldSetThePassedValueToThePassedKey() { var testHashTable = new HashTable<int, int>(); testHashTable.Set(1, 1); testHashTable[1] = 2; Assert.AreEqual(2, testHashTable[1]); }
public void HashTableShouldWorkProperlyWithCollectionValues() { var testHashTable = new HashTable<int, List<int>>(); testHashTable.Set(1, new List<int> {1, 2, 3}); Assert.AreEqual(3, testHashTable[1][2]); }
public void InsertValueByDuplicatedKey_ExpectedException() { HashTable<int, int> hashTable = new HashTable<int, int>(10); hashTable.Add(1, 1); hashTable.Add(1, 2); }
public void SetShouldReplaceTheExistingValueWithTheNewOneWhenKeyExists() { var testHashTable = new HashTable<int, int>(); testHashTable.Set(1, 1); testHashTable.Set(1, 2); Assert.AreEqual(2, testHashTable[1]); }
public void ClearShouldEmptyTheTableAndKeepTheCurrentCapacity() { var table = new HashTable<string, List<int>>(); for (int i = 0; i < 50; i++) { table[i.ToString()] = new List<int>(); for (int j = 0; j < 5; j++) { table[i.ToString()].Add(j); } Assert.IsTrue(table[i.ToString()].Count > 0); } int finalCapacity = table.Capacity; table.Clear(); Assert.IsTrue(finalCapacity >= 50); Assert.AreEqual(finalCapacity, table.Capacity); Assert.AreEqual(0, table.Count); for (int i = 0; i < 50; i++) { Assert.IsFalse(table.ContainsKey(i.ToString())); } }
private static void PrintClubsPoints(HashTable<string, int> clubsPoints) { foreach (KeyValuePair<string, int> clubPoints in clubsPoints) { Console.WriteLine(clubPoints); } }
private static int HashTable(char[] data) { int[] diffs = new int[data.Length]; int diff = 0; for(int i = 0; i < data.Length; i++) { if (LettersAndNumbers.IsNumber(data[i])) diff++; else diff--; diffs[i] = diff; } HashTable<int, int> hashTable = new HashTable<int, int>(); hashTable[0] = -1; int max = 0; for(int i = 0; i < diffs.Length; i++) { if (hashTable.Contains(diffs[i])) max = Math.Max(max, i - hashTable[diffs[i]]); else hashTable[diffs[i]] = i; } return max; }
static void Main(string[] args) { var contactInfo = new HashTable<string, string>(); var inSeachMode = false; var line = Console.ReadLine(); while (!string.IsNullOrEmpty(line)) { try { if (line == "search") { var name = Console.ReadLine(); var phoneNumber = FindUserInfo(name, contactInfo); Console.WriteLine("{0} -> {1}", name, phoneNumber); inSeachMode = true; } if (!inSeachMode) { ProcessContactInfo(line, contactInfo); } line = Console.ReadLine(); } catch (ArgumentException ex) { Console.WriteLine(ex.Message); } } }
static void Main(string[] args) { HashTable<string, string> phoneBook = new HashTable<string, string>(); while (true) { var line = Console.ReadLine(); if (line == "search") { while (true) { line = Console.ReadLine(); if (line == "break") { break; } var entry = phoneBook.Find(line); if (entry != null) { Console.WriteLine("{0} -> {1}", entry.Key, entry.Value); } else { Console.WriteLine("Contact {0} does not exist!", line); } } } else { string[] phoneEntries = line.Split(new string[] { DELIMITER }, StringSplitOptions.RemoveEmptyEntries).ToArray(); phoneBook.Add(phoneEntries[0], phoneEntries[1]); } } }
public void DeleteTest() { HashTable ht = new HashTable(35); ht.AddToHashTable("GUITAR"); ht.DeleteFromHashTable("GUITAR"); Assert.IsFalse(ht.Search("GUITAR")); }
public void Initialize() { hashFunction1 = new HashFunction1(); hashFunction2 = new HashFunction2(); hashTable1 = new HashTable(5, hashFunction1); hashTable2 = new HashTable(5, hashFunction2); }
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(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]); }
static void Main() { HashTable<string, string> hashTable = new HashTable<string, string>(); hashTable.Add("1", "aa1"); hashTable.Add("2", "22a"); hashTable.Add("3", "wwer"); hashTable.Add("4", "rrrr"); hashTable.Add("5", "qqqq"); hashTable.Add("6", "tttt"); Console.WriteLine(hashTable.Find("2")); Console.WriteLine("Count: {0}", hashTable.Count); hashTable.Remove("1"); Console.WriteLine("Count: {0}", hashTable.Count); Console.WriteLine(hashTable["3"]); Console.WriteLine("\nKeys: "); foreach (var item in hashTable.Keys) { Console.WriteLine(item); } Console.WriteLine("\nIteration with foreach:"); foreach (var item in hashTable) { Console.WriteLine("{0}: {1}", item.Key, item.Value); } }
static void Main() { HashTable<string, string> hashTable = new HashTable<string, string>(); string input = Console.ReadLine(); while (input != "search") { string[] parameters = input.Split('-'); string contact = parameters[0]; string number = parameters[1]; hashTable[contact] = number; input = Console.ReadLine(); } input = Console.ReadLine(); while (input != "end") { if (hashTable.ContainsKey(input)) { Console.WriteLine("{0} -> {1}", input, hashTable[input]); } else { Console.WriteLine("Contact {0} does not exist", input); } input = Console.ReadLine(); } }
static void Main() { HashTable<string, int> hash = new HashTable<string, int>(32); hash.Add("Pesho", 6); hash.Add("Pesho", 6); hash.Add("Pesho", 3); hash.Add("Gosho", 9); hash.Add("Tosho", 4); hash.Add("Viko", 7); hash.Add("Viko", 7); hash.Add("high 5", 7); hash["Johnatan"] = 3333; hash["viko"] = 1111111; hash.Remove("Tosho"); foreach (var item in hash) { Console.WriteLine("{0} -> {1}", item.Key, item.Value); } hash.Clear(); foreach (var item in hash) { Console.WriteLine("{0} -> {1}", item.Key, item.Value); } }
/* Task 4: * Implement the data structure "hash table" in a class HashTable<K,T>. * Keep the data in array of lists of key-value pairs (LinkedList<KeyValuePair<K,T>>[]) * with initial capacity of 16. When the hash table load runs over 75%, perform resizing to 2 * times larger capacity. Implement the following methods and properties: Add(key, value), Find(key)value, * Remove( key), Count, Clear(), this[], Keys. Try to make the hash table to support iterating over its elements * with foreach. */ //Few functionalities are missing. If I have time I will add them as well. static void Main(string[] args) { var hashTable = new HashTable<string, int>(); for (int i = 0; i < 100; i++) { hashTable.Add("Entri" + i, i); } Console.WriteLine(hashTable.Count()); Console.WriteLine(hashTable.Find("Entri50")); for (int i = 50; i < 100; i++) { hashTable.Remove("Entri" + i); } //Will throw an exception //Console.WriteLine(hashTable.Find("Entri50")); var keys = hashTable.Keys(); foreach (var key in keys) { Console.WriteLine(key); } hashTable.Clear(); Console.WriteLine(hashTable.Count()); }
public void AddingByIndexShouldAddCorrectly() { var table = new HashTable<string, int>(); table["pesho"] = 2; Assert.AreEqual(2, table["pesho"]); }
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 static void Main() { HashTable<int, string> table = new HashTable<int, string>(); table.Add(2, "Pesho"); table.Add(3, "Jhon"); table.Add(67, "Evlogi"); table.Add(23, "Jhon"); table.Add(27, "Pesho"); table.Add(35, "Jhon"); table.Add(66, "Evlogi"); table.Add(11, "Jhon"); table.Add(32, "Pesho"); table.Add(19, "Jhon"); table.Add(12, "Evlogi"); table.Add(13, "Jhon"); table.Add(14, "Pesho"); table.Add(30, "Jhon"); table.Add(44, "Evlogi"); foreach (var item in table) { Console.WriteLine(item.Value); } }
public void TestHashTableResizing() { HashTable <int, int> integerTable = new HashTable <int, int>(); int numberOfElements = 25; for (int i = 0; i < numberOfElements; i++) { integerTable.Add(i, i * 2); } for (int i = 0; i < numberOfElements; i++) { Assert.AreEqual(i * 2, integerTable[i], "Incorrectly resizing the array!"); } int actualCount = integerTable.Count; Assert.AreEqual(numberOfElements, actualCount, "The table count is incorrectly calculated!"); }
/// <summary> /// Adds all the common values from a given binary tree and a hash table to a given list. /// </summary> /// <param name="values">hash table of stringified values to be searched</param> /// <param name="root">root of Binary tree to be compared</param> /// <param name="result">empty list to hold any found matches</param> private static void Intersect(HashTable values, Node root, List <int> result) { if (root == null) { return; } if (root.LeftChild != null) { Intersect(values, root.LeftChild, result); } if (root.RightChild != null) { Intersect(values, root.RightChild, result); } if (values.Contains(root.Value.ToString()) && !result.Contains(root.Value)) { result.Add(root.Value); } }
public void RetrieveTest2() { // Arrange HashTable hashTable = new HashTable(); var data1 = new HashTable.HashNode(5, "Андрей"); var data2 = new HashTable.HashNode(25, "Сергей"); var data3 = new HashTable.HashNode(5, "Олег"); int count = 2; // Act hashTable.DoubleHashInsert(data1.Key, data1.Data); hashTable.DoubleHashInsert(data2.Key, data2.Data); hashTable.DoubleHashInsert(data3.Key, data3.Data); // Assert Assert.AreEqual(data1.Data, hashTable.Retrieve(data1.Key).Data); Assert.AreEqual(count, hashTable.Retrieve(data1.Key).count); }
public void HashTableCountWorksCorectWithAddAndRemoveOfElements() { var hashTable = new HashTable <int, string>(); var removedElementsCount = 10; var expectedCount = 50 - removedElementsCount; for (int i = 0; i < 50; i++) { hashTable.Add(i, "Test text " + i); } for (int i = 5; i < removedElementsCount + 5; i++) { hashTable.Remove(i); } Assert.AreEqual(expectedCount, hashTable.Count); }
public void CanInsertValue() { //arrange HashTable ht = new HashTable(); //act ht.Add("bear", 50); ht.Add("act", 5); ht.Add("dog", 1); ht.Add("pig", 30); ht.Add("ball", 75); ht.Add("rat", 23); ht.Add("man", 99); int findValue = ht.Find("bear"); //assert Assert.Equal(50, findValue); }
public void Clear_ClearTable() { HashTable <string, int> hashTable = new HashTable <string, int>(); 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.Clear(); Assert.IsTrue(hashTable.Count == 0); }
public void HashTest10000n1000() { int flag; var size = 10000; var rnd = new Random(); flag = rnd.Next(size); var hash = new HashTable(size); for (var i = 0; i < size; i++) { var element = rnd.Next(); hash.PutPair(i, element); } for (var i = 0; i < 1000; i++) { Assert.AreEqual(null, hash.GetValueByKey(rnd.Next(1000) + 10000)); } }
static void WriteData(HashTable table, System.IO.TextWriter writer) { for (int i = 0; i < table.values.Count(); ++i) { writer.Write(i + ": "); if (table.values[i] != null) { ListNode <uint> o = table.values[i]; while (o != null) { writer.Write(o.value + " "); o = o.next; } } writer.WriteLine(); } }
public void TestLongestPalindrome() { var test = "abccccddaa"; var result = HashTable.LongestPalindrome(test); Assert.AreEqual(9, result); test = "ab"; result = HashTable.LongestPalindrome(test); Assert.AreEqual(1, result); test = "aa"; result = HashTable.LongestPalindrome(test); Assert.AreEqual(2, result); test = "aaa"; result = HashTable.LongestPalindrome(test); Assert.AreEqual(3, result); }
public void Find_FindItem() { HashTable <string, int> hashTable = new HashTable <string, int>(); hashTable.Add("Pesdfsho1", 6); hashTable.Add("Peqeqwsho2", 6); hashTable.Add("Peawsho3", 16); hashTable.Add("Pesqddho4", 6); hashTable.Add("Pwdesho5", 26); hashTable.Add("Pescszho6", 6); hashTable.Add("Pesaaho7", 56); hashTable.Add("Pezxcsho8", 6); hashTable.Add("Pesqwdho9", 16); hashTable.Add("Pescscho10", 6); var actual = hashTable.Find("Pesaaho7"); Assert.AreEqual(56, actual); }
/// <summary> /// Checks for first repeated word in a long string /// </summary> /// <param name="input">The input string</param> /// <returns>returns the first repeated word</returns> public static string RepeatedWord(string input) { string[] temp = input.ToLower().Split(" "); HashTable table = new HashTable(); foreach (string word in temp) { if (!table.Contains(word)) { table.Add(word, word); } else { return(word); } } return("No Repeated Words"); }
public void TestFindMinWindow() { var a = "adobecodebanc"; var result = HashTable.FindMinWindow(a); Assert.AreEqual(7, result); a = "abce"; result = HashTable.FindMinWindow(a); Assert.AreEqual(4, result); a = "aaaa"; result = HashTable.FindMinWindow(a); Assert.AreEqual(1, result); a = "abcabcbb"; result = HashTable.FindMinWindow(a); Assert.AreEqual(3, result); }
public void TestHashTableContains() { HashTable <string, int> hashTable = new HashTable <string, int>(3, 0.9f); hashTable.Add("m", 0); hashTable.Add("b", 0); hashTable.Add("t", 0); hashTable.Add("o", 0); hashTable.Add("z", 0); hashTable.Add("k", 0); hashTable.Add("g", 0); hashTable.Add("a5", 0); hashTable.Add("c", 0); hashTable.Add("a2", 0); hashTable.Add("a7", 0); hashTable.Add("i", 0); hashTable.Add("h", 0); Assert.IsTrue(hashTable.ContainsKey("m")); Assert.IsTrue(hashTable.Contains(new KeyValuePair <string, int>("m", 0))); Assert.IsTrue(hashTable.ContainsKey("b")); Assert.IsTrue(hashTable.Contains(new KeyValuePair <string, int>("b", 0))); Assert.IsTrue(hashTable.ContainsKey("t")); Assert.IsTrue(hashTable.Contains(new KeyValuePair <string, int>("t", 0))); Assert.IsTrue(hashTable.ContainsKey("o")); Assert.IsTrue(hashTable.Contains(new KeyValuePair <string, int>("o", 0))); Assert.IsTrue(hashTable.ContainsKey("z")); Assert.IsTrue(hashTable.Contains(new KeyValuePair <string, int>("z", 0))); Assert.IsTrue(hashTable.ContainsKey("k")); Assert.IsTrue(hashTable.Contains(new KeyValuePair <string, int>("k", 0))); Assert.IsTrue(hashTable.ContainsKey("g")); Assert.IsTrue(hashTable.Contains(new KeyValuePair <string, int>("g", 0))); Assert.IsTrue(hashTable.ContainsKey("a5")); Assert.IsTrue(hashTable.Contains(new KeyValuePair <string, int>("a5", 0))); Assert.IsTrue(hashTable.ContainsKey("c")); Assert.IsTrue(hashTable.Contains(new KeyValuePair <string, int>("a2", 0))); Assert.IsTrue(hashTable.ContainsKey("a7")); Assert.IsTrue(hashTable.Contains(new KeyValuePair <string, int>("a7", 0))); Assert.IsTrue(hashTable.ContainsKey("i")); Assert.IsTrue(hashTable.Contains(new KeyValuePair <string, int>("i", 0))); Assert.IsTrue(hashTable.ContainsKey("h")); Assert.IsTrue(hashTable.Contains(new KeyValuePair <string, int>("h", 0))); }
public void TestTryGetValue_Fail() { HashTable <string, int> hashTable = new HashTable <string, int>(); hashTable.Add("asd", 10); int count = 1000; for (int i = 0; i < count; i++) { hashTable.Add(i.ToString(), i); } int value; bool found = hashTable.TryGetValue("qwe", out value); Assert.AreEqual(false, found); Assert.AreEqual(0, value); }
/// <summary> /// Initializes a new instance of the <see cref="Warcraft.MPQ.MPQ"/> class. /// </summary> /// <param name="mpqStream">An open stream to data containing an MPQ archive.</param> public MPQ([NotNull] Stream mpqStream) { _archiveReader = new BinaryReader(mpqStream); Header = new MPQHeader(_archiveReader.ReadBytes((int)PeekHeaderSize())); // Seek to the hash table and load it _archiveReader.BaseStream.Position = (long)Header.GetHashTableOffset(); var encryptedHashTable = _archiveReader.ReadBytes((int)Header.GetHashTableSize()); var hashTableData = MPQCrypt.DecryptData(encryptedHashTable, HashTable.TableKey); ArchiveHashTable = new HashTable(hashTableData); // Seek to the block table and load it _archiveReader.BaseStream.Position = (long)Header.GetBlockTableOffset(); var encryptedBlockTable = _archiveReader.ReadBytes((int)Header.GetBlockTableSize()); var blockTableData = MPQCrypt.DecryptData(encryptedBlockTable, BlockTable.TableKey); ArchiveBlockTable = new BlockTable(blockTableData); if (Header.GetFormat() != MPQFormat.ExtendedV1) { return; } // Seek to the extended block table and load it, if necessary if (Header.GetExtendedBlockTableOffset() <= 0) { return; } _archiveReader.BaseStream.Position = (long)Header.GetExtendedBlockTableOffset(); var extendedTable = new List <ushort>(); for (var i = 0; i < Header.GetBlockTableEntryCount(); ++i) { extendedTable.Add(_archiveReader.ReadUInt16()); } ExtendedBlockTable = extendedTable; }
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"); } }
public void HashTableHashCode() { var table1 = new HashTable <string, string>() { { "hello", "world" }, { "hello", "kitty" } }; var table2 = new HashTable <string, string>() { { "one", "two" } }; var table3 = new HashTable <string, string>() { { "one", "two" } }; Assert.AreNotEqual(table1.GetHashCode(), table2.GetHashCode()); Assert.AreEqual(table2.GetHashCode(), table3.GetHashCode()); }
public void AddsOnlyCommons() { HashTable left = new HashTable(); left.Add("light", "bright"); left.Add("nope", "nah"); left.Add("bad", "evil"); HashTable right = new HashTable(); right.Add("nope", "yup"); right.Add("light", "dark"); right.Add("good", "evil"); List <object[]> expected = new List <object[]>(); expected.Add(new object[] { "bad", "evil", null }); expected.Add(new object[] { "light", "bright", "dark" }); expected.Add(new object[] { "nope", "nah", "yup" }); Assert.Equal(expected, Program.LeftJoin(left, right)); }
public void KeyPresent_Value() { //Arrange HashTable <string, int> hashTable = new HashTable <string, int>(); hashTable.Add("key1", 1); hashTable.Add("key2", 2); hashTable.Add("key3", 3); string keyToRemove = "key2"; //Act bool removed = hashTable.Remove(keyToRemove); //Assert bool valuePresent = hashTable.ContainsKey(keyToRemove); Assert.True(removed); Assert.False(valuePresent); }
public void HashTableCopyTo() { var values = new List <KeyValuePair <string, int> >() { new KeyValuePair <string, int>("one", 1), new KeyValuePair <string, int>("two", 2), new KeyValuePair <string, int>("three", 3), }; var table = new HashTable <string, int>(); foreach (var value in values) { table.Add(value); } var array = new KeyValuePair <string, int> [3]; table.CopyTo(array, 0); Assert.IsTrue(array.SequenceEqual(values)); }
public void CanJoinSingle() { HashTable synonyms = new HashTable(1); synonyms.Add("fond", "enamored"); HashTable antonyms = new HashTable(1); antonyms.Add("fond", "averse"); string[][] joined = Program.LeftJoin(synonyms, antonyms); string[][] expected = { new string[] { "fond", "enamored", "averse" } }; Assert.Equal(expected, joined); }
private void ExpandIfNeeded() { float loadFactor = (float)(this.Count + 1) / this.Capacity; if (loadFactor >= LoadFactor) { var tempArray = new HashTable <TKey, TValue>(this.Capacity * 2); foreach (var kvp in this.elements.Where(e => e != null)) { foreach (var element in kvp) { tempArray.Add(element.Key, element.Value); } } this.elements = tempArray.elements; } }
public void Add_1000_Elements_Grow_ShouldWorkCorrectly() { // Arrange var hashTable = new HashTable <string, int>(1); // Act var expectedElements = new List <KeyValue <string, int> >(); for (int i = 0; i < 1000; i++) { hashTable.Add("key" + i, i); expectedElements.Add(new KeyValue <string, int>("key" + i, i)); } // Assert var actualElements = hashTable.ToList(); CollectionAssert.AreEquivalent(expectedElements, actualElements); }
public void RemoveMultiple() { var hashTable = new HashTable <int, int>(); const int elementsCount = 1000; for (int i = 0; i < elementsCount; i++) { hashTable[i] = i; } for (int i = 0; i < elementsCount / 2; i++) { hashTable.Remove(i); } Assert.AreEqual(elementsCount / 2, hashTable.Count); Assert.AreEqual(elementsCount / 2, hashTable.Keys.Count); }
public void CanCheckIfContainsCanFindKey() { //arrange HashTable ht = new HashTable(); //act ht.Add("bear", 50); ht.Add("act", 5); ht.Add("dog", 1); ht.Add("pig", 30); ht.Add("ball", 75); ht.Add("rat", 23); ht.Add("man", 99); int findValue = ht.Find("bear"); //assert Assert.True(ht.Contains("ball")); }
private void RefreshImage() { this.imgContainerHeight = this.MapContainer.Height * 2; this.imgContainerWidth = this.MapContainer.Width * 2; HashTable tileLayers = this.MapContainer.TileLayerList; ScaleTransform zoom = new ScaleTransform(); zoom.CenterX = 150; zoom.CenterY = 150; zoom.ScaleX = 2; zoom.ScaleY = 2; for (int i = 0; i < tileLayers.Length; i++) { if ((tileLayers.GetItemByIndex(i) as ITile).EnableFillImg && (tileLayers.GetItemByIndex(i) as UIElement).Visibility == Visibility.Visible) { IMap tmap = (tileLayers.GetItemByIndex(i) as IMap); Image imgTmp = tmap.DrawToImage(); imgTmp.RenderTransform = zoom; this.imgContainer.Children.Add(imgTmp); FrameworkElement ui = (FrameworkElement)(tileLayers.GetItemByIndex(i)); tmpCanvasLeft = Canvas.GetLeft(ui); tmpCanvasTop = Canvas.GetTop(ui); this.imgContainerWidth = ui.Width * 2; this.imgContainerHeight = ui.Height * 2; } } HashTable vectorLayers = this.MapContainer.VectorLayerList; for (int j = 0; j < vectorLayers.Length; j++) { if ((vectorLayers.GetItemByIndex(j) as UIElement).Visibility == Visibility.Visible) { IMap vmap = (vectorLayers.GetItemByIndex(j) as IMap); Image imgTmp = vmap.DrawToImage(); imgTmp.RenderTransform = zoom; this.imgContainer.Children.Add(imgTmp); Canvas.SetLeft(imgTmp, -tmpCanvasLeft * 2); Canvas.SetTop(imgTmp, -tmpCanvasTop * 2); } } }
static Nullable <int> HashTableFind(HashTable <string, int> table, string key) { var arraySize = table.buckets.Length; int index = getIndex(key, arraySize); var values = table.buckets; if (values[index] == null) { return(null); } else { if (values[index].Key.Equals(key)) { return(values[index].Value); } else { // TODO: Ex2.1; potentialIndex = ? var potentialIndex = 0; // PLACEHOLDER: REMOVE AND REPLACE WITH YOUR CODE while (values[potentialIndex] != null) { if (values[potentialIndex].Key.Equals(key)) { return(values[potentialIndex].Value); } potentialIndex++; if (potentialIndex >= arraySize) { potentialIndex = 0; } if (potentialIndex == index) { return(null); } } } } return(null); }
private static void Run() { HashTable hashTable = new HashTable(); FillWithDict(hashTable); hashTable.ShowTableInfo(); bool running = true; while (running) { Console.WriteLine($"{Prompts["operations"]}"); string input = Console.ReadLine(); string word = ""; switch (input) { case "1": Console.Write($"{Prompts["word"]}"); word = Console.ReadLine(); hashTable.Add(word); hashTable.ShowTableInfo(); break; case "2": Console.Write($"{Prompts["word"]}"); word = Console.ReadLine(); hashTable.Find(word); break; case "3": Console.Write($"{Prompts["word"]}"); word = Console.ReadLine(); hashTable.Delete(word); hashTable.ShowTableInfo(); break; case "4": running = false; break; } } }
public static void TestHashTableSeekSlot() { var hashTable = new HashTable(19, 3); var slot = hashTable.SeekSlot("Ro"); Assert.AreEqual(3, slot); slot = hashTable.SeekSlot("R"); Assert.AreEqual(6, slot); slot = hashTable.SeekSlot("Alphanumeric"); Assert.AreEqual(6, slot); slot = hashTable.SeekSlot("Number"); Assert.AreEqual(9, slot); var hashTable2 = new HashTable(3, 1); hashTable2.Put("1"); hashTable2.Put("2"); hashTable2.Put("3"); Assert.AreEqual(-1, hashTable2.SeekSlot("4")); }
public void CapacityShouldIncreasePersistently() { var hashtable = new HashTable <string, string>(); var lastCapacity = hashtable.Capacity; var counter = 16; var next = 0; while (hashtable.Count < 1024) { for (int i = 0; i < 1 + (counter * 3) / 4; i++) { hashtable.Add((next++).ToString(), "dinozavyr"); } lastCapacity = hashtable.Capacity; counter *= 2; Assert.AreEqual(counter, lastCapacity); } }