Merge pull request #2067 from JangAyeon/main

[JangAyeon] WEEK 02 Solutions

Author: JangAyeon

3sum/JangAyeon.js

@@ -0,0 +1,31 @@
+var threeSum = function (nums) {
+  let res = [];
+  nums.sort((a, b) => a - b);
+
+  for (let i = 0; i < nums.length; i++) {
+    if (i > 0 && nums[i] === nums[i - 1]) {
+      continue;
+    }
+
+    let j = i + 1;
+    let k = nums.length - 1;
+
+    while (j < k) {
+      let total = nums[i] + nums[j] + nums[k];
+
+      if (total > 0) {
+        k--;
+      } else if (total < 0) {
+        j++;
+      } else {
+        res.push([nums[i], nums[j], nums[k]]);
+        j++;
+
+        while (nums[j] === nums[j - 1] && j < k) {
+          j++;
+        }
+      }
+    }
+  }
+  return res;
+};

climbing-stairs/JangAyeon.js

@@ -0,0 +1,14 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var climbStairs = function (n) {
+  const dp = [0, 1, 2];
+  for (let i = 3; i <= n; i++) {
+    const value = dp[i - 2] + dp[i - 1];
+    dp.push(value);
+    // console.log(i, value)
+  }
+
+  return dp[n];
+};

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

@@ -0,0 +1,29 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+var productExceptSelf = function (nums) {
+  let answer = [];
+
+  const p = [];
+  for (let i = 0; i < nums.length; i++) {
+    if (i == 0) {
+      const n = nums.slice(i + 1).reduce((acc, curr) => (acc *= curr), 1);
+      console.log(n);
+      p.push([1, n]);
+      answer.push(1 * n);
+    } else {
+      const [left, right] = p[i - 1];
+      if (nums[i] === 0) {
+        const n = nums.slice(i + 1).reduce((acc, curr) => (acc *= curr), 1);
+        p.push([left * nums[i - 1], n]);
+        answer.push(left * nums[i - 1] * n);
+      } else {
+        p.push([left * nums[i - 1], right / nums[i]]);
+        answer.push((left * nums[i - 1] * right) / nums[i]);
+      }
+    }
+  }
+
+  return answer;
+};

valid-anagram/JangAyeon.js

@@ -0,0 +1,31 @@
+/**
+ * @param {string} s
+ * @param {string} t
+ * @return {boolean}
+ */
+var isAnagram = function (s, t) {
+  const sCounter = new Map();
+  for (let e of s) {
+    // console.log(e)
+    const value = sCounter.has(e) ? sCounter.get(e) + 1 : 1;
+    sCounter.set(e, value);
+  }
+  console.log(sCounter);
+
+  for (let e of t) {
+    if (!sCounter.has(e)) {
+      return false;
+    }
+    const value = sCounter.get(e);
+    if (value - 1 < 0) {
+      return false;
+    }
+    if (value - 1 == 0) {
+      sCounter.delete(e);
+    } else {
+      sCounter.set(e, value - 1);
+    }
+  }
+  const notAllused = [...sCounter.keys()].length;
+  return !notAllused;
+};

validate-binary-search-tree/JangAyeon.js

@@ -0,0 +1,28 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {boolean}
+ */
+const dfs = (node, left, right) => {
+  if (!node) {
+    return true;
+  }
+
+  return (
+    node.val > left &&
+    node.val < right &&
+    dfs(node.left, left, node.val) &&
+    dfs(node.right, node.val, right)
+  );
+};
+
+const isValidBST = function (root) {
+  return dfs(root, -Infinity, Infinity);
+};