Merge remote-tracking branch 'upstream/main'

Author: mykoo

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/TonyKim9401.java

@@ -0,0 +1,15 @@
+class Solution {
+    public int climbStairs(int n) {
+        // Time complexity: O(n);
+        // Space complexity: O(n);
+        int[] dp = new int[n+1];
+
+        if (n >= 1) dp[1] = 1;
+        if (n >= 2) dp[2] = 2;
+
+        for (int i = 3; i <= n; i++) {
+            dp[i] = dp[i-1] + dp[i-2];
+        }
+        return dp[n];
+    }
+}

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/gitsunmin.ts

@@ -0,0 +1,17 @@
+/**
+ * https://leetcode.com/problems/climbing-stairs
+ * time complexity : O(n)
+ * space complexity : O(1)
+ */
+
+export const upStairs = (n: number): number => {
+    let [l, r] = [1, 2];
+    for (let i = 3; i <= n; i++) [l, r] = [r, l + r];
+
+    return r;
+};
+
+export function climbStairs(n: number): number {
+    if (n <= 2) return n;
+    return upStairs(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/hwanmini.js

@@ -0,0 +1,18 @@
+// 시간복잡도 O(n)
+// 공간복잡도 O(n)
+
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var climbStairs = function(n) {
+    const stairs = [1, 2]
+
+    for (let i = 2; i < n; i++) {
+        stairs[i] = stairs[i-1] + stairs[i-2]
+    }
+
+    return stairs[n-1]
+};
+
+console.log(climbStairs(5))

climbing-stairs/hyejjun.js

@@ -0,0 +1,28 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var climbStairs = function (n) {
+  if (n <= 2) return n;
+
+  let first = 1;
+  let second = 2;
+
+  for (let i = 3; i <= n; i++) {
+    let third = first + second;
+    first = second;
+    second = third;
+  }
+
+  return second;
+};
+
+console.log(climbStairs(2));
+console.log(climbStairs(3));
+console.log(climbStairs(4));
+console.log(climbStairs(5));
+
+/*
+시간 복잡도: O(n)
+공간 복잡도: O(1)
+*/

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/naringst.js

@@ -0,0 +1,28 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+/**
+ * Note: DP
+ * 결국 1개 전의 값에서 1칸을 더 가거나, 2개 전의 값에서 2칸을 더 가는 경우의 수가 생긴다.
+ * 1일때에는 1칸을 가는 방법의 경우 뿐이지만, 2일때에는 0칸 가는 것에서 2칸을 가거나 1칸을 가는 것에서 1칸을 더 갈 수 있다.
+ * 3일 때에는 1까지 갔을 경우에서 2칸을 더 가거나, 2까지 갔을 경우에서 1칸을 더 가면 되니까 1까지 갔을 경우의 수 + 2까지 갔을 경우의 수
+ *
+ *
+ * Runtime: 41ms, Memory: 48.95MB
+ * Time complexity: O(n)
+ * Space complexity: O(n)
+ *
+ */
+
+var climbStairs = function (n) {
+  const dp = Array(n).fill(0);
+  dp[1] = 1;
+  dp[2] = 2;
+
+  for (let i = 3; i < n + 1; i++) {
+    dp[i] = dp[i - 2] + dp[i - 1];
+  }
+
+  return dp[n];
+};