Upload math_problem.py

math_problem.py

@@ -0,0 +1,447 @@
+import random
+import math
+from typing import Callable
+from fractions import Fraction
+
+# ── ヘルパー関数 ──
+
+
+def is_terminating(frac: Fraction) -> bool:
+    """
+    Fraction frac が有限小数(=分母の素因数が2と5のみ)かどうかを判定する
+    """
+    d = frac.denominator
+    while d % 2 == 0:
+        d //= 2
+    while d % 5 == 0:
+        d //= 5
+    return d == 1
+
+
+def precedence(op: str) -> int:
+    """演算子の優先順位を返す（+,-:1、*,/:2）"""
+    if op in ["+", "-"]:
+        return 1
+    elif op in ["*", "/"]:
+        return 2
+    return 0
+
+
+def fraction_to_decimal_string(f: Fraction, decimal_places: int) -> str:
+    """
+    Fraction f を decimal_places 桁の小数文字列に変換する。
+    ※ f は既に有限小数（循環しない）と仮定。
+    """
+    return format(float(f), f".{decimal_places}f")
+
+
+# ── 式ツリーの生成・評価・文字列変換 ──
+
+
+def generate_expr_tree(n: int, leaf_generator: Callable) -> dict:
+    """
+    n 個の項（葉）を持つ式ツリーを再帰的に生成する。
+    leaf_generator() は葉（数値）を生成する関数。
+    演算子は '+', '-', '*', '/' の中からランダムに選ぶ。
+    """
+    if n == 1:
+        return {"type": "num", "value": leaf_generator()}
+    else:
+        k = random.randint(1, n - 1)
+        left_tree = generate_expr_tree(k, leaf_generator)
+        right_tree = generate_expr_tree(n - k, leaf_generator)
+        op = random.choice(["+", "-", "*", "/"])
+        return {"type": "op", "op": op, "left": left_tree, "right": right_tree}
+
+
+def evaluate(tree: dict) -> Fraction:
+    """
+    式ツリー tree を Fraction を用いて再帰的に評価する。
+    ゼロ除算が起こった場合は ZeroDivisionError を発生する。
+    """
+    if tree["type"] == "num":
+        return tree["value"]
+    else:
+        op = tree["op"]
+        left_val = evaluate(tree["left"])
+        right_val = evaluate(tree["right"])
+        if op == "+":
+            return left_val + right_val
+        elif op == "-":
+            return left_val - right_val
+        elif op == "*":
+            return left_val * right_val
+        elif op == "/":
+            if right_val == 0:
+                raise ZeroDivisionError
+            return left_val / right_val
+
+
+def tree_to_text(
+    tree: dict,
+    parent_precedence: int = 0,
+    force_paren: bool = False,
+    decimal_places: int = None,
+) -> str:
+    """
+    式ツリー tree を普通のテキスト形式の文字列に変換する。
+    ・葉（"num"）の場合、decimal_places が指定されていれば小数形式で表示する。
+    ・内部ノードの場合、標準の演算子優先順位に従い必要に応じて括弧を追加するほか、確率的に追加する。
+    """
+    if tree["type"] == "num":
+        if decimal_places is not None:
+            return fraction_to_decimal_string(tree["value"], decimal_places)
+        else:
+            # 整数の場合は Fraction の分母が 1 なら整数として表示
+            if tree["value"].denominator == 1:
+                return str(tree["value"].numerator)
+            else:
+                return str(tree["value"])
+    else:
+        op = tree["op"]
+        current_precedence = precedence(op)
+        left_str = tree_to_text(
+            tree["left"], current_precedence, decimal_places=decimal_places
+        )
+        right_str = tree_to_text(
+            tree["right"], current_precedence, decimal_places=decimal_places
+        )
+        expr_str = f"{left_str} {op} {right_str}"
+        # 親との優先順位関係や、ランダムに括弧を付ける
+        if (
+            current_precedence < parent_precedence
+            or force_paren
+            or random.random() < 0.3
+        ):
+            return f"({expr_str})"
+        else:
+            return expr_str
+
+
+def tree_to_tex(
+    tree: dict,
+    parent_precedence: int = 0,
+    force_paren: bool = False,
+    decimal_places: int = None,
+) -> str:
+    """
+    式ツリー tree を TeX 形式の文字列に変換する。
+    ・掛け算は "\\times"、割り算は分数形式 "\\frac{...}{...}" で表現する。
+    ・必要に応じて \left( ... \right) で括弧を追加する。
+    """
+    if tree["type"] == "num":
+        if decimal_places is not None:
+            return fraction_to_decimal_string(tree["value"], decimal_places)
+        else:
+            if tree["value"].denominator == 1:
+                return str(tree["value"].numerator)
+            else:
+                return str(tree["value"])
+    else:
+        op = tree["op"]
+        current_precedence = precedence(op)
+        if op == "/":
+            # 割り算は常に分数形式で出力
+            left_tex = tree_to_tex(tree["left"], 0, decimal_places=decimal_places)
+            right_tex = tree_to_tex(tree["right"], 0, decimal_places=decimal_places)
+            expr_tex = f"\\frac{{{left_tex}}}{{{right_tex}}}"
+        else:
+            left_tex = tree_to_tex(
+                tree["left"], current_precedence, decimal_places=decimal_places
+            )
+            right_tex = tree_to_tex(
+                tree["right"], current_precedence, decimal_places=decimal_places
+            )
+            op_tex = op
+            if op == "*":
+                op_tex = "\\times"
+            expr_tex = f"{left_tex} {op_tex} {right_tex}"
+        if (
+            current_precedence < parent_precedence
+            or force_paren
+            or random.random() < 0.3
+        ):
+            return f"\\left({expr_tex}\\right)"
+        else:
+            return expr_tex
+
+
+# ── 問題作成関数 ──
+
+
+# ① 整数の四則演算の問題作成関数
+def create_integer_arithmetic_problem(
+    min_val: int = -10, max_val: int = 10, max_terms: int = 5
+) -> tuple[str, str, str]:
+    """
+    指定範囲の整数（負の値も可）と、'+', '-', '*', '/'、括弧を組み合わせた
+    四則演算の計算問題（項数は 2 ～ max_terms のランダムな個数）を作成する。
+    ※ただし、計算結果が循環小数（有限小数でない）になったり、ゼロ除算となるものは除外。
+    戻り値は (テキスト形式の式, TeX 形式の式) のタプル。
+    """
+    while True:
+        num_operands = random.randint(2, max_terms)
+        tree = generate_expr_tree(
+            num_operands, lambda: Fraction(random.randint(min_val, max_val))
+        )
+        try:
+            result = evaluate(tree)
+        except ZeroDivisionError:
+            continue
+        if not is_terminating(result):
+            continue
+        text_expr = tree_to_text(tree)
+        tex_expr = tree_to_tex(tree)
+        return text_expr, tex_expr, eval(str(result))
+
+
+# ② 小数を含む四則演算の問題作成関数
+def generate_decimal_leaf(min_val: int, max_val: int, decimal_places: int) -> Fraction:
+    """
+    指定範囲の整数部分に、指定桁数の小数部分を持つ数値を生成する。
+    内部的には Fraction(n, 10**decimal_places) として正確に扱う。
+    """
+    factor = 10**decimal_places
+    n = random.randint(min_val * factor, max_val * factor)
+    return Fraction(n, factor)
+
+
+def create_decimal_arithmetic_problem(
+    min_val: int = -10, max_val: int = 10, max_terms: int = 5, decimal_places: int = 1
+) -> tuple[str, str, str]:
+    """
+    小数（有限小数となるように生成）を用いた四則演算の計算問題を作成する関数。
+    戻り値は (テキスト形式の式, TeX 形式の式) のタプル。
+    """
+    while True:
+        num_operands = random.randint(2, max_terms)
+        tree = generate_expr_tree(
+            num_operands,
+            lambda: generate_decimal_leaf(min_val, max_val, decimal_places),
+        )
+        try:
+            result = evaluate(tree)
+        except ZeroDivisionError:
+            continue
+        if not is_terminating(result):
+            continue
+        text_expr = tree_to_text(tree, decimal_places=decimal_places)
+        tex_expr = tree_to_tex(tree, decimal_places=decimal_places)
+        return text_expr, tex_expr, eval(str(result))
+
+
+# ③ 一次方程式の問題作成関数
+def format_coefficient(k: int) -> str:
+    """
+    係数 k による x 項の表示を整形する。
+    例えば、1 → "x"、それ以外は "kx" とする。
+    """
+    if k == 1:
+        return "x"
+    else:
+        return f"{k}x"
+
+
+def create_linear_equation_problem(
+    min_val: int = -10, max_val: int = 10, max_terms: int = 3
+) -> tuple[str, str, str]:
+    """
+    一変数 (x) を含む一次方程式の問題を作成する関数です。
+    まず、定数部分 T を（整数の四則演算の問題として）作成し、
+    ランダムな非零係数 k と解 x₀ を決定して、
+
+        T + k*x = T の値 + k*x₀
+
+    という形の方程式とします。
+
+    ここで、左辺の表示において x の項の位置を
+    "begin"（先頭） / "middle"（定数部分を 2 分割して中央） / "end"（末尾）
+    のいずれかにランダムで配置するように変更しています。
+
+    戻り値は (テキスト形式の方程式, TeX 形式の方程式, 解 x₀) のタプルです。
+    """
+
+    def create_integer_arithmetic_problem_with_result(
+        min_val: int, max_val: int, max_terms: int
+    ) -> tuple[str, str, Fraction]:
+        while True:
+            num_operands = random.randint(2, max_terms)
+            tree = generate_expr_tree(
+                num_operands, lambda: Fraction(random.randint(min_val, max_val))
+            )
+            try:
+                result = evaluate(tree)
+            except ZeroDivisionError:
+                continue
+            if not is_terminating(result):
+                continue
+            text_expr = tree_to_text(tree)
+            tex_expr = tree_to_tex(tree)
+            return text_expr, tex_expr, result
+
+    # 定数��分 T の式（文字列）とその値 T_value を生成
+    text_const, tex_const, T_value = create_integer_arithmetic_problem_with_result(
+        min_val, max_val, max_terms
+    )
+    # 非零の係数 k と解 x₀ をランダムに選ぶ
+    possible = [i for i in range(min_val, max_val + 1) if i != 0]
+    k = random.choice(possible) if possible else 1
+    x0 = random.randint(min_val, max_val)
+    # 右辺は T_value + k*x₀
+    R_value = T_value + k * x0
+
+    # x の項の配置位置をランダムに決定
+    mode = random.choice(["begin", "middle", "end"])
+
+    if mode == "begin":
+        # x の項を先頭に配置
+        if k >= 0:
+            lhs_text = f"{format_coefficient(k)} + {text_const}"
+            lhs_tex = f"{format_coefficient(k)} + {tex_const}"
+        else:
+            lhs_text = f"- {format_coefficient(abs(k))} + {text_const}"
+            lhs_tex = f"- {format_coefficient(abs(k))} + {tex_const}"
+    elif mode == "end":
+        # x の項を末尾に配置（従来の形式）
+        if k >= 0:
+            lhs_text = f"{text_const} + {format_coefficient(k)}"
+            lhs_tex = f"{tex_const} + {format_coefficient(k)}"
+        else:
+            lhs_text = f"{text_const} - {format_coefficient(abs(k))}"
+            lhs_tex = f"{tex_const} - {format_coefficient(abs(k))}"
+    else:  # mode == "middle"
+        # 定数 T_value を 2 つの定数 A と B に分割し、その間に x の項を配置
+        def format_fraction(frac: Fraction) -> str:
+            if frac.denominator == 1:
+                return str(frac.numerator)
+            else:
+                return str(float(frac))
+
+        A = Fraction(random.randint(min_val, max_val))
+        B = T_value - A
+        A_text = format_fraction(A)
+        B_text = format_fraction(B)
+        A_tex = A_text  # 数値の場合、TeX 表記も同じ
+        B_tex = B_text
+        if k >= 0:
+            lhs_text = f"{A_text} + {format_coefficient(k)} + {B_text}"
+            lhs_tex = f"{A_tex} + {format_coefficient(k)} + {B_tex}"
+        else:
+            lhs_text = f"{A_text} - {format_coefficient(abs(k))} + {B_text}"
+            lhs_tex = f"{A_tex} - {format_coefficient(abs(k))} + {B_tex}"
+
+    # 右辺の数値表示（整数なら整数、Fraction なら float 表示）
+    if R_value.denominator == 1:
+        rhs_text = str(R_value.numerator)
+        rhs_tex = str(R_value.numerator)
+    else:
+        rhs_text = str(float(R_value))
+        rhs_tex = str(float(R_value))
+
+    eq_text = lhs_text + " = " + rhs_text
+    eq_tex = lhs_tex + " = " + rhs_tex
+    return eq_text, eq_tex, eval(str(x0))
+
+
+def create_two_decimals(
+    min_val: float, max_val: float, precision: float
+) -> tuple[float, float, float]:
+    """
+    指定された範囲 [min_val, max_val] 内で、
+    整数部分が共通かつ、小数点以下の桁数(precision)を指定して、
+    その精度以下の値をランダムに選んだ2つの数値を生成する関数です。
+
+    Parameters:
+        min_val (float): 生成する数値の最小値
+        max_val (float): 生成する数値の最大値
+        precision (int): 小数点以下の桁数（0以上の整数）
+
+    Returns:
+        tuple: 生成された2つの数値 (num1, num2)
+    """
+    if min_val >= max_val:
+        raise ValueError("min_valはmax_valより小さくなければなりません。")
+    if precision < 0:
+        raise ValueError("precisionは0以上の整数である必要があります。")
+
+    # 指定した精度に応じたスケール（例: precision=3 なら scale=1000）
+    scale = int(10**precision)
+
+    valid_candidates = []  # (整数部分, 許容されるfraction部の整数値リスト) のタプルを格納
+
+    # 整数部分の候補は、min_valの整数部分からmax_valの整数部分まで
+    for k in range(math.floor(min_val), math.floor(max_val) + 1):
+        # kを共通の整数部分とする場合の、小数部分がとれる範囲は
+        #   r = 数値 - k が [r_lower, r_upper) に収まる必要がある
+        r_lower = max(0, min_val - k)  # 下限
+        r_upper = min(1, max_val - k)  # 上限（1未満にする）
+
+        # 小数部分は、指定精度で離散化された値 i/scale (i = 0, 1, ..., scale-1) として扱う
+        # i/scale が [r_lower, r_upper) に入る i を抽出します
+        allowed_i = [
+            i for i in range(scale) if (i / scale) >= r_lower and (i / scale) < r_upper
+        ]
+
+        if allowed_i:  # 少なくとも1つの値がとれるなら候補に追加
+            valid_candidates.append((k, allowed_i))
+
+    if not valid_candidates:
+        raise ValueError("指定された範囲内で共通の整数部分を持つ数値が生成できません。")
+
+    # 有効な候補からランダムに1つ選びます
+    k, allowed_i = random.choice(valid_candidates)
+
+    if len(allowed_i) < 2:
+        # もし候補が1種類しかなければ、異なる2つの数値を生成できません
+        raise ValueError("指定された範囲と精度では、異なる2つの数値を生成できません。")
+
+    # allowed_i から重複しない2つの値をランダムに選びます
+    i1, i2 = random.sample(allowed_i, 2)
+
+    num1 = k + i1 / scale
+    num2 = k + i2 / scale
+
+    greater = max(num1, num2)
+
+    return num1, num2, greater
+
+
+# ── 使用例 ──
+
+if __name__ == "__main__":
+    print("【整数の四則演算の問題】")
+    text_expr, tex_expr, result = create_integer_arithmetic_problem(
+        -100,
+        100,
+        max_terms=8,
+    )
+    print("テキスト形式 :", text_expr)
+    print("TeX 形式    :", tex_expr)
+    print("答え        :", result)
+
+    print("\n【小数を含む四則演算の問題】")
+    text_expr, tex_expr, result = create_decimal_arithmetic_problem(
+        -100,
+        100,
+        max_terms=8,
+        decimal_places=1,
+    )
+    print("テキスト形式 :", text_expr)
+    print("TeX 形式    :", tex_expr)
+    print("答え        :", result)
+
+    print("\n【一次方程式の問題】")
+    eq_text, eq_tex, x0 = create_linear_equation_problem(
+        -100,
+        100,
+        max_terms=8,
+    )
+    print("テキスト形式 :", eq_text)
+    print("TeX 形式    :", eq_tex)
+    print("解 x0       :", x0)
+
+    print("\n【2つの小数の比較問題】")
+    num1, num2, greater = create_two_decimals(-100.0, 100.0, 3)
+    print("小数1       :", num1)
+    print("小数2       :", num2)
+    print("大きい方    :", greater)