const stack = [1,2,3,4];

stack.push(5); 
// [1,2,3,4,5]

stack.pop();
// -> 5
// [1,2,3,4]

const queue = [1,2,3,4];

queue.enqueue(5); 
// [1,2,3,4,5]

queue.dequeue();
// -> 1
// [2,3,4,5]

const linkedlist = {
  head: {
    value: 1
    next: {
      value: 2
      next: {
        value: 3
        next: null
      }
    }
  }
}

/** Class representing a Stack. */

class Stack {

  constructor() {
    this.storage = {};
  }
  /*
  * Adds a new value at the end of the 
  * stack
  * @param {*} value the value to push
  */
  push() {

  }

  /*
  * Removes the value at the end of the stack and returns it
  * @return {*} the last and newest value in the stack
  */
  pop() {

  }
  /*
  * Returns the value at the end of the stack without removing it
  * @return {*} the last and newest value in the stack
  */
  peek() {

  }
}

/** Class representing a Queue. */

class Queue {

  constructor() {
    this.storage = {};
  }
  /*
  * Enqueues a new value at the end 
  * of the queue
  * @param {*} value - the value to 
  * enqueue
  */
  enqueue() {

  }

  /*
  * Dequeues the value from the beginning of the queue and returns it
  * @return {*} the first and oldest value in the queue
  */
  dequeue() {

  }
  /*
  * Returns the value at the beginning of the queue without removing it from the queue
  * @return {*} value the first and oldest value in the queue
  */
  peek() {

  }
}

/** Class representing a Linked List */

class LinkedList {

  constructor() {
    this.storage = {};
  }
  /*
  * Inserts a new value to the end of the linked list
  * @param {*} value - the value to insert
  */
  insert() {

  }
  /*
  * Deletes a node
  * @param {*} node - the node to remove
  * @return {*} value - the deleted node's value
  */
  remove() {

  }
  /*
  * Removes the value at the end of the linked list
  * @return {*} - the removed value
  */
  removeTail() {

  }
  /*
  * Searches the linked list and returns true if it contains the value passed
  * @param {*} value - the value to search for
  * @return {boolean} - true if value is found, otherwise false
  */
  contains() {

  }  
  /*
  * Checks if a node is the head of the linked list 
  * @param {{prev:Object|null, next:Object|null}} node - the node to check
  * @return {boolean} - true if node is the head, otherwise false
  */
  isHead() {

  }
  /*
  * Checks if a node is the tail of the linked list 
  * @param {{prev:Object|null, next:Object|null}} node - the node to check
  * @return {boolean} - true if node is the tail, otherwise false
  */
  isTail() {

  }
}

/** Class representing a Hash Table */

class HashTable {

  constructor() {
    this.storage = [];
  }
  /*
  * Inserts a new key-value pair
  * @param {string} key - the key associated 
  * with the value
  * @param {*} value - the value to insert
  */
  insert() {

  }
  /*
  * Deletes a key-value pair
  * @param {string} key - the key associated with the value
  * @return {*} value - the deleted value
  */
  remove() {

  }
  /*
  * Returns the value associated with a key
  * @param {string} key - the key to search for
  * @return {*} - the value associated with the key
  */
  retrieve() {

  }  
  /*
  * Hashes string value into an integer that can be mapped to an array index
  * @param {string} str - the string to be hashed
  * @param {number} n - the size of the storage array
  * @return {number} - an integer between 0 and n
  */
  _hash(str, n) {
    let sum = 0;
    for (let i = 0; i < str.length; i++)
        sum += str.charCodeAt(i) * 3

    return sum % n;
  }
}

/** Class representing an Aray, a fictional data 
* structure similar to an array except that the 
* underlying storage is a string 
*/

class Aray {
  constructor() {
    this.storage = '';
  }
  /*
  * Pushes a value at the end of the aray
  * @param {string} value - the value to insert
  * @return {number} - the length of the aray
  */
  push() {

  }
  /*
  * Pops off the last value of the aray
  * @return {string} value - the popped value
  */
  pop() {

  }
  /*
  * Returns the length of the aray
  * @return {number} - the length of the aray
  */
  length() {

  }  
}