Merge branch 'book' into gitbook

Author: amejiarosario

.gitignore

@@ -3,3 +3,7 @@ node_modules
 coverage/
 **/dist/
 _book/
+<<<<<<< HEAD
+=======
+.DS_Store
+>>>>>>> book

lab/exercises/easy/search-insert-position.js

@@ -0,0 +1,42 @@
+/* eslint-disable */
+
+/**
+ * binary search O(log n)
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
+var searchInsert = function(nums, target, start =  0) {
+  if (!nums.length) return start;
+  const i = parseInt(nums.length / 2, 10);
+
+  if (nums[i] === target) {
+    return start + i;
+  } else if (target > nums[i]) {
+    const newArray = nums.slice(i + 1);
+    if (!newArray.length) return start + i + 1;
+    return searchInsert(newArray, target, start + i + 1);
+  } else {
+    return searchInsert(nums.slice(0, i), target, start);
+  }
+};
+
+// ---
+
+const assert = require('assert');
+function test() {
+  assert.equal(searchInsert([], 0), 0);
+  assert.equal(searchInsert([], 1), 0);
+
+  assert.equal(searchInsert([1], 0), 0);
+  assert.equal(searchInsert([1], 2), 1);
+
+  assert.equal(searchInsert([1,3,5,6], 5), 2);
+  assert.equal(searchInsert([1,3,5,6], 2), 1);
+  assert.equal(searchInsert([1,3,5,6], 7), 4);
+  assert.equal(searchInsert([1,3,5,6], 0), 0);
+
+  assert.equal(searchInsert([1,3,5], 5), 2);
+
+}
+test();

lab/exercises/hard/regular-expression-matching.js

@@ -0,0 +1,131 @@
+/* eslint-disable */
+
+/**
+ * https://leetcode.com/articles/regular-expression-matching/
+ * Pattern:
+ * '.' Matches any single character.
+ * '*' Matches zero or more of the preceding element.
+ *
+ * @param {string} s
+ * @param {string} p
+ * @return {boolean}
+ */
+var isMatch = function(s, p) {
+  let si = s.length - 1;
+
+  for(let pi = p.length - 1; pi > 0; pi--) {
+    switch(p[pi]) {
+      case '.':
+        if (si > 0) { si--; }
+        else { return false; }
+        break;
+      case '*':
+        const char = p[--pi];
+        while(si > 0 && (char === '.' || char === s[si])) {
+          si--;
+        }
+        break;
+      default:
+        if (si > 0 && p[pi] === s[si]) {
+          si--;
+        } else {
+          return false;
+        }
+    }
+  }
+
+  return si <= 0;
+};
+
+const assert = require('assert');
+function test() {
+  assert.equal(isMatch('aa', 'aa'), true);
+  assert.equal(isMatch('aa', 'a'), false);
+
+  assert.equal(isMatch('aa', 'a.'), true);
+  assert.equal(isMatch('aaa', 'a.'), false);
+  assert.equal(isMatch('aaa', 'a..'), true);
+
+  assert.equal(isMatch('', 'a*'), true);
+  assert.equal(isMatch('a', 'a*'), true);
+  assert.equal(isMatch('aa', 'a*'), true);
+  assert.equal(isMatch('aab', 'a*'), false);
+  assert.equal(isMatch('aab', 'a*b'), true);
+
+  assert.equal(isMatch('aab', 'c*a*b'), true);
+  assert.equal(isMatch('caab', 'c*a*b'), true);
+
+  assert.equal(isMatch('abc', '.*'), true);
+
+  assert.equal(isMatch('mississippi', 'mis*is*p*.'), false);
+  assert.equal(isMatch('mississippi', 'mis*is*ip*.'), true);
+
+  assert.equal(isMatch('ab', '.*..'), true);
+  assert.equal(isMatch('abcz', '.*z'), true);
+  assert.equal(isMatch('abcz', '.*x'), false);
+  assert.equal(isMatch('zabc', 'z.*'), true);
+  assert.equal(isMatch('zabc', 'x.*'), false);
+  assert.equal(isMatch('zabcz', 'z.*z'), true);
+  assert.equal(isMatch('zabcx', 'z.*z'), false);
+}
+test();
+
+
+
+/////
+
+var isMatch3 = function(s, p) {
+  let pi = 0;
+
+  for(let si = 0; si < s.length; si++) {
+    switch(p[pi]) {
+      case '.':
+        if (pi < p.length) { pi++; }
+        else { return false; }
+        break;
+      case '*':
+        const last = p[pi - 1];
+        if(last === s[si]) {
+          break; // break switch
+        }
+        pi++; // continue to the default case
+      default:
+        if (pi < p.length && p[pi] === s[si]) {
+          pi++;
+          continue;
+        } else {
+          return false;
+        }
+    }
+  }
+
+  return true;
+};
+
+var isMatch2 = function(s, p) {
+  let pi = p.length - 1;
+
+  for(let si = s.length - 1; si > 0; si--) {
+    switch(p[pi]) {
+      case '.':
+        if (pi > 0) { pi--; }
+        else { return false; }
+        break;
+      case '*':
+        const last = p[--pi];
+        while(si > 0 && last === s[si]) {
+          si--;
+        }
+        break;
+      default:
+        if (pi > 0 && p[pi] === s[si]) {
+          pi--;
+          continue;
+        } else {
+          return false;
+        }
+    }
+  }
+
+  return true;
+};

