Merge pull request #321 from kim-young/main

[kimyoung] WEEK 01 Solutions

Author: leokim0922

contains-duplicate/kimyoung.js

@@ -0,0 +1,13 @@
+var containsDuplicate = function (nums) {
+  let set = new Set(); // create a set to keep track of items within the nums array
+  for (const el of nums) set.add(el); // add items to the set, duplicates will automatically be ignored (set vs map)
+  return set.size !== nums.length; // compare the length of nums array and the size of the set, which shows if there's a duplicate or not
+};
+
+// test cases
+console.log(containsDuplicate([])); // false
+console.log(containsDuplicate([1, 2, 3, 1])); // true
+console.log(containsDuplicate([1, 2, 3, 4])); // false
+
+// space - O(n) - creating a set to store elements
+// time - O(n) - traverse through the array

kth-smallest-element-in-a-bst/kimyoung.js

@@ -0,0 +1,15 @@
+var kthSmallest = function (root, k) {
+  const nums = [];
+  function helper(node) { // helper method to traverse the binary tree to map the node values to nums array
+    if (!node) return;
+    nums.push(node.val);
+    if (node.left) helper(node.left); // recursive call to left node if it exists
+    if (node.right) helper(node.right); // recursive call to right node if it exists
+  }
+  helper(root);
+  const sorted = nums.sort((a, b) => a - b); // sort the nums array
+  return sorted[k - 1]; //  return kth smallest val
+};
+
+// space - O(n) - mapping node values into nums array
+// time - O(nlogn) - sort

number-of-1-bits/kimyoung.js

@@ -0,0 +1,16 @@
+var hammingWeight = function (n) {
+  let bitVal = n.toString(2); // convert input value to bit
+  let setBits = 0;
+  for (const char of bitVal) { // iterate through the string bit value to check the number of "1"s
+    if (char === "1") setBits++; // increment if char === "1"
+  }
+  return setBits;
+};
+
+// test cases
+console.log(hammingWeight(11)); // 3
+console.log(hammingWeight(128)); // 1
+console.log(hammingWeight(2147483645)); // 30
+
+// space - O(1) - created only constant variables
+// time - O(n) - iterate through the bitVal string (larger the number the longer the string)

palindromic-substrings/kimyoung.js

@@ -0,0 +1,29 @@
+var countSubstrings = function (s) {
+  let result = 0;
+  for (let i = 0; i < s.length; i++) {
+    let left = i,
+      right = i; // odd length substrings
+    helper(s, left, right);
+
+    (left = i), (right = i + 1); // even length substrings
+    helper(s, left, right);
+  }
+  function helper(s, l, r) {
+    // increment result and keep expanding left and right, while left and right indexes are within range and they're equal
+    while (l >= 0 && r <= s.length && s[l] === s[r]) {
+      result++;
+      l--;
+      r++;
+    }
+  }
+  return result;
+};
+
+// test cases
+console.log(countSubstrings("abc")); // 3
+console.log(countSubstrings("aaa")); // 6
+console.log(countSubstrings("a")); // 1
+console.log(countSubstrings("")); // 0
+
+// space - O(1) - constant variable `result`
+// time - O(n^2) - iterating through the string and expanding both ways

top-k-frequent-elements/kimyoung.js

@@ -0,0 +1,19 @@
+var topKFrequent = function (nums, k) {
+  let obj = {};
+  for (const num of nums) {
+    obj[num] ? obj[num]++ : (obj[num] = 1);
+  }
+  let sorted = Object.entries(obj).sort((a, b) => b[1] - a[1]);
+  let result = [];
+  for (let i = 0; i < k; i++) {
+    result.push(sorted[i][0]);
+  }
+  return result;
+};
+
+// test cases
+console.log(topKFrequent([1, 1, 1, 2, 2, 3], 2)); // [1, 2]
+console.log(topKFrequent([1], 1)); // [1]
+
+// space - O(n) - mapping the object in [key, freq]
+// time - O(nlogn) - sorting the mapped objects in the order of frequency