public void TestFindLeft()
{
var array = new[] { 5, 7, 10, 12, 19, 20 };
var position = BinarySearchHelper.Search(array, 0, array.Length, 7);
Assert.AreEqual(1, position);
}
public void TestFindLessWithStart2()
{
var array = new[] { -9, 1, 2 };
var less = BinarySearchHelper.FindLess(array, -9, 2, 3);
Assert.AreEqual(0, less);
}
public void TestFindLessOrEqualWithStart()
{
var array = new[] { 9, 28, 44, 47, 47, 47, 90 };
var less = BinarySearchHelper.FindLessOrEqual(array, 47, 4);
Assert.AreEqual(2, less);
}
public static PointInt[] Solve(int N, int[][] commands, long[] K)
{
var squares = new SquareInfo[commands.Length + 1];
squares[0] = new SquareInfo {
Row = 0, Col = 0, Width = N, First = 0, DeltaInRow = 1, DeltaInCol = N, Direction = 0
};
squares[0].CalcExtra(N);
for (var i = 1; i <= commands.Length; i++)
{
var command = commands[i - 1];
var ai = command[0];
var bi = command[1];
var di = command[2];
var prev = squares[i - 1];
var newRow = ai - 1;
var newCol = bi - 1;
var square = new SquareInfo
{
Row = newRow,
Col = newCol,
Width = di + 1,
First = prev.First + (newCol - prev.Col) * prev.DeltaInRow + (newRow - prev.Row + di) * prev.DeltaInCol,
DeltaInRow = -prev.DeltaInCol,
DeltaInCol = prev.DeltaInRow,
Direction = i % 4,
};
square.CalcExtra(N);
squares[i] = square;
}
var result = new PointInt[K.Length];
for (var i = 0; i < K.Length; i++)
{
var wi = K[i];
var si = BinarySearchHelper.BinarySearchRightBiased(squares, sq =>
{
var rem = wi % N;
var div = wi / N;
var contains = sq.MinRem <= rem && rem <= sq.MaxRem && sq.MinDiv <= div && div <= sq.MaxDiv;
return(contains ? 0 : 1);
});
result[i] = GetPoint(squares[si], wi, N);
}
return(result);
}
protected override void Merge(int[] array, int[] arrayResult, int start, int pivot, int end)
{
Parallel.Invoke(() => Parallel.ForEach(Enumerable.Range(start, pivot - start), index =>
{
var value = array[index];
var less = BinarySearchHelper.FindLess(array, value, pivot, end);
arrayResult[index + less] = value;
}),
() => Parallel.ForEach(Enumerable.Range(pivot, end - pivot), index =>
{
var value = array[index];
var less = BinarySearchHelper.FindLessOrEqual(array, value, start, pivot);
arrayResult[start + index - pivot + less] = value;
}));
}
protected override void Merge(int[] array, int[] arrayResult, int start, int pivot, int end)
{
// collect separate action arrays for each individual operation
var firstPart = Enumerable.Range(start, pivot - start).Select(index => new Action(() =>
{
var value = array[index];
var less = BinarySearchHelper.FindLess(array, value, pivot, end);
arrayResult[index + less] = value;
}));
var secondPart = Enumerable.Range(pivot, end - pivot).Select(index => new Action(() =>
{
var value = array[index];
var less = BinarySearchHelper.FindLessOrEqual(array, value, start, pivot);
arrayResult[start + index - pivot + less] = value;
}));
// combine into 4 big actions
var actions = new Action[4];
var i = 0;
foreach (var action in firstPart)
{
actions[i] += action;
i++;
if (i == actions.Length)
{
i = 0;
}
}
foreach (var action in secondPart)
{
actions[i] += action;
i++;
if (i == actions.Length)
{
i = 0;
}
}
ThreadPoolHelper.SpawnAndWait(actions);
}
public OperationAdapter()
{
sortTarget = new QuickSortHelper();
searchTarget = new BinarySearchHelper();
}
public void Test1()
{
var res = BinarySearchHelper.BinarySearch(new[] {1, 2, 4, 5}, 3, null);
Assert.Equal(~2, res);
}
public void Test3()
{
var res = BinarySearchHelper.BinarySearch(new[] { 1, 2, 2, 3 }, 1, null);
Assert.InRange(res, 0, 1);
}
public void TestFindLess2(int[] array, int value, int expected)
{
var position = BinarySearchHelper.FindLessOrEqual(array, value);
Assert.AreEqual(expected, position);
}
public static int Solve(string s)
{
var N = s.Length;
var opt = N / 4;
var lefts = new int[N + 1][];
lefts[0] = new int[4];
for (var i = 1; i <= N; i++)
{
var c = s[i - 1];
var counts = new int[4];
for (var d = 0; d < 4; d++)
{
counts[d] = lefts[i - 1][d];
}
counts[c == 'A' ? 0 : c == 'C' ? 1 : c == 'T' ? 2 : 3]++;
lefts[i] = counts;
}
if (lefts[N].Sum(c => Math.Abs(c - opt)) == 0)
{
return(0);
}
var rights = new int[N + 1][];
rights[N] = new int[4];
for (var j = N - 1; j >= 0; j--)
{
var c = s[j];
var counts = new int[4];
for (var d = 0; d < 4; d++)
{
counts[d] = j == N - 1 ? 0 : rights[j + 1][d];
}
counts[c == 'A' ? 0 : c == 'C' ? 1 : c == 'T' ? 2 : 3]++;
rights[j] = counts;
}
var best = int.MaxValue;
for (var j = N; j >= 0; j--)
{
var right = rights[j];
var bestI = BinarySearchHelper.BinarySearchLeftBiased(lefts, counts => - Distance(right, counts, opt));
var distanceHere = Distance(right, lefts[bestI], opt);
if (distanceHere < 0 || bestI >= j)
{
continue;
}
if (bestI >= 0)
{
best = Math.Min(best, j - bestI);
}
}
return(best);
}