lab/exercises/medium/next-permutation.js

@@ -0,0 +1,133 @@
+/* eslint-disable */
+
+/**
+ * Runtime O(10^n)
+ * https://leetcode.com/problems/next-permutation/
+ * @param {number[]} nums
+ * @return {void} Do not return anything, modify nums in-place instead.
+ */
+var nextPermutation2 = function(nums) {
+  const current = parseInt(nums.join(''), 10);
+  const max = Math.pow(10, nums.length);
+
+  for(let next = current + 1; next < max; next++) {
+    if(isPermutation(nums, next)) {
+      setNumbersInArray(nums, next);
+      return;
+    }
+  }
+};
+
+function isPermutation(array, number) {
+  return array.sort().join('') === numberToArray(number, array.length).sort().join('');
+}
+
+function numberToArray(num, pad = 0) {
+  return num.toString().padStart(pad, "0").split('').map(s => +s)
+}
+
+function setNumbersInArray(to, number) {
+  const from = numberToArray(number, to.length);
+
+  for(let i = 0; i < to.length; i++) {
+    to[i] = from[i];
+  }
+}
+
+
+/*
+  // swap last with previous and check if is bigger
+  // if not, swap last with previous - 1 recursively and check if bigger
+  // sort in asc order the rest and check if bigger
+
+123
+132
+213
+231
+312
+321
+---
+123
+*/
+
+// generate all numbers - discard no matching: O(10^n)
+//
+
+
+// starting from last find a bigger number than current
+
+
+function nextPermutation(nums) {
+
+  // try to find next
+  for(let i = nums.length - 2; i >= 0; i--) {
+    let smallestBigger;
+
+    for(let j = i + 1; j < nums.length; j++) {
+      if (nums[j] > nums[i]) {
+        smallestBigger = Math.min(nums[j], smallestBigger || nums[j]);
+      }
+    }
+
+    if (smallestBigger) {
+      const k = nums.lastIndexOf(smallestBigger);
+      [nums[i], nums[k]] = [nums[k], nums[i]]; // swap
+      // sort asc starting from i
+      sort(nums, i + 1);
+      return;
+    }
+  }
+
+  sort(nums);
+}
+
+/**
+ * Sort in-place from start on
+ * @param {*} array
+ * @param {*} start
+ */
+function sort(array, start = 0) {
+  for(let i = start; i < array.length; i++) {
+    for (let j = i + 1; j < array.length; j++) {
+      if (array[i] > array[j]) {
+        [array[i], array[j]] = [array[j], array[i]];
+      }
+    }
+  }
+}
+
+// -----
+const assert = require('assert');
+function test() {
+  let a;
+
+  a = [100, 4,3,2];
+  sort(a, 1);
+  assert.deepEqual(a, [100, 2, 3, 4]);
+
+  a = [1, 2, 3];
+  nextPermutation(a);
+  assert.deepStrictEqual(a, [1, 3, 2]);
+
+  a = [2, 3, 1];
+  nextPermutation(a);
+  assert.deepStrictEqual(a, [3, 1, 2]);
+
+  a = [3, 2, 1];
+  nextPermutation(a);
+  assert.deepEqual(a, [1, 2, 3]);
+
+  a = [0,0,4,2,1,0];
+  nextPermutation(a);
+  assert.deepStrictEqual(a, [0,1,0,0,2,4]);
+
+  // Time Limit Exceeded on leetcode for O(n^10) algorithm
+  a = [2,2,7,5,4,3,2,2,1];
+  nextPermutation(a);
+  assert.deepStrictEqual(a, [2,3,1,2,2,2,4,5,7]);
+
+  a = [5,4,7,5,3,2];
+  nextPermutation(a);
+  assert.deepEqual(a, [5,5,2,3,4,7]);
+}
+test();

