Merge pull request amejiarosario#72 from amejiarosario/feat/queue-interview-questions

Feat/queue interview questions

Author: amejiarosario

book/D-interview-questions-solutions.asc

@@ -47,7 +47,7 @@ include::interview-questions/max-subarray.js[tag=description]
 include::interview-questions/max-subarray.js[tag=solution]
 ----
 
-The runtime is `O(n)` and space complexity of `O(1)`.
+The runtime is `O(n)` and the space complexity of `O(1)`.
 
 
 
@@ -90,11 +90,10 @@ Algorithm:
 
 [source, javascript]
 ----
-include::interview-questions/buy-sell-stock.js[tag=description]
-include::interview-questions/buy-sell-stock.js[tag=solution]
+include::interview-questions/buy-sell-stock.js[tag=description,solution]
 ----
 
-The runtime is `O(n)` and space complexity of `O(1)`.
+The runtime is `O(n)` and the space complexity of `O(1)`.
 
 
 
@@ -126,8 +125,7 @@ Another case to take into consideration is that lists might have different lengt
 
 [source, javascript]
 ----
-include::interview-questions/merge-lists.js[tag=description]
-include::interview-questions/merge-lists.js[tag=solution]
+include::interview-questions/merge-lists.js[tag=description,solution]
 ----
 
 Notice that we used a "dummy" node or "sentinel node" to have some starting point for the final list.
@@ -159,7 +157,7 @@ include::interview-questions/linkedlist-same-data.js[tag=hasSameDataBrute1]
 
 Notice that the problem mentions that lists could be huge (millions of nodes). If the first character on each list is different, we are unnecessarily computing millions of nodes, when a straightforward check will do the job.
 
-A better way to solve this problem is iterating over each character on both lists, and when we found mistmatch, we return `false` immediately. If they are the same, we still have to visit all of them.
+A better way to solve this problem is iterating over each character on both lists, and when we found a mismatch, we return `false` immediately. If they are the same, we still have to visit all of them.
 
 *Algorithm*:
 
@@ -172,12 +170,11 @@ A better way to solve this problem is iterating over each character on both list
 
 [source, javascript]
 ----
-include::interview-questions/linkedlist-same-data.js[tag=description]
-include::interview-questions/linkedlist-same-data.js[tag=solution]
+include::interview-questions/linkedlist-same-data.js[tag=description,solution]
 ----
 
 The function `findNextPointerIndex` is a helper to navigate each character on a linked list.
-Notice, that we increase the index (`i + 1`) on each iteration.
+Notice that we increase the index (`i + 1`) on each iteration.
 If the index overflows, it moves to the next node and reset the index to zero.
 
 
@@ -207,7 +204,7 @@ This is a parsing problem, and usually, stacks are good candidates for them.
 
 *Algorithm*:
 
-- Create a mapping for each opening bracket, to its closing counterpart.
+- Create a mapping for each opening bracket to its closing counterpart.
 - Iterate through the string
     - When we found an opening bracket, insert the corresponding closing bracket into the stack.
     - When we found a closing bracket, pop from the stack and make sure it corresponds to the current character.
@@ -267,6 +264,75 @@ The stack contains the indexes rather than the temperatures themselves.
 
 
 
