Add Climbing Stairs

Author: marttp

kotlin/Dynamic Programming/ClimbingStairsBottomUp.kt

@@ -0,0 +1,15 @@
+fun climbingStairsBottmoUp(n: Int): Int {
+    if (n <= 2) {
+        return n
+    }
+    val dp = IntArray(n + 1)
+    // Base cases.
+    dp[1] = 1
+    dp[2] = 2
+    // Starting from step 3, calculate the number of ways to reach each
+    // step until the n-th step.
+    for (i in 3..n) {
+        dp[i] = dp[i - 1] + dp[i - 2]
+    }
+    return dp[n]
+}

kotlin/Dynamic Programming/ClimbingStairsBottomUpOptimize.kt

@@ -0,0 +1,16 @@
+fun climbingStairsBottomUpOptimized(n: Int): Int {
+    if (n <= 2) {
+        return n
+    }
+    // Set 'oneStepBefore' and 'twoStepsBefore' as the base cases.
+    var oneStepBefore = 2
+    var twoStepsBefore = 1
+    for (i in 3..n) {
+        // Calculate the number of ways to reach the current step.
+        val current = oneStepBefore + twoStepsBefore
+        // Update the values for the next iteration.
+        twoStepsBefore = oneStepBefore
+        oneStepBefore = current
+    }
+    return oneStepBefore
+}

kotlin/Dynamic Programming/ClimbingStairsTopDown.kt

@@ -0,0 +1,19 @@
+fun climbingStairsTopDown(n: Int): Int {
+    val memo = hashMapOf<Int, Int>()
+    return climbingStairsTopDown(n, memo)
+}
+
+fun climbingStairsTopDown(n: Int, memo: HashMap<Int, Int>): Int {
+    // Base cases: With a 1-step staircase, there's only one way to
+    // climb it. With a 2-step staircase, there are two ways to climb it.
+    if (n <= 2) {
+        return n
+    }
+    if (memo[n] != 0) {
+        return memo[n]!!
+    }
+    // The number of ways to climb to the n-th step is equal to the sum
+    // of the number of ways to climb to step n - 1 and to n - 2.
+    memo[n] = climbingStairsTopDown(n - 1, memo) + climbingStairsTopDown(n - 2, memo)
+    return memo[n]!!
+}