lab/exercises/medium/permute.js

@@ -0,0 +1,55 @@
+/* eslint-disable */
+
+/**
+ * https://www.youtube.com/watch?v=AfxHGNRtFac
+ * https://www.geeksforgeeks.org/write-a-c-program-to-print-all-permutations-of-a-given-string/
+ * https://leetcode.com/articles/permutations/
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+var permute = function (nums) {
+  var result = [];
+  backtrack(nums, result);
+  return result;
+};
+
+function backtrack(nums, result, first = 0) {
+  // console.log(Array(first).fill("    ").join(""), JSON.stringify({nums, first}));
+  if (first === nums.length - 1) {
+    // console.log(nums);
+    result.push(nums.slice());
+  } else {
+    for (let i = first; i < nums.length; i++) {
+      swap(nums, first, i);
+      backtrack(nums, result, first + 1);
+      swap(nums, first, i);
+    }
+  }
+};
+
+function swap(array, i, j) {
+  [array[i], array[j]] = [array[j], array[i]]
+}
+
+// ---
+
+const assert = require('assert');
+
+function test() {
+  // assert.deepEqual(permute([1]), [
+  //   [1]
+  // ]);
+  // assert.deepEqual(permute([1, 2]), [
+  //   [1, 2],
+  //   [2, 1]
+  // ]);
+  assert.deepEqual(permute([1, 2, 3]), [
+    [1, 2, 3],
+    [1, 3, 2],
+    [2, 1, 3],
+    [2, 3, 1],
+    [3, 2, 1],
+    [3, 1, 2]
+  ]);
+}
+test();

lab/exercises/medium/top-k-frequent-elements.js

@@ -0,0 +1,105 @@
+/* eslint-disable */
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number[]}
+ */
+var topKFrequent = function(nums, k) {
+  const count = getCount(nums); // O(n)
+  const frequenciesToNumbers = invertMapKeyValues(count); // O(n)
+
+  // print the last k most frequent
+  const descendingFrequencies = Array.from(frequenciesToNumbers.keys()).sort((a, b) => b - a);
+  const valuesByFrequencencies = descendingFrequencies.reduce((array, key) => {
+    return array.concat(frequenciesToNumbers.get(key));
+  },[]);
+
+  // console.log(JSON.stringify({freqToNum: Array.from(freqToNum), f, v}));
+
+  return valuesByFrequencencies.slice(0, k);
+};
+
+/**
+ * Get repeated number count
+ * Runtime: O(n)
+ * @param {array} nums
+ * @returns {Map} counts
+ */
+function getCount(nums) {
+  const counts = new Map();
+
+  for(let n of nums) {
+    if(counts.has(n)) {
+      counts.set(n, 1 + counts.get(n));
+    } else {
+      counts.set(n, 1);
+    }
+  }
+
+  return counts;
+}
+
+/**
+ * Invert key and values in a Map.
+ * Similar to _.invert (https://lodash.com/docs/4.17.11#invert)
+ * @param {*} map
+ */
+function invertMapKeyValues(map) {
+  const inverted = new Map();
+
+  for(let [key, value] of map.entries()) {
+    if (inverted.has(value)) {
+      inverted.set(value, inverted.get(value).concat(key));
+    } else {
+      inverted.set(value, [key]);
+    }
+  }
+
+  return inverted;
+}
+
+/*
+< O(n log n) - linear or log
+
+*/
+
+// hashmap
+
+// ---
+
+const assert = require('assert');
+function test() {
+  assert.deepEqual(topKFrequent([1], 1), [1]);
+  assert.deepEqual(topKFrequent([1,1,1,2,2,3], 2), [1, 2]);
+  assert.deepEqual(topKFrequent([3, 1, 4, 4, 5, 2, 6, 1], 2), [1, 4]);
+  assert.deepEqual(topKFrequent([7, 10, 11, 5, 2, 5, 5, 7, 11, 8, 9], 4).sort(), [5, 11, 7, 10].sort());
+  assert.deepEqual(topKFrequent([
+    5,1,-1,-8,-7,8,-5,0,1,10,8,0,-4,3,-1,-1,4,-5,4,-3,0,2,2,2,4,-2,-4,8,-7,-7,2,-8,0,-8,10,8,-8,-2,-9,4,-7,6,6,-1,4,2,8,-3,5,-9,-3,6,-8,-5,5,10,2,-5,-1,-5,1,-3,7,0,8,-2,-3,-1,-5,4,7,-9,0,2,10,4,4,-4,-1,-1,6,-8,-9,-1,9,-9,3,5,1,6,-1,-2,4,2,4,-6,4,4,5,-5
+  ], 7).sort(), [
+    4,-1,2,-5,-8,8,0
+  ].sort());
+}
+test();
+
+
+/*
+{
+  freqToNum: Map {
+    12 => [4],
+    10 => [-1],
+    8 => [2],
+    7 => [-5],
+    6 => [-8, 8, 0],
+    5 => [5, -3, -9, 6],
+      4 => [1, -7, 10, -2],
+      3 => [-4],
+      2 => [3, 7],
+      1 => [9, -6]
+  },
+  f: [8, 7, 6, 5, 4, 3, 2, 12, 10, 1],
+  v: [2, -5, -8, 8, 0, 5, -3, -9, 6, 1, -7, 10, -2, -4, 3, 7, 4, -1, 9, -6]
+}
+
+other solutions: https://leetcode.com/submissions/detail/202508293/
+*/

