public IEnumerable <Test> PopFrontReturnsFrontItems()
{
yield return(Assert.That(small.PopFront()).Is.EqualTo("try"));
yield return(Assert.That(small.PopFront()).Is.EqualTo("catch"));
yield return(Assert.That(small.PopFront()).Is.EqualTo("for"));
}
public void TestPushPopFront()
{
var deque = new Deque <int>();
deque.PushFront(1);
deque.PushFront(2);
deque.PushFront(3);
Assert.AreEqual(3, deque.PopFront());
Assert.AreEqual(2, deque.PopFront());
Assert.AreEqual(1, deque.PopFront());
Assert.AreEqual(0, deque.Count);
}
private Deque<string> Create(params string[] elements)
{
var sut = new Deque<string>() { "_", "_", "_", "_" };
sut.PopFront();
sut.PopBack();
foreach(var element in elements)
{
sut.PushBack(element);
}
sut.PopFront();
sut.PopFront();
return sut;
}
public void Set(bool useTaskPool = false)
{
TaskCompletionSource <object> release = null;
lock (queue)
{
if (queue.Count > 0)
{
release = queue.Front;
queue.PopFront();
}
else
{
signaled = true;
}
}
if (release != null)
{
if (useTaskPool)
{
Task.Factory.StartNew(s => ((TaskCompletionSource <object>)s).TrySetResult(null),
release,
CancellationToken.None,
TaskCreationOptions.PreferFairness,
TaskScheduler.Default
);
}
else
{
release.TrySetResult(null);
}
}
}
private static IEnumerable <string> FrontPop(Deque <string> deque, int count)
{
for (int c = 0; c < count; c++)
{
yield return(deque.PopFront());
}
}
public void Solve()
{
var n = sc.Integer();
var k = sc.Integer();
var deq = new Deque <int>();
for (int i = 0; i < n; i++)
{
deq.PushBack(sc.Char() - 'A');
}
var flip = 0;
k = Math.Min(k, 2 * n + (k % (4 * n)));
for (int T = 0; T < k; T++)
{
var x = deq[0] ^ flip;
if (x == 0)
{
deq[0] ^= 1;
}
else
{
deq.PopFront();
flip ^= 1;
deq.PushBack(flip);
}
}
var c = new char[n];
for (int i = 0; i < n; i++)
{
c[i] = (char)((deq[i] ^ flip) + 'A');
}
IO.Printer.Out.WriteLine(c.AsString());
}
public static void printKMax(int[] arr, int n, int k)
{
Deque <int> qi = new Deque <int>();
int i;
for (i = 0; i < k; i++) // first window of the array
{
while ((qi.Count > 0) && (arr[i] >= arr[qi.PeekBack()]))
{
qi.PopBack();
}
qi.PushBack(i);
}
for (i = k; i < n; ++i)
{
Console.WriteLine(arr[qi.PeekFront()]); // the front item is the largest element in previous window.
while (qi.Count > 0 && qi.PeekFront() <= i - k) // this is where the comparison is happening!
{
qi.PopFront(); //now it's out of its window k
}
while (qi.Count > 0 && arr[i] >= arr[qi.PeekBack()]) // repeat
{
qi.PopBack();
}
qi.PushBack(i);
}
Console.WriteLine(arr[qi.PeekFront()]);
}
private static long SolveB(IEnumerable <string> data, int preambleLength = 25, int combinationSize = 2)
{
var dataStrings = data.ToArray();
var array = Text.StringsToLongs(dataStrings).ToArray();
var numbers = new Span <long>(array);
var expectedSum = SolveA(dataStrings, preambleLength, combinationSize);
var d = new Deque <long>();
var i = 0;
while (i < numbers.Length)
{
var sum = d.Sum();
if (sum < expectedSum)
{
d.AddBack(numbers[i++]);
}
else if (sum > expectedSum)
{
d.PopFront();
}
else
{
break;
}
}
return(d.Min() + d.Max());
}
public static void Main()
{
var nq = Console.ReadLine().Split().Select(int.Parse).ToArray();
var n = nq[0];
var q = nq[1];
Deque <Tuple <string, int> > queue = new Deque <Tuple <string, int> >();
for (int i = 0; i < n; i++)
{
var data = Console.ReadLine().Split();
queue.PushBack(new Tuple <string, int>(data[0], int.Parse(data[1])));
}
int elapsed = 0;
while (0 < queue.Count)
{
var elem = queue.PopFront();
var time = Min(elem.Item2, q);
elapsed += time;
if (time == elem.Item2)
{
Console.WriteLine($"{elem.Item1} {elapsed}");
}
else
{
queue.PushBack(new Tuple <string, int>(elem.Item1, elem.Item2 - time));
}
}
}
public void EnumerateDeque_Invalidation_PopFront()
{
List <int> coll = new List <int>()
{
4, 5, 8, 10, 2
};
Deque <int> deque = new Deque <int>(coll); //tests add
int index = 0;
try
{
foreach (int num in deque)
{
deque.PopFront();
Assert.AreEqual(num, coll[index]);
++index;
}
Assert.Fail();
}
catch (InvalidOperationException)
{
}
}
public override T PopFront()
{
lock (root)
{
return(deque.PopFront());
}
}
public int Pop()
{
if (max.Front == data.Front)
{
max.PopFront();
}
return(data.PopFront());
}
private void execute()
{
while (m_eventDeque.Count > 0)
{
var eventContext = m_eventDeque.PopFront();
Dispatch(eventContext.CurrentEvent, eventContext.Args);
}
}
public void RemoveFront()
{
deq.AddFront(1);
deq.AddFront(2);
deq.AddRear(3);
var result = deq.PopFront();
Assert.Equal(2, result);
}
/// <summary>
/// Puts a path renderer at the back of the list. Evicts the front of the list if at capacity.
/// </summary>
/// <param name="pathRenderer">The path renderer to put at the back of the list.</param>
private void PushBack(PathRenderer pathRenderer)
{
if (pathList.Count >= CAPACITY)
{
pathList.PopFront().SetVisible(false);
}
pathList.PushBack(pathRenderer);
pathRenderer.SetVisible(outlinePath);
}
public Test FrontDrainingDequeGetsEmptied()
{
while (deque.Count > 0)
{
deque.PopFront();
}
return(Assert.That(deque).Is.Empty&&
Assert.That(deque.Count).Is.Zero);
}
public void PopFrontTest()
{
var list = new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 };
var deque = new Deque <int>(list);
Assert.AreEqual(0, deque.PopFront());
Assert.AreEqual(8, deque.Count);
Assert.AreEqual(9, deque.Capacity);
Assert.AreEqual(1, deque[0]);
}
public override void ActionTaken(Query query)
{
if (actionQueue.Count != 0)
{
actionQueue.PopFront();
}
if (query == Query.Move)
{
MapManager.AddNoiseSourse(new NoiseSource(NoiseType.StepsOfGuard, 1, 4, Position, "S"));
}
}
public Token Read()
{
if (FillQueue(0))
{
return(Queue.PopFront());
}
else
{
return(Token.EOF);
}
}
private void EnforceSizeLimit()
{
Debug.Assert(undoGroupDepth == 0);
while (undostack.Count > sizeLimit)
{
undostack.PopFront();
}
while (redostack.Count > sizeLimit)
{
redostack.PopFront();
}
}
public void TestRemoveAt()
{
Deque<int> test = new Deque<int>(6);
test.Add(0);
test.Add(1);
test.Add(2);
test.Add(3);
test.Add(4);
test.Add(5);
test.PopFront();
test.PopFront();
test.Add(6);
test.Add(7);
test.RemoveAt(2);
int[] arr = test.ToArray();
CollectionAssert.AreEqual(arr, new int[] { 2, 3, 5, 6, 7 });
Assert.AreEqual(test.Count, 5);
}
// Use this for initialization
void Awake()
{
testDeque = new Deque <int>(N);
//Test push, pop, and get when initial size is not exceeded
testDeque.PushFront(1);
testDeque.PushBack(-1);
testDeque.PushFront(2);
testDeque.PushFront(-2);
testDeque.PushFront(3);
Debug.Assert(testDeque.Get(0) == 3);
Debug.Assert(testDeque.Get(1) == -2);
Debug.Assert(testDeque.Get(2) == 2);
Debug.Assert(testDeque.Get(3) == 1);
Debug.Assert(testDeque.Get(4) == -1);
Debug.Assert(testDeque.PopFront() == 3);
Debug.Assert(testDeque.PopBack() == -1);
Debug.Assert(testDeque.PopBack() == 1);
Debug.Assert(testDeque.PopBack() == 2);
Debug.Assert(testDeque.PopFront() == -2);
}
public void TestRemoveAt()
{
Deque <int> test = new Deque <int>(6);
test.Add(0);
test.Add(1);
test.Add(2);
test.Add(3);
test.Add(4);
test.Add(5);
test.PopFront();
test.PopFront();
test.Add(6);
test.Add(7);
test.RemoveAt(2);
int[] arr = test.ToArray();
CollectionAssert.AreEqual(arr, new int[] { 2, 3, 5, 6, 7 });
Assert.AreEqual(test.Count, 5);
}
private static void TestPopFront(Deque <int> deque)
{
deque.Clear();
PopulateDequePushBack(deque);
for (int i = 0; i < ElementCount; i++)
{
int j = deque.PopFront();
Debug.Assert(j == i);
}
Debug.Assert(deque.Count == 0);
}
public void AddValue(float value)
{
while (_buffer.Count != 0 && _buffer.Front.value <= value)
{
_buffer.PopFront();
}
_buffer.PushFront(new IndexValuePair(_count, value));
_count++;
while (_buffer.Back.index < (_count - _history))
{
_buffer.PopBack();
}
}
private static void TestPopFront(Deque<int> deque)
{
deque.Clear();
PopulateDequePushBack(deque);
int j;
for(int i = 0; i < ElementCount; i++)
{
j = (int)deque.PopFront();
System.Diagnostics.Debug.Assert(j == i);
}
System.Diagnostics.Debug.Assert(deque.Count == 0);
}
void Solve()
{
var K = F();
var es = new List <E> [K];
for (var i = 0; i < K; i++)
{
es[i] = new List <E> {
new E((i + 1) % K, true), new E((i * 10) % K, false)
}
}
;
var d = new int[K];
for (var i = 0; i < K; i++)
{
d[i] = MOD;
}
d[1] = 0;
var deq = new Deque <int>();
deq.PushFront(1);
while (deq.Count > 0)
{
var u = deq.PopFront();
foreach (var t in es[u])
{
int v = t.T, cost = t.IsHeavy ? 1 : 0, tmp = d[u] + cost;
if (d[v] > tmp)
{
d[v] = tmp;
if (t.IsHeavy)
{
deq.PushBack(v);
}
else
{
deq.PushFront(v);
}
}
}
}
Console.WriteLine(d[0] + 1);
}
}
private void HandleSelectionChange()
{
Key prevSelected = selectedKey;
if (Vector3.Distance(selectedKey.transform.position, selectedTransform.position) > selectedKey.transform.localScale.y / 2 + KeySpacing)
{
if (selectedKey.transform.localPosition.y > selectedTransform.localPosition.y && selectedKey.Note > 0)
{
Key lowestKey = keys.PeekBack();
selectedKeyOffset -= (selectedKey.transform.localScale.y + KeySpacing);
keys.PopFront().GetComponent <Poolable>().ReturnToPool();
Key nextKey = keyPool.GetObject(GetNextKeyPosition(lowestKey, -1), lowestKey.transform.rotation).GetComponent <Key>();
nextKey.transform.SetParent(transform);
nextKey.Note = lowestKey.Note - 1;
keys.PushBack(nextKey);
}
else if (selectedKey.transform.localPosition.y < selectedTransform.localPosition.y && selectedKey.Note < 127)
{
selectedKeyOffset += (selectedKey.transform.localScale.y + KeySpacing);
keys.PopBack().GetComponent <Poolable>().ReturnToPool();
Key highestKey = keys.PeekFront();
Key nextKey = keyPool.GetObject(GetNextKeyPosition(highestKey, 1), highestKey.transform.rotation).GetComponent <Key>();
nextKey.transform.SetParent(transform);
nextKey.Note = highestKey.Note + 1;
keys.PushFront(nextKey);
}
selectedKey = keys.Get(HalfKeys);
}
if (!selectedKey.Equals(prevSelected))
{
PlayHapticTick();
lastNoteSelected = selectedKey.Note;
if (NoteSelected != null)
{
noteArgs.Note = selectedKey.Note;
NoteSelected(this, noteArgs);
}
}
}
int BFS01(int S, int T, List <Edge>[] E)
{
var deq = new Deque <long>();
int N = E.Length;
var minCost = new int[N];
for (int i = 0; i < N; i++)
{
minCost[i] = INF;
}
minCost[S] = 0;
deq.PushBack((long)S << 32);
while (deq.Count > 0)
{
long mask = deq.PopFront();
int a = (int)(mask >> 32), cost = (int)mask;
if (cost > minCost[a])
{
continue;
}
if (a == T)
{
return(cost);
}
foreach (var e in E[a])
{
if (minCost[e.to] == INF)
{
minCost[e.to] = minCost[a] + e.cost;
if (e.cost == 0)
{
deq.PushFront(((long)e.to << 32) + minCost[a]);
}
else
{
deq.PushBack(((long)e.to << 32) + minCost[a] + 1);
}
}
}
}
return(INF);
}
public void Solve()
{
var n = ri;
var L = rl;
var deq = new Deque <X>();
double sum = 0;
for (int _ = 0; _ < n; _++)
{
var x = new X(ri, ri);
sum += x.temp * x.vol;
if (deq.Count == 0)
{
deq.PushBack(x);
}
else
{
//???????
{
var v = x.vol;
while (v > 0)
{
var p = deq.PopFront(); sum -= p.temp * p.vol;
var mi = Math.Min(v, p.vol);
p.vol -= mi; v -= mi;
if (p.vol > 0)
{
deq.PushFront(p); sum += p.temp * p.vol;
}
}
}
while (deq.Count > 0 && deq[deq.Count - 1].temp >= x.temp)
{
var p = deq.PopBack();
var nv = x.vol + p.vol;
x = new X((x.temp * x.vol + p.temp * p.vol) / nv, nv);
}
deq.PushBack(x);
}
Console.WriteLine("{0:0.000000000000}", 1.0 * sum / L);
}
}
public void PushFront()
{
for (int i = 0; i < 100; i++)
{
_buffer.PushBack(i);
Assert.That(_buffer.Back, Is.EqualTo(i));
Assert.That(_buffer.Count, Is.EqualTo(i + 1));
for (int j = 0; j <= i; j++)
{
Assert.That(j, Is.EqualTo(_buffer[j]));
}
}
for (int i = 0; i < 100; i++)
{
int value;
Assert.That(_buffer.Front, Is.EqualTo(i));
_buffer.PopFront(out value);
Assert.That(i, Is.EqualTo(value));
}
}
void OnGUI()
{
if (GUILayout.Button("Push back"))
{
_deque.PushBack(_i++);
Log();
}
if (GUILayout.Button("Push front"))
{
_deque.PushFront(_i++);
Log();
}
if (GUILayout.Button("Pop back"))
{
Debug.Log($"Pop back:{_deque.PopBack()}");
Log();
}
if (GUILayout.Button("Pop front"))
{
Debug.Log($"Pop front:{_deque.PopFront()}");
Log();
}
}
public void RecordSample(int sampleCount)
{
float inclusiveMs = ticksToMs(accumulatedInclusiveTicks / sampleCount);
float exclusiveMs = ticksToMs(accumulatedExclusiveTicks / sampleCount);
ClearSample();
switch (units)
{
case GraphUnits.Miliseconds:
inclusive.PushBack(inclusiveMs);
exclusive.PushBack(exclusiveMs);
inclusiveMax.AddValue(inclusiveMs);
exclusiveMax.AddValue(exclusiveMs);
break;
case GraphUnits.Framerate:
inclusive.PushBack(1000.0f / inclusiveMs);
exclusive.PushBack(1000.0f / exclusiveMs);
inclusiveMax.AddValue(1000.0f / inclusiveMs);
exclusiveMax.AddValue(1000.0f / exclusiveMs);
break;
default:
throw new Exception("Unexpected units type");
}
while (inclusive.Count > maxHistory)
{
inclusive.PopFront();
}
while (exclusive.Count > maxHistory)
{
exclusive.PopFront();
}
}
private void CreateNFA(string input)
{
Stack<char> operatorStack = new Stack<char>();
var expandedInput = ConcatExpand(input);
for (int i = 0; i < expandedInput.Length; i++)
{
char c = expandedInput[i];
if (char.IsLetterOrDigit(c))
Push(c);
else if (operatorStack.Count == 0)
operatorStack.Push(c);
else if (c == '(')
operatorStack.Push(c);
else if (c == ')')
{
while (operatorStack.Peek() != '(')
{
var op = operatorStack.Pop();
if (op == (char)8)
Concat();
else if (op == '*')
Star();
else if (op == '|')
Union();
else
return;
}
operatorStack.Pop(); //pop up '('
}
else
{
while (operatorStack.Count != 0 && Presedece(c, operatorStack.Peek()))
{
var op = operatorStack.Pop();
if (op == (char)8)
Concat();
else if (op == '*')
Star();
else if (op == '|')
Union();
else
return;
}
operatorStack.Push(c);
}
}
while (operatorStack.Count > 0)
{
var op = operatorStack.Pop();
if (op == (char)8)
Concat();
else if (op == '*')
Star();
else if (op == '|')
Union();
else
return;
}
if (_operandStack.Count == 0)
return;
var A = _operandStack.Pop();
A.GetLastState().AcceptState = true;
#if DEBUG
if (A.GetFirstState() != null)
{
using (var stream = File.OpenWrite("NFA.txt"))
{
using (var sw = new StreamWriter(stream))
{
HashSet<int> processedStates = new HashSet<int>();
Deque<State> unprocessedStates = new Deque<State>();
unprocessedStates.PushBack(A.GetFirstState());
while(unprocessedStates.Count>0)
{
var state = unprocessedStates.PopFront();
var labels = state.GetLabels();
foreach (var label in labels)
{
var destinationStates = state.GetStates(label);
if (destinationStates != null)
{
foreach (var dest in destinationStates)
{
sw.WriteLine("Start:" + state.ToString() + "," + "End:" + dest.ToString() + "," + "Label:" + (label!=EPSILON? label.ToString():"EPSILON"));
if (!processedStates.Contains(dest.StateId))
{
unprocessedStates.PushBack(dest);
}
}
}
}
processedStates.Add(state.StateId);
}
}
}
}
#endif
_NFA = A;
}
