fix: TC, SC

climbing-stairs/whewchews.ts

@@ -1,5 +1,4 @@
-function climbStairs(n: number): number {
-  /*
+/*
     * 아이디어 
     * 층수 제한: 1 <= n <= 45
     * 1 or 2 step 만 올라갈 수 있음
@@ -12,7 +11,7 @@ function climbStairs(n: number): number {
     * 6 -> [1,1,1,1,1,1]      [2,1,1,1,1] [...] [1,1,1,1,2]                     [2,2,1,1], [2,1,2,1], [2,1,1,2] [1,1,2,2], [1,2,1,2], [1,2,2,1]
     =>     (1:n, 2:0) n가지   (1:n-2, 2:1) / n가지                         (1: n-4, 2: n/2) C(n, n/2) 가지   
     */
-
+function climbStairs(n: number): number {
   // # Solution 1
 
   // const stair = {1: 1, 2:2}
@@ -41,13 +40,14 @@ function climbStairs(n: number): number {
   // # Solution 3: 재귀
   const memo = { 1: 1, 2: 2 };
   function calculateClimbingWay(n, memo) {
-    if (!(n in memo)) {
-      if (n < 3) {
-        return n;
-      }
-      memo[n] =
-        calculateClimbingWay(n - 1, memo) + calculateClimbingWay(n - 2, memo);
+    if (n in memo) return memo[n];
+
+    if (n < 3) {
+      return n;
     }
+    memo[n] =
+      calculateClimbingWay(n - 1, memo) + calculateClimbingWay(n - 2, memo);
+
     return memo[n];
   }
   return calculateClimbingWay(n, memo);

coin-change/whewchews.ts

@@ -8,7 +8,8 @@ function coinChange(coins: number[], amount: number): number {
    * coins를 순회하면서 누적액에 동전을 더한 값이 amount보다 작으면 queue에 넣는다.
    * queue가 빌때까지 반복
    * 큐가 비어있고 amount를 만들수 없으면 -1을 return
-   */ const queue = [[0, 0]]; // [number of coins, accumulated amount]
+   */
+  const queue = [[0, 0]]; // [number of coins, accumulated amount]
   const visited = new Set();
 
   while (queue.length > 0) {
@@ -28,5 +29,5 @@ function coinChange(coins: number[], amount: number): number {
   }
   return -1;
 }
-// TC: 각 금액(amount)마다 동전(coins)을 순회하므로 O(N*M) N: amount, M: coins.length
+// TC: 각 금액(amount)마다 동전(coins)을 순회하므로 O(N^2*M) N: amount, M: coins.length
 // SC: O(N) N: amount

combination-sum/whewchews.ts

@@ -36,8 +36,7 @@ function combinationSum(candidates: number[], target: number): number[][] {
     * 
     */
 
-    // TC: O(2^N) N = candidates.length
-    // SC: O(T) T = target
+
       function backtrack(candidates: number[], start:number, total:number){
           if(target === total){
               result.push([...path])
@@ -64,8 +63,8 @@ function combinationSum(candidates: number[], target: number): number[][] {
       return result
 
   };
-  // TC: O(2^N) 
-  // SC: O(2^N)
+    // TC: O(n^t) n = candidates.length, t = target 크기
+    // SC: O(t)
 
   /*  #Solution 2 : DP
   * candidates을 가지고 target 값을 만들 수 있는 모든 조합을 미리 찾아둔다.
@@ -99,17 +98,13 @@ function combinationSum(candidates: number[], target: number): number[][] {
 
 
 
-  // SC: O(T+1) T = target
+  // SC: O(t) t = target
   const dp = Array.from({ length: target + 1 }, () => []);
   dp[0] = [[]];
 
 
-// TC: O(C), C = candidates.length
   for (let candidate of candidates) {
-  // TC: O(T) T = target
     for (let i = candidate; i <= target; i++) {
-    // TC: O(K) K = dp[i - candidate].length
-    // SC: O(K)
       for (let combination of dp[i - candidate]) {
         dp[i].push([...combination, candidate]);
       }
@@ -119,5 +114,5 @@ function combinationSum(candidates: number[], target: number): number[][] {
   return dp[target];
 }
 
-// TC: O(C * T * K)
-// SC: O((T+1) * K* T)
+// TC: O(n * t * 2^n)  n = candidates.length, t = target
+// SC: O((t*2^n) // 최악의 경우 모든 조합(2^n) 저장 가능

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

@@ -1,16 +1,16 @@
+/* #Solution 1
+ * sum: 전체 곱을 구한다.
+ * zeroCount: 0의 개수가 몇개인지 센다.
+ * 1. 자신이 0이면,
+ * 1-1. 자신이외의 0이 있는지 확인하고 있으면 0을 return
+ * 1-2. 자신 이외에 0이 없으면 전체 곱을 return
+ * 2. 자신이 0이 아니면
+ * 2-1. zeroCount가 있는지 보고 있으면 0을 return
+ * 2-2. zero가 없으면 sum/self를 return
+ *
+ * 그러나... 문제에 나누기 연산자를 쓰면 안된다고 했으므로 Solution 2로 가자.
+ */
 function productExceptSelf(nums: number[]): number[] {
-  /* #Solution 1
-   * sum: 전체 곱을 구한다.
-   * zeroCount: 0의 개수가 몇개인지 센다.
-   * 1. 자신이 0이면,
-   * 1-1. 자신이외의 0이 있는지 확인하고 있으면 0을 return
-   * 1-2. 자신 이외에 0이 없으면 전체 곱을 return
-   * 2. 자신이 0이 아니면
-   * 2-1. zeroCount가 있는지 보고 있으면 0을 return
-   * 2-2. zero가 없으면 sum/self를 return
-   *
-   * 그러나... 문제에 나누기 연산자를 쓰면 안된다고 했으므로 Solution 2로 가자.
-   */
   //   let zeroCount = 0;
   //   const sum = nums.reduce((p, c) => {
   //     if (c === 0) {

two-sum/whewchews.ts

@@ -1,14 +1,13 @@
+/*
+ * 아이디어
+ * 처음부터 배열을 순회하며 [0,1] [0,2] [0,3] [0, ...], [1,2], [1,3], [1,...] ... [nums.length-2, nums.length-1] 를 돌면서 두 인자의 합이 target이 되는 지점을 찾는다.
+ * 순서대로 돌면 최악의 경우 가장 마지막 자리까지 갈 수도 있다.
+ * 절대 값이 되지 못하는, 최소 조건을 생각해보자.
+ * 주의1:범위가 -10^9 <= nums[i] <= 10^9로 음수값도 있음
+ * 주의2: 정렬된 순서가 아님.
+ * 값을 Map에 저장해두고 {value: index}, Map에 자신과 더했을때 target이 나오는 value가 있는지 확인
+ */
 function twoSum(nums: number[], target: number): number[] {
-  /*
-   * 아이디어
-   * 처음부터 배열을 순회하며 [0,1] [0,2] [0,3] [0, ...], [1,2], [1,3], [1,...] ... [nums.length-2, nums.length-1] 를 돌면서 두 인자의 합이 target이 되는 지점을 찾는다.
-   * 순서대로 돌면 최악의 경우 가장 마지막 자리까지 갈 수도 있다.
-   * 절대 값이 되지 못하는, 최소 조건을 생각해보자.
-   * 주의1:범위가 -10^9 <= nums[i] <= 10^9로 음수값도 있음
-   * 주의2: 정렬된 순서가 아님.
-   * 값을 Map에 저장해두고 {value: index}, Map에 자신과 더했을때 target이 나오는 value가 있는지 확인
-   */
-
   // SC: O(N)
   const dict = new Map();