+:leveloffset: +1
+
+=== Solutions for Queue Questions
+(((Interview Questions Solutions, Queue)))
+
+:leveloffset: -1
+
+
+[#queue-q-recent-counter]
+include::content/part02/queue.asc[tag=queue-q-recent-counter]
+
+We are asked to keep track of the request's count only within a given time window. A queue is a perfect application for this. We can add any new request to the	 Queue. Also, we need to check if the oldest element is outside the time window. If so, we remove it from the queue.
+
+*Algorithm*:
+
+- Enqueue new requests.
+- Take a `peek` at the oldest request in the queue.
+- While `current timestamp - oldest timestamp`, dequeue the oldest.
+- Return the length of the queue.
+
+*Implementation*:
+
+[source, javascript]
+----
+include::interview-questions/recent-counter.js[tag=description,solution]
+----
+
+Notice that we enqueue every request, and then we check all the ones that have "expire" and remove them from the queue.
+
+*Complexity Analysis*:
+
+- Time: `O(n)`, where `n` is the number of requests. One Enqueue/Dequeue operation is O(1). However, we might run into a worst-case where all requests have to be dequeued.
+- Space: `O(W)`, where `W` is the time window. We can have at most W requests in the queue since they are in increasing order without duplicates.
+
+
+[#queue-q-design-snake-game]
+include::content/part02/queue.asc[tag=queue-q-design-snake-game]
+
+This game is perfect to practice working with Queues. There are at least two opportunities to use a Queue. You can enqueue the food location, and also you can keep the snake's body parts on a Queue. We insert a new position into the snake's queue on every move and dequeue the last location to indicate the snake moved. Every time the snake eats food, it grows one more unit. The food gets dequeue, and we place the next food location (if any).
+
+*Algorithm*:
+
+- Based on the snake's head current position, calculate the next location based on the given move `direction`.
+- If the new position is outside the boundaries, it's game over (return -1).
+- If the new location has food, remove that eaten food from its queue and place the next food on the map (if any).
+- If the new position doesn't have food, remove the tail of the snake since it moved.
+- If the snake new position hits itself, game over (return -1). To make this check, we have 2 options:
+    - Queue: we can visit all the elements on the snake's queue (body) and check if a new position collides. That's `O(n)`
+    - Set: we can maintain a `set` with all the snake locations, so the check is `O(1)`.
+- Move the snake's head to a new location (enqueue)
+- Return the score (snake's length - 1);
+
+*Implementation*:
+
+[source, javascript]
+----
+include::interview-questions/design-snake-game.js[tag=description,solution]
+----
+
+As you can see, we opted for using a set to trade speed for memory.
+
+*Complexity Analysis*:
+
+- Time: `O(1)`. Insert/Remove from Queue is constant time. Check for body collisions is `O(1)` when using a set. If instead of a set, you traversed the snake's queue to find a collision, it would be `O(n)`.  Here`n` is the snake's max length, which is the size of the screen (height x width).
+- Space: `O(n + m)`. `m` is the number of food items, and `n` is the snake's maximum size (height x width).
+
+
+
+
 // [#linkedlist-q-FILENAME]
 // include::content/part02/linked-list.asc[tag=linkedlist-q-FILENAME]
 
@@ -293,4 +359,3 @@ The stack contains the indexes rather than the temperatures themselves.
 
 // - Time: `O(?)`. WHY?
 // - Space: `O(?)`. WHY?
-

book/config

@@ -276,13 +276,24 @@ To sum up, the time complexity of an array is:
 |===
 //end::table
 
-==== Interview Questions
+==== Practice Questions
 (((Interview Questions, Arrays)))
 
 // tag::array-q-max-subarray[]
 ===== Max Subarray
 
 *AR-1*) _Given an array of integers, find the maximum sum of consecutive elements (subarray)._
+
+Examples:
+
+[source, javascript]
+----
+maxSubArray([1, -3, 10, -5]); // 10 (taking only 10)
+maxSubArray([-3, 4,-1, 2, 1, -5]); // 6 (sum [4,-1, 2, 1])
+maxSubArray([-2, 1, -3, 4, -1, 3, 1]); // 7 (sum [4,-1, 3, 1])
+----
+
+_Seen in interviews at: Amazon, Apple, Google, Microsoft, Facebook_
 // end::array-q-max-subarray[]
 
 [source, javascript]
@@ -298,6 +309,18 @@ _Solution: <<array-q-max-subarray>>_
 ===== Best Time to Buy and Sell an Stock
 
 *AR-2*) _You are given an array of integers. Each value represents the closing value of the stock on that day. You are only given one chance to buy and then sell. What's the maximum profit you can obtain? (Note: you have to buy first and then sell)_
+
+Examples:
+
+[source, javascript]
+----
+maxProfit([1, 2, 3]) // 2 (buying at 1 and selling at 3)
+maxProfit([3, 2, 1]) // 2 (no buys)
+maxProfit([5, 10, 5, 10]) // 5 (buying at 5 and selling at 10)
+
+----
+
+_Seen in interviews at: Amazon, Facebook, Bloomberg_
 // end::array-q-buy-sell-stock[]
 
 [source, javascript]

book/content/part02/array.asc

@@ -286,16 +286,22 @@ Use a doubly linked list when:
 
 For the next two linear data structures <<part02-linear-data-structures#stack>> and <<part02-linear-data-structures#queue>>, we are going to use a doubly-linked list to implement them. We could use an array as well, but since inserting/deleting from the start performs better with linked-lists, we will use that.
 
-==== Interview Questions
-(((Interview Questions, Arrays)))
-
-
-
+==== Practice Questions
+(((Interview Questions, Linked Lists)))
 
 // tag::linkedlist-q-merge-lists[]
 ===== Merge Linked Lists into One
 
 *LL-1*) _Merge two sorted lists into one (and keep them sorted)_
