static void Main(string[] args)
{
var hash = new MyHashtable();
hash.Add(1, 2);
Debugger.Break();
}
/**
* 根据json集合生成插入语句
*/
// [WebMethod(Description = "<span style='color:#f74'>根据json集合生成插入语句 ;</span>")]
public string AA_createInsertsql_ByHashTable(string key)
{
String jsonStr = "[{\"name\":\"王五\",\"age\":\"29\",\"start_time\":\"2013-02-03\",\"sex\":\"男\",\"itm\":\"2\"}]";
MyHashtable table = new MyHashtable();
return(SqlUtil.getInsertSql("AABB", table.CreateJsonArr(jsonStr)[0]));
}
public void MyHashtable_Add5_succeeds()
{
var hashtbl = new MyHashtable <string, Person>(10);
var p = new Person()
{
Name = "Louise", City = "Dublin"
};
var p2 = new Person()
{
Name = "Mary", City = "Dublin"
};
var p3 = new Person()
{
Name = "John", City = "Dublin"
};
var p4 = new Person()
{
Name = "Louise", City = "Cork"
};
var p5 = new Person()
{
Name = "Gary", City = "Galway"
};
hashtbl.Add(p.Name, p);
hashtbl.Add(p2.Name, p2);
hashtbl.Add(p3.Name, p3);
hashtbl.Add(p4.Name, p4);
hashtbl.Add(p5.Name, p5);
Assert.AreEqual(hashtbl.Count(), 5);
}
// return the string representation of the whole
// tree rooted at this particular node
//
public string TreeToString(int sig, MyHashtable nameMap)
{
MyHashtable inqueue = new MyHashtable();
Queue todo = new Queue();
todo.Enqueue(sig);
StringBuilder result = new StringBuilder();
while (todo.Count != 0)
{
int nd = (int)todo.Dequeue();
int l = LeftChild(nd);
int r = RightChild(nd);
NodeType tp = NdType(nd);
if (tp == NodeType.AND || tp == NodeType.XOR)
{
if (!inqueue.Contains(l))
{
todo.Enqueue(l);
inqueue.Add(l, null);
}
if (!inqueue.Contains(r))
{
todo.Enqueue(r);
inqueue.Add(r, null);
}
}
result.Append(ToString(nd, nameMap));
}
return(result.ToString());
}
public void MyHashtable(int[] items, int capacity)
{
var hashtable = new MyHashtable <int>(capacity);
for (int i = 0; i < items.Length; i++)
{
hashtable.Add($"item {items[i]}", items[i]);
}
}
//</Snippet2>
static void Main()
{
MyHashtable myHashTable = new MyHashtable();
myHashTable.Add("one", 1);
myHashTable.Add("two", 2);
Console.WriteLine(myHashTable.ToString());
Console.WriteLine("In Main.");
}
// this demonstrate the structure interface
static void test_structure_solver(string[] args)
{
SATSolver solver = new SATSolver();
int a = solver.CreatePI();
int b = solver.CreatePI();
int c = solver.CreatePI();
//int d = solver.CreatePI();
int xor_a_b = solver.Xor(a, b);
int not_a = solver.Not(a);
int not_b = solver.Not(b);
int and_a_not_b = solver.And(a, not_b);
int and_b_not_a = solver.And(b, not_a);
int xor_a_b_p = solver.Or(and_a_not_b, and_b_not_a);
int miter = solver.Xor(xor_a_b, xor_a_b_p);
SATStatus r = solver.TestSAT(miter);
WriteLine(String.Format("Test Right {0}", r.ToString()));
int and_a_b = solver.And(a, b);
int xor_a_b_wrong = solver.Or(and_a_not_b, and_a_b);
int miter1 = solver.Xor(xor_a_b, xor_a_b_wrong);
r = solver.TestSAT(miter1);
WriteLine(String.Format("Test Wrong {0}", r.ToString()));
int and_a_b_c = solver.And(solver.And(a, b), c);
int flag = solver.AllocFlag();
solver.MarkTransitiveFanins(and_a_b_c, flag);
for (int i = 0, sz = solver.NumPI(); i < sz; ++i)
{
int node_id = solver.NthPI(i);
bool flagset = solver.IsNodeFlagSet(node_id, flag);
if (flagset)
{
WriteLine(String.Format("PI {0} is in the transitive fanin", i));
}
else
{
WriteLine(String.Format("PI {0} is NOT in the transitive fanin", i));
}
}
solver.ClearFlag(flag);
MyHashtable nameMap = new MyHashtable();
nameMap.Add(0, "PrimaryIn 0");
WriteLine(solver.TreeToString(miter1, nameMap));
WriteLine(solver.TreeToString(xor_a_b, nameMap));
WriteLine("Press Return...");
System.Console.ReadLine();
}
/**
* 根据json对象生成插入语句
*/
// [WebMethod(Description = "<span style='color:#f74'>根据json对象生成插入语句 ;</span>")]
public string AA_createInsertsql_ByDictionary(string key)
{
string jsonStr = "{\"name\":\"王五\",\"age\":\"29\",\"time\":\"2013-02-03\",\"sex\":\"男\"}";
Dictionary <string, object> dictionary = MyHashtable.JsonToDictionary(jsonStr);
if (dictionary == null)
{
return("{\"result\":\"1\",\"message:\"传入参数错误\"}");
}
return(SqlUtil.getInsertSql("AABB", dictionary));
}
public void TestForCollisonOfHashKeys1()
{
MyHashtable test3 = new MyHashtable();
test3.Add("Cat", 1);
test3.Add("Cat", 2);
test3.Add("Doe", 3);
test3.Add("Doe", 4);
Assert.Equal(163, test3.GetHash("Cat"));
Assert.Equal(163, test3.GetHash("Doe"));
}
public void TestGetValue()
{
var expected = "bar2";
var table = new MyHashtable <string, string>();
table["foo"] = "bar";
table["foo"] = "bar2";
var actual = table.GetValue("foo");
Assert.AreEqual(expected, actual);
}
public void TestForContainMethodOfHash()
{
MyHashtable test2 = new MyHashtable();
test2.Add("test", 1);
test2.Add("test", 2);
test2.Add("test2", 3);
test2.Add("test2", 4);
Assert.True(test2.Contains("test"));
Assert.True(test2.Contains("test2"));
Assert.False(test2.Contains("test1"));
}
public void TestGetHashKey()
{
var inputs = new string[10] {
"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"
};
var table = new MyHashtable <string, string>();
for (var i = 0; i < inputs.Length; i++)
{
Console.WriteLine(string.Format("{0}={1}", inputs[i], table.GetHashKey(inputs[i])));
}
Assert.IsTrue(true);
}
public void MyHashtable_Add1_Find1_succeeds()
{
var hashtbl = new MyHashtable <string, Person>(10);
var p = new Person()
{
Name = "Louise", City = "Dublin"
};
hashtbl.Add(p.Name, p);
var result = hashtbl.Find(p.Name);
Assert.AreEqual(result.Name, p.Name);
Assert.AreEqual(result.City, p.City);
}
public void TestForAddingValuesToHash()
{
MyHashtable test1 = new MyHashtable();
test1.Add("test", 1);
test1.Add("test", 2);
test1.Add("test", 3);
test1.Add("test", 4);
List <int> result = test1.Find("test");
List <int> expect = new List <int> {
1, 2, 3, 4
};
Assert.Equal(expect, result);
}
void prepare_original_nodes(int a_flag, int b_flag, MyHashtable uid2lits, MyHashtable uid2sig, MyHashtable involved)
{
MyHashtable uid2vid = new MyHashtable();
for (int i = 1; i < solver.variables.size(); ++i)
{
Variable var = solver.variable(i);
if (var != null && (var.flag(a_flag) || var.flag(b_flag)))
{
uid2vid[var.uid] = i;
}
}
foreach (object obj in involved)
{
int uid = (int)((DictionaryEntry)obj).Key;
if (!is_node(uid) || !uid2vid.Contains(node_uid(uid)))
{
continue;
}
int nid = node_uid(uid);
int cls_id = cls_idx(uid);
int vid = (int)uid2vid[nid];
int [] lits = get_cls(vid, cls_id);
int sig;
sharp_assert(solver.variable(vid).flag(a_flag) || solver.variable(vid).flag(b_flag));
if (solver.variable(vid).flag(b_flag))
{
sig = solver.one();
}
else
{
sig = solver.zero();
foreach (int lit in lits)
{
sharp_assert(solver.node(lit).flag(a_flag));
if (solver.node(lit).flag(b_flag))
{
sig = solver.bor(sig, lit);
}
}
}
uid2lits[uid] = lits;
uid2sig[uid] = sig;
}
}
public void MyHashtable_Add2_succeeds()
{
var hashtbl = new MyHashtable <string, Person>(10);
var p = new Person()
{
Name = "Louise", City = "Dublin"
};
var p2 = new Person()
{
Name = "Mary", City = "Dublin"
};
hashtbl.Add(p.Name, p);
hashtbl.Add(p2.Name, p2);
Assert.AreEqual(hashtbl.Count(), 2);
}
public void TestForCollisionOfHashKeys2()
{
MyHashtable test3 = new MyHashtable();
test3.Add("Cat", 1);
test3.Add("Cat", 2);
test3.Add("Doe", 3);
test3.Add("Doe", 4);
List <int> catValueList = test3.Find("Cat");
List <int> doeValueList = test3.Find("Doe");
List <int> expected = new List <int> {
1, 2, 3, 4
};
Assert.Equal(expected, catValueList);
Assert.Equal(expected, doeValueList);
}
public void TestEqualityComparerBasic()
{
MyHashtable hsh1;
IEqualityComparer ikc;
//[] Default ctor
hsh1 = new MyHashtable();
Assert.Null(hsh1.EqualityComparer);
//[] ctor(IKeyComparer)
System.Globalization.CultureInfo prevCulture = System.Globalization.CultureInfo.DefaultThreadCurrentCulture;
System.Globalization.CultureInfo.DefaultThreadCurrentCulture = new System.Globalization.CultureInfo("de-DE");
ikc = StringComparer.CurrentCulture;
hsh1 = new MyHashtable(0, 1.0f, ikc);
Assert.Equal(ikc, hsh1.EqualityComparer);
System.Globalization.CultureInfo.DefaultThreadCurrentCulture = prevCulture;
}
public void TestEqualityComparerBasic()
{
MyHashtable hsh1;
IEqualityComparer ikc;
//[] Default ctor
hsh1 = new MyHashtable();
Assert.Null(hsh1.EqualityComparer);
//[] ctor(IKeyComparer)
System.Globalization.CultureInfo prevCulture = System.Globalization.CultureInfo.DefaultThreadCurrentCulture;
System.Globalization.CultureInfo.DefaultThreadCurrentCulture = new System.Globalization.CultureInfo("de-DE");
ikc = StringComparer.CurrentCulture;
hsh1 = new MyHashtable(0, 1.0f, ikc);
Assert.Equal(ikc, hsh1.EqualityComparer);
System.Globalization.CultureInfo.DefaultThreadCurrentCulture = prevCulture;
}
public MyHashtable generate_unsat_core()
{
if (empty == null)
{
fatal("Not UNSAT, Cannot Generate Core");
}
MyHashtable hash = new MyHashtable();
foreach (int uid in empty.reasons)
{
hash.Add(uid, null);
}
long oldpos = storage.Position;
storage.Seek(0, SeekOrigin.End);
while (storage.Position > 0)
{
ResolveNode nd = ResolveNode.DeSerializeBackward(storage);
sharp_assert(!is_node(nd.uid));
if (hash.Contains(nd.uid))
{
foreach (int id in nd.reasons)
{
int uid = id;
if (is_node(id))
{
uid = node_uid(id);
}
if (!hash.Contains(uid))
{
hash.Add(uid, null);
}
}
hash.Remove(nd.uid);
}
}
storage.Seek(oldpos, SeekOrigin.Begin);
return(hash);
}
MyHashtable find_all_involved()
{
if (empty == null)
{
fatal("Not UNSAT, Cannot Generate Core");
}
MyHashtable hash = new MyHashtable();
foreach (int uid in empty.reasons)
{
hash.Add(uid, 1);
}
long oldpos = storage.Position;
storage.Seek(0, SeekOrigin.End);
while (storage.Position > 0)
{
ResolveNode nd = ResolveNode.DeSerializeBackward(storage);
if (hash.Contains(nd.uid))
{
foreach (int uid in nd.reasons)
{
if (!hash.Contains(uid))
{
hash[uid] = 1;
}
else
{
hash[uid] = (int)hash[uid] + 1;
}
}
}
}
storage.Seek(oldpos, SeekOrigin.Begin);
return(hash);
}
// return the string representation of this particular node
//
public string ToString(int sig, MyHashtable nameMap)
{
string result = sig.ToString() + "\t= ";
if (IsNegated(sig))
{
int t = NonNegated(sig);
result += "Not(" +
t.ToString() + ")\n" +
ToString(t, nameMap);
}
else
{
NodeType tp = NdType(sig);
switch (tp)
{
case NodeType.UNKNOWN:
case NodeType.FREE:
case NodeType.CONSTANT:
case NodeType.VARIABLE:
result += "ERROR";
break;
case NodeType.AND:
case NodeType.XOR:
int l = LeftChild(sig);
int r = RightChild(sig);
string lstr, rstr;
lstr = l.ToString();
rstr = r.ToString();
if (tp == NodeType.AND)
{
result += "AND (" + lstr + ", " + rstr + ")";
}
else
{
result += "XOR (" + lstr + ", " + rstr + ")";
}
break;
case NodeType.PI:
int sig_pi = NodeToPI(sig);
if (sig_pi != -1)
{
if (nameMap.Contains(sig_pi))
{
result += nameMap[sig_pi];
}
else
{
result += "PI" + sig_pi.ToString();
}
}
else
{
result += "ERROR";
}
break;
}
result += "\n";
}
return(result);
}
void prepare_original_clauses(int a_gid, int b_gid, MyHashtable uid2lits, MyHashtable uid2sig, MyHashtable involved, int[] var_flag)
{
for (int i = 0; i < var_flag.Length; ++i)
{
var_flag[i] = 0;
}
for (int i = 0; i < solver.clauses.size(); ++i)
{
Clause cl = clause(i);
if (cl == null || !involved.Contains(cl.uid))
{
continue;
}
if (cl.type == ClType.ORIGINAL)
{
if (cl.gid(a_gid))
{
sharp_assert(!cl.gid(b_gid));
foreach (int lit in cl.literals)
{
var_flag [VID(lit)] |= A_LOCAL;
}
}
else
{
sharp_assert(cl.gid(b_gid));
foreach (int lit in cl.literals)
{
var_flag [VID(lit)] |= B_LOCAL;
}
}
}
uid2lits[cl.uid] = cl.literals;
}
for (int i = 0; i < solver.original_clauses.size(); ++i)
{
Clause cl = clause(solver.original_clauses[i]);
sharp_assert(cl != null);
sharp_assert(cl.type == ClType.ORIGINAL);
if (!involved.Contains(cl.uid))
{
continue;
}
int signal;
if (cl.gid(a_gid))
{
sharp_assert(!cl.gid(b_gid));
signal = solver.zero();
foreach (int lit in cl.literals)
{
if (var_flag[VID(lit)] == GLOBAL)
{
signal = solver.bor(signal, lit);
}
}
}
else
{
sharp_assert(cl.gid(b_gid));
signal = solver.one();
}
uid2sig[cl.uid] = signal;
}
}
public int gen_interpolant_from_clauses(int a_gid, int b_gid)
{
//solver.dump_file = new StreamWriter ("dump_file");
//solver.dump_file.WriteLine ("{0} = INIT_VARS", solver.num_variables());
sharp_assert(solver.is_pure_clause_based());
solver.convert_vars_to_pi();
MyHashtable uid2lits = new MyHashtable();
MyHashtable uid2sig = new MyHashtable();
MyHashtable involved = find_all_involved();
int [] var_flag = new int [solver.variables.size()];
prepare_original_clauses(a_gid, b_gid, uid2lits, uid2sig, involved, var_flag);
long oldpos = storage.Position;
storage.Seek(0, SeekOrigin.Begin);
while (storage.Position < storage.Length)
{
ResolveNode nd = ResolveNode.DeSerializeForward(storage);
if (!involved.Contains(nd.uid))
{
continue;
}
int uid = nd.reasons[0];
sharp_assert(involved.Contains(uid));
sharp_assert(uid2lits.Contains(uid));
sharp_assert(uid2sig.Contains(uid));
int [] lits = (int[])uid2lits[uid];
int signal = (int)uid2sig[uid];
int count = (int)involved[uid] - 1;
if (count == 0)
{
uid2lits.Remove(uid);
uid2sig.Remove(uid);
involved.Remove(uid);
}
else
{
involved[uid] = count;
}
for (int i = 1; i < nd.reasons.Length; ++i)
{
uid = nd.reasons[i];
sharp_assert(uid < (1 << 29));
sharp_assert(involved.Contains(uid));
sharp_assert(uid2lits.Contains(uid));
sharp_assert(uid2sig.Contains(uid));
int [] lits1 = (int[])uid2lits[uid];
int signal1 = (int)uid2sig[uid];
count = (int)involved[uid] - 1;
if (count == 0)
{
uid2lits.Remove(uid);
uid2sig.Remove(uid);
involved.Remove(uid);
}
else
{
involved[uid] = count;
}
int pivot = find_pivot(lits, lits1);
lits = resolve(lits, lits1);
if (var_flag[pivot] == A_LOCAL)
{
signal = solver.bor(signal, signal1);
}
else
{
signal = solver.band(signal, signal1);
}
}
if (!uid2lits.Contains(nd.uid))
{
uid2lits[nd.uid] = lits;
}
sharp_assert(!uid2sig.Contains(nd.uid));
uid2sig[nd.uid] = signal;
}
storage.Seek(oldpos, SeekOrigin.Begin);
{
int uid = empty.reasons[0];
sharp_assert(involved.Contains(uid));
sharp_assert(uid2lits.Contains(uid));
sharp_assert(uid2sig.Contains(uid));
int [] lits = (int[])uid2lits[uid];
int signal = (int)uid2sig[uid];
int count = (int)involved[uid] - 1;
if (count == 0)
{
uid2lits.Remove(uid);
uid2sig.Remove(uid);
involved.Remove(uid);
}
else
{
involved[uid] = count;
}
for (int i = 1; i < empty.reasons.Length; ++i)
{
uid = empty.reasons[i];
sharp_assert(involved.Contains(uid));
sharp_assert(uid2lits.Contains(uid));
sharp_assert(uid2sig.Contains(uid));
int [] lits1 = (int[])uid2lits[uid];
int signal1 = (int)uid2sig[uid];
count = (int)involved[uid] - 1;
if (count == 0)
{
uid2lits.Remove(uid);
uid2sig.Remove(uid);
involved.Remove(uid);
}
else
{
involved[uid] = count;
}
int pivot = find_pivot(lits, lits1);
lits = resolve(lits, lits1);
if (var_flag[pivot] == A_LOCAL)
{
signal = solver.bor(signal, signal1);
}
else
{
signal = solver.band(signal, signal1);
}
}
sharp_assert(lits.Length == 0);
sharp_assert(involved.Count == 0);
sharp_assert(uid2lits.Count == 0);
sharp_assert(uid2sig.Count == 0);
//solver.dump_file.WriteLine ("{0} = CONSTRAINT", signal);
//solver.dump_file.Close();
return(signal);
}
}
// gretay -- change start
public int gen_interpolant_from_signals_ex(int a_node, int a_cls_id, int b_node, int b_cls_id, int[] c_cls_id, int[] c_interp)
{
//solver.dump_file = new StreamWriter ("dump_file");
//solver.dump_file.WriteLine ("{0} = INIT_VARS", solver.num_variables());
int a_flag = solver.alloc_flag();
int b_flag = solver.alloc_flag();
solver.mark_transitive_fanins(a_node, a_flag);
solver.mark_transitive_fanins(b_node, b_flag);
assert(c_cls_id.Length == c_interp.Length);
MyHashtable uid2lits = new MyHashtable();
MyHashtable uid2sig = new MyHashtable();
MyHashtable involved = find_all_involved();
prepare_original_nodes(a_flag, b_flag, uid2lits, uid2sig, involved);
// init A info
int a_uid = solver.clause(a_cls_id).uid;
if (involved.Contains(a_uid))
{
uid2lits[a_uid] = solver.clause(a_cls_id).literals;
int s = solver.zero();
foreach (int lit in solver.clause(a_cls_id).literals)
{
sharp_assert(solver.node(lit).flag(a_flag));
if (solver.node(lit).flag(b_flag))
{
s = solver.bor(s, lit);
}
}
uid2sig[a_uid] = s;
//uid2sig[a_uid] = a_node;
}
// init B info
int b_uid = solver.clause(b_cls_id).uid;
if (involved.Contains(b_uid))
{
uid2lits[b_uid] = solver.clause(b_cls_id).literals;
uid2sig[b_uid] = solver.one();
}
// init C info
for (int i = 0; i < c_cls_id.Length; i++)
{
Clause cl = solver.clause(c_cls_id[i]);
if (involved.Contains(cl.uid))
{
uid2lits[cl.uid] = cl.literals;
uid2sig[cl.uid] = c_interp[i];
}
}
long oldpos = storage.Position;
storage.Seek(0, SeekOrigin.Begin);
while (storage.Position < storage.Length)
{
ResolveNode nd = ResolveNode.DeSerializeForward(storage);
if (!involved.Contains(nd.uid))
{
continue;
}
int [] lits;
int signal;
int uid = nd.reasons[0];
sharp_assert(involved.Contains(uid));
sharp_assert(uid2sig.Contains(uid));
lits = (int[])uid2lits[uid];
signal = (int)uid2sig[uid];
int count = (int)involved[uid] - 1;
if (count == 0)
{
uid2lits.Remove(uid);
uid2sig.Remove(uid);
involved.Remove(uid);
}
else
{
involved[uid] = count;
}
for (int i = 1; i < nd.reasons.Length; ++i)
{
uid = nd.reasons[i];
sharp_assert(uid < (1 << 29));
sharp_assert(involved.Contains(uid));
sharp_assert(uid2lits.Contains(uid));
sharp_assert(uid2sig.Contains(uid));
int [] lits1 = (int[])uid2lits[uid];
int signal1 = (int)uid2sig[uid];
count = (int)involved[uid] - 1;
if (count == 0)
{
uid2lits.Remove(uid);
uid2sig.Remove(uid);
involved.Remove(uid);
}
else
{
involved[uid] = count;
}
int pivot = find_pivot(lits, lits1);
lits = resolve(lits, lits1);
if ((solver.variable(pivot).flag(a_flag)) &&
(!solver.variable(pivot).flag(b_flag)))
{
signal = solver.bor(signal, signal1);
}
else
{
signal = solver.band(signal, signal1);
}
}
if (!uid2lits.Contains(nd.uid))
{
uid2lits[nd.uid] = lits;
}
sharp_assert(!uid2sig.Contains(nd.uid));
uid2sig[nd.uid] = signal;
}
storage.Seek(oldpos, SeekOrigin.Begin);
{
int uid = empty.reasons[0];
sharp_assert(involved.Contains(uid));
sharp_assert(uid2lits.Contains(uid));
sharp_assert(uid2sig.Contains(uid));
int [] lits = (int[])uid2lits[uid];
int signal = (int)uid2sig[uid];
int count = (int)involved[uid] - 1;
if (count == 0)
{
uid2lits.Remove(uid);
uid2sig.Remove(uid);
involved.Remove(uid);
}
else
{
involved[uid] = count;
}
for (int i = 1; i < empty.reasons.Length; ++i)
{
uid = empty.reasons[i];
sharp_assert(involved.Contains(uid));
sharp_assert(uid2lits.Contains(uid));
sharp_assert(uid2sig.Contains(uid));
int [] lits1 = (int[])uid2lits[uid];
int signal1 = (int)uid2sig[uid];
count = (int)involved[uid] - 1;
if (count == 0)
{
uid2lits.Remove(uid);
uid2sig.Remove(uid);
involved.Remove(uid);
}
else
{
involved[uid] = count;
}
int pivot = find_pivot(lits, lits1);
lits = resolve(lits, lits1);
if ((solver.variable(pivot).flag(a_flag)) &&
(!solver.variable(pivot).flag(b_flag)))
{
signal = solver.bor(signal, signal1);
}
else
{
signal = solver.band(signal, signal1);
}
}
sharp_assert(lits.Length == 0);
sharp_assert(involved.Count == 0);
sharp_assert(uid2lits.Count == 0);
sharp_assert(uid2sig.Count == 0);
//solver.dump_file.WriteLine ("{0} = CONSTRAINT", signal);
//solver.dump_file.Close();
solver.free_flag(a_flag);
solver.free_flag(b_flag);
//solver.free_flag(c_flag);
return(signal);
}
}
static void Main(string[] args)
{
MyHashtable ht = new MyHashtable();
ht.Add("one", 5);
Console.WriteLine("Added => Key: one, value: 5 ");
ht.Add("one", 15);
Console.WriteLine("Added => Key: one, value: 15 ");
ht.Add("two", 10);
Console.WriteLine("Added => Key: two, value: 10 ");
Console.WriteLine();
List <int> valueList = ht.Find("one");
Console.WriteLine("Key of 'one' contains following values: ");
foreach (int val in valueList)
{
Console.WriteLine(val);
}
Console.WriteLine();
bool contain = ht.Contains("one");
bool contains = ht.Contains("One");
Console.WriteLine();
Console.WriteLine("Hastable contains a key of 'one': " + contain);
Console.WriteLine("Hastable contains a key of 'One': " + contains);
Console.WriteLine();
Console.WriteLine();
Console.WriteLine();
Console.WriteLine();
Console.WriteLine("Collision test of 'Cat' and 'Doe' : ");
Console.WriteLine();
MyHashtable colsn = new MyHashtable();
colsn.Add("Cat", 50);
Console.WriteLine("Added => Key: Cat, value: 50 ");
colsn.Add("Doe", 100);
Console.WriteLine("Added => Key: Doe, value: 100 ");
List <int> catList = colsn.Find("Cat");
List <int> doeList = colsn.Find("Doe");
Console.WriteLine("Key: Cat holds following value(s): ");
foreach (int i in catList)
{
Console.WriteLine(i);
}
Console.WriteLine();
Console.WriteLine("Key: Doe holds following value(s);");
foreach (int i in doeList)
{
Console.WriteLine(i);
}
Console.WriteLine();
bool containCat = colsn.Contains("Cat");
bool containDoe = colsn.Contains("Doe");
Console.WriteLine();
Console.WriteLine("Hastable contains a key of 'Cat': " + containCat);
Console.WriteLine("Hastable contains a key of 'Doe': " + containDoe);
}
