[이병현] Week 3

climbing-stairs/tolluset.ts

@@ -0,0 +1,16 @@
+/**
+ * TC: O(n)
+ * SC: O(n)
+ * */
+function climbStairs(n: number): number {
+  const dp = new Array(n + 1).fill(0);
+
+  dp[1] = 1;
+  dp[2] = 2;
+
+  for (let i = 3; i <= n; i++) {
+    dp[i] = dp[i - 1] + dp[i - 2];
+  }
+
+  return dp[n];
+}

coin-change/tolluset.ts

@@ -0,0 +1,22 @@
+/*
+ * TC: O(amount * coins.length)
+ * SC: 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++) {
+    coins.forEach((coin) => {
+      if (coin <= i) {
+        dp[i] = Math.min(dp[i], dp[i - coin] + 1);
+      }
+    });
+  }
+
+  return dp[amount] === Infinity ? -1 : dp[amount];
+}

combination-sum/tolluset.ts

@@ -0,0 +1,24 @@
+/**
+ * TC: O(candidates.length ^ target / min(candidates))
+ * SC: O(target / min(candidates)
+ */
+function combinationSum(candidates: number[], target: number): number[][] {
+  const result: number[][] = [];
+  const dfs = (start: number, spot: number, path: number[]) => {
+    if (spot === 0) {
+      result.push([...path]);
+      return;
+    }
+
+    for (let i = start; i < candidates.length; i++) {
+      if (candidates[i] <= spot) {
+        path.push(candidates[i]);
+        dfs(i, spot - candidates[i], path);
+        path.pop();
+      }
+    }
+  };
+  dfs(0, target, []);
+
+  return result;
+}

product-of-array-except-self/tolluset.ts

@@ -0,0 +1,23 @@
+/*
+ * TC: O(n)
+ * SC: O(n)
+ * */
+
+function productExceptSelf(nums: number[]): number[] {
+  const n = nums.length;
+  const answer = new Array(n).fill(1);
+
+  let left = 1;
+  nums.forEach((num, i) => {
+    answer[i] = left;
+    left *= num;
+  });
+
+  let right = 1;
+  nums.reverse().forEach((num, i) => {
+    answer[n - 1 - i] *= right;
+    right *= num;
+  });
+
+  return answer;
+}

two-sum/tolluset.ts

@@ -0,0 +1,21 @@
+/*
+ * TC: O(n)
+ * SC: O(n)
+ * */
+function twoSum(nums: number[], target: number): number[] {
+  const n = nums.length;
+  const answer = new Map<number, number>();
+
+  for (let i = 0; i < n; i++) {
+    const diff = target - nums[i];
+    const before = answer.get(diff);
+
+    if (before) {
+      return [before, i];
+    }
+
+    answer.set(nums[i], i);
+  }
+
+  return [];
+}