Merge pull request neetcode-gh#363 from loczek/main

Created javascript solutions for 20 problems

Author: neetcode-gh

javascript/105-Construct-Binary-Tree-from-Preorder-and-Inorder-Traversal.js

@@ -0,0 +1,10 @@
+function buildTree(preorder, inorder) {
+  if (!preorder.length || !inorder.length) return null;
+
+  let root = new TreeNode(preorder[0]);
+  let mid = inorder.indexOf(preorder[0]);
+
+  root.left = buildTree(preorder.slice(1, mid + 1), inorder.slice(0, mid));
+  root.right = buildTree(preorder.slice(mid + 1), inorder.slice(mid + 1));
+  return root;
+}

javascript/131-Palindrome-Partitioning.js

@@ -0,0 +1,33 @@
+function partition(s) {
+  let res = [];
+  let part = [];
+
+  function dfs(i) {
+    if (i >= s.length) {
+      res.push(part.slice());
+      return;
+    }
+
+    for (let j = i; j < s.length; j++) {
+      if (isPali(s, i, j)) {
+        part.push(s.slice(i, j + 1));
+        dfs(j + 1);
+        part.pop();
+      }
+    }
+  }
+
+  dfs(0);
+  return res;
+
+  function isPali(s, l, r) {
+    while (l < r) {
+      if (s[l] != s[r]) {
+        return false;
+      }
+      l = l + 1;
+      r = r - 1;
+    }
+    return true;
+  }
+}

javascript/1448-Count-Good-Nodes-in-Binary-Tree.js

@@ -0,0 +1,20 @@
+function goodNodes(root) {
+  let total = 0;
+
+  function traverse(node, prev) {
+    if (!node) return;
+
+    if (node.left || node.right) {
+      traverse(node.left, Math.max(node.val, prev));
+      traverse(node.right, Math.max(node.val, prev));
+    }
+
+    if (node.val >= prev) {
+      total += 1;
+    }
+  }
+
+  traverse(root, root.val);
+
+  return total;
+}

javascript/17-Letter-Combinations-of-a-Phone-Number.js

@@ -0,0 +1,31 @@
+function letterCombinations(digits) {
+  let res = [];
+
+  const digitToChar = {
+    2: "abc",
+    3: "def",
+    4: "ghi",
+    5: "jkl",
+    6: "mno",
+    7: "qprs",
+    8: "tuv",
+    9: "wxyz",
+  };
+
+  function backtrack(i, curStr) {
+    if (curStr.length === digits.length) {
+      res.push(curStr);
+      return;
+    }
+
+    for (const c of digitToChar[digits[i]]) {
+      backtrack(i + 1, curStr + c);
+    }
+  }
+
+  if (digits) {
+    backtrack(0, "");
+  }
+
+  return res;
+}

javascript/198-House-Robber.js

@@ -0,0 +1,12 @@
+function rob(nums) {
+  let rob1 = 0;
+  let rob2 = 0;
+
+  for (const n of nums) {
+    let temp = Math.max(n + rob1, rob2);
+    rob1 = rob2;
+    rob2 = temp;
+  }
+
+  return rob2;
+}

javascript/2-Add-Two-Numbers.js

@@ -0,0 +1,27 @@
+function addTwoNumbers(l1, l2) {
+  let temp1 = l1;
+  let temp2 = l2;
+
+  let dummy = new ListNode(0);
+  let merged = dummy;
+
+  let carry = 0;
+
+  while (temp1 || temp2) {
+    let sum = (temp1?.val || 0) + (temp2?.val || 0) + carry;
+    carry = Math.floor(sum / 10);
+    sum = sum % 10;
+
+    merged.next = new ListNode(sum);
+    merged = merged.next;
+
+    if (temp1) temp1 = temp1?.next;
+    if (temp2) temp2 = temp2?.next;
+  }
+
+  if (carry > 0) {
+    merged.next = new ListNode(carry);
+  }
+
+  return dummy.next;
+}

javascript/202-Happy-Number.js

@@ -0,0 +1,25 @@
+function isHappy(n) {
+  const visit = new Set();
+
+  while (!visit.has(n)) {
+    visit.add(n);
+    n = sumOfSquares(n);
+
+    if (n == 1) return true;
+  }
+
+  return false;
+}
+
+function sumOfSquares(n) {
+  let output = 0;
+
+  while (n) {
+    let digit = n % 10;
+    digit = digit ** 2;
+    output += digit;
+    n = Math.floor(n / 10);
+  }
+
+  return output;
+}

javascript/208-Implement-Trie.js

@@ -0,0 +1,50 @@
+class TrieNode {
+  constructor() {
+    this.children = {};
+    this.endOfWord = false;
+  }
+}
+
+class Trie {
+  constructor() {
+    this.root = new TrieNode();
+  }
+
+  insert(word) {
+    let cur = this.root;
+
+    for (const c of word) {
+      if (!(c in cur.children)) {
+        cur.children[c] = new TrieNode();
+      }
+      cur = cur.children[c];
+    }
+    cur.endOfWord = true;
+  }
+
+  search(word) {
+    let cur = this.root;
+
+    for (const c of word) {
+      if (!(c in cur.children)) {
+        return false;
+      }
+      cur = cur.children[c];
+    }
+
+    return cur.endOfWord;
+  }
+
+  startsWith(prefix) {
+    let cur = this.root;
+
+    for (const c of prefix) {
+      if (!(c in cur.children)) {
+        return false;
+      }
+      cur = cur.children[c];
+    }
+
+    return true;
+  }
+}

javascript/211-Design-Add-and-Search-Words-Data-Structure.js

@@ -0,0 +1,55 @@
+class TrieNode {
+  constructor() {
+    this.children = {};
+    this.endOfWord = false;
+  }
+}
+
+class WordDictionary {
+  constructor() {
+    this.root = new TrieNode();
+  }
+
+  addWord(word) {
+    let cur = this.root;
+
+    for (const c of word) {
+      if (!(c in cur.children)) {
+        cur.children[c] = new TrieNode();
+      }
+      cur = cur.children[c];
+    }
+    cur.endOfWord = true;
+  }
+
+  search(word) {
+    function dfs(j, root) {
+      let cur = root;
+
+      for (let i = j; i < word.length; i++) {
+        const c = word[i];
+
+        if (c === ".") {
+          for (const key in cur.children) {
+            if (Object.prototype.hasOwnProperty.call(cur.children, key)) {
+              const child = cur.children[key];
+
+              if (dfs(i + 1, child)) {
+                return true;
+              }
+            }
+          }
+          return false;
+        } else {
+          if (!(c in cur.children)) {
+            return false;
+          }
+          cur = cur.children[c];
+        }
+      }
+
+      return cur.endOfWord;
+    }
+    return dfs(0, this.root);
+  }
+}

javascript/22-Generate-Parentheses.js

@@ -0,0 +1,27 @@
+function generateParenthesis(n) {
+  const stack = [];
+  const res = [];
+
+  function backtrack(openN, closedN) {
+    if (openN === n && closedN === n) {
+      res.push(stack.join(""));
+      return;
+    }
+
+    if (openN < n) {
+      backtrack(openN + 1, closedN);
+      stack.pop();
+      stack.push("(");
+    }
+
+    if (closedN < openN) {
+      backtrack(openN, closedN + 1);
+      stack.push(")");
+      stack.pop();
+    }
+  }
+
+  backtrack(0, 0);
+
+  return res;
+}