[uraflower] WEEK 03 solutions

combination-sum/uraflower.js

@@ -0,0 +1,44 @@
+/**
+ * 주어진 배열의 원소 조합(중복 허용)의 합이 target인 모든 경우를 반환하는 함수
+ * @param {number[]} candidates
+ * @param {number} target
+ * @return {number[][]}
+ */
+const combinationSum = function(candidates, target) {
+    const sortedCandidates = candidates.filter((x) => x <= target).sort((a, b) => Number(a) - Number(b));
+    const answer = [];
+
+    if (sortedCandidates.length === 0) {
+        return answer;
+    }
+
+    function search(currentIdx, combination, total) {
+        if (total === target) {
+            answer.push([...combination]); // 배열 자체를 넣으면 참조 때문에 값이 변경되므로, 복사해서 넣어야 함
+            return;
+        }
+
+        if (total > target) {
+            return; // backtracking
+        }
+
+        combination.push(sortedCandidates[currentIdx]);
+        search(currentIdx, combination, total + sortedCandidates[currentIdx]);
+        combination.pop();
+
+        if (total + sortedCandidates[currentIdx] > target) {
+            return; // backtracking
+        }
+
+        if (currentIdx + 1 < sortedCandidates.length) {
+            search(currentIdx + 1, combination, total);
+        }
+    }
+
+    search(0, [], 0);
+    return answer;
+};
+
+// t: target
+// 시간복잡도: O(2^t)
+// 공간복잡도: O(t)

decode-ways/uraflower.js

@@ -0,0 +1,36 @@
+/**
+ * 주어진 문자열을 복호화하는 경우의 수를 반환하는 함수
+ * @param {string} s
+ * @return {number}
+ */
+const numDecodings = function(s) {
+    const dp = {};
+
+    function decode(idx) {
+        if (s[idx] === '0') {
+            return 0;
+        }
+
+        if (idx === s.length) {
+            return 1;
+        }
+
+        if (dp[idx]) {
+            return dp[idx];
+        }
+
+        let result = 0;
+        result += decode(idx + 1); // 현재 문자만 쓰는 경우: 다음 문자부터 탐색
+        if (s[idx + 1] && Number(s[idx] + s[idx+1]) <= 26) {
+            result += decode(idx + 2); // 현재 문자와 다음 문자 붙여서 쓰는 경우: 다다음 문자부터 탐색
+        }
+
+        dp[idx] = result;
+        return result;
+    }
+
+    return decode(0);
+};
+
+// 시간복잡도: O(n) (메모이제이션 안하면 매 인덱스마다 최대 2개의 하위 호출이 발생하여 O(2^n))
+// 공간복잡도: O(n)

maximum-subarray/uraflower.js

@@ -0,0 +1,22 @@
+/**
+ * 주어진 배열에서 원소의 합이 가장 큰 부분 배열의 합을 반환하는 함수
+ * @param {number[]} nums
+ * @return {number}
+ */
+const maxSubArray = function(nums) {
+    let max = nums[0];
+    let subSum = 0;
+
+    nums.forEach((num) => {
+        subSum = Math.max(subSum + num, num);
+
+        if (max < subSum) {
+            max = subSum;
+        }
+    });
+
+    return max;
+};
+
+// 시간복잡도: O(n)
+// 공간복잡도: O(1)

number-of-1-bits/uraflower.js

@@ -0,0 +1,12 @@
+/**
+ * 주어진 숫자를 2진수로 표현했을 때 비트가 1인 개수를 반환하는 함수
+ * @param {number} n
+ * @return {number}
+ */
+const hammingWeight = function(n) {
+    const binary = n.toString(2);
+    return Array.from(binary).filter((bit) => bit == 1).length;
+};
+
+// 시간복잡도: O(n)
+// 공간복잡도: O(n)

valid-palindrome/uraflower.js

@@ -0,0 +1,26 @@
+/**
+ * 주어진 문자열이 조건을 만족하는 회문인지 여부를 반환하는 함수
+ * @param {string} s
+ * @return {boolean}
+ */
+const isPalindrome = function(s) {
+    const filtered = Array.from(s.toLowerCase()).reduce((str, char) => {
+        return isAlphanumeric(char) ? str + char : str;
+    }, '');
+
+    for (let left = 0, right = filtered.length - 1; left < right; left++, right--) {
+        if (filtered[left] !== filtered[right]) {
+            return false;
+        }
+    }
+
+    return true;
+};
+
+
+function isAlphanumeric(char) {
+    return char !== ' ' && (('a' <= char && char <= 'z') || !Number.isNaN(Number(char)));
+}
+
+// 시간복잡도: O(n)
+// 공간복잡도: O(n)