public bool NegTest1()
{
bool retVal = true;
Array array;
IComparer myc;
TestLibrary.TestFramework.BeginScenario("NegTest1: Array.Sort(Array, IComparer) null array");
try
{
array = null;
myc = new MyComparer();
Array.Sort(array, myc);
TestLibrary.TestFramework.LogError("004", "Exception expected.");
retVal = false;
}
catch (ArgumentNullException)
{
// expected
}
catch (Exception e)
{
TestLibrary.TestFramework.LogError("005", "Unexpected exception: " + e);
retVal = false;
}
return(retVal);
}
protected override void OnDataSourceChanged(EventArgs e)
{
base.OnDataSourceChanged(e);
MyComparer YourComparer = null;
this.Sort(YourComparer);
}
public void Setup()
{
var random = new Random();
data = new MyClass[N];
for (int i = 0; i < N; ++i)
{
data[i] = MyClass.Generate(random, N * 10, 25);
}
List <SortBy> sortBys = new List <SortBy>
{
new SortBy {
PropName = "IntProp2", Ascending = true
},
new SortBy {
PropName = "StrProp1", Ascending = false
}
};
Func <MyClass, MyClass, int> generatedSortFunc = SortFuncCompiler.MakeSortFunc <MyClass>(sortBys);
//Func<MyClass, MyClass, int> generatedSortFunc = SortFuncCompilerFEC.MakeSortFunc<MyClass>(sortBys);
GeneratedComparer = new MyComparer <MyClass>(generatedSortFunc);
HandcodedComparer = new MyComparer <MyClass>(SortOneIntOneStrHC);
}
public void UsesProvidedComparerOfT()
{
MyComparer <int> comparer = new MyComparer <int>();
Assert.That(rangeConstraint.Using(comparer).Matches(19));
Assert.That(comparer.Called, "Comparer was not called");
}
public void UsesProvidedComparerOfT()
{
MyComparer <int> comparer = new MyComparer <int>();
Assert.That(2 + 2, Is.EqualTo(4).Using(comparer));
Assert.That(comparer.Called, "Comparer was not called");
}
public bool NegTest1()
{
bool retVal = true;
Array keys;
Array items;
IComparer myc;
TestLibrary.TestFramework.BeginScenario("NegTest1: Array.Sort(Array, Array, int, int, IComparer) keys is null");
try
{
keys = null;
items = null;
myc = new MyComparer();
Array.Sort(keys, items, 0, 0, myc);
TestLibrary.TestFramework.LogError("005", "Exception expected.");
retVal = false;
}
catch (ArgumentNullException)
{
// expected
}
catch (Exception e)
{
TestLibrary.TestFramework.LogError("006", "Unexpected exception: " + e);
retVal = false;
}
return(retVal);
}
public bool NegTest3()
{
bool retVal = true;
Array keys;
Array items;
IComparer myc;
int length;
TestLibrary.TestFramework.BeginScenario("NegTest3: Array.Sort(Array, Array, int, int, IComparer) length too long");
try
{
// creat the array
length = (TestLibrary.Generator.GetInt32(-55) % (c_MAX_SIZE - c_MIN_SIZE)) + c_MIN_SIZE;
keys = Array.CreateInstance(typeof(byte), length);
items = Array.CreateInstance(typeof(byte), length);
myc = new MyComparer();
Array.Sort(keys, items, length + 10, length, myc);
TestLibrary.TestFramework.LogError("009", "Exception expected.");
retVal = false;
}
catch (ArgumentException)
{
// expected
}
catch (Exception e)
{
TestLibrary.TestFramework.LogError("010", "Unexpected exception: " + e);
retVal = false;
}
return(retVal);
}
public ListViewItemComparer(int column, SortOrder order)
{
col = column;
this.order = order;
//CaseInsensitiveComparer ObjectCompare = new CaseInsensitiveComparer();
ObjectCompare = new MyComparer();
}
public static void Main()
{
List <string> letters = new List <string>();
letters.Add("this");
letters.Add("is");
letters.Add("a");
letters.Add("test");
Display(letters);
MyComparer dc = new MyComparer();
letters.Sort(dc);
Display(letters);
SearchAndInsert(letters, "E", dc);
Display(letters);
SearchAndInsert(letters, "A", dc);
Display(letters);
SearchAndInsert(letters, "T", dc);
Display(letters);
SearchAndInsert(letters, null, dc);
Display(letters);
}
public void ShouldThrowExceptionIfFromIsLessThanTo()
{
var comparer = new MyComparer <int>();
rangeConstraint = new RangeConstraint <int>(42, 5);
rangeConstraint.Using(comparer).Matches(19);
}
public void UsesProvidedComparerOfT()
{
MyComparer <int> comparer = new MyComparer <int>();
ComparisonConstraint.Using(comparer).ApplyTo(0);
Assert.That(comparer.Called, "Comparer was not called");
}
public int[] RelativeSortArray(int[] arr1, int[] arr2)
{
var comparer = new MyComparer(arr2);
Array.Sort(arr1, comparer);
return(arr1);
}
/// <summary>
/// This method is inherited from the IComparer interface. It compares the two objects passed using a case insensitive comparison.
/// </summary>
/// <param name="x">First object to be compared</param>
/// <param name="y">Second object to be compared</param>
/// <returns>The result of the comparison. "0" if equal, negative if 'x' is less than 'y' and positive if 'x' is greater than 'y'</returns>
public int Compare(object x, object y)
{
int compareResult;
ListViewItem listviewX, listviewY;
// Cast the objects to be compared to ListViewItem objects
listviewX = (ListViewItem)x;
listviewY = (ListViewItem)y;
// Compare the two items
//compareResult = ObjectCompare.Compare(listviewX.SubItems[ColumnToSort].Text, listviewY.SubItems[ColumnToSort].Text);
MyComparer mc = new MyComparer();
compareResult = mc.Compare(listviewX.SubItems[ColumnToSort].Text, listviewY.SubItems[ColumnToSort].Text);
// Calculate correct return value based on object comparison
if (OrderOfSort == SortOrder.Ascending)
{
// Ascending sort is selected, return normal result of compare operation
return(compareResult);
}
else if (OrderOfSort == SortOrder.Descending)
{
// Descending sort is selected, return negative result of compare operation
return(-compareResult);
}
else
{
// Return '0' to indicate they are equal
return(0);
}
}
public void UsesProvidedIComparer()
{
MyComparer comparer = new MyComparer();
comparisonConstraint.Using(comparer).Matches(0);
Assert.That(comparer.Called, "Comparer was not called");
}
public void Setup()
{
var random = new Random();
data = new MyClass[N];
for (int i = 0; i < N; ++i)
{
data[i] = MyClass.Generate(random, N * 10, 25);
}
// Compile order methods
List <SortBy> sortBys = new List <SortBy>
{
new SortBy {
PropName = "IntProp2", Ascending = true
},
new SortBy {
PropName = "StrProp1", Ascending = false
}
};
Func <MyClass, MyClass, int> sortMyClass = SortFuncCompiler.MakeSortFunc <MyClass>(sortBys);
linqComparer = new MyComparer <MyClass>(sortMyClass);
nativeComparer = new MyComparer <MyClass>(Sorters.SortOneIntOneStrHC);
}
public void UsesProvidedIComparer()
{
MyComparer comparer = new MyComparer();
Assert.That(new string[] { "Hello", "World" },
new CollectionContainsConstraint("World").Using(comparer));
Assert.That(comparer.Called, "Comparer was not called");
}
public void UsesProvidedComparerOfT()
{
ICollection al = new SimpleObjectCollection(1, 2);
MyComparer <int> comparer = new MyComparer <int>();
Assert.That(al, Is.Ordered.Using(comparer));
Assert.That(comparer.Called, "Comparer was not called");
}
private static void SearchAndInsert(List <string> list, string insert, MyComparer dc)
{
int index = list.BinarySearch(insert, dc);
if (index < 0)
{
list.Insert(~index, insert);
}
}
public bool PosTest1()
{
bool retVal = true;
Array keys;
Array items;
int length;
IComparer myc;
byte element;
TestLibrary.TestFramework.BeginScenario("PosTest1: Array.Sort(Array, Array, int, int, IComparer) ");
try
{
myc = new MyComparer();
for (int j=0; j<c_NUM_LOOPS; j++)
{
// creat the array
length = (TestLibrary.Generator.GetInt32(-55) % (c_MAX_SIZE-c_MIN_SIZE)) + c_MIN_SIZE;
keys = Array.CreateInstance(typeof(byte), length);
items = Array.CreateInstance(typeof(byte), length);
// fill the array
for (int i=0; i<keys.Length; i++)
{
keys.SetValue((object)TestLibrary.Generator.GetByte(-55), i);
items.SetValue(keys.GetValue(i), i);
}
Array.Sort(keys, items, 0, length, myc);
// ensure that all the elements are sorted
element = (byte)keys.GetValue(0);
for(int i=0; i<keys.Length; i++)
{
if (element > (byte)keys.GetValue(i))
{
TestLibrary.TestFramework.LogError("000", "Unexpected key: Element (" + element + ") is greater than (" + (byte)keys.GetValue(i) + ")");
retVal = false;
}
if ((byte)items.GetValue(i) != (byte)keys.GetValue(i))
{
TestLibrary.TestFramework.LogError("001", "Unexpected item: Expected(" + (byte)keys.GetValue(i) + ") Actual(" + (byte)items.GetValue(i) + ")");
retVal = false;
}
}
}
}
catch (Exception e)
{
TestLibrary.TestFramework.LogError("002", "Unexpected exception: " + e);
retVal = false;
}
return retVal;
}
public bool PosTest1()
{
bool retVal = true;
Array keys;
Array items;
int length;
IComparer myc;
byte element;
TestLibrary.TestFramework.BeginScenario("PosTest1: Array.Sort(Array, Array, int, int, IComparer) ");
try
{
myc = new MyComparer();
for (int j = 0; j < c_NUM_LOOPS; j++)
{
// creat the array
length = (TestLibrary.Generator.GetInt32(-55) % (c_MAX_SIZE - c_MIN_SIZE)) + c_MIN_SIZE;
keys = Array.CreateInstance(typeof(byte), length);
items = Array.CreateInstance(typeof(byte), length);
// fill the array
for (int i = 0; i < keys.Length; i++)
{
keys.SetValue((object)TestLibrary.Generator.GetByte(-55), i);
items.SetValue(keys.GetValue(i), i);
}
Array.Sort(keys, items, 0, length, myc);
// ensure that all the elements are sorted
element = (byte)keys.GetValue(0);
for (int i = 0; i < keys.Length; i++)
{
if (element > (byte)keys.GetValue(i))
{
TestLibrary.TestFramework.LogError("000", "Unexpected key: Element (" + element + ") is greater than (" + (byte)keys.GetValue(i) + ")");
retVal = false;
}
if ((byte)items.GetValue(i) != (byte)keys.GetValue(i))
{
TestLibrary.TestFramework.LogError("001", "Unexpected item: Expected(" + (byte)keys.GetValue(i) + ") Actual(" + (byte)items.GetValue(i) + ")");
retVal = false;
}
}
}
}
catch (Exception e)
{
TestLibrary.TestFramework.LogError("002", "Unexpected exception: " + e);
retVal = false;
}
return(retVal);
}
static void Main()
{
MyComparer comparer = new MyComparer();
List <int> list = new List <int> {
1, 2, 3
};
list.Sort(comparer);
return;
}
public void UsesProvidedComparerOfT()
{
ArrayList al = new ArrayList();
al.Add(1);
al.Add(2);
MyComparer<int> comparer = new MyComparer<int>();
Assert.That(al, Is.Ordered.Using(comparer));
Assert.That(comparer.Called, "Comparer was not called");
}
public void ConstructWithCustomComparer()
{
var myComparer = new MyComparer();
BTreeDictionary <string, string> dictionary = null;
Assert.DoesNotThrow(() => dictionary = new BTreeDictionary <string, string>(myComparer));
Assert.That(dictionary.Underlying, Is.Not.Null);
Assert.That(dictionary.KeyComparer, Is.Not.Null);
Assert.That(dictionary.KeyComparer, Is.SameAs(myComparer));
Assert.That(dictionary.IsReadOnly, Is.False);
}
static void Main(string[] args)
{
string[] mas = new string[]{"28052014", "14042014", "01012015"};
IComparer c = new MyComparer();
Array.Sort(mas, c);
foreach (var item in mas)
{
Console.WriteLine(item);
}
}
private void Button1_Click(object sender, EventArgs e)
{
DataTable table = new DataTable();
string[] data = new string[2];
data[0] = textBox1.Text;
data[1] = Score.ToString();
scoreCount++;
dataGrid.Rows.Add(data);
MyComparer comp = new MyComparer();
dataGrid.Sort(comp);
this.Close();
}
public void IndexOf_WithComparer()
{
var @true = new MyComparer((l, r) => true);
var @false = new MyComparer((l, r) => false);
Assert.AreEqual(0, new[] { 1, 2, 3 }.IndexOf(2, @true));
Assert.AreEqual(1, new[] { 1, 2, 3 }.IndexOf(2, EqualityComparer <object> .Default));
Assert.AreEqual(1, new[] { 1, 2, 3 }.IndexOf(2, default(IEqualityComparer)));
Assert.AreEqual(-1, new[] { 1, 2, 3 }.IndexOf(2, @false));
Assert.AreEqual(0, new[] { 1, 2, 3 }.IndexOf(-1, @true));
Assert.AreEqual(-1, new[] { 1, 2, 3 }.IndexOf(-1, EqualityComparer <object> .Default));
Assert.AreEqual(-1, new[] { 1, 2, 3 }.IndexOf(-1, default(IEqualityComparer)));
Assert.AreEqual(-1, new[] { 1, 2, 3 }.IndexOf(-1, @false));
}
public bool PosTest1()
{
bool retVal = true;
Array array;
int length;
double element;
IComparer myc;
TestLibrary.TestFramework.BeginScenario("PosTest1: Array.Sort(Array, IComparer) ");
try
{
for (int j = 0; j < c_NUM_LOOPS; j++)
{
myc = new MyComparer();
// creat the array
length = (TestLibrary.Generator.GetInt32(-55) % (c_MAX_SIZE - c_MIN_SIZE)) + c_MIN_SIZE;
array = Array.CreateInstance(typeof(Double), length);
// fill the array
for (int i = 0; i < array.Length; i++)
{
array.SetValue((object)TestLibrary.Generator.GetDouble(-55), i);
}
Array.Sort(array, myc);
// ensure that all the elements are sorted
element = (double)array.GetValue(0);
for (int i = 0; i < array.Length; i++)
{
if (element > (double)array.GetValue(i))
{
TestLibrary.TestFramework.LogError("000", "Unexpected value: Element (" + element + ") is greater than (" + (double)array.GetValue(i) + ")");
retVal = false;
}
}
}
}
catch (Exception e)
{
TestLibrary.TestFramework.LogError("001", "Unexpected exception: " + e);
retVal = false;
}
return(retVal);
}
public bool PosTest1()
{
bool retVal = true;
Array array;
int length;
double element;
IComparer myc;
TestLibrary.TestFramework.BeginScenario("PosTest1: Array.Sort(Array, IComparer) ");
try
{
for(int j=0; j<c_NUM_LOOPS; j++)
{
myc = new MyComparer();
// creat the array
length = (TestLibrary.Generator.GetInt32(-55) % (c_MAX_SIZE-c_MIN_SIZE)) + c_MIN_SIZE;
array = Array.CreateInstance(typeof(Double), length);
// fill the array
for (int i=0; i<array.Length; i++)
{
array.SetValue((object)TestLibrary.Generator.GetDouble(-55), i);
}
Array.Sort(array, myc);
// ensure that all the elements are sorted
element = (double)array.GetValue(0);
for(int i=0; i<array.Length; i++)
{
if (element > (double)array.GetValue(i))
{
TestLibrary.TestFramework.LogError("000", "Unexpected value: Element (" + element + ") is greater than (" + (double)array.GetValue(i) + ")");
retVal = false;
}
}
}
}
catch (Exception e)
{
TestLibrary.TestFramework.LogError("001", "Unexpected exception: " + e);
retVal = false;
}
return retVal;
}
public int[][] Merge(int[][] intervals)
{
if (intervals == null || intervals.Length == 0)
{
return(intervals);
}
var comparer = new MyComparer();
Array.Sort(intervals, comparer);
var rs = new List <int[]>(intervals.Length);
var merged = intervals[0];
for (var i = 1; i < intervals.Length; i++)
{
var interval = intervals[i];
if (CanMergeLeft(merged, interval))
{
merged = MergeLeft(merged, interval);
}
else
{
rs.Add(merged);
merged = interval;
}
}
rs.Add(merged);
var rrs = new LinkedList <int[]>();
merged = rs[rs.Count - 1];
for (var i = rs.Count - 2; i > -1; i--)
{
var interval = rs[i];
if (CanMergeLeft(interval, merged))
{
merged = MergeLeft(interval, merged);
}
else
{
rrs.AddFirst(merged);
merged = interval;
}
}
rrs.AddFirst(merged);
return(rrs.ToArray());
}
public static void Main()
{
List <string> list1 = new List <string> {
"A", "B", "C", "D", "E"
};
List <string> list2 = new List <string> {
"D", "E", "F", "G", "H"
};
var comparer = new MyComparer();
var inList1ButNotList2 = list1.Except(list2, comparer);
var inList2ButNotList1 = list2.Except(list1, comparer);
var inBothLists = list1.Intersect(list2, comparer);
Console.WriteLine("In list1 but not list2 = " + string.Join(", ", inList1ButNotList2));
Console.WriteLine("In list2 but not list1 = " + string.Join(", ", inList2ButNotList1));
Console.WriteLine("In both lists = " + string.Join(", ", inBothLists));
}
/// <summary>
/// Given coins of some denominations (say 4, 5, 7), find the least number of coins to user so to get a number N.
/// E.g. N = 100
/// Coins = 4, 5, 7
/// Solution = 7*13 + 5 + 4 => 15 coins
/// </summary>
/// <returns>Minimum Number of coins </returns>
public static int StartGetLeastCoinsForANumber(int[] coinsColl, int N)
{
// sort coins in descending order
// create a dictionary where coin denomination is key and number od coins (solution) is value
// first call of recursive function passing empty dictionary, coins collection, and coinIdx 0
// if dict.Keys.Count == 0 => No solution
// else, sum of all values.
MyComparer comp = new MyComparer();
Array.Sort <int>(coinsColl, comp);
Dictionary <int, int> dict = new Dictionary <int, int>();
GetLeastCoinsForANumber(N, coinsColl, dict, 0);
return(dict.Values.Sum());
}
static void Sort(MyComparer comp)
{
bool fl = true;
while (fl)
{
fl = false;
for (int i = 0; i < lst.Count - 1; i++)
{
if (!comp.Invoke(lst[i], lst[i + 1]))
{
var st = lst[i];
lst[i] = lst[i + 1];
lst[i + 1] = st;
fl = true;
}
}
}
}
/// <summary>
/// Question 2
/// </summary>
private static void ListManipulation()
{
List <string> names = new List <string> {
"Tobenna", "Tunde", "Caleb"
};
names.Add("Charles");
names.AddRange(new [] { "John", "James" });
names.Insert(2, "William");
MyComparer descendingComparer = new MyComparer();
//names.Sort((x, y) => -1 * x.CompareTo(y));
names.Sort(descendingComparer);
foreach (string name in names)
{
Console.WriteLine(name);
}
}
public bool NegTest3()
{
bool retVal = true;
Array keys;
Array items;
IComparer myc;
int length;
TestLibrary.TestFramework.BeginScenario("NegTest3: Array.Sort(Array, Array, int, int, IComparer) length too long");
try
{
// creat the array
length = (TestLibrary.Generator.GetInt32(-55) % (c_MAX_SIZE-c_MIN_SIZE)) + c_MIN_SIZE;
keys = Array.CreateInstance(typeof(byte), length);
items = Array.CreateInstance(typeof(byte), length);
myc = new MyComparer();
Array.Sort(keys, items, length+10, length, myc);
TestLibrary.TestFramework.LogError("009", "Exception expected.");
retVal = false;
}
catch (ArgumentException)
{
// expected
}
catch (Exception e)
{
TestLibrary.TestFramework.LogError("010", "Unexpected exception: " + e);
retVal = false;
}
return retVal;
}
public bool NegTest1()
{
bool retVal = true;
Array array;
IComparer myc;
TestLibrary.TestFramework.BeginScenario("NegTest1: Array.Sort(Array, IComparer) null array");
try
{
array = null;
myc = new MyComparer();
Array.Sort(array, myc);
TestLibrary.TestFramework.LogError("004", "Exception expected.");
retVal = false;
}
catch (ArgumentNullException)
{
// expected
}
catch (Exception e)
{
TestLibrary.TestFramework.LogError("005", "Unexpected exception: " + e);
retVal = false;
}
return retVal;
}
public bool NegTest1()
{
bool retVal = true;
Array keys;
Array items;
IComparer myc;
TestLibrary.TestFramework.BeginScenario("NegTest1: Array.Sort(Array, Array, int, int, IComparer) keys is null");
try
{
keys = null;
items = null;
myc = new MyComparer();
Array.Sort(keys, items, 0, 0, myc);
TestLibrary.TestFramework.LogError("005", "Exception expected.");
retVal = false;
}
catch (ArgumentNullException)
{
// expected
}
catch (Exception e)
{
TestLibrary.TestFramework.LogError("006", "Unexpected exception: " + e);
retVal = false;
}
return retVal;
}
