Merge branch 'DaleStudy:main' into main

Author: gitsunmin

.github/labeler.yml

@@ -0,0 +1,44 @@
+js:
+  - changed-files:
+      - any-glob-to-any-file:
+          - "**/*.js"
+
+ts:
+  - changed-files:
+      - any-glob-to-any-file:
+          - "**/*.ts"
+
+py:
+  - changed-files:
+      - any-glob-to-any-file:
+          - "**/*.py"
+
+java:
+  - changed-files:
+      - any-glob-to-any-file:
+          - "**/*.java"
+
+c++:
+  - changed-files:
+      - any-glob-to-any-file:
+          - "**/*.cpp"
+
+swift:
+  - changed-files:
+      - any-glob-to-any-file:
+          - "**/*.swift"
+
+kotlin:
+  - changed-files:
+      - any-glob-to-any-file:
+          - "**/*.kt"
+
+go:
+  - changed-files:
+      - any-glob-to-any-file:
+          - "**/*.go"
+
+elixir:
+  - changed-files:
+      - any-glob-to-any-file:
+          - "**/*.exs"

.github/workflows/automation.yaml

@@ -11,3 +11,16 @@ jobs:
       pull-requests: write
     steps:
       - uses: toshimaru/[email protected]
+
+  label-lang:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+
+    permissions:
+      contents: read
+      pull-requests: write
+
+    steps:
+      - uses: actions/labeler@v5
+        with:
+          repo-token: ${{ github.token }}

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;
+}

climbing-stairs/bemelon.py

@@ -0,0 +1,17 @@
+class Solution:
+    # Space complexity: O(1)
+    # Tiem complexity: O(n)
+    def climbStairs(self, n: int) -> int:
+        # dp[0] is n - 2
+        # dp[1] is n - 1
+        dp = [1, 2]
+
+        if n <= 2: 
+            return dp[n - 1]
+        
+        for i in range(3, n + 1): 
+            # dp[n] = dp[n - 1] + dp[n - 2]
+            #       = dp[1] + dp[0]
+            dp[(i - 1) % 2] = sum(dp)
+        
+        return dp[(n - 1) % 2]

climbing-stairs/flynn.cpp

@@ -0,0 +1,13 @@
+class Solution {
+public:
+int climbStairs(int n) {
+vector<int> memo(2, 1);
+
+        for (int i = 2; i <= n; i++) {
+            memo.push_back(memo[i - 1] + memo[i - 2]);
+        }
+
+        return memo[n];
+    }
+
+};

climbing-stairs/heozeop.cpp

@@ -0,0 +1,20 @@
+// Time Complexity: O(n)
+// Spatial Complexity: O(n)
+
+class Solution {
+public:
+  int climbStairs(int n) {
+    vector<int> dp(n + 1, 0);
+
+    if (n == 1) {
+        return 1;
+    }
+
+    dp[0] = dp[1] = 1;
+    for(int i = 2; i <= n; ++i) {
+        dp[i] = dp[i - 1] + dp[i - 2];
+    }
+
+    return dp[n];
+  }
+};

climbing-stairs/jdalma.kt

@@ -0,0 +1,32 @@
+package leetcode_study
+
+import io.kotest.matchers.shouldBe
+import org.junit.jupiter.api.Test
+
+class `climbing-stairs` {
+
+    /**
+     * 1. bottom-up 방식으로 가능한 경우의 수를 누적한다.
+     * TC: O(n), SC: O(n)
+     */
+    fun climbStairs(n: Int): Int {
+        val dp = IntArray(n + 1).apply {
+            this[1] = 1
+            if (n >= 2) this[2] = 2
+        }
+
+        for (num in 3 .. n) {
+            dp[num] = dp[num - 1] + dp[num - 2]
+        }
+
+        return dp[n]
+    }
+
+    @Test
+    fun `입력받은 목푯값에 1과 2만 더하여 도달할 수 있는 경우의 수를 반환한다`() {
+        climbStairs(1) shouldBe 1
+        climbStairs(2) shouldBe 2
+        climbStairs(3) shouldBe 3
+        climbStairs(4) shouldBe 5
+    }
+}

climbing-stairs/kimyoung.js

@@ -0,0 +1,12 @@
+// found a pattern where the result is the addition of two previous elements,
+// but not sure if this is the expected answer
+var climbStairs = function (n) { 
+    let arr = new Array(n).fill(1);
+    for (let i = 2; i <= n; i++) {
+        arr[i] = arr[i - 2] + arr[i - 1];
+    }
+    return n === 1 ? 1 : arr[n];
+};
+
+// time - O(n) iterate up to n times
+// space - O(n) creates an array upto n elements

climbing-stairs/sunjae95.js

@@ -0,0 +1,18 @@
+/**
+ * @description
+ * brainstorming:
+ * Dynamic Programming
+ *
+ * time complexity: O(n)
+ * space complexity: O(n)
+ */
+
+var climbStairs = function (n) {
+  const dp = Array.from({ length: n + 1 }, () => 0);
+  dp[1] = 1;
+  dp[2] = 2;
+
+  for (let i = 3; i < n + 1; i++) dp[i] = dp[i - 1] + dp[i - 2];
+
+  return dp[n];
+};

climbing-stairs/taekwon-dev.java

@@ -0,0 +1,28 @@
+/**
+ *  시간 복잡도: O(n)
+ *  - n = 5 경우를 가정하고 생각해보기
+ *  - 3층 계단 -> 2층, 1층 계산 (이 경우는 이미 메모되어 있어서 별도로 계산하진 않음)
+ *  - 4층 계단 -> 3층, 2층 계산 (2층은 메모에 있는 것 활용)
+ *  - 5층 계단 -> 4층, 3층 계산 (3층은 메모에 있는 것 활용)
+ *  - ...
+ *  - 각 단계 별로 (메모를 활용해) 아직 계산되지 않은 것을 한 번씩 호출하게 되므로 O(n)
+ *  - 근데 만약 메모를 사용하지 않으면? (중복 호출이 많이 일어남 ... O(n^2))
+ *
+ *  공간 복잡도: O(n)
+ */
+class Solution {
+    public int climbStairs(int n) {
+        int[] memo = new int[n + 1];
+        return climbStairs(n, memo);
+    }
+
+    public int climbStairs(int n, int[] memo) {
+        if (n == 1) return 1;
+        if (n == 2) return 2;
+
+        if (memo[n] > 0) return memo[n];
+
+        memo[n] = climbStairs(n - 1, memo) + climbStairs(n - 2, memo);
+        return memo[n];
+    }
+}