[혜준] Week1 문제 풀이

contains-duplicate/hyejjun.js

@@ -0,0 +1,16 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var containsDuplicate = function (nums) {
+
+  const set = new Set(nums);
+
+  return nums.length !== set.size ? true : false;
+
+};
+
+
+console.log(containsDuplicate([1, 2, 3, 1])); // true
+console.log(containsDuplicate([1, 2, 3, 4])); // false
+console.log(containsDuplicate([1, 1, 1, 3, 3, 4, 3, 2, 4, 2])); // true

number-of-1-bits/hyejjun.js

@@ -0,0 +1,20 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var hammingWeight = function (n) {
+
+  let val = n.toString(2);
+
+  let res = 0;
+  [...val].forEach((val) => res += parseInt(val))
+
+  return res;
+
+};
+
+// O(LogN)
+
+console.log(hammingWeight(11));
+console.log(hammingWeight(128));
+console.log(hammingWeight(2147483645));

palindromic-substrings/hyejjun.js

@@ -0,0 +1,32 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var countSubstrings = function (s) {
+    let count = 0;
+
+    function checkPalindromic(left, right) {
+        while (left >= 0 && right < s.length && s[left] === s[right]) {
+            count++;
+            left--;
+            right++;
+        }
+
+    }
+
+    for (let i = 0; i < s.length; i++) {
+        checkPalindromic(i, i);
+        checkPalindromic(i, i + 1);
+    }
+
+    return count;
+};
+
+console.log(countSubstrings("abc"));
+console.log(countSubstrings("aaa"));
+
+
+/*
+Time Complexity : O(n^2)
+Space Complexity: O(1)
+*/

top-k-frequent-elements/hyejjun.js

@@ -0,0 +1,25 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number[]}
+ */
+var topKFrequent = function (nums, k) {
+    const count = {};
+
+    nums.forEach((num) => {
+        count[num] = (count[num] || 0) + 1;
+    });
+
+    const filtered = Object.keys(count).sort((a, b) => count[b] - count[a]);
+
+    return filtered.slice(0, k).map(Number);
+
+};
+
+console.log(topKFrequent([1, 1, 1, 2, 2, 3], 2)); // [1, 2]
+console.log(topKFrequent([1], 1)); // [1]
+
+/*
+Time Complexity : O(NLogN)
+Space Complexity: O(N)
+*/