[jun0811] WEEK 01 solutions

contains-duplicate/jun0811.js

@@ -0,0 +1,18 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var containsDuplicate = function (nums) {
+  const count = [];
+  let res = false;
+
+  for (const num of nums) {
+    if (count[num]) {
+      res = true;
+      break;
+    } else {
+      count[num] = 1;
+    }
+  }
+  return res;
+};

longest-common-subsequence/jun0811.js

@@ -0,0 +1,29 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var longestConsecutive = function (nums) {
+  const set = new Set();
+
+  // set 생성 : O(n)
+  for (const num of nums) {
+    set.add(num);
+  }
+
+  let res = 0;
+
+  // set 순회 : O(n)
+  for (const num of set) {
+    if (set.has(num - 1)) continue;
+    let tmp = 1;
+    let cur = num;
+    // While 루프 전체: O(n)
+    while (true) {
+      const v = (cur += 1);
+      if (set.has(v)) tmp += 1;
+      else break;
+    }
+    if (tmp > res) res = tmp;
+  }
+  return res;
+};

number-of-1-bits/jun0811.js

@@ -0,0 +1,12 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var hammingWeight = function (n) {
+  let res = 0;
+  while (n > 0) {
+    res += n & 1;
+    n = n >> 1; // 나누기 2
+  }
+  return res;
+};

top-k-frequent-elements/jun0811.js

@@ -0,0 +1,20 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number[]}
+ */
+var topKFrequent = function (nums, k) {
+  const countMap = new Map();
+  for (const num of nums) {
+    if (countMap.has(num)) {
+      countMap.set(num, countMap.get(num) + 1);
+    } else {
+      countMap.set(num, 1);
+    }
+  }
+  const countArr = [...countMap];
+  countArr.sort((a, b) => b[1] - a[1]);
+
+  const res = countArr.slice(0, k).map((count) => count[0]);
+  return res;
+};

two-sum/jun0811.js

@@ -0,0 +1,26 @@
+// Time Complexity : O(N^2)
+
+var twoSum = function (nums, target) {
+  const l = nums.length;
+  for (let i = 0; i < l; i++) {
+    for (let j = i + 1; j < l; j++) {
+      const value = nums[i] + nums[j];
+      if (value == target) return [i, j];
+    }
+  }
+};
+
+// Time Complexity : O(N)
+
+var twoSum = function (nums, target) {
+  const Map = {};
+
+  nums.forEach((num, idx) => {
+    Map[num] = idx;
+  });
+
+  for (const idx in nums) {
+    const value = target - nums[idx];
+    if (Map[value] >= 0 && Map[value] != idx) return [+idx, Map[value]];
+  }
+};