Merge pull request #384 from HC-kang/main

[강희찬] WEEK 3 Solution

Author: HC-kang

climbing-stairs/HC-kang.ts

@@ -0,0 +1,11 @@
+// T.C. O(n)
+// S.C. O(1)
+function climbStairs(n: number): number {
+  let p = 0;
+  let q = 1;
+  for (let i = 0; i < n; i++) {
+    q = q + p;
+    p = q - p;
+  }
+  return q;
+}

coin-change/HC-kang.ts

@@ -0,0 +1,15 @@
+// T.C: O(coins.length * amount)
+// S.C: O(amount)
+function coinChange(coins: number[], amount: number): number {
+  if (amount == 0) return 0;
+  const dp = new Array(amount + 1).fill(Infinity);
+  dp[0] = 0;
+  for (let i = 1; i <= amount; i++) {
+    for (let j = 0; j < coins.length; j++) {
+      if (coins[j] <= i) {
+        dp[i] = Math.min(dp[i], dp[i - coins[j]] + 1);
+      }
+    }
+  }
+  return dp[amount] === Infinity ? -1 : dp[amount];    
+};

combination-sum/HC-kang.ts

@@ -0,0 +1,19 @@
+// T.C: O(n^t) // n: candidates.length, t: target
+// S.C: O(n)
+function combinationSum(candidates: number[], target: number): number[][] {
+  const result: number[][] = [];
+  function dfs(start: number, target: number, path: number[]) {
+    if (target < 0) return;
+    if (target === 0) {
+      result.push([...path]);
+      return;
+    }
+    for (let i = start; i < candidates.length; i++) {
+      path.push(candidates[i]);
+      dfs(i, target - candidates[i], path);
+      path.pop();
+    }
+  }
+  dfs(0, target, []);
+  return result;  
+};

product-of-array-except-self/HC-kang.ts

@@ -0,0 +1,18 @@
+// T.C: O(n)
+// S.C: O(n)
+function productExceptSelf(nums: number[]): number[] {
+  const arr: number[] = new Array(nums.length);
+  let product = 1;
+  for (let i = 0; i < nums.length; i++) {
+    arr[i] = product;
+    product *= nums[i];
+  }
+
+  product = 1;
+  for (let i = nums.length - 1; i >= 0; i--) {
+    arr[i] *= product;
+    product *= nums[i];
+  }
+
+  return arr;
+};

two-sum/HC-kang.ts

@@ -0,0 +1,13 @@
+// T.C. O(n)
+// S.C. O(n)
+function twoSum(nums: number[], target: number): number[] {
+  const sumMap = new Map<number, number>();
+  for (const [i, num] of nums.entries()) {
+    const diff = target - num;
+    if (sumMap.has(diff)) {
+      return [sumMap.get(diff)!, i];
+    }
+    sumMap.set(num, i);
+  }
+  return [];
+}