public void Clear() { _buffer.PushBack(1); _buffer.PushFront(1); Assert.That(_buffer.Count, Is.EqualTo(2)); _buffer.Clear(); Assert.That(_buffer.Count, Is.EqualTo(0)); }
public Test FrontPushesItemsAtFront() { deque.PushFront("extern"); deque.PushFront("void"); deque.PushFront("stackalloc"); return(Assert.That(deque.Take(3)).Is.SequenceEqualTo("stackalloc", "void", "extern")); }
public void ReleasedAfterPushFront() { Deque dq = new Deque(); Assert.IsTrue(dq.MutexAvailable()); dq.PushFront("abc"); Assert.IsTrue(dq.MutexAvailable()); dq.PushFront("def"); Assert.IsTrue(dq.MutexAvailable()); }
public void TestPeekFrontBack() { var deque = new Deque <int>(); deque.PushFront(1); deque.PushFront(2); Assert.AreEqual(2, deque.PeekFront()); Assert.AreEqual(1, deque.PeekBack()); Assert.AreEqual(2, deque.Count); }
public void Resize(uint Size) { //m_Cache.Resize(Size, uint.MaxValue); m_Cache.Clear(); for (int x = 0; x < Size; x++) { m_Cache.PushFront(uint.MaxValue); } }
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); }
public static void Main() { var s = Console.ReadLine(); var q = int.Parse(Console.ReadLine()); Deque <char> deque = new Deque <char>(); foreach (var c in s) { deque.PushBack(c); } int front = 0; for (int i = 0; i < q; i++) { var query = Console.ReadLine(); if (query == "1") { front ^= 1; } else { if (query[2] == '1' ^ front == 0) { deque.PushBack(query[4]); } else { deque.PushFront(query[4]); } } } Console.WriteLine(string.Join("", front == 0 ? deque : deque.Reverse())); }
private static void FrontPushAll(Deque <string> deque, params string[] items) { foreach (string item in items) { deque.PushFront(item); } }
public void EnumerateDeque_Invalidation_PushFront() { 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.PushFront(4); Assert.AreEqual(num, coll[index]); ++index; } Assert.Fail(); } catch (InvalidOperationException) { } }
public override void PushFront(T item) { lock (root) { deque.PushFront(item); } }
/// <summary> /// Executes the delegate on the main thread that this object executes on. /// </summary> /// <param name="method"> /// A Delegate to a method that takes parameters of the same number and /// type that are contained in args. /// </param> /// <param name="args"> /// An array of type Object to pass as arguments to the given method. /// </param> /// <returns> /// An IAsyncResult interface that represents the asynchronous operation /// started by calling this method. /// </returns> /// <remarks> /// The delegate is placed at the beginning of the queue. Its invocation /// takes priority over delegates already in the queue. /// </remarks> public IAsyncResult BeginInvokePriority(Delegate method, params object[] args) { #region Require if (disposed) { throw new ObjectDisposedException("DelegateQueue"); } else if (method == null) { throw new ArgumentNullException(); } #endregion DelegateQueueAsyncResult result; // If BeginInvokePriority was called from a different thread than the one // in which the DelegateQueue is running. if (InvokeRequired) { result = new DelegateQueueAsyncResult(this, method, args, false, NotificationType.BeginInvokeCompleted); lock (lockObject) { // Put the method at the front of the queue. delegateDeque.PushFront(result); Monitor.Pulse(lockObject); } } // Else BeginInvokePriority was called from the same thread in which the // DelegateQueue is running. else { result = new DelegateQueueAsyncResult(this, method, args, true, NotificationType.None); // The method is invoked here instead of placing it in the // queue. The reason for this is that if EndInvoke is called // from the same thread in which the DelegateQueue is running and // the method has not been invoked, deadlock will occur. result.Invoke(); } return(result); }
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); } }
/// <summary> /// Puts a path renderer at the front of the list. Evicts the back of the list if at capacity. /// </summary> /// <param name="pathRenderer">The path renderer to put at the front of the list.</param> private void PushFront(PathRenderer pathRenderer) { if (pathList.Count >= CAPACITY) { pathList.PopBack().SetVisible(false); } pathList.PushFront(pathRenderer); pathRenderer.SetVisible(outlinePath); }
public void PushFrontTest() { var list = new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 }; var deque = new Deque <int>(list); deque.PushFront(9); Assert.AreEqual(10, deque.Count); Assert.AreEqual(18, deque.Capacity); Assert.AreEqual(9, deque[0]); }
void Init(int selectedNote) { if (selectedNote < 0) { selectedNote = lastNoteSelected; } gameObject.SetActive(true); selectedKey = keyPool.GetObject(selectedTransform.position, selectedTransform.rotation).GetComponent <Key>(); selectedKey.Note = selectedNote; selectedKey.transform.SetParent(transform); keys.PushFront(selectedKey); InitHalfKeyboard(1); InitHalfKeyboard(-1); selectedKeyOffset = 0; maxKeyPositionY = NoteToKeyPosition(127); selectedKeyPositionY = NoteToKeyPosition(selectedNote); }
public void TestPushFrontOnEmpty() { //arrange Deque dq = new Deque(); //act dq.PushFront("abcd"); //assert Assert.AreSame(dq.head, dq.tail); Assert.IsNotNull(dq.head); Assert.AreEqual(dq.head.data, "abcd"); }
// 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 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(); } }
public void TestOtherQueueOrder() { // queue-like ordering (FIFO) can also be achieved using push_front and pop_back Deque dq = new Deque(); for (int i = 0; i < 10; i++) { dq.PushFront(i); } for (int i = 0; i < 10; i++) { int j = (int)dq.PopBack(); Assert.AreEqual(i, j); } }
public void TestStackOrder() { // stack-like (LIFO) ordering is achieved using push_front and pop Deque dq = new Deque(); for (int i = 0; i < 10; i++) { dq.PushFront(i); } for (int i = 9; i >= 0; i--) { int j = (int)dq.Pop(); Assert.AreEqual(i, j); } }
public override void ActionRejected(Query query) { switch (query) { case Query.Move: var target = Position + GameState.ConvertDirectionToSize[Direction]; if (!MapManager.InBounds(target)) { return; } if (MapManager.Map[target.X, target.Y].ObjectContainer.ShowDecor() is ClosedDoor) { actionQueue.PushFront(Query.Interaction); } break; } }
private static void PopulateDequePushFront(Deque deque) { deque.Clear(); for (int i = 0; i < ElementCount; i++) { deque.PushFront(i); } Debug.Assert(deque.Count == ElementCount); int j = ElementCount - 1; foreach (int i in deque) { Debug.Assert(i == j); j--; } }
private static void PopulateDequePushFront(Deque deque) { deque.Clear(); for(int i = 0; i < ElementCount; i++) { deque.PushFront(i); } System.Diagnostics.Debug.Assert(deque.Count == ElementCount); int j = ElementCount - 1; foreach(int i in deque) { System.Diagnostics.Debug.Assert(i == j); j--; } }
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); } }
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() { Scan(); var ans = new int[K]; var q = new Deque <S>(); q.PushBack(new S(1, 1)); while (q.Count > 0) { var t = q.PopBack(); if (ans[t.Num] != 0) { continue; } ans[t.Num] = t.Sum; q.PushBack(new S((t.Num * 10) % K, t.Sum)); q.PushFront(new S((t.Num + 1) % K, t.Sum + 1)); } Console.WriteLine(ans[0]); }
public static void Main() { int n = int.Parse(Console.ReadLine()); var a = Console.ReadLine().Split().Select(int.Parse).ToArray(); Deque <int> deque = new Deque <int>(); for (int i = 0; i < a.Length; i++) { if (((i ^ n) & 1) == 0) { deque.PushBack(a[i]); } else { deque.PushFront(a[i]); } } Console.WriteLine(string.Join(" ", deque)); }
public static void Solve() { var N = Scanner.Scan <int>(); var S = Scanner.ScanLine(); var deq = new Deque <int>(); deq.PushBack(N); foreach (var(c, i) in S.Select((x, i) => (x, i)).Reverse()) { if (c == 'L') { deq.PushBack(i); } else { deq.PushFront(i); } } Console.WriteLine(string.Join(" ", deq)); }
public void Deque_Add_FrontExtension() { List <int> coll = new List <int>() { 4, 5, 8, 10, 2, 5, 6, 7 }; Deque <int> deque = new Deque <int>(coll); //tests add coll.Insert(0, 5); deque.PushFront(5); Assert.AreEqual(coll.Count, deque.Count); int index = 0; foreach (int a in deque) { Assert.AreEqual(coll[index], a); ++index; } }
public void Deque_ExtendRight_thenLeft() { List <int> coll = new List <int>(); Deque <int> deque = new Deque <int>(); //tests add for (int i = 0; i < 3 * 56; i++) //see default sizes; might have changed { coll.Add(i); deque.Add(i); } deque.PushFront(50); coll.Insert(0, 50); int index = 0; foreach (int a in deque) { Assert.AreEqual(coll[index], a); ++index; } }
public static void Main() { string s = Console.ReadLine(); bool reversed = false; Deque <char> deq = new Deque <char>(); foreach (var c in s) { if (c == 'R') { reversed = !reversed; } else { if (reversed) { deq.PushFront(c); } else { deq.PushBack(c); } } } Stack <char> res = new Stack <char>(); foreach (var item in reversed ? deq.Reverse() : deq) { if (res.Any() && item == res.Peek()) { res.Pop(); } else { res.Push(item); } } Console.WriteLine(res.Reverse().ToArray()); }