[hozzijeong] WEEK 02 solutions

3sum/hozzijeong.js

@@ -0,0 +1,45 @@
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+var threeSum = function(nums) {
+    nums.sort((a,b) => a-b);
+    const length = nums.length;
+
+    const answer = [];
+
+
+    for(let i = 0; i < length - 2; i++){
+        if(i > 0 && nums[i] === nums[i-1]) continue;
+        if(nums[i] > 0) break;
+
+        let left = i + 1;
+        let right = length -1;
+
+        while(left < right){
+            const result = nums[left]+ nums[right] + nums[i];
+
+            if(result > 0) {
+                right -= 1;
+            }
+
+            if(result < 0) {
+                left +=1;
+            }
+
+            if(result === 0) {
+                answer.push([nums[i],nums[left],nums[right]]);
+
+                while(left < right && nums[left] === nums[left + 1]) left += 1;
+                while(left < right && nums[right] === nums[right - 1]) right -=1;
+
+                left += 1;
+                right -= 1;
+            }
+        }
+
+
+    }
+
+    return answer    
+};

climbing-stairs/hozzijeong.js

@@ -0,0 +1,21 @@
+/**
+ * DP 문제라는 것을 알았지만 개념을 잘 몰라서 약간의 검색을 했습니다.
+ * 하나의 문제를 여러 작은 문제들로 쪼갤 수 있고, 그 쪼갠 문제가 다시 해당 문제의 해답이 될 수 있으며, 중복된 값이 존재하는 조건에 맞기 떄문에 DP로 풀었습니다.
+ * 처음에는 피보나치 형식으로 접근했다가 시간초과가 나버려서 bottom-up 방식으로 변경해서 적용했습니다
+ */
+
+
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var climbStairs = function(n) {
+    const answer = [1,2];
+
+    for(let i = 2; i < n; i++){
+        const value = answer[i-1] + answer[i-2];
+        answer.push(value);
+    }
+
+    return answer[n-1];
+};

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

@@ -0,0 +1,23 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+var productExceptSelf = function(nums) {
+    // 0이 2개 이상인 경우에는 무조건 0
+    if(nums.filter((num) => num === 0).length > 1) return Array.from({length:nums.length}).fill(0);
+
+    // 0이  1개인 경우에 나타나는 수
+    const hasZero = nums.includes(0);
+
+    const allMatrix = nums.filter(Boolean). reduce((acc, cur) => (acc * cur),1);
+
+    return nums.map((num) => {
+        if(hasZero){
+            if(num !== 0) return 0;
+
+            return allMatrix
+        }
+
+        return allMatrix / num
+    });
+};

valid-anagram/hozzijeong.js

@@ -0,0 +1,48 @@
+/**
+ * @param {string} s
+ * @param {string} t
+ * @return {boolean}
+ */
+
+ /**
+  * map을 통해 문자의 개수를 저장하고, 두 문자열의 문자 개수를 비교해서 다른 값이 있다면 false를 반환하도록 풀이를작성했습니다
+  *
+  */
+var isAnagram = function(s, t) {
+    if(s.length !== t.length) return false;
+
+    const length = s.length;
+
+    const stringMap = new Map();
+    const targetMap = new Map();
+
+    for(let i = 0; i < length; i ++){
+
+        const stringChar = s[i];
+        const currentStringMap = stringMap.get(stringChar);
+
+        if(currentStringMap){
+            stringMap.set(stringChar, currentStringMap + 1)
+        }else{
+            stringMap.set(stringChar, 1)
+        }
+
+        const targetChar = t[i];
+        const currentTargetMap = targetMap.get(targetChar);
+
+        if(currentTargetMap){
+            targetMap.set(targetChar, currentTargetMap + 1)
+        }else{
+            targetMap.set(targetChar, 1)
+        }
+    }
+
+    for(const [char, count] of [...stringMap]){
+        const targetCount = targetMap.get(char);
+
+        if(!targetCount) return false;
+        if(targetCount !== count) return false;
+    }
+
+    return true
+};