[togo26] WEEK 02 solutions

3sum/togo26.js

@@ -0,0 +1,57 @@
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+/// TC: TLE / SC: O(n)
+// var threeSum = function(nums) {
+//     const result = [];
+//     const memo = {};
+
+//     for (let i = 0; i < nums.length; i++) {
+//         for (let j = 0; j < nums.length; j++) {
+//             for (let k = 0; k < nums.length; k++) {
+//                 if (i === k || i === j || j === k) continue;
+//                 const comb = [nums[i], nums[j], nums[k]].sort((a, b) => a - b).join(",");
+
+//                 if (memo[comb]) continue;
+//                 if (!memo[comb]) memo[comb] = true;
+//                 const sum = nums[i] + nums[j] + nums[k];
+//                 if (sum === 0) result.push([nums[i], nums[j], nums[k]]);
+//             }
+//         }
+//     }
+
+//     return result;
+// };
+
+// TC: O(n^2) / SC: O(1)
+var threeSum = function (nums) {
+  const result = [];
+
+  nums.sort((a, b) => a - b);
+
+  for (let i = 0; i < nums.length; i++) {
+    if (i > 0 && nums[i] === nums[i - 1]) continue;
+    if (nums[i] > 0) break;
+
+    let left = i + 1;
+    let right = nums.length - 1;
+
+    while (left < right) {
+      const sum = nums[left] + nums[right];
+      if (sum === -nums[i]) {
+        result.push([nums[i], nums[left], nums[right]]);
+        while (left < right && nums[left] === nums[left + 1]) left++;
+        while (left < right && nums[right] === nums[right - 1]) right--;
+        left++;
+        right--;
+      } else if (sum < -nums[i]) {
+        left++;
+      } else {
+        right--;
+      }
+    }
+  }
+
+  return result;
+};

climbing-stairs/togo26.js

@@ -0,0 +1,28 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+
+// TC: O(n) / SC: O(n)
+var climbStairs = function (n) {
+  if (n <= 3) return n;
+  const dp = [1, 2, 3];
+  for (let i = 3; i < n; i++) {
+    dp[i] = dp[i - 2] + dp[i - 1];
+  }
+
+  return dp[dp.length - 1];
+};
+
+// TC: O(n) / SC: O(1)
+var climbStairs = function (n) {
+  let temp,
+    pre1 = 1,
+    pre2 = 1;
+  for (let i = 1; i < n; i++) {
+    temp = pre2;
+    pre2 = pre1 + pre2;
+    pre1 = temp;
+  }
+  return pre2;
+};

product-of-array-except-self/togo26.js

@@ -0,0 +1,37 @@
+// TC: O(n) / SC: O(n)
+var productExceptSelf = function (nums) {
+  const left = [1];
+  const right = [1];
+  const result = [];
+
+  for (let i = 1; i < nums.length; i++) {
+    left.push(left[i - 1] * nums[i - 1]);
+  }
+
+  for (let i = nums.length - 1; i > 0; i--) {
+    right.push(right[nums.length - 1 - i] * nums[i]);
+  }
+
+  for (let i = 0, j = nums.length - 1; i < nums.length; i++, j--) {
+    result[i] = left[i] * right[j];
+  }
+
+  return result;
+};
+
+// TC: O(n) / SC: O(1)
+var productExceptSelf = function (nums) {
+  const left = new Array(nums.length).fill(1);
+
+  for (let i = 1; i < nums.length; i++) {
+    left[i] = left[i - 1] * nums[i - 1];
+  }
+
+  let rightProduct = 1;
+  for (let i = nums.length - 1; i >= 0; i--) {
+    left[i] *= rightProduct;
+    rightProduct *= nums[i];
+  }
+
+  return left;
+};

valid-anagram/togo26.js

@@ -0,0 +1,25 @@
+/**
+ * @param {string} s
+ * @param {string} t
+ * @return {boolean}
+ */
+// TC: O(nlogn) / SC: O(n)
+var isAnagram = function (s, t) {
+  const sortedS = [...s].sort().join('');
+  const sortedT = [...t].sort().join('');
+  return sortedS === sortedT;
+};
+
+// TC: O(n) / SC: O(n)
+var isAnagram = function (s, t) {
+  if (s.length !== t.length) return false;
+  const sCount = [...s].reduce((acc, cur) => {
+    acc[cur] = (acc[cur] ?? 0) + 1;
+    return acc;
+  }, {});
+  const tCount = [...t].reduce((acc, cur) => {
+    acc[cur] = (acc[cur] ?? 0) + 1 ;
+    return acc;
+  }, {});
+  return Object.keys(sCount).every(key => sCount[key] === tCount[key]);
+};

validate-binary-search-tree/togo26.js

@@ -0,0 +1,14 @@
+/**
+ * @param {TreeNode} root
+ * @return {boolean}
+ */
+// TC: O(n) / SC: Best O(height) - Worst O(n)
+var isValidBST = function (root) {
+  function traverse(node, min, max) {
+    if (!node) return true;
+    if (!(min < node.val && node.val < max)) return false;
+    return traverse(node.left, min, node.val) && traverse(node.right, node.val, max);
+  }
+
+  return traverse(root, -Infinity, Infinity);
+};