public static int[] Generate(int size, int MinRange, int MaxRange, ArraySort sortType)
{
int[] array = new int [size];
Array.Sort(array);
switch (sortType)
{
case ArraySort.Descending:
Array.Reverse(array);
break;
case ArraySort.AShape:
case ArraySort.VShape:
if (sortType == ArraySort.AShape)
{
Array.Reverse(array);
}
int[] shapeArray = new int[array.Length];
int j = (int)Math.Floor((double)(array.Length - 1) / 2);
for (int i = 0; i < array.Length; i++)
{
shapeArray[j] = array[i];
j = (i % 2 == 0) ? j + (i + 1) : j - (i + 1);
}
array = shapeArray;
break;
}
return(array);
}
public override SubQuery[] GetSubqueries(Session session)
{
OrderedHashSet <SubQuery> set = null;
if (this._expression != null)
{
set = this._expression.CollectAllSubqueries(set);
}
for (int i = 0; i < this._arguments.Length; i++)
{
set = this._arguments[i].CollectAllSubqueries(set);
}
if ((set == null) || (set.Size() == 0))
{
return(SubQuery.EmptySubqueryArray);
}
SubQuery[] a = new SubQuery[set.Size()];
set.ToArray(a);
ArraySort.Sort <SubQuery>(a, 0, a.Length, a[0]);
for (int j = 0; j < base.Subqueries.Length; j++)
{
a[j].PrepareTable(session);
}
return(a);
}
public IList <IList <int> > ThreeSum(int[] nums)
{
IList <IList <int> > result = new List <IList <int> >();
if (nums == null || nums.Length < 2)
{
return(result);
}
ArraySort.QuickSort(nums, 0, nums.Length - 1);
for (int i = 0; i < nums.Length; i++)
{
if (nums[i] > 0)
{
return(result);
}
if (i > 0 && nums[i].Equals(nums[i - 1]))
{
continue;
}
else
{
int left = i + 1;
int right = nums.Length - 1;
while (left < right)
{
int currentValue = nums[i] + nums[left] + nums[right];
if (currentValue.Equals(0))
{
result.Add(new List <int>
{
nums[i],
nums[left],
nums[right]
});
left++;
right--;
while (left < right && nums[left].Equals(nums[left - 1]))
{
left++;
}
while (left < right && nums[right].Equals(nums[right + 1]))
{
right--;
}
}
else if (currentValue > 0)
{
right--;
}
else
{
left++;
}
}
}
}
return(result);
}
public virtual void SortOrder()
{
if (this._queryExpression.OrderIndex != null)
{
this._mainIndex = this._queryExpression.OrderIndex;
ArraySort.Sort <object[]>(this._table, 0, base.Size, this);
}
this.Reset();
}
public void QuickSortWithoutRecursionTest(int[] array)
{
ArraySort.QuickSortWithoutRecursion(array, 0, array.Length - 1);
bool actual = array.JudgeOrdered(true);
bool excepted = true;
Assert.Equal(excepted, actual);
}
public void SelectionSortTest(int[] array)
{
ArraySort.SelectionSort(array);
bool actual = array.JudgeOrdered(true);
bool excepted = true;
Assert.Equal(excepted, actual);
}
public virtual void SortUnion(SortAndSlice sortAndSlice)
{
if (sortAndSlice.index != null)
{
this._mainIndex = sortAndSlice.index;
ArraySort.Sort <object[]>(this._table, 0, base.Size, this);
this.Reset();
}
}
public void MergeSort_ValidInputData_Test()
{
var result1 = ArraySort.MergeSort(_testArr1);
CollectionAssert.AreEqual(_resultArr1, result1);
var result2 = ArraySort.MergeSort(_testArr2);
CollectionAssert.AreEqual(_resultArr2, result2);
}
public void CanSortEmpty()
{
var items = new int[] { };
var threshold = 4;
var count = ArraySort.MoveItemsLessThanThresholdToStart(items, threshold);
IsArrayContentEqual(new int[] { }, items);
Assert.AreEqual(0, count);
}
public void CanSortNoItemsLessThanThreshold()
{
var items = new[] { 6, 4, 5, 8 };
var threshold = 4;
var count = ArraySort.MoveItemsLessThanThresholdToStart(items, threshold);
IsArrayContentEqual(new[] { 6, 4, 5, 8 }, items);
Assert.AreEqual(0, count);
}
public void CanSortAllItemsLessThanThreshold()
{
var items = new[] { 3, 1, 2, 3 };
var threshold = 4;
var count = ArraySort.MoveItemsLessThanThresholdToStart(items, threshold);
IsArrayContentEqual(new[] { 3, 1, 2, 3 }, items);
Assert.AreEqual(4, count);
}
public void CanSortWithNoAdjacentItemsLessThanThreshold()
{
var items = new[] { 3, 6, 4, 2, 5, 3, 8 };
var threshold = 4;
var count = ArraySort.MoveItemsLessThanThresholdToStart(items, threshold);
IsArrayContentEqual(new[] { 3, 2, 3, 6, 4, 5, 8 }, items);
Assert.AreEqual(3, count);
}
public void QuickSort_ValidInputData_Test()
{
var result1 = ArraySort.QuickSort(_testArr1, 0, _testArr1.Length - 1);
CollectionAssert.AreEqual(_resultArr1, result1);
var result2 = ArraySort.QuickSort(_testArr2, 0, _testArr2.Length - 1);
CollectionAssert.AreEqual(_resultArr2, result2);
}
public int ThreeSumClosest(int[] nums, int target)
{
if (nums == null)
{
return(0);
}
if (nums.Length == 1)
{
return(nums[0]);
}
if (nums.Length == 2)
{
return(nums[0] + nums[1]);
}
if (nums.Length == 3)
{
return(nums[0] + nums[1] + nums[2]);
}
ArraySort.QuickSort(nums, 0, nums.Length - 1);
if (target > 0 && nums[0] > target)
{
return(nums[0] + nums[1] + nums[2]);
}
int sum = 0;
int diff = 2001;
for (int i = 0; i < nums.Length - 2; i++)
{
int left = i + 1;
while (left < nums.Length)
{
int right = nums.Length - 1;
while (left < right)
{
int currentSum = nums[i] + nums[left] + nums[right];
int currentDiff = currentSum - target;
if (currentDiff.Equals(0))
{
return(currentSum);
}
else if ((currentDiff * currentDiff) < (diff * diff))
{
sum = currentSum;
diff = currentDiff;
}
right--;
}
left++;
}
}
return(sum);
}
public void FilterDigit_InputArray1217157_Return177()
{
// Arr
int[] arr = { 12, 17, 0, 7 };
int[] expected = { 17, 7 };
// Arc
int[] actual = ArraySort.FilterDigit(arr, 7);
// Assert
CollectionAssert.AreEqual(expected, actual);
}
public void FilterDigit_Inputnegativenumbers_ReturnSuitableNumbers()
{
// Arr
int[] arr = { -12, -17, -20, 7 };
int[] expected = { -12, -20 };
// Arc
int[] actual = ArraySort.FilterDigit(arr, 2);
// Assert
CollectionAssert.AreEqual(expected, actual);
}
public void FilterDigit_InputValue0_NumbersWidth0()
{
// Arr
int[] arr = { 12, 0, 15, 105, 10456 };
int[] expected = { 0, 105, 10456 };
// Arc
int[] actual = ArraySort.FilterDigit(arr, 0);
// Assert
CollectionAssert.AreEqual(expected, actual);
}
public void QuickSortTest()
{
var sorter = new ArraySort();
Assert.AreEqual("0, 1, 2, 3, 4, 5, 6, 7", string.Join(", ", sorter.QuickSort((int[])this._fullyUnsortedEvenLengthArray.Clone(), 0, this._fullyUnsortedEvenLengthArray.Length - 1)));
Assert.AreEqual("0, 1, 2, 3, 4, 5, 6, 7", string.Join(", ", sorter.QuickSort((int[])this._sortedEvenLengthArray.Clone(), 0, this._sortedEvenLengthArray.Length - 1)));
Assert.AreEqual("0, 1, 2, 3, 4, 5, 6, 7", string.Join(", ", sorter.QuickSort((int[])this._unsortedEvenLengthArray.Clone(), 0, this._unsortedEvenLengthArray.Length - 1)));
Assert.AreEqual("1, 2, 3, 4, 5, 6, 7", string.Join(", ", sorter.QuickSort((int[])this._fullyUnsortedOddLengthArray.Clone(), 0, this._fullyUnsortedOddLengthArray.Length - 1)));
Assert.AreEqual("1, 2, 3, 4, 5, 6, 7", string.Join(", ", sorter.QuickSort((int[])this._sortedOddLengthArray.Clone(), 0, this._sortedOddLengthArray.Length - 1)));
Assert.AreEqual("1, 2, 3, 4, 5, 6, 7", string.Join(", ", sorter.QuickSort((int[])this._unsortedOddLengthArray.Clone(), 0, this._unsortedOddLengthArray.Length - 1)));
}
public void BubbleSortRecursiveTest()
{
var sorter = new ArraySort();
Assert.AreEqual("0, 1, 2, 3, 4, 5, 6, 7", string.Join(", ", sorter.BubbleSortRecursive((int[])this._fullyUnsortedEvenLengthArray.Clone(), this._fullyUnsortedEvenLengthArray.Length)));
Assert.AreEqual("0, 1, 2, 3, 4, 5, 6, 7", string.Join(", ", sorter.BubbleSortRecursive((int[])this._sortedEvenLengthArray.Clone(), this._sortedEvenLengthArray.Length)));
Assert.AreEqual("0, 1, 2, 3, 4, 5, 6, 7", string.Join(", ", sorter.BubbleSortRecursive((int[])this._unsortedEvenLengthArray.Clone(), this._unsortedEvenLengthArray.Length)));
Assert.AreEqual("1, 2, 3, 4, 5, 6, 7", string.Join(", ", sorter.BubbleSortRecursive((int[])this._fullyUnsortedOddLengthArray.Clone(), this._fullyUnsortedOddLengthArray.Length)));
Assert.AreEqual("1, 2, 3, 4, 5, 6, 7", string.Join(", ", sorter.BubbleSortRecursive((int[])this._sortedOddLengthArray.Clone(), this._sortedOddLengthArray.Length)));
Assert.AreEqual("1, 2, 3, 4, 5, 6, 7", string.Join(", ", sorter.BubbleSortRecursive((int[])this._unsortedOddLengthArray.Clone(), this._unsortedOddLengthArray.Length)));
}
public override void Compile(Session session, ISchemaObject parentObject)
{
using (Scanner scanner = new Scanner(this.statement))
{
ParserDQL rdql = new ParserDQL(session, scanner);
rdql.Read();
this.ViewSubQuery = rdql.XreadViewSubquery(this);
base.queryExpression = this.ViewSubQuery.queryExpression;
if (base.GetColumnCount() == 0)
{
if (this.ColumnNames == null)
{
this.ColumnNames = this.ViewSubQuery.queryExpression.GetResultColumnNames();
}
if (this.ColumnNames.Length != this.ViewSubQuery.queryExpression.GetColumnCount())
{
throw Error.GetError(0x15d9, this.GetName().StatementName);
}
TableUtil.SetColumnsInSchemaTable(this, this.ColumnNames, base.queryExpression.GetColumnTypes(), base.queryExpression.GetColumnNullability());
}
OrderedHashSet <SubQuery> set = OrderedHashSet <SubQuery> .AddAll(OrderedHashSet <SubQuery> .Add(base.queryExpression.GetSubqueries(), this.ViewSubQuery), this.ViewSubQuery.GetExtraSubqueries());
this.ViewSubqueries = new SubQuery[set.Size()];
set.ToArray(this.ViewSubqueries);
ArraySort.Sort <SubQuery>(this.ViewSubqueries, 0, this.ViewSubqueries.Length, this.ViewSubqueries[0]);
foreach (SubQuery query in this.ViewSubqueries)
{
if (query.ParentView == null)
{
query.ParentView = this;
}
query.PrepareTable(session);
}
this.ViewSubQuery.GetTable().view = this;
this.ViewSubQuery.GetTable().ColumnList = base.ColumnList;
this._schemaObjectNames = rdql.compileContext.GetSchemaObjectNames();
this._baseTable = base.queryExpression.GetBaseTable();
}
if (this._baseTable != null)
{
switch (this._check)
{
case 0:
case 2:
return;
case 1:
base.queryExpression.GetCheckCondition();
return;
}
throw Error.RuntimeError(0xc9, "View");
}
}
static void Main(string[] args)
{
int[] firstArray = new int[] { 12, 6, -122, 5, 890, -3, 24, 89, 4, -76, 0 };
string[] secondArray = new string[] { "one", "two", "three", "four", "five", "six" };
ArraySort <int> .Sort(firstArray, new IntComparer());
ArraySort <string> .Sort(secondArray, new StringComparer());
Display(firstArray);
Display(secondArray);
Console.ReadKey();
}
public void NumberFinderByString_171017_177()
{
// Arr
int[] array = new int[] { 17, 10, 1, 7 };
int digit = 7;
int[] expected = new int[] { 17, 7 };
// Act
int[] actual = ArraySort.FilterDigit(array, digit, true);
// Assert
CollectionAssert.AreEqual(expected, actual);
}
public virtual IRowIterator FindFirstRow(object[] data)
{
int position = ArraySort.SearchFirst <object[]>(this._table, 0, base.Size, data, this);
if (position < 0)
{
position = base.Size;
}
else
{
position--;
}
return(new DataIterator(position, this));
}
public void NumberFinderByString_123456101636_61636()
{
// Arr
int[] array = new int[] { 1, 2, 3, 4, 5, 6, 10, 16, 36 };
int digit = 6;
int[] expected = new int[] { 6, 16, 36 };
// Act
int[] actual = ArraySort.FilterDigit(array, digit, true);
// Assert
CollectionAssert.AreEqual(expected, actual);
}
private void SaveRows(int count)
{
lock (this)
{
if (count != 0)
{
this._rowComparator.SetType(1);
this._sortTimer.Start();
ArraySort.Sort <ICachedObject>(this._rowTable, 0, count, this._rowComparator);
this._sortTimer.Stop();
this._saveAllTimer.Start();
this.dataFileCache.SaveRows(this._rowTable, 0, count);
this._saveRowCount += count;
this._saveAllTimer.Stop();
}
}
}
public T[] SubArray(int fromPosition, int numberOfElements, ArraySort order = ArraySort.Unsorted)
{
if (fromPosition < 0 || fromPosition >= this.Array.Length || numberOfElements <= 0)
{
return(new T[0]);
}
int index = 0;
T[] singleArray = new T[this.Array.GetLength(0) * this.Array.GetLength(1)];
for (int i = 0; i < this.Array.GetLength(0); i++)
{
for (int j = 0; j < this.Array.GetLength(1); j++)
{
singleArray[index] = this.Array[i, j];
index++;
}
}
if (fromPosition + numberOfElements > singleArray.Length)
{
T[] result = new T[singleArray.Length - fromPosition];
for (int i = fromPosition, j = 0; i < singleArray.Length; i++, j++)
{
result[j] = singleArray[i];
}
result = SortArray(result, order);
return(result);
}
T[] single = new T[numberOfElements];
for (int i = fromPosition, j = 0; i < singleArray.Length && j < numberOfElements; i++, j++)
{
single[j] = singleArray[i];
}
single = SortArray(single, order);
return(single);
}
public virtual void Union(RowSetNavigatorData other)
{
this.RemoveDuplicates();
other.RemoveDuplicates();
while (other.HasNext())
{
object[] next = other.GetNext();
int num = ArraySort.SearchFirst <object[]>(this._table, 0, base.Size, next, this);
if (num < 0)
{
num = -num - 1;
base.CurrentPos = num;
this.Insert(next);
}
}
other.Close();
this.Reset();
}
public void SortByMaxAbsRowElement_AscendentOrder_ChangedInitialArray()
{
int[][] expected = new int[5][] { new int[] { 15, 5, 7, 10, -15, 7 }, new int[] { 8, 4, 7, 10, 9, 5, 20, }, new int[] { 1, 30, 7, 3 - 30 }, null, null };
ArraySort.Sort(initial, (x, y) =>
{
if (x == null && y == null)
{
return(0);
}
if (x == null)
{
return(-1);
}
if (y == null)
{
return(1);
}
if (x.Select(x1 => Math.Abs(x1)).ToArray().Max() < y.Select(y1 => Math.Abs(y1)).ToArray().Max())
{
return(1);
}
else if (x.Select(x1 => Math.Abs(x1)).ToArray().Max() > y.Select(y1 => Math.Abs(y1)).ToArray().Max())
{
return(-1);
}
else
{
return(0);
}
});
for (int i = 0; i < initial.Length; i++)
{
CollectionAssert.AreEqual(initial[i], expected[i]);
}
ArraySort.Sort(initial, new AbsCondition());
for (int i = 0; i < initial.Length; i++)
{
CollectionAssert.AreEqual(initial[i], expected[i]);
}
}
public virtual SubQuery[] GetSubqueries(Session session)
{
OrderedHashSet <SubQuery> first = null;
for (int i = 0; i < this.TargetRangeVariables.Length; i++)
{
if (this.TargetRangeVariables[i] != null)
{
OrderedHashSet <SubQuery> subqueries = this.TargetRangeVariables[i].GetSubqueries();
first = OrderedHashSet <SubQuery> .AddAll(first, subqueries);
}
}
for (int j = 0; j < this.UpdateExpressions.Length; j++)
{
first = this.UpdateExpressions[j].CollectAllSubqueries(first);
}
if (this.InsertExpression != null)
{
first = this.InsertExpression.CollectAllSubqueries(first);
}
if (this.condition != null)
{
first = this.condition.CollectAllSubqueries(first);
}
if (this.queryExpression != null)
{
OrderedHashSet <SubQuery> subqueries = this.queryExpression.GetSubqueries();
first = OrderedHashSet <SubQuery> .AddAll(first, subqueries);
}
if ((first == null) || (first.Size() == 0))
{
return(SubQuery.EmptySubqueryArray);
}
SubQuery[] a = new SubQuery[first.Size()];
first.ToArray(a);
ArraySort.Sort <SubQuery>(a, 0, a.Length, a[0]);
for (int k = 0; k < a.Length; k++)
{
a[k].PrepareTable(session);
}
return(a);
}
private T[] SortArray(T[] input, ArraySort order)
{
switch (order)
{
case ArraySort.Ascending:
System.Array.Sort(input);
break;
case ArraySort.Descending:
System.Array.Sort(input);
System.Array.Reverse(input);
break;
case ArraySort.Unsorted:
default:
break;
}
return(input);
}
public void SortArray_Test(int[][] sortedArray, IComparer<int[]> comparator, ArraySort sort) {
sort.Sort(m_Array, comparator);
CollectionAssert.AreEqual(m_Array, sortedArray);
}
