feat(solutions): Add 0050 Pow(x, n)

Two approaches: Iterative binary exponentiation (O(log n) time, O(1)
space) decomposes n into binary bits; Recursive (O(log n) time, O(log n)
space) uses divide and conquer. Both handle negative exponents.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: lufftw

generators/0050_powx_n.py

@@ -0,0 +1,69 @@
+# generators/0050_powx_n.py
+"""
+Test Case Generator for Problem 0050 - Pow(x, n)
+
+LeetCode Constraints:
+- -100.0 < x < 100.0
+- -2^31 <= n <= 2^31 - 1
+- -10^4 <= x^n <= 10^4
+"""
+import json
+import random
+from typing import Iterator, Optional
+
+
+def generate(count: int = 10, seed: Optional[int] = None) -> Iterator[str]:
+    """Generate random test cases for Pow(x, n)."""
+    if seed is not None:
+        random.seed(seed)
+
+    # Edge cases
+    edge_cases = [
+        (2.0, 10),  # Simple power
+        (2.1, 3),  # Floating point base
+        (2.0, -2),  # Negative exponent
+        (1.0, 1000000),  # Large exponent with base 1
+        (0.0, 5),  # Zero base
+    ]
+
+    for x, n in edge_cases:
+        yield f"{x}\n{n}"
+        count -= 1
+        if count <= 0:
+            return
+
+    for _ in range(count):
+        yield _generate_random_case()
+
+
+def _generate_random_case() -> str:
+    """Generate a random x and n with valid result range."""
+    # Keep x and n small to avoid overflow
+    x = round(random.uniform(-10, 10), 5)
+    if abs(x) < 0.1:
+        x = random.choice([-1.0, 1.0, 2.0])
+
+    # Limit n to keep result in range
+    max_n = 20 if abs(x) > 1 else 100
+    n = random.randint(-max_n, max_n)
+
+    # Avoid 0^negative
+    if x == 0 and n < 0:
+        n = abs(n)
+
+    return f"{x}\n{n}"
+
+
+def generate_for_complexity(n: int) -> str:
+    """
+    Generate test case with exponent n for complexity estimation.
+    """
+    n = max(-1000, min(n, 1000))
+    x = 1.0001 if n > 0 else 0.9999
+    return f"{x}\n{n}"
+
+
+if __name__ == "__main__":
+    for i, test in enumerate(generate(5, seed=42), 1):
+        lines = test.split("\n")
+        print(f"Test {i}: {lines[0]}^{lines[1]}")

meta/problems/0050_powx_n.toml

@@ -0,0 +1,39 @@
+# Problem: Pow(x, n)
+# https://leetcode.com/problems/powx-n/
+
+id = "0050"
+slug = "0050_powx_n"
+title = "Pow(x, n)"
+leetcode_id = 50
+url = "https://leetcode.com/problems/powx-n/"
+
+difficulty = "medium"
+topics = ["math", "recursion"]
+companies = ["facebook", "amazon", "google"]
+roadmaps = ["neetcode_150"]
+
+api_kernels      = ["BinaryExponentiation"]
+patterns         = ["exponentiation_by_squaring", "divide_and_conquer"]
+families         = ["math"]
+data_structures  = []
+algorithms       = ["binary_exponentiation"]
+related_problems = ["0069", "0372"]
+
+[files]
+solution  = "solutions/0050_powx_n.py"
+generator = "generators/0050_powx_n.py"
+tests_dir = "tests/"
+
+[[solutions]]
+key    = "default"
+class  = "SolutionIterative"
+method = "myPow"
+complexity = "O(log n) time, O(1) space"
+notes      = "Iterative binary exponentiation"
+
+[[solutions]]
+key    = "recursive"
+class  = "SolutionRecursive"
+method = "myPow"
+complexity = "O(log n) time, O(log n) space"
+notes      = "Recursive divide and conquer"

solutions/0050_powx_n.py

