Create solver_percent.py

solver_percent.py

@@ -0,0 +1,189 @@
+from __future__ import annotations
+
+import re
+from typing import Optional, List
+
+from models import SolverResult
+
+
+def _nums(text: str) -> List[float]:
+    return [float(x) for x in re.findall(r"-?\d+(?:\.\d+)?", text)]
+
+
+def solve_percent(text: str) -> Optional[SolverResult]:
+    lower = (text or "").lower()
+
+    if "%" not in lower and "percent" not in lower:
+        return None
+
+    nums = _nums(lower)
+
+    # Pattern 1: "40% of a number is 24"
+    m = re.search(
+        r"(\d+(?:\.\d+)?)\s*%?\s*(?:percent)?\s*of\s+(?:a\s+number|number|x|an?\s+amount).*?\bis\b\s*(-?\d+(?:\.\d+)?)",
+        lower,
+    )
+    if m:
+        pct = float(m.group(1)) / 100.0
+        value = float(m.group(2))
+        if pct == 0:
+            return None
+        result = value / pct
+        return SolverResult(
+            domain="quant",
+            solved=True,
+            topic="percent",
+            answer_value=f"{result:g}",
+            internal_answer=f"{result:g}",
+            steps=[
+                "Convert the percent to a decimal.",
+                "Set up percent × whole = part.",
+                "Divide the part by the decimal percent to get the whole.",
+            ],
+        )
+
+    # Pattern 2: "What is 25% of 80?"
+    m = re.search(
+        r"what\s+is\s+(\d+(?:\.\d+)?)\s*%?\s*(?:percent)?\s*of\s*(-?\d+(?:\.\d+)?)",
+        lower,
+    )
+    if m:
+        pct = float(m.group(1)) / 100.0
+        whole = float(m.group(2))
+        result = pct * whole
+        return SolverResult(
+            domain="quant",
+            solved=True,
+            topic="percent",
+            answer_value=f"{result:g}",
+            internal_answer=f"{result:g}",
+            steps=[
+                "Convert the percent to a decimal.",
+                "Multiply the whole by the decimal percent.",
+            ],
+        )
+
+    # Pattern 3: "24 is what percent of 60?"
+    m = re.search(
+        r"(-?\d+(?:\.\d+)?)\s+is\s+what\s+percent\s+of\s+(-?\d+(?:\.\d+)?)",
+        lower,
+    )
+    if m:
+        part = float(m.group(1))
+        whole = float(m.group(2))
+        if whole == 0:
+            return None
+        result = (part / whole) * 100
+        return SolverResult(
+            domain="quant",
+            solved=True,
+            topic="percent",
+            answer_value=f"{result:g}",
+            internal_answer=f"{result:g}",
+            steps=[
+                "Use percent = part ÷ whole × 100.",
+                "Divide the part by the whole.",
+                "Convert the decimal to a percent.",
+            ],
+        )
+
+    # Pattern 4: "What percent of 60 is 24?"
+    m = re.search(
+        r"what\s+percent\s+of\s+(-?\d+(?:\.\d+)?)\s+is\s+(-?\d+(?:\.\d+)?)",
+        lower,
+    )
+    if m:
+        whole = float(m.group(1))
+        part = float(m.group(2))
+        if whole == 0:
+            return None
+        result = (part / whole) * 100
+        return SolverResult(
+            domain="quant",
+            solved=True,
+            topic="percent",
+            answer_value=f"{result:g}",
+            internal_answer=f"{result:g}",
+            steps=[
+                "Use percent = part ÷ whole × 100.",
+                "Divide the part by the whole.",
+                "Convert to percent form.",
+            ],
+        )
+
+    # Pattern 5: percent increase/decrease
+    m = re.search(
+        r"(-?\d+(?:\.\d+)?)\s*%?\s*(?:percent)?\s*(increase|decrease)[sd]?\s+from\s+(-?\d+(?:\.\d+)?)\s+to\s+(-?\d+(?:\.\d+)?)",
+        lower,
+    )
+    if m:
+        # rare wording, not ideal
+        pass
+
+    m = re.search(
+        r"(?:increase|decrease)[sd]?\s+from\s+(-?\d+(?:\.\d+)?)\s+to\s+(-?\d+(?:\.\d+)?)",
+        lower,
+    )
+    if m and ("percent" in lower or "%" in lower):
+        old = float(m.group(1))
+        new = float(m.group(2))
+        if old == 0:
+            return None
+        result = ((new - old) / old) * 100
+        return SolverResult(
+            domain="quant",
+            solved=True,
+            topic="percent_change",
+            answer_value=f"{result:g}",
+            internal_answer=f"{result:g}",
+            steps=[
+                "Find the change: new − old.",
+                "Divide by the original value.",
+                "Multiply by 100 to convert to a percent.",
+            ],
+        )
+
+    # Pattern 6: "increased by 20%" / "decreased by 20%"
+    m = re.search(
+        r"(-?\d+(?:\.\d+)?)\s+(?:is\s+)?(increased|decreased)\s+by\s+(\d+(?:\.\d+)?)\s*%",
+        lower,
+    )
+    if m:
+        value = float(m.group(1))
+        direction = m.group(2)
+        pct = float(m.group(3)) / 100.0
+        result = value * (1 + pct if direction == "increased" else 1 - pct)
+        return SolverResult(
+            domain="quant",
+            solved=True,
+            topic="percent_change",
+            answer_value=f"{result:g}",
+            internal_answer=f"{result:g}",
+            steps=[
+                "Convert the percent to a decimal.",
+                "Use multiplier 1 + p for increase or 1 − p for decrease.",
+                "Multiply the original value by that multiplier.",
+            ],
+        )
+
+    # Pattern 7: percent error / generic part-whole if 2 nums and clue words
+    if len(nums) >= 2 and ("of" in lower or "is" in lower):
+        # conservative fallback
+        pct = nums[0]
+        whole = nums[1]
+        if pct <= 100:
+            result = (pct / 100.0) * whole
+            return SolverResult(
+                domain="quant",
+                solved=True,
+                topic="percent",
+                answer_value=f"{result:g}",
+                internal_answer=f"{result:g}",
+                steps=[
+                    "Interpret the first number as a percent.",
+                    "Convert it to a decimal.",
+                    "Multiply by the base quantity.",
+                ],
+            )
+
+    return None