Merge branch 'DaleStudy:main' into main

Author: river20s

combination-sum/Wonjuny0804.ts

@@ -0,0 +1,22 @@
+function combinationSum(candidates: number[], target: number): number[][] {
+  const result: number[][] = [];
+
+  const dfs = (start: number, target: number, path: number[]) => {
+      if (target === 0) {
+          result.push([...path]);
+          return;
+      }
+
+      for (let i = start; i < candidates.length; i++) {
+          if (candidates[i] > target) continue;
+
+          path.push(candidates[i]);
+          dfs(i, target - candidates[i], path);
+          path.pop();
+      }
+  }
+
+  candidates.sort((a, b) => a - b);
+  dfs(0, target, []);
+  return result;
+};

combination-sum/hoyeongkwak.ts

@@ -0,0 +1,17 @@
+function combinationSum(candidates: number[], target: number): number[][] {
+  const dp: number[][][] = Array(target + 1).fill(null).map(() => [])
+  dp[0] = [[]]
+
+  for (let i = 1; i <= target; i++){
+    for (const num of candidates) {
+        if (i - num >= 0 && dp[i - num].length > 0) {
+            for (const combo of dp[i - num]) {
+                if (combo.length === 0 || num >= combo[combo.length - 1]) {
+                    dp[i].push([...combo, num])
+                }
+            }
+        }
+    }
+  }
+  return dp[target]
+};

decode-ways/Wonjuny0804.ts

@@ -0,0 +1,21 @@
+function numDecodings(s: string): number {
+  const memo: Record<number, number> = {};
+
+  const dfs = (index: number): number => {
+      if (index === s.length) return 1;
+      if (s[index] === '0') return 0;
+
+      if (memo[index] !== undefined) return memo[index];
+
+      let res = dfs(index + 1);
+
+      if (index + 1 < s.length && Number(s.slice(index, index + 2)) <= 26) {
+          res += dfs(index + 2);
+      }
+
+      memo[index] = res;
+      return res;
+  }
+
+  return dfs(0);
+}

decode-ways/hoyeongkwak.ts

@@ -0,0 +1,20 @@
+/* 
+    time complexity : O(n)
+    space complexity : O(n)
+*/
+function numDecodings(s: string): number {
+    const memo = new Map<number, number>()
+    const decode = (index: number): number => {
+        if (index === s.length) return 1
+        if (s[index] === '0') return 0
+        if (memo.has(index)) return memo.get(index)
+        
+        let ways = decode(index + 1)
+        if (index + 1 < s.length && (s[index] === '1' || (s[index] === '2' && parseInt(s[index + 1]) <= 6))) {
+            ways += decode(index + 2)
+        }
+        memo.set(index, ways)
+        return ways
+    }
+    return decode(0)
+}

maximum-subarray/Wonjuny0804.ts

@@ -0,0 +1,13 @@
+function maxSubArray(nums: number[]): number {
+  const n = nums.length;
+  const dp = new Array(n).fill(0);
+  dp[0] = nums[0];
+  let result = dp[0];
+
+  for (let i = 1; i < n; i++) {
+      dp[i] = Math.max(nums[i], dp[i - 1] + nums[i]);
+      result = Math.max(result, dp[i]);
+  }
+
+  return result;
+}

maximum-subarray/hoyeongkwak.ts

@@ -0,0 +1,21 @@
+/* 
+    time complexity : O(n)
+    space complexity : O(1)
+*/
+function maxSubArray(nums: number[]): number {
+    let maxSum = -Infinity
+    let currSum = 0
+
+    for (let i = 0; i < nums.length; i++) {
+        currSum += nums[i]
+
+        if (currSum > maxSum) {
+            maxSum = currSum
+        }
+
+        if (currSum < 0) {
+            currSum = 0
+        }
+    }
+    return maxSum
+};

number-of-1-bits/RiaOh.js

@@ -2,6 +2,8 @@
  * @param {number} n
  * @return {number}
  */
+
+// week3 다시 올림
 var hammingWeight = function (n) {
   const binary = n.toString(2);
   const arr = [...binary];

number-of-1-bits/Wonjuny0804.ts

@@ -0,0 +1,6 @@
+function hammingWeight(n: number): number {
+  return n
+    .toString(2)
+    .split("")
+    .reduce((acc, i) => acc + +i, 0);
+}

number-of-1-bits/hoyeongkwak.ts

@@ -0,0 +1,20 @@
+/* 
+    time complexity : O(log n)
+    space complexity : O(1)
+*/
+function hammingWeight(n: number): number {   
+    let count = 0
+    while ( n != 0) {
+        count += n & 1
+        n >>>= 1
+    }
+    return count
+
+    /* 
+    time complexity : O(log n)
+    space complexity : O(log n)
+    */
+    // const twoBits = n.toString(2)
+    // const bitCount = twoBits.split('').filter((s) => s === '1').length
+    // return bitCount
+};

two-sum/Wonjuny0804.ts

@@ -0,0 +1,35 @@
+/*
+
+    Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.
+    You may assume that each input would have exactly one solution, and you may not use the same element twice.
+    You can return the answer in any order.
+
+    Example 1:
+
+    Input: nums = [2,7,11,15], target = 9
+    Output: [0,1]
+    Explanation: Because nums[0] + nums[1] == 9, we return [0, 1].
+
+    Example 2:
+
+    Input: nums = [3,2,4], target = 6
+    Output: [1,2]
+
+    Example 3:
+
+    Input: nums = [3,3], target = 6
+    Output: [0,1]
+
+*/
+
+function twoSum(nums: number[], target: number): number[] {
+  const map = new Map();
+
+  for (let i = 0; i < nums.length; i++) {
+    const diff = target - nums[i];
+    if (map.has(nums[i])) return [map.get(nums[i]), i];
+    else map.set(diff, i);
+  }
+
+  return [];
+}