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