public static void Main()
{
// Create and initialize a new array.
String[] words = { "The", "QUICK", "BROWN", "FOX", "jumps",
"over", "the", "lazy", "dog" };
// Instantiate the reverse comparer.
IComparer revComparer = new ReverseComparer();
// Display the values of the array.
Console.WriteLine("The original order of elements in the array:");
DisplayValues(words);
// Sort a section of the array using the default comparer.
Array.Sort(words, 1, 3);
Console.WriteLine("After sorting elements 1-3 by using the default comparer:");
DisplayValues(words);
// Sort a section of the array using the reverse case-insensitive comparer.
Array.Sort(words, 1, 3, revComparer);
Console.WriteLine("After sorting elements 1-3 by using the reverse case-insensitive comparer:");
DisplayValues(words);
// Sort the entire array using the default comparer.
Array.Sort(words);
Console.WriteLine("After sorting the entire array by using the default comparer:");
DisplayValues(words);
// Sort the entire array by using the reverse case-insensitive comparer.
Array.Sort(words, revComparer);
Console.WriteLine("After sorting the entire array using the reverse case-insensitive comparer:");
DisplayValues(words);
}
public void Comparer()
{
var comparer = new ReverseComparer <int>();
var sortedList = new SortedList <int>(comparer);
Assert.AreEqual(comparer, sortedList.Comparer);
}
public static void Main()
{
string[] dinosaurs = { "Pachycephalosaurus",
"Amargasaurus",
"Mamenchisaurus",
"Tarbosaurus",
"Tyrannosaurus",
"Albertasaurus" };
Console.WriteLine();
foreach (string dinosaur in dinosaurs)
{
Console.WriteLine(dinosaur);
}
Console.WriteLine("\nSort(dinosaurs, 3, 3)");
Array.Sort(dinosaurs, 3, 3);
Console.WriteLine();
foreach (string dinosaur in dinosaurs)
{
Console.WriteLine(dinosaur);
}
ReverseComparer rc = new ReverseComparer();
Console.WriteLine("\nSort(dinosaurs, 3, 3, rc)");
Array.Sort(dinosaurs, 3, 3, rc);
Console.WriteLine();
foreach (string dinosaur in dinosaurs)
{
Console.WriteLine(dinosaur);
}
}
public static void Main()
{
string[] dinosaurs = { "Pachycephalosaurus",
"Amargasaurus",
"Tyrannosaurus",
"Mamenchisaurus",
"Deinonychus",
"Edmontosaurus" };
Console.WriteLine();
foreach (string dinosaur in dinosaurs)
{
Console.WriteLine(dinosaur);
}
ReverseComparer rc = new ReverseComparer();
Console.WriteLine("\nSort");
Array.Sort(dinosaurs, rc);
Console.WriteLine();
foreach (string dinosaur in dinosaurs)
{
Console.WriteLine(dinosaur);
}
Console.WriteLine("\nBinarySearch for 'Coelophysis':");
int index = Array.BinarySearch(dinosaurs, "Coelophysis", rc);
ShowWhere(dinosaurs, index);
Console.WriteLine("\nBinarySearch for 'Tyrannosaurus':");
index = Array.BinarySearch(dinosaurs, "Tyrannosaurus", rc);
ShowWhere(dinosaurs, index);
}
public void NormalComparer()
{
var original = StringComparer.Ordinal;
var subject = new ReverseComparer <string>(original);
Assert.AreEqual(original.Compare("x", "y"), subject.Compare("y", "x"));
Assert.AreEqual(0, subject.Compare("x", "x"));
}
public void Simple()
{
var comparer = new ReverseComparer <int>();
Assert.AreEqual(comparer.Compare(2, 3), 1);
Assert.AreEqual(comparer.Compare(3, 2), -1);
Assert.AreEqual(comparer.Compare(0, 0), 0);
Assert.AreEqual(comparer.Compare(0, 1), 1);
Assert.AreEqual(comparer.Compare(1, 0), -1);
}
public void TestSortByComparer()
{
ReverseComparer comparer = new ReverseComparer();
Array.Sort(m_arrOriginal, comparer);
CollectionAssert.IsOrdered(m_arrOriginal, comparer);
Element[] expectedArray = { m_maximum, m_middle, m_minimum };
CollectionAssert.AreEqual(expectedArray, m_arrOriginal);
}
public void Set()
{
var comparer = new ReverseComparer <int>();
IComparer <int> newComparer = new IntComparer();
comparer.Comparer = newComparer;
Assert.AreEqual(comparer.Comparer, newComparer);
}
public void Simple()
{
var comparer = new ReverseComparer<int>();
Assert.AreEqual(comparer.Compare(2, 3), 1);
Assert.AreEqual(comparer.Compare(3, 2), -1);
Assert.AreEqual(comparer.Compare(0, 0), 0);
Assert.AreEqual(comparer.Compare(0, 1), 1);
Assert.AreEqual(comparer.Compare(1, 0), -1);
}
/// <summary>
/// Reverses the original comparer; if it was already a reverse comparer,
/// the previous version was reversed (rather than reversing twice).
/// In other words, for any comparer X, X==X.Reverse().Reverse().
/// </summary>
public static IComparer <T> Reverse <T>(this IComparer <T> original)
{
ReverseComparer <T> originalAsReverse = original as ReverseComparer <T>;
if (originalAsReverse != null)
{
return(originalAsReverse.OriginalComparer);
}
return(new ReverseComparer <T>(original));
}
public void ReverseComparerReturnsZeroWhenFirstItemEqualsSecondItem()
{
var comparer = new ReverseComparer <int>(Comparer <int> .Default);
int first = 1;
int second = 1;
int result = comparer.Compare(first, second);
Assert.AreEqual(0, result);
}
public void ReverseComparerReturnsPositiveOneWhenFirstItemIsLessThanSecondItem()
{
var comparer = new ReverseComparer <int>(Comparer <int> .Default);
int first = 1;
int second = 2;
int result = comparer.Compare(first, second);
Assert.AreEqual(1, result);
}
public void CustomComparer_Limits_GreaterThan()
{
// Arrange
var comparer = new CustomIntComparerLimits();
var reversedComparer = new ReverseComparer <int>(comparer);
// Act-Assert (Precondition)
Assert.Equal(int.MaxValue, comparer.Compare(2, 1));
// Act-Assert
Assert.Equal(int.MinValue, reversedComparer.Compare(2, 1));
}
public void ReverseDefaultStringComparer_WithNull_GreaterThan()
{
// Arrange
var comparer = Comparer <string> .Default;
var reversedComparer = new ReverseComparer <string>(comparer);
// Act-Assert (Precondition)
Assert.Equal(1, comparer.Compare("A", null));
// Act-Assert
Assert.Equal(-1, reversedComparer.Compare("A", null));
}
public void ReverseDefaultIntegerComparer_LessThan()
{
// Arrange
var comparer = Comparer <int> .Default;
var reversedComparer = new ReverseComparer <int>(comparer);
// Act-Assert (Precondition)
Assert.Equal(-1, comparer.Compare(1, 2));
// Act-Assert
Assert.Equal(1, reversedComparer.Compare(1, 2));
}
public void Simple()
{
var comparer = new ReverseComparer <int>();
Assert.AreEqual(comparer.Comparer, Comparer <int> .Default);
IComparer <int> newComparer = new IntComparer();
comparer = new ReverseComparer <int>(newComparer);
Assert.AreEqual(comparer.Comparer, newComparer);
}
public void ReverseDefaultStringComparer_WithNull_LessEqual()
{
// Arrange
var comparer = Comparer <string> .Default;
var reversedComparer = new ReverseComparer <string>(comparer);
// Act-Assert (Precondition)
Assert.Equal(0, comparer.Compare(null, null));
// Act-Assert
Assert.Equal(0, reversedComparer.Compare(null, null));
}
public void CustomComparer_LessThan()
{
// Arrange
var comparer = new CustomIntComparer();
var reversedComparer = new ReverseComparer <int>(comparer);
// Act-Assert (Precondition)
Assert.Equal(-2, comparer.Compare(1, 2));
// Act-Assert
Assert.Equal(2, reversedComparer.Compare(1, 2));
}
public void Test_ReverseComparer_EqualTo()
{
// Arrange.
IComparer <int> baseComparer = Comparer <int> .Default;
IComparer <int> reverseComparer = new ReverseComparer <int>(baseComparer);
// Act.
int result = baseComparer.Compare(2, 2);
int reversedResult = reverseComparer.Compare(2, 2);
// Assert.
Assert.Equal(result, reversedResult);
Assert.Equal(0, result);
Assert.Equal(0, reversedResult);
}
public void Test_ReverseComparer_GreaterThan()
{
// Arrange.
IComparer <int> baseComparer = Comparer <int> .Default;
IComparer <int> reverseComparer = new ReverseComparer <int>(baseComparer);
// Act.
int result = baseComparer.Compare(2, 1);
int reversedResult = reverseComparer.Compare(2, 1);
// Assert.
Assert.NotEqual(result, reversedResult);
Assert.True(result > 0);
Assert.True(reversedResult < 0);
}
public static void Main()
{
string[] letters = { "A", "B", "E", "C", "F", "G" };
int[] letterSizes = { 40, 5, 3, 22, 1, 18 };
Console.WriteLine();
for (int i = 0; i < letters.Length; i++)
{
Console.WriteLine("{0}: up to {1} meters long.", letters[i], letterSizes[i]);
}
Console.WriteLine("\nSort(letters, letterSizes)");
Array.Sort(letters, letterSizes);
for (int i = 0; i < letters.Length; i++)
{
Console.WriteLine("{0}: up to {1} meters long.",
letters[i], letterSizes[i]);
}
ReverseComparer rc = new ReverseComparer();
Console.WriteLine("\nSort(letters, letterSizes, rc)");
Array.Sort(letters, letterSizes, rc);
for (int i = 0; i < letters.Length; i++)
{
Console.WriteLine("{0}: up to {1} meters long.",
letters[i], letterSizes[i]);
}
Console.WriteLine("\nSort(letters, letterSizes, 3, 3)");
Array.Sort(letters, letterSizes, 3, 3);
for (int i = 0; i < letters.Length; i++)
{
Console.WriteLine("{0}: up to {1} meters long.",
letters[i], letterSizes[i]);
}
Console.WriteLine("\nSort(letters, letterSizes, 3, 3, rc)");
Array.Sort(letters, letterSizes, 3, 3, rc);
for (int i = 0; i < letters.Length; i++)
{
Console.WriteLine("{0}: up to {1} meters long.",
letters[i], letterSizes[i]);
}
}
public static void TestComparerScope()
{
var comparer = new ReverseComparer <int>(Comparer <int> .Default);
var list = new List <int>()
{
0, 1, 2
};
try
{
Assert.AreEqual(1, list.BinarySearch(1, comparer), "1 found in list at index 1.");
}
catch (Exception)
{
Assert.Fail("Exception thrown in BinarySearch");
}
}
static void Main(string[] args)
{
IComparer compare = new ReverseComparer();
int[] compArr = Console.ReadLine().Split(new[] { " " }, StringSplitOptions.RemoveEmptyEntries)
.Select(int.Parse).ToArray();
Array.Sort(compArr, compare);
int index = 0;
for (int i = 0; i < compArr.Length; i++)
{
if (compArr[i] % 2 != 0)
{
index = i - 1;
break;
}
}
Console.WriteLine(String.Join(" ", compArr.Take(index + 1).ToArray().OrderBy(x => x).ToArray()) + "// " + String.Join(" ", compArr.Skip(index + 1).ToArray().OrderBy(x => x).ToArray()));
}
public string Sort(string str)
{
var c = str.ToArray();
var s = new string[c.Length];
for (var i = 0; i < c.Length; i++)
{
s[i] = c[i].ToString();
}
IComparer rev = new ReverseComparer();
Array.Sort(s, rev);
str = "";
for (var i = 0; i < c.Length; i++)
{
str += s[i];
}
return(str);
}
/*
* Задание 2
* Заполнить с консоли массив из N элементов. Отсортировать. Вывести результат. N - задается с консоли
*/
public void Task2()
{
while (true)
{
v.TaskText("Задание 2.", "Заполнить с консоли массив из N элементов. \nОтсортировать. Вывести результат. N - задается с консоли");
try
{
v.TaskExtraText("Введите число N: ");
int n = GetIntNumberFromScreen();
int[] array = new int[n];
v.TaskExtraText("Заполняем массив: ");
for (int i = 0; i < n; i++)
{
v.TaskExtraText("Введите число: ");
array[i] = GetIntNumberFromScreen();
}
// Instantiate the reverse comparer.
IComparer revComparer = new ReverseComparer();
Array.Sort(array, revComparer);
string res = "";
for (int i = array.GetLowerBound(0); i <= array.GetUpperBound(0); i++)
{
res += array[i] + ", ";
}
res = res.Trim().Trim(',');
v.TaskResult(res);
break;
}
catch (Exception e)
{
v.TaskWarning(e.Message.ToString());
continue;
}
}
}
public static int TopNpeakHelper(ref double[] intensities, ref double[] mArray, IFilteringParams filteringParams)
{
IComparer <double> c = new ReverseComparer();
Array.Sort(intensities, mArray, c);
int numPeaks = intensities.Length;
if (filteringParams.MinimumAllowedIntensityRatioToBasePeakM.HasValue)
{
double minIntensity = filteringParams.MinimumAllowedIntensityRatioToBasePeakM.Value * intensities[0];
numPeaks = Math.Min(intensities.Count(b => b >= minIntensity), numPeaks);
}
if (filteringParams.NumberOfPeaksToKeepPerWindow.HasValue)
{
numPeaks = Math.Min(filteringParams.NumberOfPeaksToKeepPerWindow.Value, numPeaks);
}
return(numPeaks);
}
public ListHeapWithIndices(Comparer <TValue> comparer = null)
{
if (comparer == null)
{
this.comparer = new DefaultComparer <TValue>();
}
else
{
this.comparer = comparer;
}
Array.Resize(ref elementsKey, 100);
Array.Resize(ref elementsValue, 100);
Array.Resize(ref keysPosition, 100);
for (int i = 0; i < 100; ++i)
{
keysPosition[i] = -i - 2;
}
reverseComparer = new ReverseComparer(comparer);
}
// Complete the climbingLeaderboard function below.
static int[] climbingLeaderboard(int[] scores, int[] alice)
{
var distict = scores.Distinct().ToArray();
var result = new int[alice.Length];
var comparer = new ReverseComparer <int>();
for (int index = 0; index < alice.Length; index++)
{
var search = Array.BinarySearch(distict, alice[index], comparer);
if (search >= 0)
{
result[index] = search + 1;
}
else
{
result[index] = -search;
}
}
return(result);
}
private void Button2_Click(object sender, EventArgs e)
{
IComparer revComparer = new ReverseComparer();
double sum = 0;
k = (int)(numericUpDown2.Value);
for (int i = 0; i < myArr.Length; i++)
{
if (i % 2 == 0 && myArr[i] > 0)
{
sum += myArr[i];
}
}
textBox1.Text = sum.ToString();
Array.Sort(myArr, value - k, k, revComparer);
for (int i = 0; i < myArr.Length; i++)
{
dataGridView1[i, 0].Value = myArr[i];
}
}
public void SortersEtc()
{
PropertyRecordSorter prs = new PropertyRecordSorter("longName");
// Save and restore!
string xml = DynamicLoader.PersistObject(prs, "sorter");
XmlDocument doc = new XmlDocument();
doc.LoadXml(xml);
// And check all the pieces...
PropertyRecordSorter prsOut = DynamicLoader.RestoreObject(doc.DocumentElement) as PropertyRecordSorter;
prsOut.Cache = m_cache;
Assert.AreEqual("longName", prsOut.PropertyName);
// Putting an IntStringComparer here is utterly bizarre, but it tests out one more class.
StringFinderCompare sfComp = new StringFinderCompare(new OwnMonoPropFinder(m_cache.MainCacheAccessor, 445),
new ReverseComparer(new IntStringComparer()));
sfComp.SortedFromEnd = true;
// Save and restore!
xml = DynamicLoader.PersistObject(sfComp, "comparer");
doc = new XmlDocument();
doc.LoadXml(xml);
// And check all the pieces...
StringFinderCompare sfCompOut = DynamicLoader.RestoreObject(doc.DocumentElement) as StringFinderCompare;
sfCompOut.Cache = m_cache;
Assert.IsTrue(sfCompOut.Finder is OwnMonoPropFinder);
Assert.IsTrue(sfCompOut.SubComparer is ReverseComparer);
Assert.IsTrue(sfCompOut.SortedFromEnd);
ReverseComparer rcOut = sfCompOut.SubComparer as ReverseComparer;
Assert.IsTrue(rcOut.SubComp is IntStringComparer);
}
/// <summary>
/// Sorts an array of <see cref="SccStamp"/> objects by their
/// revision numbers in ascending or descending order.
/// </summary>
public static void SortByLastChanged(SccStamp[] stamps, bool descending)
{
IComparer comparer = new LastChangedComparer();
if (descending)
comparer = new ReverseComparer(comparer);
Array.Sort(stamps, comparer);
}
//-------------------------------------------------------------------------------//
//Caller write
public static void SaveData(string naam, int score)
{
//hier benoem ik path tot de locatie van de .exe
var path = AppDomain.CurrentDomain.BaseDirectory;
//declareren van verschillende variabelen
string[] savearray = new string[12];
string[] newsavearray = new string[12];
int lengte = 0;
//proberen van laden van savedata if aanwezig, anders doet hij niks
string message = Decrypt();
string save = LoadData();
if (save == "Er is nog geen\nsave file\naanwezig")
{
}
else
{
savearray = save.Split(new string[] { "\n" }, StringSplitOptions.RemoveEmptyEntries);
lengte = LengteLoad(@"" + path + "lengte.ini");
}
//lengte +1 ivm 1 extra entry
if (lengte < 11)
{
lengte = lengte + 1;
}
//koppelen van score en naam, score vooraan ivm sorteren
string koppel = score + " punten gehaald door: " + naam;
if (savearray[0] == null)
{
//lege list op basis van niks
List <string> scorelist = new List <string>();
scorelist.Add(koppel);
scorelist.CopyTo(newsavearray);
}
else
{
//list aanmaken op basis van savearray
List <string> scorelist = new List <string>(savearray);
scorelist.Add(koppel);
scorelist.CopyTo(newsavearray);
}
//reverse comparer initialiseren
IComparer revComparer = new ReverseComparer();
//de array omgekeerd sorteren op basis van ASCII oid.
Array.Sort(newsavearray, revComparer);
//omzetten naar bytes
byte[] serialized = Serialize(lengte, newsavearray);
//deze bytes writen
WriteToFile(@"" + path + "highscores.sav", serialized);
//lengte writen
LengteWrite(@"" + path + "lengte.ini", lengte);
Encrypt();
//}
}
public void Comparer()
{
var comparer = new ReverseComparer<int>();
var sortedList = new SortedList<int>(comparer);
Assert.AreEqual(comparer, sortedList.Comparer);
}
/// <summary>
/// Sorts an array of <see cref="SccStamp"/> objects by their
/// revision numbers in ascending or descending order.
/// </summary>
public static void SortByRevision(SccStamp[] stamps, bool descending)
{
IComparer comparer = new RevisionComparer();
if (descending)
comparer = new ReverseComparer(comparer);
Array.Sort(stamps, comparer);
}
private void absolute()
{
IComparer revComparer = new ReverseComparer();
Array.Sort(prior, revComparer);
while(true)
{
//foreach(var val1 in prior)
for(int i = 0; i < prior.Length; i++)
{
if(prior[i] == -1) continue;
foreach(var val2 in ProcessData)
{
if(Int32.Parse(val2[3].Text) == prior[i])
{
Invoke(new Action(() => val2[5].Text = "Выполняется"));
Thread.Sleep(Int32.Parse(val2[1].Text)*1000);
val2[7].Text = (Int32.Parse(val2[7].Text) + Int32.Parse(val2[1].Text)).ToString();
if(Int32.Parse(val2[7].Text) >= Int32.Parse(val2[2].Text))
{
Invoke(new Action(() => val2[4].Text = "100%"));
Invoke(new Action(() => val2[5].Text = "Выполнен"));
prior[i] = -1;
break;
}
Invoke(new Action(() => val2[4].Text = (100*double.Parse(val2[7].Text)/double.Parse(val2[2].Text)).ToString() + "%"));
Invoke(new Action(() => val2[5].Text = "Очередь"));
}
}
}
if(checking(prior)) break;
}
}