+
+Examples:
+
+----
+mergeTwoLists(2->3->4, 1->2); // 1->2->2->3->4
+mergeTwoLists(2->3->4,null); // 2->3->4
+----
+
+_Seen in interviews at: Amazon, Adobe, Microsoft, Google_
 // end::linkedlist-q-merge-lists[]
 
 [source, javascript]
@@ -313,7 +319,17 @@ _Solution: <<linkedlist-q-merge-lists>>_
 // tag::linkedlist-q-linkedlist-same-data[]
 ===== Check if two strings lists are the same
 
-*LL-2*) _Given two linked lists with strings, check if are the same_
+*LL-2*) _Given two linked lists with strings, check if the data is equivalent._
+
+Examples:
+
+----
+hasSameData(he->ll->o, hel->lo); // true
+hasSameData(hello, hel->lo); // true
+hasSameData(he->ll->o, h->i); // false
+----
+
+_Seen in interviews at: Facebook_
 // end::linkedlist-q-linkedlist-same-data[]
 
 [source, javascript]

book/content/part02/linked-list.asc

@@ -14,11 +14,11 @@ A queue is a linear data structure where the data flows in a *First-In-First-Out
 .Queue data structure is like a line of people: the First-in, is the First-out
 image::image30.png[image,width=528,height=171]
 
-A queue is like a line of people at the bank; the person that arrived first is the first to go out as well.
+A queue is like a line of people at the bank; the person who arrived first is the first to go out.
 
 Similar to the stack, we only have two operations (insert and remove). In a Queue, we add elements to the back of the list and remove it from the front.
 
-We could use an array or a linked list to implement a Queue. However, it is recommended only to use a linked list. Why? An array has a linear runtime _O(n)_ to remove an element from the start while a linked list has constant time _O(1)_.
+We could use an array or a linked list to implement a Queue. However, it is recommended only to use a linked list. Why? An array has a linear runtime _O(n)_ to remove an element from the start, while a linked list has constant time _O(1)_.
 
 .Queue's constructor
 [source, javascript]
@@ -56,15 +56,15 @@ As discussed, this operation has a constant runtime.
 
 ==== Implementation usage
 
-We can use our Queue class like follows:
+We can use our Queue class as follows:
 
 .Queue usage example
 [source, javascript]
 ----
 include::{codedir}/data-structures/queues/queue.js[tag=snippet, indent=0]
 ----
 
-You can see that the items are dequeued in the same order they were added, FIFO (first-in, first out).
+You can see that the items are dequeued in the same order they were added, FIFO (first-in, first-out).
 
 ==== Queue Complexity
 
@@ -81,3 +81,66 @@ As an experiment, we can see in the following table that if we had implemented t
 |===
 // end::table[]
 indexterm:[Runtime, Linear]
