Merge pull request #2004 from sujeong-dev/main

[sujeong-dev] WEEK 01 solutions

Author: sujeong-dev

contains-duplicate/sujeong-dev.js

@@ -0,0 +1,46 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ * 
+ * 시간복잡도 계산
+ * 입력 크기(n)가 커질 때 연산 횟수가 n에 비례해서 증가
+ * => O(n)
+ * 
+ * 공간복잡도 계산
+ * indices가 nums에 비례해서 할당
+ * 상수 i 할당
+ * => O(n)
+ */
+var containsDuplicate = function (nums) {
+  let indices = {};
+  nums.forEach((num, index) => {
+    indices[num] = index;
+  });
+
+  for (let i = 0; i < nums.length; i++) {
+    if (nums[i] in indices && indices[nums[i]] !== i) return true;
+  }
+
+  return false;
+};
+
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ * 
+ * 시간복잡도 계산
+ * Set의 size속성은 입력 크기와 관계없이 일정한 시간이 걸림
+ * => O(1)
+ * 
+ * 공간복잡도 계산
+ * indices가 nums에 비례해서 할당
+ * 상수 i 할당
+ * => O(n)
+ */
+var containsDuplicate = function (nums) {
+  const indices = new Set(nums);
+
+  if (indices.size !== nums.length) return true;
+
+  return false;
+};

top-k-frequent-elements/sujeong-dev.js

@@ -0,0 +1,28 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number[]}
+ * 
+ * 시간복잡도 계산
+ * for loop가  O(n)
+ * reduce가 O(n)
+ * sort가 O(n log n)
+ * => O(n log n)
+ */
+var topKFrequent = function (nums, k) {
+  let result = [];
+  for (let i = 0; i < nums.length; i++) {
+    if (result.find((el) => el.key == nums[i])) continue;
+    const count = nums.reduce((cnt, el) => cnt + (nums[i] === el), 0);
+    result.push({ key: nums[i], value: count });
+  }
+
+  return result
+    .sort((a, b) => b.value - a.value)
+    .slice(0, k)
+    .map((el) => el.key);
+};
+
+/**
+ * Follow up: Your algorithm's time complexity must be better than O(n log n), where n is the array's size.
+ */

two-sum/sujeong-dev.js

@@ -0,0 +1,52 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number[]}
+ * 
+ * 시간복잡도 계산
+ * 입력 크기(n)가 커질 때 연산 횟수가 n^2에 비례해서 증가
+ * => O(n^2)
+ * 
+ * 공간복잡도 계산
+ * 상수 i 할당
+ * 상수 j 할당
+ * => o(1)
+ */
+var twoSum = function (nums, target) {
+  for (let i = 0; i < nums.length; i++) {
+    for (let j = 0; j < nums.length; j++) {
+      if (i === j) continue;
+      if (nums[i] + nums[j] === target) return [i, j];
+    }
+  }
+};
+
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number[]}
+ * 
+ * 시간복잡도 계산
+ * 입력 크기(n)가 커질 때 연산 횟수가 n에 비례해서 증가
+ * => O(n)
+ * 
+ * 공간복잡도 계산
+ * result가 nums에 비례해서 할당
+ * 상수 i, findNum 할당
+ * => O(n)
+ */
+var twoSum = function (nums, target) {
+  let result = {};
+
+  nums.forEach((num, index) => {
+    result[num] = index;
+  });
+
+  for (let i = 0; i < nums.length; i++) {
+    const findNum = target - nums[i];
+
+    if (findNum in result && result[findNum] !== i) {
+      return [i, result[findNum]];
+    }
+  }
+};