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; }