+
+
+==== Practice Questions
+(((Interview Questions, Queue)))
+
+
+// tag::queue-q-recent-counter[]
+===== Recent Counter
+
+*QU-1*) _Design a class that counts the most recent requests within a time window._
+
+Example:
+
+[source, javascript]
+----
+const counter = new RecentCounter(10); // The time window is 10 ms.
+counter.request(1000); // 1 (first request, it always counts)
+counter.request(3000); // 1 (last requests was 2000 ms ago, > 10ms, so doesn't count)
+counter.request(3100); // 1 (last requests was 100 ms ago, > 10ms, so doesn't count)
+counter.request(3105); // 2 (last requests was 5 ms ago, <= 10ms, so it counts)
+----
+
+_Seen in interviews at: Google, Bloomberg, Yandex_
+// end::queue-q-recent-counter[]
+
+
+[source, javascript]
+----
+include::../../interview-questions/recent-counter.js[tag=description]
+  // write you code here
+}
+----
+
+_Solution: <<queue-q-recent-counter>>_
+
+
+// tag::queue-q-design-snake-game[]
+===== Design Snake Game
+
+*QU-2*) _Design the `move` function for the snake game. The move function returns an integer representing the current score. If the snake goes out of the given height and width or hit itself the game is over and return `-1`._
+
+Example:
+
+[source, javascript]
+----
+const snakeGame = new SnakeGame(4, 2, [[1, 2], [0, 1]]);
+expect(snakeGame.move('R')).toEqual(0); //  0
+expect(snakeGame.move('D')).toEqual(0); //  0
+expect(snakeGame.move('R')).toEqual(1); //  1 (ate food1)
+expect(snakeGame.move('U')).toEqual(1); //  1
+expect(snakeGame.move('L')).toEqual(2); //  2 (ate food2)
+expect(snakeGame.move('U')).toEqual(-1); // -1 (hit wall)
+----
+
+_Seen in interviews at: Amazon, Bloomberg, Apple_
+// end::queue-q-design-snake-game[]
+
+[source, javascript]
+----
+include::../../interview-questions/design-snake-game.js[tag=description]
+----
+
+_Solution: <<queue-q-design-snake-game>>_

book/content/part02/queue.asc

@@ -87,17 +87,26 @@ Implementing the stack with an array and linked list would lead to the same time
 It's not very common to search for values on a stack (other Data Structures are better suited for this). Stacks are especially useful for implementing <<part03-graph-data-structures#dfs-tree, Depth-First Search>>.
 
 
-==== Interview Questions
-(((Interview Questions, Arrays)))
-
-
-
-
+==== Practice Questions
+(((Interview Questions, Stack)))
 
 // tag::stack-q-valid-parentheses[]
 ===== Validate Parentheses / Braces / Brackets
 
 *ST-1*) _Given an string with 3 types of brakets: `()`, `{}`, and `[]`. Validate they are properly closed and opened._
+
+Examples:
+
+[source, javascript]
+----
+isParenthesesValid('(){}[]'); // true
+isParenthesesValid('('); // false (closing parentheses is missing)
+isParenthesesValid('([{}])'); // true
+isParenthesesValid('[{]}'); // false (brakets are not closed in the right order)
+isParenthesesValid('([{)}]'); // false (closing is out of order)
+----
+
+_Seen in interviews at: Amazon, Bloomberg, Facebook, Citadel_
 // end::stack-q-valid-parentheses[]
 
 [source, javascript]
@@ -117,6 +126,16 @@ _Solution: <<stack-q-valid-parentheses>>_
 ===== Daily Temperaturs
 
 *ST-2*) _Given an array of integers from 30 to 100 (daily temperatures), return another array that for each day in the input, tells you how many days you would have to wait until a warmer temperature. If no warmer temperature is possible then return `0` for that element._
+
+Examples:
+
+[source, javascript]
+----
+dailyTemperatures([30, 28, 50, 40, 30]); // [2 (to 50), 1 (to 28), 0, 0, 0]
+dailyTemperatures([73, 69, 72, 76, 73, 100]); // [3, 1, 1, 0, 1, 100]
+----
+
+_Seen in interviews at: Amazon, Adobe, Cisco_
 // end::stack-q-daily-temperatures[]
 
 [source, javascript]

book/content/part02/stack.asc

@@ -5,8 +5,8 @@
  * for each elem from the input.
  *
  * @examples
- *    dailyTemperatures([30, 28, 50, 40, 30]); // [2, 1, 0, 0, 0]
- *    dailyTemperatures([73, 69, 72, 76, 73]); // [3, 1, 1, 0, 0]
+ *  dailyTemperatures([30, 28, 50, 40, 30]); // [2, 1, 0, 0, 0]
+ *  dailyTemperatures([73, 69, 72, 76, 73]); // [3, 1, 1, 0, 0]
  *
  * @param {number[]} t - Daily temperatures
  */