lab/exercises/medium/top-k-frequent-elements2.js

@@ -0,0 +1,105 @@
+/* eslint-disable */
+
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number[]}
+ */
+var topKFrequent2 = function (nums, k) {
+
+  let newObj = {};
+
+  for (let n of nums) {
+    if (newObj[n]) {
+      newObj[n]++;
+    } else {
+      newObj[n] = 1;
+    }
+  }
+
+  return Object.keys(newObj).sort((a, b) => newObj[b] - newObj[a]).splice(0, k);
+};
+
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number[]}
+ */
+
+var topKFrequent = function (nums, k) {
+  var obj = {};
+  nums.forEach(function (item) {
+    if (!obj[item])
+      obj[item] = 1;
+    else
+      obj[item]++;
+  });
+
+  var arr = [];
+
+  for (var key in obj) {
+    arr.push({
+      key: key,
+      value: obj[key]
+    });
+  }
+
+  arr.sort(function (a, b) {
+    return b.value - a.value;
+  });
+
+  var ans = [];
+  for (var i = 0; i < k; i++)
+    ans.push(+arr[i].key);
+
+
+  // console.log(JSON.stringify({
+  //   obj,
+  //   arr,
+  //   ans
+  // }))
+
+  return ans;
+};
+
+// ---
+
+const assert = require('assert');
+
+function test() {
+  assert.deepEqual(topKFrequent([1], 1), [1]);
+  assert.deepEqual(topKFrequent([1, 1, 1, 2, 2, 3], 2), [1, 2]);
+  assert.deepEqual(topKFrequent([3, 1, 4, 4, 5, 2, 6, 1], 2), [1, 4]);
+  // assert.deepEqual(topKFrequent([7, 10, 11, 5, 2, 5, 5, 7, 11, 8, 9], 4).sort(), [5, 11, 7, 10].sort());
+  // assert.deepEqual(topKFrequent([7, 10, 11, 5, 2, 5, 5, 7, 11, 8, 9], 4).sort(), [5, 7, 11, 2].sort());  // also
+  assert.deepEqual(topKFrequent([
+    5, 1, -1, -8, -7, 8, -5, 0, 1, 10, 8, 0, -4, 3, -1, -1, 4, -5, 4, -3, 0, 2, 2, 2, 4, -2, -4, 8, -7, -7, 2, -8, 0, -8, 10, 8, -8, -2, -9, 4, -7, 6, 6, -1, 4, 2, 8, -3, 5, -9, -3, 6, -8, -5, 5, 10, 2, -5, -1, -5, 1, -3, 7, 0, 8, -2, -3, -1, -5, 4, 7, -9, 0, 2, 10, 4, 4, -4, -1, -1, 6, -8, -9, -1, 9, -9, 3, 5, 1, 6, -1, -2, 4, 2, 4, -6, 4, 4, 5, -5
+  ], 7).sort(), [
+    4, -1, 2, -5, -8, 8, 0
+  ].sort());
+}
+test();
+
+
+/*
+{
+  freqToNum: Map {
+    12 => [4],
+    10 => [-1],
+    8 => [2],
+    7 => [-5],
+    6 => [-8, 8, 0],
+    5 => [5, -3, -9, 6],
+      4 => [1, -7, 10, -2],
+      3 => [-4],
+      2 => [3, 7],
+      1 => [9, -6]
+  },
+  f: [8, 7, 6, 5, 4, 3, 2, 12, 10, 1],
+  v: [2, -5, -8, 8, 0, 5, -3, -9, 6, 1, -7, 10, -2, -4, 3, 7, 4, -1, 9, -6]
+}
+
+other solutions: https://leetcode.com/submissions/detail/202508293/
+*/