@@ -0,0 +1,144 @@
+# solutions/0050_powx_n.py
+"""
+Problem: Pow(x, n)
+https://leetcode.com/problems/powx-n/
+
+Implement pow(x, n), which calculates x raised to the power n.
+
+Constraints:
+- -100.0 < x < 100.0
+- -2^31 <= n <= 2^31 - 1
+- n is an integer
+- Either x is not zero or n > 0
+- -10^4 <= x^n <= 10^4
+"""
+from _runner import get_solver
+
+SOLUTIONS = {
+    "default": {
+        "class": "SolutionIterative",
+        "method": "myPow",
+        "complexity": "O(log n) time, O(1) space",
+        "description": "Iterative binary exponentiation",
+    },
+    "recursive": {
+        "class": "SolutionRecursive",
+        "method": "myPow",
+        "complexity": "O(log n) time, O(log n) space",
+        "description": "Recursive binary exponentiation",
+    },
+}
+
+
+class SolutionIterative:
+    """
+    Iterative binary exponentiation (exponentiation by squaring).
+
+    Key insight: x^n can be computed in O(log n) multiplications by
+    decomposing n into binary. For example, x^13 = x^8 * x^4 * x^1
+    since 13 = 1101 in binary.
+
+    At each step, we check if current bit is set (n & 1). If so,
+    multiply result by current power of x. Then square x and shift n.
+    Handles negative exponents by inverting x and negating n.
+    """
+
+    def myPow(self, x: float, n: int) -> float:
+        # Handle negative exponent: x^(-n) = (1/x)^n
+        if n < 0:
+            x = 1 / x
+            n = -n
+
+        result = 1.0
+
+        while n > 0:
+            # If current bit is set, multiply result by current power
+            if n & 1:
+                result *= x
+
+            # Square x for next bit position
+            x *= x
+            # Move to next bit
+            n >>= 1
+
+        return result
+
+
+class SolutionRecursive:
+    """
+    Recursive binary exponentiation with divide and conquer.
+
+    The recurrence relation is:
+    - x^n = (x^(n/2))^2 if n is even
+    - x^n = x * (x^(n/2))^2 if n is odd
+    - x^0 = 1 (base case)
+
+    This naturally halves the problem each step, giving O(log n) depth.
+    Uses O(log n) stack space for recursion.
+    """
+
+    def myPow(self, x: float, n: int) -> float:
+        # Handle negative exponent
+        if n < 0:
+            x = 1 / x
+            n = -n
+
+        return self._pow(x, n)
+
+    def _pow(self, x: float, n: int) -> float:
+        # Base case
+        if n == 0:
+            return 1.0
+
+        # Recursive case: compute x^(n/2)
+        half = self._pow(x, n // 2)
+
+        # Square the result
+        if n % 2 == 0:
+            return half * half
+        else:
+            return half * half * x
+
+
+def judge(actual, expected, input_data: str) -> bool:
+    """
+    Validate power computation with tolerance for floating point.
+    """
+    import json
+
+    lines = input_data.strip().split("\n")
+    x = json.loads(lines[0])
+    n = json.loads(lines[1])
+
+    # Compute expected using Python's pow
+    expected_result = pow(x, n)
+
+    # Allow small relative error for floating point
+    if expected_result == 0:
+        return abs(actual) < 1e-9
+    return abs(actual - expected_result) / abs(expected_result) < 1e-5
+
+
+JUDGE_FUNC = judge
+
+
+def solve():
+    import sys
+    import json
+
+    lines = sys.stdin.read().strip().split("\n")
+
+    # Parse input: x and n
+    x = json.loads(lines[0])
+    n = json.loads(lines[1])
+
+    # Get solver and compute power
+    solver = get_solver(SOLUTIONS)
+    result = solver.myPow(x, n)
+
+    # Output with reasonable precision
+    print(json.dumps(result, separators=(",", ":")))
+
+
+if __name__ == "__main__":
+    solve()

tests/0050_powx_n_1.in

@@ -0,0 +1,2 @@
+2.00000
+10

tests/0050_powx_n_1.out

@@ -0,0 +1 @@
+1024.00000

tests/0050_powx_n_2.in

@@ -0,0 +1,2 @@
+2.10000
+3

tests/0050_powx_n_2.out

@@ -0,0 +1 @@
+9.26100

tests/0050_powx_n_3.in

@@ -0,0 +1,2 @@
+2.00000
+-2

tests/0050_powx_n_3.out

@@ -0,0 +1 @@
+0.25000