Merge pull request #657 from anniemon/main

[anniemon78] Week 1

Author: anniemon

contains-duplicate/anniemon.js

@@ -0,0 +1,23 @@
+/**
+ * 시간 복잡도:
+ * 맵에서 nums[i]를 찾거나 삽입하는 데 걸리는 시간 O(1) * n(nums.length)
+ * 즉, O(n)
+ * 공간 복잡도:
+ * 최대 map의 크기는 nums.length만큼
+ * 즉, O(n)
+ */
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var containsDuplicate = function(nums) {
+  const map = new Map();
+  for(let i = 0; i < nums.length; i++) {
+      if(!map.has(nums[i])) {
+          map.set(nums[i], i);
+      } else {
+          return true;
+      }
+  }
+  return false;
+};

longest-consecutive-sequence/anniemon.js

@@ -0,0 +1,30 @@
+/**
+ * 시간 복잡도:
+ *   set의 요소 중 연속하는 시퀀스의 첫번째 숫자일 때만
+ *   while 루프를 실행
+ *   따라서 요소당 최대 1회 순회
+ *   즉, 시간 복잡도는 O(n)
+ * 공간 복잡도:
+ *   set은 중복이 없을 경우 최대 O(n)를 차지함
+ *   즉, 공간 복잡도는 O(n)
+ */
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var longestConsecutive = function (nums) {
+  const set = new Set(nums);
+  let res = 0;
+  for (const n of set) {
+      let seqLen = 0, target = n;
+      const isSeqStart = !set.has(target - 1);
+      if (isSeqStart) {
+          while (set.has(target)) {
+              target++;
+              seqLen++;
+          }
+      }
+      res = Math.max(seqLen, res);
+  }
+  return res;
+};

top-k-frequent-elements/anniemon.js

@@ -0,0 +1,24 @@
+/**
+ * 시간 복잡도:
+ * nums.length만큼의 배열을 정렬해야 하므로
+ * 즉, O(n * log n)
+ * 공간 복잡도:
+ * 최대 nums.length만큼의 map 생성
+ * 즉, O(n)
+ */
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number[]}
+ */
+var topKFrequent = function(nums, k) {
+  const map = new Map();
+  for(const n of nums) {
+      if(!map.has(n)) {
+          map.set(n, 0);
+      }
+      map.set(n, map.get(n) + 1)
+  }
+  const sorted = Array.from(map).sort((a, b) => b[1]-a[1]);
+  return sorted.slice(0, k).map(e =>  e[0])
+};

valid-palindrome/anniemon.js

@@ -0,0 +1,34 @@
+/**
+ * 시간 복잡도:
+ * s.length만큼 탐색. 즉, O(n)
+ * 공간 복잡도:
+ * 변수와 함수만 저장. 즉, O(1)
+ */
+
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+var isPalindrome = function(s) {
+  const isAlphaNumeric = (v) => {
+      return (/^[a-z0-9]$/i).test(v);
+  };
+
+  let l = 0;
+  let r = s.length - 1;
+  while(l < r) {
+      while(!isAlphaNumeric(s[l]) && l < r) {
+          l++;
+      }
+      while(!isAlphaNumeric(s[r]) && l < r) {
+          r--;
+      }
+
+      if(s[l].toLowerCase() !== s[r].toLowerCase()) {
+          return false;
+      }
+      l++;
+      r--;
+  }
+  return true;
+};