feat: Climbing Stairs

Author: wislertt

.templates/leetcode/json/climbing_stairs.json

@@ -0,0 +1,42 @@
+{
+    "problem_name": "climbing_stairs",
+    "solution_class_name": "Solution",
+    "problem_number": "70",
+    "problem_title": "Climbing Stairs",
+    "difficulty": "Easy",
+    "topics": "Math, Dynamic Programming, Memoization",
+    "tags": ["grind-75"],
+    "readme_description": "You are climbing a staircase. It takes `n` steps to reach the top.\n\nEach time you can either climb `1` or `2` steps. In how many distinct ways can you climb to the top?",
+    "readme_examples": [
+        {
+            "content": "```\nInput: n = 2\nOutput: 2\n```\n**Explanation:** There are two ways to climb to the top.\n1. 1 step + 1 step\n2. 2 steps"
+        },
+        {
+            "content": "```\nInput: n = 3\nOutput: 3\n```\n**Explanation:** There are three ways to climb to the top.\n1. 1 step + 1 step + 1 step\n2. 1 step + 2 steps\n3. 2 steps + 1 step"
+        }
+    ],
+    "readme_constraints": "- 1 <= n <= 45",
+    "readme_additional": "",
+    "solution_imports": "",
+    "solution_methods": [
+        { "name": "climb_stairs", "parameters": "n: int", "return_type": "int", "dummy_return": "1" }
+    ],
+    "test_imports": "import pytest\nfrom leetcode_py.test_utils import logged_test\nfrom .solution import Solution",
+    "test_class_name": "ClimbingStairs",
+    "test_helper_methods": [
+        { "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }
+    ],
+    "test_methods": [
+        {
+            "name": "test_climb_stairs",
+            "parametrize": "n, expected",
+            "parametrize_typed": "n: int, expected: int",
+            "test_cases": "[(1, 1), (2, 2), (3, 3), (4, 5), (5, 8), (6, 13), (10, 89), (20, 10946), (45, 1836311903)]",
+            "body": "result = self.solution.climb_stairs(n)\nassert result == expected"
+        }
+    ],
+    "playground_imports": "from solution import Solution",
+    "playground_test_case": "# Example test case\nn = 3\nexpected = 3",
+    "playground_execution": "result = Solution().climb_stairs(n)\nresult",
+    "playground_assertion": "assert result == expected"
+}

Makefile

@@ -1,5 +1,5 @@
 PYTHON_VERSION = 3.13
-PROBLEM ?= first_bad_version
+PROBLEM ?= climbing_stairs
 FORCE ?= 0
 COMMA := ,
 

leetcode/climbing_stairs/README.md

@@ -0,0 +1,44 @@
+# Climbing Stairs
+
+**Difficulty:** Easy
+**Topics:** Math, Dynamic Programming, Memoization
+**Tags:** grind-75
+
+**LeetCode:** [Problem 70](https://leetcode.com/problems/climbing-stairs/description/)
+
+## Problem Description
+
+You are climbing a staircase. It takes `n` steps to reach the top.
+
+Each time you can either climb `1` or `2` steps. In how many distinct ways can you climb to the top?
+
+## Examples
+
+### Example 1:
+
+```
+Input: n = 2
+Output: 2
+```
+
+**Explanation:** There are two ways to climb to the top.
+
+1. 1 step + 1 step
+2. 2 steps
+
+### Example 2:
+
+```
+Input: n = 3
+Output: 3
+```
+
+**Explanation:** There are three ways to climb to the top.
+
+1. 1 step + 1 step + 1 step
+2. 1 step + 2 steps
+3. 2 steps + 1 step
+
+## Constraints
+
+- 1 <= n <= 45

leetcode/climbing_stairs/__init__.py

@@ -0,0 +1,79 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "imports",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from solution import Solution"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "setup",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Example test case\n",
+    "n = 3\n",
+    "expected = 3"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "execute",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "3"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "result = Solution().climb_stairs(n)\n",
+    "result"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "test",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "assert result == expected"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "leetcode-py-py3.13",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.13.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

leetcode/climbing_stairs/playground.ipynb

@@ -0,0 +1,16 @@
+class Solution:
+    # Time: O(n)
+    # Space: O(1)
+
+    # This follows Fibonacci pattern
+    # Standard Fib: F(0)=0, F(1)=1, F(2)=1, F(3)=2, F(4)=3, F(5)=5...
+    def climb_stairs(self, n: int) -> int:
+        if n <= 2:
+            return n
+
+        prev2, prev1 = 1, 2
+        for _ in range(3, n + 1):
+            current = prev1 + prev2
+            prev2, prev1 = prev1, current
+
+        return prev1

leetcode/climbing_stairs/solution.py

@@ -0,0 +1,19 @@
+import pytest
+
+from leetcode_py.test_utils import logged_test
+
+from .solution import Solution
+
+
+class TestClimbingStairs:
+    def setup_method(self):
+        self.solution = Solution()
+
+    @pytest.mark.parametrize(
+        "n, expected",
+        [(1, 1), (2, 2), (3, 3), (4, 5), (5, 8), (6, 13), (10, 89), (20, 10946), (45, 1836311903)],
+    )
+    @logged_test
+    def test_climb_stairs(self, n: int, expected: int):
+        result = self.solution.climb_stairs(n)
+        assert result == expected