[나리] WEEK 03 Solutions

climbing-stairs/naringst.js

@@ -0,0 +1,28 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+/**
+ * Note: DP
+ * 결국 1개 전의 값에서 1칸을 더 가거나, 2개 전의 값에서 2칸을 더 가는 경우의 수가 생긴다.
+ * 1일때에는 1칸을 가는 방법의 경우 뿐이지만, 2일때에는 0칸 가는 것에서 2칸을 가거나 1칸을 가는 것에서 1칸을 더 갈 수 있다.
+ * 3일 때에는 1까지 갔을 경우에서 2칸을 더 가거나, 2까지 갔을 경우에서 1칸을 더 가면 되니까 1까지 갔을 경우의 수 + 2까지 갔을 경우의 수
+ *
+ *
+ * Runtime: 41ms, Memory: 48.95MB
+ * Time complexity: O(n)
+ * Space complexity: O(n)
+ *
+ */
+
+var climbStairs = function (n) {
+  const dp = Array(n).fill(0);
+  dp[1] = 1;
+  dp[2] = 2;
+
+  for (let i = 3; i < n + 1; i++) {
+    dp[i] = dp[i - 2] + dp[i - 1];
+  }
+
+  return dp[n];
+};

product-of-array-except-self/naringst.js

@@ -0,0 +1,74 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+
+/**
+ * Runtime: 124ms, Memory: 65.06MB
+ * Time complexity: O(n^2)
+ * Space complexity: O(n)
+ * -> answer 배열에 O(n)
+ * -> splicedArr 배열에 O(n)
+ */
+
+var productExceptSelf = function (nums) {
+  const totalProduct = nums.reduce((total, current) => total * current, 1);
+  const answer = Array(nums.length).fill(0);
+
+  for (let i = 0; i < nums.length; i++) {
+    answer[i] = totalProduct / nums[i];
+    if (nums[i] === 0) {
+      const splicedArr = nums.filter(function (_, index) {
+        return index !== i;
+      });
+      answer[i] = splicedArr.reduce((total, current) => total * current, 1);
+    }
+  }
+
+  return answer;
+};
+
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+
+/**
+ * 위의 풀이는 0일 때마다 순회를 해야 하기 때문에 해당 부분을 0의 개수를 세어 처리하도록 변경한 풀이
+
+ * Runtime: 109ms, Memory: 63.45MB
+ * Time complexity: O(n)
+ * Space complexity: O(n)
+
+ */
+var productExceptSelf = function (nums) {
+  let totalProduct = 1;
+  let zeroCount = 0;
+  const answer = Array(nums.length).fill(0);
+
+  for (let numIndex = 0; numIndex < nums.length; numIndex++) {
+    if (nums[numIndex] === 0) {
+      zeroCount += 1;
+    } else {
+      totalProduct *= nums[numIndex];
+    }
+  }
+
+  for (let i = 0; i < nums.length; i++) {
+    if (nums[i] === 0) {
+      if (zeroCount - 1 > 0) {
+        answer[i] = 0;
+      } else {
+        answer[i] = totalProduct;
+      }
+    } else {
+      if (zeroCount > 0) {
+        answer[i] = 0;
+      } else {
+        answer[i] = totalProduct / nums[i];
+      }
+    }
+  }
+
+  return answer;
+};

two-sum/naringst.js

@@ -0,0 +1,49 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number[]}
+ */
+
+/**
+ * Runtime: 107ms, Memory: 49.52MB
+ * Time complexity: O(n^2)
+ * Space complexity: O(n^2)
+ *
+ * **/
+
+var twoSum = function (nums, target) {
+  const answer = [];
+  for (let i = 0; i < nums.length - 1; i++) {
+    for (let j = i + 1; j < nums.length; j++) {
+      if (nums[i] + nums[j] === target) {
+        return [i, j];
+      }
+    }
+  }
+};
+
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number[]}
+ */
+
+/**
+ * 다른 풀이: two의 sum 이니까 target - 현재 값을 한 뒤, 나머지 값이 배열에 있는지 찾는 방법.
+ * 이 과정에서 해시맵을 사용해서 target - 현재 값이 map 에 존재하면 return
+ * 없다면 map에 나머지 값과 그에 해당하는 인덱스를 추가한다.
+ * 그럼 추후에는 나머지 값을 map에서 O(1)로 찾기만 하면 된다.
+ *
+ * Runtime: 49ms, Memory: 49.52MB
+ * Time complexity: O(n)
+ * Space complexity: O(n)
+ * **/
+
+var twoSum = function (nums, target) {
+  let map = new Map();
+
+  for (i = 0; i < nums.length; i++) {
+    if (map.has(target - nums[i])) return [map.get(target - nums[i]), i];
+    map.set(nums[i], i);
+  }
+};