book/interview-questions/daily-temperatures.js

@@ -0,0 +1,86 @@
+const { Queue } = require('../../src/index');
+
+// tag::description[]
+/**
+ * The snake game stars with a snake of length 1 at postion 0,0.
+ * Only one food position is shown at a time. Once it's eaten the next one shows up.
+ * The snake can move in four directions up, down, left and right.
+ * If the snake go out of the boundaries (width x height) the game is over.
+ * If the snake hit itself the game is over.
+ * When the game is over, the `move` method returns -1 otherwise, return the current score.
+ *
+ * @example
+ *  const snakeGame = new SnakeGame(3, 2, [[1, 2], [0, 1]]);
+ *  snakeGame.move('R'); //  0
+ *  snakeGame.move('D'); //  0
+ *  snakeGame.move('R'); //  0
+ *  snakeGame.move('U'); //  1
+ *  snakeGame.move('L'); //  2
+ *  snakeGame.move('U'); // -1
+ */
+class SnakeGame {
+// end::description[]
+// tag::solution[]
+
+  // end::solution[]
+  // tag::description[]
+  /**
+   * Initialize game with grid's dimension and food order.
+   * @param {number} width - The screen width (grid's columns)
+   * @param {number} height - Screen height (grid's rows)
+   * @param {number[]} food - Food locations.
+   */
+  constructor(width, height, food) {
+    // end::description[]
+    // tag::solution[]
+    this.width = width;
+    this.height = height;
+    this.food = new Queue(food);
+    this.snake = new Queue([[0, 0]]);
+    this.tail = new Set([[0, 0]]);
+    this.dirs = {
+      U: [-1, 0], D: [1, 0], R: [0, 1], L: [0, -1],
+    };
+    // end::solution[]
+    // tag::description[]
+  }
+  // end::description[]
+
+  // tag::description[]
+  /**
+   * Move snake 1 position into the given direction.
+   * It returns the score or game over (-1) if the snake go out of bound or hit itself.
+   * @param {string} direction - 'U' = Up, 'L' = Left, 'R' = Right, 'D' = Down.
+   * @returns {number} - The current score (snake.length - 1).
+   */
+  move(direction) {
+    // end::description[]
+    // tag::solution[]
+    let [r, c] = this.snake.back(); // head of the snake
+    [r, c] = [r + this.dirs[direction][0], c + this.dirs[direction][1]];
+
+    // check wall collision
+    if (r < 0 || c < 0 || r >= this.height || c >= this.width) return -1;
+
+    const [fr, fc] = this.food.front() || []; // peek
+    if (r === fr && c === fc) {
+      this.food.dequeue(); // remove eaten food.
+    } else {
+      this.snake.dequeue(); // remove snake's if not food was eaten
+      this.tail.delete(this.tail.keys().next().value);
+    }
+
+    // check collision with snake's tail
+    if (this.tail.has(`${r},${c}`)) return -1; // O(1)
+
+    this.snake.enqueue([r, c]); // add new position
+    this.tail.add(`${r},${c}`);
+
+    return this.snake.size - 1; // return score (length of the snake - 1)
+    // end::solution[]
+    // tag::description[]
+  }
+}
+// end::description[]
+
+module.exports = { SnakeGame };

book/interview-questions/design-snake-game.js

