public void TestIntersectMethodToReturnCorrectResultsWithStrings()
{
string matchedValue1 = "Java";
string matchedValue2 = "CSharp";
HashedSet <string> first = new HashedSet <string>();
first.Add("3");
first.Add(matchedValue2);
first.Add(matchedValue1);
first.Add("test");
HashedSet <string> second = new HashedSet <string>();
second.Add("testMethod");
second.Add("TestClass");
second.Add(matchedValue1);
second.Add("TestData");
second.Add(matchedValue2);
second.Add(" ");
first.Intersect(second);
Assert.AreEqual(2, first.Count);
var testResult = first.Find(matchedValue1);
Assert.AreEqual(matchedValue1, testResult);
testResult = first.Find(matchedValue2);
Assert.AreEqual(matchedValue2, testResult);
}
static void Main()
{
var set = new HashedSet<int>();
set.Add(5);
set.Add(3);
set.Add(-4);
set.Add(12);
set.Add(0);
set.Add(-50);
set.Add(10);
Console.WriteLine("Set contains 12 -> {0}", set.Find(12));
Console.WriteLine("Set contains 13 -> {0}", set.Find(13));
set.Remove(10);
Console.WriteLine("Removed 10\nSet contains 10 -> {0}", set.Find(10));
Console.WriteLine("Set contains {0} items", set.Count);
Console.WriteLine("Set 1: {0}", set);
var anotherSet = new HashedSet<int>();
anotherSet.Add(-4);
anotherSet.Add(15);
anotherSet.Add(0);
anotherSet.Add(-122);
anotherSet.Add(35);
Console.WriteLine("Set 2: {0}", anotherSet);
set.Union(anotherSet);
Console.WriteLine("Set after union: {0}", set);
set.Intersect(anotherSet);
Console.WriteLine("Set after intersect: {0}", set);
set.Clear();
Console.WriteLine("Set contains {0} items after clear", set.Count);
}
public void TestIntersectMethodToReturnCorrectResults()
{
int matchedValue1 = 18;
int matchedValue2 = -5;
HashedSet <int> first = new HashedSet <int>();
first.Add(3);
first.Add(matchedValue2);
first.Add(matchedValue1);
first.Add(14);
HashedSet <int> second = new HashedSet <int>();
second.Add(20);
second.Add(22);
second.Add(matchedValue1);
second.Add(290);
second.Add(matchedValue2);
second.Add(300);
first.Intersect(second);
Assert.AreEqual(2, first.Count);
var testResult = first.Find(matchedValue1);
Assert.AreEqual(matchedValue1, testResult);
testResult = first.Find(matchedValue2);
Assert.AreEqual(matchedValue2, testResult);
}
public static void Main()
{
var firstSet = new HashedSet<string>();
var secondSet = new HashedSet<string>();
firstSet.Add("Pesho");
firstSet.Add("Gosho");
firstSet.Add("Tosho");
secondSet.Add("Ivan");
secondSet.Add("Petkan");
secondSet.Add("Dragan");
Console.WriteLine(firstSet);
Console.WriteLine(secondSet);
Console.WriteLine(firstSet.Intersect(secondSet));
Console.WriteLine(secondSet.Intersect(firstSet));
Console.WriteLine(firstSet.Union(secondSet));
Console.WriteLine(secondSet.Union(firstSet));
firstSet.Remove("Pesho");
firstSet.Remove("Tosho");
Console.WriteLine(firstSet);
Console.WriteLine(firstSet.Find("Tosho"));
Console.WriteLine(firstSet.Find("Gosho"));
Console.WriteLine(firstSet.Count);
}
static void Main(string[] args)
{
HashedSet <int> testHashSet = new HashedSet <int>(2);
Console.WriteLine("Current HashSet count: {0}", testHashSet.Count);
testHashSet.Add(1);
testHashSet.Add(2);
testHashSet.Add(2);
testHashSet.Add(2);
testHashSet.Add(3);
testHashSet.Add(4);
testHashSet.Add(5);
testHashSet.Add(6);
Console.WriteLine(new String('*', 30));
Console.WriteLine("Current HashSet content:");
PrintHashSet(testHashSet);
Console.WriteLine(new String('*', 30));
Console.WriteLine("Current HashSet count: {0}", testHashSet.Count);
Console.WriteLine(new String('*', 30));
Console.WriteLine("Check if value 1 exist in the HashSet: {0}", testHashSet.Find(1));
Console.WriteLine(new String('*', 30));
Console.WriteLine("Check if value 11 exist in the HashSet: {0}", testHashSet.Find(11));
testHashSet.Remove(5);
Console.WriteLine(new String('*', 30));
Console.WriteLine("HashSet content after removing 5:");
PrintHashSet(testHashSet);
HashedSet <int> testHashSet2 = new HashedSet <int>(2);
testHashSet2.Add(1);
testHashSet2.Add(2);
testHashSet2.Add(12);
HashedSet <int> testHashSetUnion = testHashSet.Union(testHashSet2);
Console.WriteLine(new String('*', 30));
Console.WriteLine("HashSet union with HashSet [1, 2, 12]:");
PrintHashSet(testHashSetUnion);
HashedSet <int> testHashSetIntersection = testHashSet.Intersection(testHashSet2);
Console.WriteLine(new String('*', 30));
Console.WriteLine("HashSet intersection with HashSet [1, 2, 12]:");
PrintHashSet(testHashSetIntersection);
}
public void FindShouldReturnCorrectValueWhenSearchingForExistingElement()
{
testSet = new HashedSet <string>();
testSet.Add("Pesho");
Assert.AreEqual("Pesho", testSet.Find("Pesho"));
}
public void TestFindWithInvalidKey()
{
var table = new HashedSet<string>();
table.Add("Pesho");
var value = table.Find("Peho");
}
public void TestFindShouldProperlyWork()
{
var table = new HashedSet<string>();
table.Add("Pesho");
Assert.AreEqual(true, table.Find("Pesho"));
}
public void UnionExpectedToWorkProperly()
{
var firstSet = new HashedSet <string>();
for (int i = 1; i <= 10; i++)
{
firstSet.Add("test" + i);
}
var secondSet = new HashedSet <string>();
for (int i = 5; i <= 15; i++)
{
secondSet.Add("test" + i);
}
firstSet.Union(secondSet);
Assert.AreEqual(15, firstSet.Count);
for (int i = 1; i <= 15; i++)
{
Assert.IsTrue(firstSet.Find("test" + i));
}
}
public static void Main()
{
HashedSet<float> firstSet = new HashedSet<float>();
firstSet.Add(1f);
firstSet.Add(1.4f);
firstSet.Add(1.7f);
firstSet.Add(2f);
firstSet.Add(2.2f);
firstSet.Remove(1.7f);
Console.WriteLine(firstSet.Find(1f));
Console.WriteLine(firstSet.Count);
HashedSet<float> secondSet = new HashedSet<float>();
secondSet.Add(1f);
secondSet.Add(2f);
secondSet.Add(3f);
secondSet.Add(5f);
HashedSet<float> thirdSet = new HashedSet<float>();
thirdSet.Add(1f);
thirdSet.Add(2f);
thirdSet.Add(3f);
thirdSet.Add(5f);
secondSet.Union(firstSet);
thirdSet.Intersect(firstSet);
firstSet.Clear();
}
static void Main()
{
HashedSet <string> mySet = new HashedSet <string>();
mySet.Add("Gogo");
mySet.Add("Mimi");
mySet.Add("Tosho");
mySet.Add("Pesho");
mySet.Add("Vankata");
HashedSet <string> otherSet = new HashedSet <string>();
otherSet.Add("Tosho");
otherSet.Add("Pesho");
otherSet.Add("Moni");
Console.WriteLine(mySet.Find("Gogo"));
Console.WriteLine(mySet.Find("Gogo2"));
mySet.Remove("Gogo");
var union = mySet.Union(otherSet);
var intersect = mySet.Intersect(otherSet);
Console.WriteLine(mySet.Count());
Console.WriteLine("\nMySet");
foreach (var item in mySet)
{
Console.WriteLine(item.ToString());
}
Console.WriteLine("\nUnion");
foreach (var item in union)
{
Console.WriteLine(item.ToString());
}
Console.WriteLine("\nIntersect");
foreach (var item in intersect)
{
Console.WriteLine(item.ToString());
}
}
public void RemovingExistingElementShouldWorkCorrectly()
{
testSet = new HashedSet <string>();
testSet.Add("Pesho");
testSet.Remove("Pesho");
Assert.IsTrue(testSet.Count == 0 && testSet.Find("Pesho") == null);
}
public void FindShouldReturnValue()
{
var set = new HashedSet<int>();
int value = 5;
set.Add(value);
int actual = set.Find(value);
Assert.AreEqual(value, actual);
}
internal static void Main()
{
HashedSet<int> test = new HashedSet<int>();
HashedSet<int> other = new HashedSet<int>();
test.Add(1);
test.Add(2);
test.Add(3);
test.Add(4);
test.Add(5);
test.Add(6);
other.Add(4);
other.Add(5);
other.Add(6);
other.Add(7);
other.Add(8);
Console.WriteLine("Initial hash set:");
Console.WriteLine(string.Join(", ", test));
Console.WriteLine("--------------------------------------------------------------");
Console.WriteLine("After removal of 3:");
test.Remove(3);
Console.WriteLine(string.Join(", ", test));
Console.WriteLine("--------------------------------------------------------------");
Console.WriteLine("Is 1 found? {0}", test.Find(1));
Console.WriteLine("Is 3 found? {0}", test.Find(3));
Console.WriteLine("--------------------------------------------------------------");
Console.WriteLine("First hash set:");
Console.WriteLine(string.Join(", ", test));
Console.WriteLine("Member count: {0}", test.Count);
Console.WriteLine("--------------------------------------------------------------");
Console.WriteLine("Second hash set:");
Console.WriteLine(string.Join(", ", other));
Console.WriteLine("Member count: {0}", other.Count);
Console.WriteLine("--------------------------------------------------------------");
Console.WriteLine("Intersect of the first and second:");
Console.WriteLine(string.Join(", ", test.Intersect(other)));
Console.WriteLine("--------------------------------------------------------------");
Console.WriteLine("Union of the first and second:");
Console.WriteLine(string.Join(", ", test.Union(other)));
Console.WriteLine("--------------------------------------------------------------");
test.Clear();
Console.WriteLine("First hash set after clear:");
Console.WriteLine(string.Join(", ", test));
}
static void Main()
{
HashedSet <int> hSet = new HashedSet <int>();
hSet.Add(5);
hSet.Add(15);
hSet.Add(5);
Console.WriteLine(hSet.Find(45));
Console.WriteLine(hSet.Find(15));
hSet.Remove(5);
Console.WriteLine(hSet.Find(5));
hSet.Clear();
Console.WriteLine(hSet.Count);
hSet.Add(5);
hSet.Add(15);
hSet.Add(25);
hSet.Add(35);
HashedSet <int> hSetTwo = new HashedSet <int>();
hSetTwo.Add(4);
hSetTwo.Add(24);
hSetTwo.Add(25);
hSetTwo.Add(35);
var newIntersectedSet = hSet.Intersect(hSetTwo);
foreach (var item in newIntersectedSet.Keys)
{
Console.WriteLine(item);
}
var newUnitedSet = hSet.Union(hSetTwo);
foreach (var item in newUnitedSet.Keys)
{
Console.WriteLine(item);
}
}
public void FindShouldThrowIfKeyNotExists()
{
var set = new HashedSet<int>();
int value = 5;
set.Add(value);
int actual = set.Find(value + 1);
Assert.AreEqual(value, actual);
}
static void Main()
{
HashedSet<int> hSet = new HashedSet<int>();
hSet.Add(5);
hSet.Add(15);
hSet.Add(5);
Console.WriteLine(hSet.Find(45));
Console.WriteLine(hSet.Find(15));
hSet.Remove(5);
Console.WriteLine(hSet.Find(5));
hSet.Clear();
Console.WriteLine(hSet.Count);
hSet.Add(5);
hSet.Add(15);
hSet.Add(25);
hSet.Add(35);
HashedSet<int> hSetTwo = new HashedSet<int>();
hSetTwo.Add(4);
hSetTwo.Add(24);
hSetTwo.Add(25);
hSetTwo.Add(35);
var newIntersectedSet = hSet.Intersect(hSetTwo);
foreach (var item in newIntersectedSet.Keys)
{
Console.WriteLine(item);
}
var newUnitedSet = hSet.Union(hSetTwo);
foreach (var item in newUnitedSet.Keys)
{
Console.WriteLine(item);
}
}
/* 5 Implement the data structure "set" in a class HashedSet<T> using your class HashTable<K,T>
* to hold the elements. Implement all standard set operations like Add(T), Find(T), Remove(T),
* Count, Clear(), union and intersect.
* */
static void Main(string[] args)
{
var set = new HashedSet<int>();
Debug.Assert(set.Count == 0);
Debug.Assert(!set.Find(1));
set.Add(1);
Debug.Assert(set.Count == 1);
Debug.Assert(set.Find(1));
set.Add(2);
Debug.Assert(set.Count == 2);
Debug.Assert(set.Find(2));
set.Add(1);
Debug.Assert(set.Count == 2);
Debug.Assert(set.Find(1));
set.Remove(1);
Debug.Assert(set.Count == 1);
Debug.Assert(!set.Find(1));
Debug.Assert(set.Find(2));
var set1 = new HashedSet<int> { 1, 2, 3, 4, 5, 6 }.Intersect(new HashedSet<int> { 2, 4, 6, 8, 10 });
Debug.Assert(set1.SameContents(new[] { 2, 4, 6 }, i => i));
var set2 = new HashedSet<int> { 1, 2, 3, 4, 5, 6 }.Union(new HashedSet<int> { 2, 4, 6, 8, 10 });
Debug.Assert(set2.SameContents(new[] { 1, 2, 3, 4, 5, 6, 8, 10 }, i => i));
}
static void Main(string[] args)
{
var set = new HashedSet<int>(new[] { 1, 2, 3, 4, 5 });
Console.WriteLine("Set: {0}", set);
// Add
set.Add(6);
Console.WriteLine("Add '6' -> {0}", set);
// Add existing
set.Add(6);
Console.WriteLine("Add '6' -> {0}", set);
// Find
Console.WriteLine("Find '0': {0}", set.Find(0));
Console.WriteLine("Find '6': {0}", set.Find(6));
// Remove
set.Remove(3);
Console.WriteLine("Remove '3' -> {0}", set);
// Count
Console.WriteLine("Number of elements: {0}", set.Count);
// Union
var collection = new[] { 3, 7 };
set.Union(collection);
Console.WriteLine("Union with [{0}] -> {1}", string.Join(", ", collection), set);
// Intersection
collection = new[] { 5, 6, 7, 8, 9 };
set.Intersect(collection);
Console.WriteLine("Intersection with [{0}] -> {1}", string.Join(", ", collection), set);
// Clear
set.Clear();
Console.WriteLine("Clear set...");
Console.WriteLine("Number of elements: {0}", set.Count);
}
public void FindShouldReturnFalseIfValueDoesNotExist()
{
var set = new HashedSet <int>();
for (int i = 15; i < 20; i++)
{
set.Add(i);
}
var actual = set.Find(5);
Assert.AreEqual(false, actual);
}
public void FindShouldReturnTrueIfValueExists()
{
var set = new HashedSet <int>();
for (int i = 15; i < 20; i++)
{
set.Add(i);
}
var actual = set.Find(17);
Assert.AreEqual(true, actual);
}
public HashedSet <T> Intersection(HashedSet <T> other)
{
HashedSet <T> result = new HashedSet <T>();
foreach (T item in this)
{
if (other.Find(item))
{
result.Add(item);
}
}
return(result);
}
public void ShouldReturnTrueWhenTryingToFindAvailableElement()
{
var hashedSet = new HashedSet<string>();
for (int i = 0; i < 10; i++)
{
hashedSet.Add("test" + i);
}
for (int i = 0; i < 10; i++)
{
var expectedTrue = hashedSet.Find("test" + i);
Assert.IsTrue(expectedTrue);
}
}
public void ShouldReturnFalseWhenTryingToFindUnavailableElement()
{
var hashedSet = new HashedSet<string>();
for (int i = 0; i < 10; i++)
{
hashedSet.Add("test" + i);
}
for (int i = 0; i < 10; i++)
{
var expectedFalse = hashedSet.Find("false" + i);
Assert.IsFalse(expectedFalse);
}
}
public void ShouldReturnFalseWhenTryingToFindUnavailableElement()
{
var hashedSet = new HashedSet <string>();
for (int i = 0; i < 10; i++)
{
hashedSet.Add("test" + i);
}
for (int i = 0; i < 10; i++)
{
var expectedFalse = hashedSet.Find("false" + i);
Assert.IsFalse(expectedFalse);
}
}
public void ShouldReturnTrueWhenTryingToFindAvailableElement()
{
var hashedSet = new HashedSet <string>();
for (int i = 0; i < 10; i++)
{
hashedSet.Add("test" + i);
}
for (int i = 0; i < 10; i++)
{
var expectedTrue = hashedSet.Find("test" + i);
Assert.IsTrue(expectedTrue);
}
}
public static void Main()
{
HashedSet <string> names = new HashedSet <string>();
names.Add("Pesho");
names.Add("Pesho");
names.Add("Gosho");
names.Add("Doncho");
names.Add("Niki");
Console.WriteLine(names.Count);
names.Remove("Pesho");
names.Remove("Pesho");
Console.WriteLine(names.Count);
Console.WriteLine(names.Find("Pesho"));
names.Clear();
Console.WriteLine(names.Count);
}
public static void Main()
{
HashedSet <string> hashedSet = new HashedSet <string>();
hashedSet.Add("Pesho");
hashedSet.Add("Gosho");
hashedSet.Add("Misho");
string foundString = hashedSet.Find("Pesho");
System.Console.WriteLine(foundString);
hashedSet.Remove("Pesho");
System.Console.WriteLine(hashedSet.Count);
hashedSet.Clear();
System.Console.WriteLine(hashedSet.Count);
}
public HashedSet <T> Union(HashedSet <T> other)
{
HashedSet <T> result = new HashedSet <T>();
foreach (T item in this)
{
result.Add(item);
}
foreach (T item in other)
{
if (!result.Find(item))
{
result.Add(item);
}
}
return(result);
}
static void Main()
{
HashedSet<int> hashSet1 = new HashedSet<int>();
for (int i = 0; i < 10; i++)
{
hashSet1.Add(i);
}
Console.WriteLine("Find element with key = 4");
Console.WriteLine(hashSet1.Find(4));
Console.WriteLine("Find element with key = 2 and write the count of elements");
hashSet1.Remove(2);
Console.WriteLine(hashSet1.Count);
HashedSet<int> hashSet2 = new HashedSet<int>();
hashSet2.Add(5);
hashSet2.Add(9);
hashSet2.Add(33);
Console.WriteLine("Union: ");
hashSet1.UnionWith(hashSet2);
for (int i = 0; i < hashSet1.Container.Count; i++)
{
Console.WriteLine(hashSet1.Container.Keys[i]);
}
Console.WriteLine();
Console.WriteLine("Intersect: ");
hashSet1.IntersectWith(hashSet2);
for (int i = 0; i < hashSet1.Container.Count; i++)
{
Console.WriteLine(hashSet1.Container.Keys[i]);
}
Console.WriteLine();
Console.WriteLine("count after clear");
hashSet2.Clear();
Console.WriteLine(hashSet2.Container.Count);
}
public static void Main()
{
// Input array that contains three duplicate strings.
string[] arrayWithDuplicatedValues = { "cat", "dog", "cat", "leopard", "tiger", "cat" };
// Display the array.
Console.WriteLine("---------- Array with duplicated items ----------");
Console.WriteLine(string.Join(",", arrayWithDuplicatedValues));
// Use HashSet constructor to ensure unique strings.
var hashedSet = new HashedSet<string>();
for (int i = 0; i < arrayWithDuplicatedValues.Length; i++)
{
hashedSet.Add(arrayWithDuplicatedValues[i]);
}
// Display the resulting array.
Console.WriteLine("\n---------- HashedSet without duplicated items ----------");
foreach (var item in hashedSet)
{
Console.WriteLine(item);
}
Console.WriteLine("\n---------- Test Find(cat) ----------");
Console.WriteLine(hashedSet.Find("cat"));
Console.WriteLine("\n---------- Test Remove(cat) and print all elements again ----------");
hashedSet.Remove("cat");
foreach (var item in hashedSet)
{
Console.WriteLine(item);
}
Console.WriteLine("\n---------- Test Count() ----------");
Console.WriteLine(hashedSet.Count());
Console.WriteLine("\n---------- Test Clear() and print count ----------");
hashedSet.Clear();
Console.WriteLine(hashedSet.Count());
}
public void UnionExpectedToWorkProperly()
{
var firstSet = new HashedSet<string>();
for (int i = 1; i <= 10; i++)
{
firstSet.Add("test" + i);
}
var secondSet = new HashedSet<string>();
for (int i = 5; i <= 15; i++)
{
secondSet.Add("test" + i);
}
firstSet.Union(secondSet);
Assert.AreEqual(15, firstSet.Count);
for (int i = 1; i <= 15; i++)
{
Assert.IsTrue(firstSet.Find("test" + i));
}
}
public void TestUnionMethodWithIntegers()
{
HashedSet <int> odds = new HashedSet <int>();
odds.Add(1);
odds.Add(3);
odds.Add(5);
HashedSet <int> evens = new HashedSet <int>();
evens.Add(2);
evens.Add(4);
evens.Add(6);
odds.Union(evens);
Assert.AreEqual(6, odds.Count);
for (int i = 1; i < odds.Count; i++)
{
int result = odds.Find(i);
Assert.AreEqual(i, result);
}
}
public void FindShouldReturnCorrectValueWhenSearchingForNotExistingElement()
{
testSet = new HashedSet <string>();
Assert.IsNull(testSet.Find("Vankata"));
}
static void Main()
{
HashedSet<string> myHashSet = new HashedSet<string>();
// Add method test
Console.WriteLine("Add and foreach tests");
myHashSet.Add("kir4o");
myHashSet.Add("lili");
myHashSet.Add("tanq");
Console.WriteLine();
foreach (string element in myHashSet)
{
Console.WriteLine(element);
}
Console.WriteLine();
// Find method test
Console.WriteLine("Find method test");
Console.WriteLine("Find tanq = {0}", myHashSet.Find("tanq"));
Console.WriteLine("Find sdfasdf = {0}", myHashSet.Find("sdfasdf"));
Console.WriteLine();
// Remove method test
Console.WriteLine("Remove method test");
myHashSet.Remove("lili");
Console.WriteLine("lili removed");
Console.WriteLine();
// Union with test
HashedSet<string> otherHashSet = new HashedSet<string>();
otherHashSet.Add("venera");
otherHashSet.Add("jupiter");
otherHashSet.Add("kir4o");
Console.WriteLine("Union with:");
foreach (string element in otherHashSet)
{
Console.WriteLine(element);
}
myHashSet.UnionWith(otherHashSet);
Console.WriteLine("Resulted hashSet:");
foreach (string element in myHashSet)
{
Console.WriteLine(element);
}
Console.WriteLine();
// Intersect with test
Console.WriteLine("Intersect with :");
foreach (string element in otherHashSet)
{
Console.WriteLine(element);
}
myHashSet.IntersectWith(otherHashSet);
Console.WriteLine();
Console.WriteLine("Resulted hashSet:");
foreach (string element in myHashSet)
{
Console.WriteLine(element);
}
}
