chore(lab): add exercises

Author: amejiarosario

benchmarks/array-rotation-implementations/01-array-rotation.js

@@ -0,0 +1,9 @@
+// brute force: O(nd) | O(1)
+function rotLeft(a, d) {
+  for (let i = 0; i < d; i++) { // O(d)
+    a.push(a.shift()); // O(n), shift O(n)
+  }
+  return a;
+}
+
+module.exports = rotLeft;

benchmarks/array-rotation-implementations/01a-array-rotation.js

@@ -0,0 +1,11 @@
+// modulus for rotations: O(n^2) | O(1)
+function rotLeft(a, d) {
+  const len = a.length;
+  const rot = d % len;
+  for (let i = 0; i < rot; i++) { // O(n^2)
+    a.push(a.shift()); // O(n)
+  }
+  return a;
+}
+
+module.exports = rotLeft;

benchmarks/array-rotation-implementations/02-array-rotation.js

@@ -0,0 +1,12 @@
+// additional space: O(n) | O(n)
+function rotLeft(a, d) {
+  const len = a.length;
+  const rot = d % len;
+  const b = [];
+  for (let i = 0; i < len; i++) { // O(n)
+    b[i] = a[(rot + i) % len]; // O(1)
+  }
+  return b;
+}
+
+module.exports = rotLeft;

benchmarks/array-rotation-implementations/array-rotation.spec.js

@@ -0,0 +1,17 @@
+/*eslint-disable */
+// npx jest benchmarks/two-sum-implementations/two-sum.spec.js --watch --collectCoverage
+const implementations = [
+  { name: 1, fn: require('./01-array-rotation') },
+  { name: '1a', fn: require('./01a-array-rotation') },
+  { name: 2, fn: require('./02-array-rotation') },
+];
+
+implementations.forEach(({name, fn}) => {
+  describe(`Two Sum: ${name}`, () => {
+    it('should work on worst case', () => {
+      const rots = 1000;
+      const array = [1, 2, 3];
+      expect(fn(array, rots)).toEqual([2,3,1]);
+    });
+  });
+});

benchmarks/two-sum-implementations/01a-two-sum.js

@@ -0,0 +1,13 @@
+// Brute force: O(n^2) | O(1)
+function twoSum(nums, target) {
+  for (let i = 0; i < nums.length - 1; i++) { // O(n^2)
+    const diff = target - nums[i];
+    const offset = i + 1;
+    const idx = nums.slice(offset).findIndex((n) => n === diff); // O(n)
+    const j = offset + idx;
+    if (idx > -1) return [i, j];
+  }
+  return [];
+}
+
+module.exports = twoSum;

benchmarks/two-sum-implementations/02-two-sum.js

@@ -1,4 +1,4 @@
-// With a HashMap: O(n) | O(n)
+// [map w/dups handling] →  O(n^2) | O(n)
 function twoSum(nums, target) {
   const map = nums.reduce((m, v, i) => { // O(n)
     const ids = m.get(v) || [];
@@ -8,8 +8,9 @@ function twoSum(nums, target) {
 
   for (let i = 0; i < nums.length; i++) { // O(n)
     const diff = target - nums[i];
-    if (map.has(diff) && i !== map.get(diff)) {
-      return [i, map.get(diff)];
+    if (map.has(diff)) {
+      const id = map.get(diff).find((j) => j > i);
+      if (id > -1) return [i, id];
     }
   }
 

benchmarks/two-sum-implementations/02a-two-sum.js

@@ -0,0 +1,24 @@
+// [map w/dups handling] →  O(n^2) | O(n)
+function twoSum(nums, target) {
+  const map = mapify(nums);
+
+  for (let i = 0; i < nums.length; i++) { // O(n)
+    const diff = target - nums[i];
+    if (map.has(diff)) {
+      const id = map.get(diff).find((j) => j > i);
+      if (id > -1) return [i, id];
+    }
+  }
+
+  return [];
+}
+
+function mapify(nums) {
+  return nums.reduce((m, v, i) => { // O(n)
+    const ids = m.get(v) || [];
+    ids.push(i);
+    return m.set(v, ids);
+  }, new Map());
+}
+
+module.exports = twoSum;

benchmarks/two-sum-implementations/04-two-sum.js

@@ -0,0 +1,23 @@
+// sort + two pointers: O(n log n) | O(1)
+function twoSum(nums, target) {
+  nums.sort((a, b) => a - b);
+
+  let lo = 0;
+  let hi = nums.length - 1;
+
+  while (lo < hi) {
+    const sum = nums[lo] + nums[hi];
+    if (sum === target) {
+      return [lo, hi];
+    }
+
+    if (sum > target) {
+      hi--;
+    } else {
+      lo++;
+    }
+  }
+  return [];
+}
+
+module.exports = twoSum;

benchmarks/two-sum-implementations/two-sum.spec.js

@@ -0,0 +1,23 @@
+/*eslint-disable */
+// npx jest benchmarks/two-sum-implementations/two-sum.spec.js --watch --collectCoverage
+const implementations = [
+  { name: 1, fn: require('./01-two-sum') },
+  { name: '1a', fn: require('./01a-two-sum') },
+  { name: 2, fn: require('./02-two-sum') },
+  { name: '2a', fn: require('./02a-two-sum') },
+  { name: 3, fn: require('./03-two-sum') },
+  { name: 4, fn: require('./04-two-sum') },
+];
+
+implementations.forEach(({name, fn}) => {
+  describe(`Two Sum: ${name}`, () => {
+    xit('should work', () => {
+      expect(fn([1, 2, 3].concat(Array(1e2 - 3).fill(7)), 4)).toEqual([0, 2]);
+    });
+
+    it('should work on worst case', () => {
+      const size = 100;
+      expect(fn([...Array(size).fill(2), 3, 3 * size * 10], 3 * size * 10 + 3)).toEqual([size, size + 1]);
+    });
+  });
+});

lab/exercises/10-mixed/check-prerequisite.js

@@ -0,0 +1,33 @@
+const checkIfPrerequisite = function (n, prerequisites, queries) {
+  const graph = new Map();
+
+  Array(n).fill(0).forEach((v, i) => graph.set(i, {
+    children: [],
+    // connected: new Set(),
+  }));
+
+  prerequisites.forEach(([u, v]) => {
+    graph.get(u).children.push(v);
+    // graph.get(u).connected.add(v);
+  });
+
+
+  return queries.map(([u, v]) => isConnected(graph, u, v, new Set(), u));
+};
+
+function isConnected(graph, u, v, path = new Set(), p) {
+  // console.log({u, v, path}, graph)
+  // if (graph.get(u).connected.has(v)) return true;
+  // path.forEach(s => graph.get(p).connected.add(s));
+
+  for (const child of graph.get(u).children) {
+    if (child === v) return true;
+    if (path.has(child)) continue;
+    if (isConnected(graph, child, v, path.add(u), p)) return true;
+  }
+
+  return false;
+}
+
+
+module.exports = checkIfPrerequisite;