@@ -0,0 +1,31 @@
+const { SnakeGame } = require('./design-snake-game');
+
+describe('Queue: Design Snake Game', () => {
+  it('should game over when hits wall', () => {
+    const snakeGame = new SnakeGame(4, 2, [[1, 2], [0, 1]]);
+    expect(snakeGame.move('R')).toEqual(0); //  0
+    expect(snakeGame.move('D')).toEqual(0); //  0
+    expect(snakeGame.move('R')).toEqual(1); //  1 (ate food1)
+    expect(snakeGame.move('U')).toEqual(1); //  1
+    expect(snakeGame.move('L')).toEqual(2); //  2 (ate food2)
+    expect(snakeGame.move('U')).toEqual(-1); // -1 (hit wall)
+  });
+
+  it('should circle around without eating itself', () => {
+    const snakeGame = new SnakeGame(2, 2, [[0, 1], [1, 1], [1, 0]]);
+    expect(snakeGame.move('R')).toEqual(1);
+    expect(snakeGame.move('D')).toEqual(2);
+    expect(snakeGame.move('L')).toEqual(3);
+    expect(snakeGame.move('U')).toEqual(3);
+    expect(snakeGame.move('R')).toEqual(3);
+  });
+
+  it('should game over when hit itself', () => {
+    const snakeGame = new SnakeGame(3, 2, [[0, 1], [0, 2], [1, 2], [1, 1]]);
+    expect(snakeGame.move('R')).toEqual(1);
+    expect(snakeGame.move('R')).toEqual(2);
+    expect(snakeGame.move('D')).toEqual(3);
+    expect(snakeGame.move('L')).toEqual(4);
+    expect(snakeGame.move('U')).toEqual(-1);
+  });
+});

book/interview-questions/design-snake-game.spec.js

@@ -1,9 +1,10 @@
 // tag::description[]
 /**
  * Find the maximun sum of contiguous elements in an array.
+ *
  * @examples
- *    maxSubArray([1, -3, 10, -5]); // => 10
- *    maxSubArray([-3,4,-1,2,1,-5]); // => 6
+ *  maxSubArray([1, -3, 10, -5]); // => 10
+ *  maxSubArray([-3,4,-1,2,1,-5]); // => 6
  *
  * @param {number[]} a - Array
  */

book/interview-questions/max-subarray.js

@@ -8,6 +8,10 @@ describe('Max Subarray Sum', () => {
         expect(fn([-2, 1, -3, 4, -1, 2, 1, -5, 4])).toEqual(6);
       });
 
+      it('should work with small arrays', () => {
+        expect(fn([1, -3, 10, -5])).toEqual(10);
+      });
+
       it('should work with large arrays', () => {
         expect(fn(largeArray)).toEqual(4853);
       });

book/interview-questions/max-subarray.spec.js

@@ -0,0 +1,57 @@
+const { Queue } = require('../../src/index');
+
+// tag::description[]
+/**
+ * Counts the most recent requests within a time window.
+ * Each request has its timestamp.
+ * If the time window is 2 seconds,
+ * any requests that happened more than 2 seconds before the most recent request
+ * should not count.
+ *
+ * @example - The time window is 3 sec. (3000 ms)
+ *  const counter = new RecentCounter(3000);
+ *  counter.request(100); // 1
+ *  counter.request(1000); // 2
+ *  counter.request(3000); // 3
+ *  counter.request(3100); // 4
+ *  counter.request(3101); // 4
+ *
+ */
+class RecentCounter {
+  // end::description[]
+  // tag::solution[]
+  queue = new Queue();
+  // end::solution[]
+  // tag::description[]
+  /**
+   * @param {number} maxWindow - Max. time window (in ms) for counting requests
+   *  Defaults to 1 second (1000 ms)
+   */
+  constructor(maxWindow = 1000) {
+  // end::description[]
+  // tag::solution[]
+    this.window = maxWindow;
+  // end::solution[]
+  // tag::description[]
+  }
+
+  /**
+   * Add new request and calculate the current count within the window.
+   * @param {number} timestamp - The current timestamp (increasing order)
+   * @return {number} - The number of requests within the time window.
+   */
+  request(timestamp) {
+  // end::description[]
+  // tag::solution[]
+    this.queue.enqueue(timestamp);
+    while (timestamp - this.queue.peek() > this.window)
+      this.queue.dequeue();
+
+    return this.queue.size;
+  // end::solution[]
+  // tag::description[]
+  }
+}
+// end::description[]
+
+module.exports = { RecentCounter };

book/interview-questions/recent-counter.js

