update

Author: MaiDeveloper

.gitignore

@@ -0,0 +1,2 @@
+node_modules/
+!.gitignore

binary-heap.js

@@ -0,0 +1,188 @@
+class BinaryHeap {
+  constructor(comparator = (a, b) => {
+    return (a < b) ? -1 : (a === b ? 0 : 1);
+  }) {
+    this.heap = [];
+    this.comparator = comparator;
+  }
+  getLeftIndex(index) {
+    return 2 * index + 1;
+  }
+  getRightIndex(index) {
+    return 2 * index + 2;
+  }
+  getParentIndex(index) {
+    return Math.floor((index - 1) / 2);
+  }
+  insert(data) {
+    if (data === undefined || data === null) {
+      return false;
+    }
+    this.heap.push(data);
+    this.bubbleUp(this.heap.length - 1);
+    return true;
+  }
+  bubbleUp(index) {
+    while (index > 0) {
+      let curr = this.heap[index];
+      let parentIndex = this.getParentIndex(index);
+      let parent = this.heap[parentIndex];
+
+      let compare = this.comparator(parent, curr);
+      if (compare < 0 || compare === 0) {
+        break;
+      }
+
+      this.swap(index, parentIndex);
+      index = parentIndex;
+    }
+  }
+  extract() {
+    if (this.size() === 0) {
+      return undefined;
+    }
+
+    if (this.size() === 1) {
+      return this.heap.shift();
+    }
+
+    const value = this.heap[0];
+    this.heap[0] = this.heap.pop();
+    this.sinkDown(0);
+    return value;
+  }
+  sinkDown(currIndex) {
+    let left = this.getLeftIndex(currIndex);
+    let right = this.getRightIndex(currIndex);
+    let parentIndex = currIndex;
+
+    if (this.comparator(this.heap[left], this.heap[parentIndex]) < 0) {
+      parentIndex = left;
+    }
+
+    if (this.comparator(this.heap[right], this.heap[parentIndex]) < 0) {
+      parentIndex = right;
+    }
+
+    if (parentIndex !== currIndex) {
+      this.swap(parentIndex, currIndex);
+      this.sinkDown(parentIndex);
+    }
+  }
+  peak() {
+    return this.size() > 0 ? this.heap[0] : undefined;
+  }
+  swap(a, b) {
+    [this.heap[a], this.heap[b]] = [this.heap[b], this.heap[a]];
+  }
+  size() {
+    return this.heap.length;
+  }
+}
+
+const assert = require('chai').assert;
+
+describe('BinaryHeap', () => {
+  let minHeap;
+  beforeEach(() => {
+    minHeap = new BinaryHeap();
+  });
+  it('should defined', () => {
+    assert.equal(typeof BinaryHeap, 'function');
+  });
+  describe('#insert', () => {
+    it('should defined', () => {
+      assert.equal(typeof minHeap.insert, 'function');
+    });
+    it('should insert value to the heap', () => {
+      minHeap.insert(2);
+      minHeap.insert(5);
+      assert.deepEqual(minHeap.heap, [2, 5]);
+    });
+  });
+  describe('#size', () => {
+    it('should defined', () => {
+      assert.equal(typeof minHeap.size, 'function');
+    });
+    it('should return the length of the heap', () => {
+      assert.equal(minHeap.size(), 0);
+      minHeap.insert(2);
+      assert.equal(minHeap.size(), 1);
+    });
+  });
+  describe('#peak', () => {
+    it('should defined', () => {
+      assert.equal(typeof minHeap.peak, 'function');
+    });
+    it('should return the minimum value', () => {
+      minHeap.insert(4);
+      minHeap.insert(7);
+      minHeap.insert(1);
+      minHeap.insert(9);
+      assert.equal(minHeap.peak(), 1);
+    });
+    it('should return the minimum value without deleting', () => {
+      minHeap.insert(4);
+      minHeap.insert(7);
+      minHeap.insert(1);
+      minHeap.insert(9);
+      assert.equal(minHeap.size(), 4);
+      minHeap.peak();
+      assert.equal(minHeap.size(), 4);
+    });
+  });
+  describe('#extract', () => {
+    it('should defined', () => {
+      assert.equal(typeof minHeap.extract, 'function');
+    });
+    it('should return the minimum value', () => {
+      minHeap.insert(4);
+      minHeap.insert(7);
+      minHeap.insert(1);
+      minHeap.insert(9);
+      assert.equal(minHeap.extract(), 1);
+    });
+    it('should remove from the heap', () => {
+      minHeap.insert(4);
+      minHeap.insert(7);
+      minHeap.insert(1);
+      minHeap.insert(9);
+      assert.equal(minHeap.size(), 4);
+      minHeap.extract();
+      assert.equal(minHeap.size(), 3);
+    });
+    it('should rearrange the heap', () => {
+      minHeap.insert(4);
+      minHeap.insert(7);
+      minHeap.insert(1);
+      minHeap.insert(9);
+      assert.deepEqual(minHeap.heap, [1, 7, 4, 9]);
+      minHeap.extract();
+      assert.deepEqual(minHeap.heap, [4, 7, 9]);
+    });
+  });
+
+  describe('MaxHeap', () => {
+    it('should customize to max heap', () => {
+      const max = (a, b) => b - a;
+      const heap = new BinaryHeap(max);
+      heap.insert(9);
+      heap.insert(5);
+      heap.insert(10);
+      heap.insert(20);
+      heap.insert(7);
+      heap.insert(30);
+      heap.insert(90);
+      heap.insert(49);
+
+      const sorted = [90, 49, 30, 20, 10, 9, 7, 5];
+      const output = [];
+
+      while (heap.size()) {
+        output.push(heap.extract());
+      }
+      assert.deepEqual(output, sorted);
+    });
+  });
+});
+

