Create solver_ratio.py

solver_ratio.py

@@ -0,0 +1,157 @@
+from __future__ import annotations
+
+import re
+from math import gcd
+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 _reduce_ratio(a: int, b: int) -> tuple[int, int]:
+    if a == 0 and b == 0:
+        return (0, 0)
+    g = gcd(abs(a), abs(b))
+    return (a // g, b // g)
+
+
+def solve_ratio(text: str) -> Optional[SolverResult]:
+    lower = (text or "").lower()
+
+    if "ratio" not in lower and ":" not in lower:
+        return None
+
+    # Pattern 1: "ratio of x to y"
+    m = re.search(r"ratio\s+of\s+(-?\d+)\s+to\s+(-?\d+)", lower)
+    if m:
+        a = int(m.group(1))
+        b = int(m.group(2))
+        if b == 0 and a == 0:
+            return None
+        ra, rb = _reduce_ratio(a, b)
+        return SolverResult(
+            domain="quant",
+            solved=True,
+            topic="ratio",
+            answer_value=f"{ra}:{rb}",
+            internal_answer=f"{ra}:{rb}",
+            steps=[
+                "Write the ratio in order.",
+                "Reduce both parts by their greatest common factor.",
+            ],
+        )
+
+    # Pattern 2: "a:b = 2:3 and total is 40"
+    m = re.search(
+        r"(\d+)\s*:\s*(\d+).*?(?:sum|total).*?(\d+(?:\.\d+)?)",
+        lower,
+    )
+    if m:
+        a = float(m.group(1))
+        b = float(m.group(2))
+        total = float(m.group(3))
+        parts = a + b
+        if parts == 0:
+            return None
+        unit = total / parts
+        first = a * unit
+        second = b * unit
+        return SolverResult(
+            domain="quant",
+            solved=True,
+            topic="ratio_partition",
+            answer_value=f"{first:g}, {second:g}",
+            internal_answer=f"{first:g}, {second:g}",
+            steps=[
+                "Add the ratio parts.",
+                "Divide the total by the total number of parts to get one unit.",
+                "Multiply each ratio part by the unit value.",
+            ],
+        )
+
+    # Pattern 3: "ratio is 2:3, one part is 10 more than the other"
+    m = re.search(
+        r"(\d+)\s*:\s*(\d+).*?(\d+(?:\.\d+)?)\s+more\s+than",
+        lower,
+    )
+    if m:
+        a = float(m.group(1))
+        b = float(m.group(2))
+        diff_val = float(m.group(3))
+        diff_parts = abs(a - b)
+        if diff_parts == 0:
+            return None
+        unit = diff_val / diff_parts
+        first = a * unit
+        second = b * unit
+        return SolverResult(
+            domain="quant",
+            solved=True,
+            topic="ratio_difference",
+            answer_value=f"{first:g}, {second:g}",
+            internal_answer=f"{first:g}, {second:g}",
+            steps=[
+                "Find the difference in ratio parts.",
+                "Match that to the actual difference to get one unit.",
+                "Multiply each ratio part by the unit value.",
+            ],
+        )
+
+    # Pattern 4: "If x:y = 2:3 and y:z = 4:5, find x:z"
+    m = re.search(
+        r"(\w+)\s*:\s*(\w+)\s*=\s*(\d+)\s*:\s*(\d+).*?(\w+)\s*:\s*(\w+)\s*=\s*(\d+)\s*:\s*(\d+).*?find\s+(\w+)\s*:\s*(\w+)",
+        lower,
+    )
+    if m:
+        left1, right1, a, b = m.group(1), m.group(2), int(m.group(3)), int(m.group(4))
+        left2, right2, c, d = m.group(5), m.group(6), int(m.group(7)), int(m.group(8))
+        target1, target2 = m.group(9), m.group(10)
+
+        if right1 == left2:
+            lcm_base = b * c // gcd(b, c)
+            mul1 = lcm_base // b
+            mul2 = lcm_base // c
+            first = a * mul1
+            middle = lcm_base
+            third = d * mul2
+
+            mapping = {left1: first, right1: middle, right2: third}
+            if target1 in mapping and target2 in mapping:
+                x = mapping[target1]
+                y = mapping[target2]
+                rx, ry = _reduce_ratio(int(x), int(y))
+                return SolverResult(
+                    domain="quant",
+                    solved=True,
+                    topic="ratio_chain",
+                    answer_value=f"{rx}:{ry}",
+                    internal_answer=f"{rx}:{ry}",
+                    steps=[
+                        "Match the common middle term across both ratios.",
+                        "Scale the ratios so the shared term is equal.",
+                        "Read off the requested ratio and simplify.",
+                    ],
+                )
+
+    # Pattern 5: direct colon simplification
+    m = re.search(r"(\d+)\s*:\s*(\d+)", lower)
+    if m and any(w in lower for w in ["simplify", "reduce", "ratio"]):
+        a = int(m.group(1))
+        b = int(m.group(2))
+        ra, rb = _reduce_ratio(a, b)
+        return SolverResult(
+            domain="quant",
+            solved=True,
+            topic="ratio",
+            answer_value=f"{ra}:{rb}",
+            internal_answer=f"{ra}:{rb}",
+            steps=[
+                "Find the greatest common factor of both terms.",
+                "Divide both sides of the ratio by that factor.",
+            ],
+        )
+
+    return None