@@ -0,0 +1,21 @@
+const { RecentCounter } = require('./recent-counter');
+
+describe('Queue: Recent Counter', () => {
+  it('should count requests within the window', () => {
+    const counter = new RecentCounter(3000);
+    expect(counter.request(100)).toEqual(1); // 1
+    expect(counter.request(1000)).toEqual(2); // 2
+    expect(counter.request(3000)).toEqual(3); // 3
+    expect(counter.request(3100)).toEqual(4); // 4
+    expect(counter.request(3101)).toEqual(4); // 4 (request at time 100 is out of the 3000 window).
+  });
+
+  it('should NOT count requests out of the window', () => {
+    const counter = new RecentCounter(10);
+    expect(counter.request(100)).toEqual(1);
+    expect(counter.request(1000)).toEqual(1);
+    expect(counter.request(3000)).toEqual(1);
+    expect(counter.request(3100)).toEqual(1);
+    expect(counter.request(3101)).toEqual(2);
+  });
+});

book/interview-questions/recent-counter.spec.js

@@ -1,18 +1,31 @@
 const LinkedList = require('../linked-lists/linked-list');
 
+/* Usage Example:
+// tag::snippet[]
+const queue = new Queue();
+
+queue.enqueue('a');
+queue.enqueue('b');
+queue.dequeue(); //↪️ a
+queue.enqueue('c');
+queue.dequeue(); //↪️ b
+queue.dequeue(); //↪️ c
+// end::snippet[]
+// */
+
 // tag::constructor[]
 /**
  * Data structure where we add and remove elements in a first-in, first-out (FIFO) fashion
  */
 class Queue {
-  constructor() {
-    this.items = new LinkedList();
+  constructor(iterable = []) {
+    this.items = new LinkedList(iterable);
   }
   // end::constructor[]
 
   // tag::enqueue[]
   /**
-   * Add element to the queue
+   * Add element to the back of the queue.
    * Runtime: O(1)
    * @param {any} item
    * @returns {queue} instance to allow chaining.
@@ -25,7 +38,7 @@ class Queue {
 
   // tag::dequeue[]
   /**
-   * Remove element from the queue
+   * Remove element from the front of the queue.
    * Runtime: O(1)
    * @returns {any} removed value.
    */
@@ -47,23 +60,30 @@ class Queue {
   isEmpty() {
     return !this.items.size;
   }
+
+  /**
+   * Return the most recent value or null if empty.
+   */
+  back() {
+    if (this.isEmpty()) return null;
+    return this.items.last.value;
+  }
+
+  /**
+   * Return oldest value from the queue or null if empty.
+   * (Peek at the next value to be dequeue)
+   */
+  front() {
+    if (this.isEmpty()) return null;
+    return this.items.first.value;
+  }
 }
 
 // Aliases
+Queue.prototype.peek = Queue.prototype.front;
 Queue.prototype.add = Queue.prototype.enqueue;
+Queue.prototype.push = Queue.prototype.enqueue;
 Queue.prototype.remove = Queue.prototype.dequeue;
+Queue.prototype.pop = Queue.prototype.dequeue;
 
 module.exports = Queue;
-
-/* Usage Example:
-// tag::snippet[]
-const queue = new Queue();
-
-queue.enqueue('a');
-queue.enqueue('b');
-queue.dequeue(); //↪️ a
-queue.enqueue('c');
-queue.dequeue(); //↪️ b
-queue.dequeue(); //↪️ c
-// end::snippet[]
-// */

src/data-structures/queues/queue.js

@@ -46,4 +46,28 @@ describe('Queue', () => {
       expect(queue.isEmpty()).toBe(false);
     });
   });
+
+  describe('#back', () => {
+    it('should return null if empty', () => {
+      expect(queue.back()).toEqual(null);
+    });
+
+    it('should return newest element', () => {
+      queue.enqueue('oldest');
+      queue.enqueue('newest');
+      expect(queue.back()).toEqual('newest');
+    });
+  });
+
+  describe('#front', () => {
+    it('should return null if empty', () => {
+      expect(queue.front()).toEqual(null);
+    });
+
+    it('should return oldest element', () => {
+      queue.enqueue('oldest');
+      queue.enqueue('newest');
+      expect(queue.front()).toEqual('oldest');
+    });
+  });
 });