Architecture Migration: Polymorphic Solution Pattern¶

SOLUTIONS = {
    "default": {"method": "solve_two_pointers", ...},
    "two_ends": {"method": "solve_two_ends", ...},
}

class SolutionTwoPointers:
    def removeElement(self, nums, val): ...

class SolutionTwoEnds:
    def removeElement(self, nums, val): ...

# Wrapper functions (redundant layer)
def solve_two_pointers(nums, val):
    return SolutionTwoPointers().removeElement(nums, val)

def solve_two_ends(nums, val):
    return SolutionTwoEnds().removeElement(nums, val)

def solve():
    method_func = globals()[method_func_name]  # Calls wrapper
    result = method_func(nums, val)

SOLUTIONS = {
    "default": {"method": "mergeKListsPriorityQueue", ...},
    "divide": {"method": "mergeKListsDivideAndConquer", ...},
}

class Solution:
    def mergeKListsPriorityQueue(self, lists): ...
    def mergeKListsDivideAndConquer(self, lists): ...

def solve():
    sol = Solution()
    method_func = getattr(sol, method_func_name)  # Same instance
    result = method_func(lists)

from _runner import get_solver

SOLUTIONS = {
    "default": {
        "class": "SolutionTwoPointers",   # Required: class name
        "method": "removeElement",         # Required: LeetCode method name
        "complexity": "O(n) time, O(1) space",
        "description": "Reader/writer pointer pattern",
    },
    "two_ends": {
        "class": "SolutionTwoEnds",
        "method": "removeElement",         # Same method name (polymorphism)
        "complexity": "O(n) time, O(1) space",
        "description": "Opposite pointers approach",
    },
}

class SolutionTwoPointers:
    def removeElement(self, nums: List[int], val: int) -> int:
        ...

class SolutionTwoEnds:
    def removeElement(self, nums: List[int], val: int) -> int:
        ...

# No wrapper functions

def solve():
    nums = [...]
    val = ...

    # Clean polymorphic invocation (like LeetCode style)
    solver = get_solver(SOLUTIONS)
    k = solver.removeElement(nums, val)

    print(k)

from _runner import get_solver

def solve():
    # Parse input
    nums = list(map(int, input().split()))
    val = int(input())

    # Get solver instance (auto-selects based on SOLUTION_METHOD)
    solver = get_solver(SOLUTIONS)

    # Call method naturally - exactly like LeetCode!
    k = solver.removeElement(nums, val)

    print(k)

import inspect
import os

def get_solver(solutions_meta):
    """
    Get the solver instance for the currently selected solution method.

    Returns:
        An instance of the selected solution class.

    Example:
        solver = get_solver(SOLUTIONS)
        result = solver.twoSum(nums, target)  # Natural method call
    """
    # Auto-capture caller's globals (no need to pass explicitly)
    caller_globals = inspect.currentframe().f_back.f_globals

    method_key = os.environ.get('SOLUTION_METHOD', 'default')
    info = solutions_meta.get(method_key, solutions_meta['default'])

    return caller_globals[info['class']]()

# ✅ Valid: Single solution problem
SOLUTIONS = {
    "default": {"class": "Solution", "method": "twoSum", ...},
}

class Solution:
    def twoSum(self, nums, target): ...

# ❌ Deprecated: Multiple methods in one class
class Solution:
    def mergeKListsPriorityQueue(self, lists): ...   # Method A
    def mergeKListsDivideAndConquer(self, lists): ... # Method B (different name)

SOLUTIONS = {
    "key": {
        "class": str,        # Required: Class name (e.g., "SolutionHeap")
        "method": str,       # Required: Method name (LeetCode original)
        "complexity": str,   # Recommended: Time/space complexity
        "description": str,  # Recommended: Brief description
    },
}

# For problems with only one solution approach
SOLUTIONS = {
    "default": {"class": "Solution", "method": "twoSum"},
}

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        ...

def validate_solutions_meta(solutions_meta: dict) -> bool:
    """Validate SOLUTIONS format. SOLUTIONS is required."""
    if not solutions_meta:
        print("❌ SOLUTIONS dictionary is required")
        print("   Example:")
        print("   SOLUTIONS = {")
        print('       "default": {"class": "Solution", "method": "twoSum"},')
        print("   }")
        return False

    if 'default' not in solutions_meta:
        print("❌ SOLUTIONS must have 'default' key")
        return False

    for key, info in solutions_meta.items():
        if 'class' not in info:
            print(f"❌ SOLUTIONS['{key}'] missing 'class' field")
            return False
        if 'method' not in info:
            print(f"❌ SOLUTIONS['{key}'] missing 'method' field")
            return False

    return True

class Solution:
    def mergeKListsPriorityQueue(self, lists): ...
    def mergeKListsDivideAndConquer(self, lists): ...
    def mergeKListsGreedy(self, lists): ...

SOLUTIONS = {
    "default": {"method": "mergeKListsPriorityQueue", ...},
    "divide": {"method": "mergeKListsDivideAndConquer", ...},
    "greedy": {"method": "mergeKListsGreedy", ...},
}

class SolutionHeap:
    def mergeKLists(self, lists): ...

class SolutionDivideConquer:
    def mergeKLists(self, lists): ...

class SolutionGreedy:
    def mergeKLists(self, lists): ...

SOLUTIONS = {
    "default": {"class": "SolutionHeap", "method": "mergeKLists", ...},
    "divide": {"class": "SolutionDivideConquer", "method": "mergeKLists", ...},
    "greedy": {"class": "SolutionGreedy", "method": "mergeKLists", ...},
}