Merge pull request #1289 from hsskey/main

[hsskey] WEEK 03 solutions

Author: hsskey

combination-sum/hsskey.js

@@ -0,0 +1,29 @@
+/**
+ * @param {number[]} candidates
+ * @param {number} target
+ * @return {number[][]}
+ */
+var combinationSum = function(candidates, target) {
+    const result = []
+    function backtrack(start, curr, sum) {
+        // 현재 합계가 타겟과 같으면 결과에 추가
+        if(sum === target) {
+            result.push([...curr])
+        }
+
+        // 합계가 타겟을 초과하면 더 이상 진행하지 않음
+        if(sum > target) {
+            return
+        }
+        
+        // 현재 인덱스부터 시작하여 모든 후보를 시도
+        for(let i = start; i < candidates.length; i++) {
+            curr.push(candidates[i])
+            // 같은 숫자를 여러 번 사용할 수 있으므로 i부터 다시 시작
+            backtrack(i, curr, sum + candidates[i])
+            curr.pop()
+        }
+    }
+    backtrack(0, [], 0)
+    return result
+};

decode-ways/hsskey.js

@@ -0,0 +1,53 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var numDecodings = function(s) {
+    if (s[0] === '0') return 0;
+    
+    let count = 0;
+    const memo = {};
+    
+    function backtrack(index, curr) {
+        // 기저 조건: 문자열 끝까지 왔으면 유효한 디코딩 발견
+        if (index === s.length) {
+            count++;
+            return;
+        }
+        
+        // 메모이제이션 키 생성
+        const key = index;
+        if (memo[key] !== undefined) {
+            count += memo[key];
+            return;
+        }
+        
+        // 이전 카운트 저장
+        const prevCount = count;
+        
+        // Case 1: 한 자리 숫자로 디코딩 (1~9)
+        if (s[index] !== '0') {
+            const oneDigit = s[index];
+            curr.push(oneDigit);
+            backtrack(index + 1, curr);
+            curr.pop();
+        }
+        
+        // Case 2: 두 자리 숫자로 디코딩 (10~26)
+        if (index + 1 < s.length) {
+            const twoDigit = s.substring(index, index + 2);
+            const num = parseInt(twoDigit);
+            if (num >= 10 && num <= 26) {
+                curr.push(twoDigit);
+                backtrack(index + 2, curr);
+                curr.pop();
+            }
+        }
+        
+        // 현재 위치에서 발견한 디코딩 방법 수 저장
+        memo[key] = count - prevCount;
+    }
+    
+    backtrack(0, []);
+    return count;
+};

maximum-subarray/hsskey.js

@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var maxSubArray = function(nums) {
+    let maxSum = -Infinity
+    let currentSum = 0
+
+    for(let num of nums) {
+        currentSum = Math.max(num, currentSum + num)
+        maxSum = Math.max(maxSum, currentSum)
+    }
+
+    return maxSum
+};

number-of-1-bits/hsskey.js

@@ -0,0 +1,23 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var hammingWeight = function(n) {
+    function recursive(num) {
+        // 종료조건
+        if(String(num) === '1') {
+            return '1'
+        }
+        // 재귀호출
+        const q = Math.floor(num / 2) // 몫
+        const r = num % 2 // 나머지
+        const total = r + recursive(q)
+
+        // 데이터 통합
+        return total
+    }
+    const binaryString = recursive(n)
+    const result = [...binaryString].map(Number).reduce((a,b) => a + b, 0)
+    
+    return result
+};

valid-palindrome/hsskey.js

@@ -0,0 +1,10 @@
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+var isPalindrome = function(s) {
+    const cleanStr = s.toLowerCase().replace(/[^a-z0-9]/g, '')
+    const reversedStr = [...cleanStr].reverse().join('')
+
+    return cleanStr === reversedStr
+};