lab/exercises/medium/zigzag-conversion.js

@@ -1,5 +1,5 @@
 /* eslint-disable */
-// 2d-array
+// 2d-array; time: O(n); space: O(n^2)
 
 /**
  * @param {string} s
@@ -59,9 +59,43 @@ function goDiagonal({ col, row, index, table, word, numRows }) {
 
 const assert = require('assert');
 function test() {
+  assert.equal(convert('PAYPALISHIRING', 1), 'PAYPALISHIRING');
+  assert.equal(convert('PAYPALISHIRING', 2), 'PYAIHRNAPLSIIG');
   assert.equal(convert('PAYPALISHIRING', 3), 'PAHNAPLSIIGYIR');
   assert.equal(convert('PAYPALISHIRING', 4), 'PINALSIGYAHRPI');
-  assert.equal(convert('AB', 1), 'AB');
 }
-
 test();
+
+/*
+char* convert(char* s, int numRows) {
+  if (numRows == 1) {
+      return s;
+  }
+  int len = strlen(s);
+  char *buf = (char *) malloc(sizeof(char) * (len + 1));
+  int i = 0;
+  for (int row = 0; row < numRows; row++) {
+      int step = (numRows - 1) * 2;
+      int j = 0;
+      while (j + row < len) {
+          buf[i++] = s[j + row];
+          j += step;
+          if (row > 0 && row < numRows - 1 && j - row < len) {
+              buf[i++] = s[j - row];
+          }
+      }
+  }
+  buf[len] = '\0';
+  return buf;
+}
+*/
+
+// function convert(s, numRows) {
+//   if (numRows === 1) { return s; }
+
+//   let buffer;
+//   let i = 0;
+//   for(let row = 0; row < numRows; row++) {
+//     const step = (numRows - 1 ) * 2; // Characters in row 0 are located at indexes
+//   }
+// }