cash-register.js

@@ -0,0 +1,87 @@
+/**
+ * JavaScript Algorithms and Data Structures Projects: Cash Register
+ *
+ * Design a cash register drawer function checkCashRegister() that accepts purchase price as the first argument (price), payment as the second argument (cash), and cash-in-drawer (cid) as the third argument.
+ *
+ * cid is a 2D array listing available currency.
+ *
+ * The checkCashRegister() function should always return an object with a status key and a change key.
+ *
+ * Return {status: "INSUFFICIENT_FUNDS", change: []} if cash-in-drawer is less than the change due, or if you cannot return the exact change.
+ *
+ * Return {status: "CLOSED", change: [...]} with cash-in-drawer as the value for the key change if it is equal to the change due.
+ *
+ * Otherwise, return {status: "OPEN", change: [...]}, with the change due in coins and bills, sorted in highest to lowest order, as the value of the change key.
+ */
+
+function checkCashRegister(price, cash, cid) {
+  const drawer = {};
+  const money = [
+    ['ONE HUNDRED', 100],
+    ['TWENTY', 20],
+    ['TEN', 10],
+    ['FIVE', 5],
+    ['ONE', 1],
+    ['QUARTER', 0.25],
+    ['DIME', 0.1],
+    ['NICKEL', 0.5],
+    ['PENNY', 0.01]
+  ];
+
+  let remain = cash - price;
+  let ans = [];
+
+  for (let i = 0; i < cid.length; i++) {
+    drawer[cid[i][0]] = cid[i][1];
+  }
+
+  for (let i = 0; i < money.length && remain > 0; i++) {
+    const key = money[i][0];
+    const val = money[i][1];
+    let change = 0;
+
+    while (remain >= val && drawer[key] >= val) {
+      remain = parseFloat((remain - val).toFixed(2));
+      change = parseFloat((change + val).toFixed(2));
+      drawer[key] = parseFloat((drawer[key] - val).toFixed(2));
+    }
+
+    if (change > 0) {
+      ans.push([key, change]);
+    }
+  }
+
+  if (remain > 0) {
+    return {
+      status: "INSUFFICIENT_FUNDS",
+      change: []
+    };
+  }
+
+  let status = 'CLOSED';
+
+  for (let k in drawer) {
+    if (drawer[k] > 0) {
+      status = 'OPEN';
+    }
+  }
+
+  return {
+    status: status,
+    change: (status === 'OPEN' ? ans : cid)
+  }
+}
+
+// Example cash-in-drawer array:
+// [["PENNY", 1.01],
+// ["NICKEL", 2.05],
+// ["DIME", 3.1],
+// ["QUARTER", 4.25],
+// ["ONE", 90],
+// ["FIVE", 55],
+// ["TEN", 20],
+// ["TWENTY", 60],
+// ["ONE HUNDRED", 100]]
+
+console.log(checkCashRegister(19.5, 20, [["PENNY", 1.01], ["NICKEL", 2.05], ["DIME", 3.1], ["QUARTER", 4.25], ["ONE", 90], ["FIVE", 55], ["TEN", 20], ["TWENTY", 60], ["ONE HUNDRED", 100]]));
+console.log(checkCashRegister(19.5, 20, [["PENNY", 0.5], ["NICKEL", 0], ["DIME", 0], ["QUARTER", 0], ["ONE", 0], ["FIVE", 0], ["TEN", 0], ["TWENTY", 0], ["ONE HUNDRED", 0]]));

convert-html-entities.js

@@ -0,0 +1,18 @@
+/**
+ * Intermediate Algorithm Scripting: Convert HTML Entities
+ *
+ * Convert the characters &, <, >, " (double quote), and ' (apostrophe), in a string to their corresponding HTML entities.
+ */
+
+function convertHTML(str) {
+  const entities = {
+    '&': '&amp;',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    '\'': '&apos;'
+  };
+  return str.split('').map(s => entities[s] || s).join('');
+}
+
+convertHTML("Dolce & Gabbana");

difference-two-arrays.js

@@ -0,0 +1,30 @@
+/**
+ * Intermediate Algorithm Scripting: Diff Two Arrays
+ *
+ * Compare two arrays and return a new array with any items only found in one of the two given arrays, but not both. In other words, return the symmetric difference of the two arrays.
+ *
+ * Remember to use Read-Search-Ask if you get stuck. Try to pair program. Write your own code.
+ *
+ * Note
+ * You can return the array with its elements in any order.
+ */
+
+function diffArray(arr1, arr2) {
+  const unique = new Set();
+
+  for (let i = 0; i < arr1.length; i++) {
+    unique.add(arr1[i]);
+  }
+
+  for (let i = 0; i < arr2.length; i++) {
+    if (unique.has(arr2[i])) {
+      unique.delete(arr2[i]);
+    } else {
+      unique.add(arr2[i]);
+    }
+  }
+
+  return Array.from(unique.values());
+}
+
+console.log(diffArray([1, "calf", 3, "piglet"], [1, "calf", 3, 4]));

flatten-array.js

@@ -0,0 +1,13 @@
+function flatten_array(arr) {
+  let flatten = [];
+  for (let val of arr) {
+    if (Array.isArray(val)) {
+      flatten = flatten.concat(flatten_array(val));
+    } else {
+      flatten.push(val);
+    }
+  }
+  return flatten;
+}
+
+console.log(flatten_array([1, [2], [3, [[4]]]]));