Qwen3-Max-Preview徹底レビュー！性能・ライセンス・使い方・検証レポートを公開

from openai import OpenAI
client = OpenAI(api_key="あなたのAPIキー", base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1")
completion = client.chat.completions.create(model="qwen3-max-preview", messages=[...])

あなたは厳密採点に最適化された数学アシスタントです。
指示：思考過程は出力しないでください。各設問について最終解とごく短い根拠（20語以内）、信頼度（0〜1）のみをJSONで返してください。数式は TeX ではなく通常文字で表記し、数値は既約分数または小数（必要なら小数10桁以内）で示してください。
出力はJSONのみ、前後に余計な文言は出さないでください。

出力スキーマ
{
  "task": "math",
  "answers": [
    {"id": "M1", "answer": "<number>", "rationale": "<<=20 words>", "confidence": 0.0},
    {"id": "M2", "answer": "<number>", "rationale": "<<=20 words>", "confidence": 0.0},
    {"id": "M3", "answer": "<number>", "rationale": "<<=20 words>", "confidence": 0.0}
  ]
}

問題

M1：整数の組 
(
𝑥
,
𝑦
)
(x,y) が 
𝑥
2
+
𝑦
2
=
45
2
x
2
+y
2
=45
2
 を満たし、かつ 
𝑥
≡
𝑦
(
m
o
d
3
)
x≡y(mod3) を満たす順序対の個数を求めよ。

M2：級数 
𝑆
=
∑
𝑘
=
1
50
1
𝑘
(
𝑘
+
1
)
S=∑
k=1
50
	​

k(k+1)
1
	​

 を正確に求めよ（既約分数で可）。

M3：級数 
∑
𝑘
=
1
∞
1
𝑘
(
𝑘
+
1
)
(
𝑘
+
2
)
∑
k=1
∞
	​

k(k+1)(k+2)
1
	​

を正確に求めよ。

制約：中間計算手順の開示は禁止。数表記の曖昧な単位やテキストは入れないでください。

あなたは24ゲームのソルバーです。
指示：各セットの4つの整数をそれぞれ一度だけ使い、+ - * / と括弧のみでちょうど 24を作ってください。分数計算は可、累乗や階乗などは禁止。小数誤差は不可（厳密 24）。解がなければ "expression": "NO_SOLUTION" としてください。
出力はJSONのみ、前後にテキストを付けないでください。各セットごとに式と評価値を返してください。

出力スキーマ
{
  "task": "24-game",
  "results": [
    {"id": "A", "numbers": [3,3,8,8], "expression": "<infix or NO_SOLUTION>", "value": 24},
    {"id": "B", "numbers": [1,3,4,6], "expression": "<infix or NO_SOLUTION>", "value": 24},
    {"id": "C", "numbers": [2,2,6,6], "expression": "<infix or NO_SOLUTION>", "value": 24}
  ]
}

ルール再掲

各数字はちょうど一度使用。

使用可能：+ - * / と括弧のみ。除算のゼロ割は禁止。

評価は厳密（分数可）。24 以外は不正解。

「思考過程の説明」は出力禁止。

あなたはテスト自動採点前提のコーディングアシスタントです。
指示：Python 3.11で四則演算式評価器を実装してください。eval/ast.literal_eval の使用は禁止。シャントリングヤード法か等価アルゴリズムでパースし、+ - * / ^、括弧、単項マイナス、実数（小数点）を扱います。演算子の優先順位は ^（右結合） > * / > + -、括弧は最優先。除算は浮動小数。
出力はコードブロックのみ（Python）。説明文や余計なログは一切出さないでください。

要件

ライブラリ禁止（re は可）。外部依存なし。

関数シグネチャ：def eval_expr(s: str) -> float:

例外時は ValueError を送出（不正トークン、未閉括弧、ゼロ除算など）。

丸めはしない（内部は浮動小数、戻り値は float）。

ファイル末尾に簡易スモークテストを含め、if __name__ == "__main__": で以下を検証し標準出力に行ごとに結果のみを出力：

1+2*3 → 7.0

-3^2 → -9.0（単項マイナスは ^ より弱い）

(1-3/4) → 0.25

2^(3^2) → 512.0（右結合）

((3-8/3)) → - -? はパース可能か（例外なく評価できること）

1/0 は ValueError

出力フォーマット（厳守）
# コードのみ（説明やコメントは任意、ただし実行時に出力を汚さないこと）


禁止：思考過程の開示、ベンチマーク値の推定、外部APIやオンライン実行環境への依存。
目的：同一入力に対し、両モデルが正しくパーサを設計・実装できるか、境界条件・演算子結合規則・エラー処理を含めて比較可能にする。

import re

def eval_expr(s: str) -> float:
    tokens = tokenize(s)
    postfix = infix_to_postfix(tokens)
    return evaluate_postfix(postfix)

def tokenize(s: str):
    token_spec = [
        ('NUMBER', r'\d+(\.\d*)?|\.\d+'),
        ('OP', r'[+\-*/^]'),
        ('LPAREN', r'\('),
        ('RPAREN', r'\)'),
        ('WHITESPACE', r'\s+'),
    ]
    tok_regex = '|'.join(f'(?P<{pair[0]}>{pair[1]})' for pair in token_spec)
    tokens = []
    pos = 0
    s = s.strip()
    while pos < len(s):
        match = re.match(tok_regex, s[pos:])
        if not match:
            raise ValueError(f"Invalid token at position {pos}")
        kind = match.lastgroup
        value = match.group()
        pos += len(value)
        if kind == 'WHITESPACE':
            continue
        elif kind == 'NUMBER':
            tokens.append(('NUMBER', float(value)))
        elif kind == 'OP':
            tokens.append(('OP', value))
        elif kind == 'LPAREN':
            tokens.append(('LPAREN', value))
        elif kind == 'RPAREN':
            tokens.append(('RPAREN', value))
    return tokens

def infix_to_postfix(tokens):
    precedence = {'+': 1, '-': 1, '*': 2, '/': 2, '^': 3}
    right_associative = {'^'}
    output = []
    stack = []
    i = 0
    while i < len(tokens):
        token_type, value = tokens[i]
        if token_type == 'NUMBER':
            output.append(value)
        elif token_type == 'OP':
            if value == '-' and (i == 0 or tokens[i-1][0] in ['OP', 'LPAREN']):
                # 単項マイナス処理
                j = i + 1
                while j < len(tokens) and tokens[j][0] == 'OP' and tokens[j][1] == '-':
                    j += 1
                if j >= len(tokens) or tokens[j][0] not in ['NUMBER', 'LPAREN']:
                    raise ValueError("Invalid unary minus")
                if tokens[j][0] == 'NUMBER':
                    num = tokens[j][1]
                    count_minus = j - i
                    if count_minus % 2 == 1:
                        num = -num
                    output.append(num)
                    i = j
                else:  # 括弧が続く場合
                    count_minus = j - i
                    is_negative = count_minus % 2 == 1
                    i = j
                    # 括弧内の式を再帰的に処理
                    paren_level = 0
                    start = i
                    while i < len(tokens):
                        if tokens[i][0] == 'LPAREN':
                            paren_level += 1
                        elif tokens[i][0] == 'RPAREN':
                            paren_level -= 1
                            if paren_level == 0:
                                break
                        i += 1
                    if paren_level != 0:
                        raise ValueError("Mismatched parentheses")
                    inner_tokens = tokens[start+1:i]
                    inner_postfix = infix_to_postfix(inner_tokens)
                    inner_value = evaluate_postfix(inner_postfix)
                    if is_negative:
                        inner_value = -inner_value
                    output.append(inner_value)
                    i += 1
                continue
            else:
                while (stack and stack[-1] != '(' and
                       stack[-1] in precedence and
                       (precedence[stack[-1]] > precedence[value] or
                        (precedence[stack[-1]] == precedence[value] and value not in right_associative))):
                    output.append(stack.pop())
                stack.append(value)
        elif token_type == 'LPAREN':
            stack.append('(')
        elif token_type == 'RPAREN':
            while stack and stack[-1] != '(':
                output.append(stack.pop())
            if not stack:
                raise ValueError("Mismatched parentheses")
            stack.pop()  # pop '('
        i += 1

    while stack:
        if stack[-1] in '()':
            raise ValueError("Mismatched parentheses")
        output.append(stack.pop())
    return output

def evaluate_postfix(postfix):
    stack = []
    for token in postfix:
        if isinstance(token, float):
            stack.append(token)
        else:
            if len(stack) < 2:
                if token == '-' and len(stack) == 1:
                    # これは通常起こらないはず（単項マイナスはトークン化で処理済み）
                    a = stack.pop()
                    stack.append(-a)
                else:
                    raise ValueError("Insufficient operands")
            else:
                b = stack.pop()
                a = stack.pop()
                if token == '+':
                    stack.append(a + b)
                elif token == '-':
                    stack.append(a - b)
                elif token == '*':
                    stack.append(a * b)
                elif token == '/':
                    if b == 0:
                        raise ValueError("Division by zero")
                    stack.append(a / b)
                elif token == '^':
                    stack.append(a ** b)
    if len(stack) != 1:
        raise ValueError("Invalid expression")
    return stack[0]

if __name__ == "__main__":
    test_cases = [
        "1+2*3",
        "-3^2",
        "(1-3/4)",
        "2^(3^2)",
        "((3-8/3))",
        "1/0"
    ]
    for expr in test_cases:
        try:
            result = eval_expr(expr)
            print(result)
        except ValueError as e:
            print("ValueError")

import re
from typing import List, Tuple, Union

Token = Union[float, str]

# Shunting-yard based evaluator with unary minus, ^ right-assoc, (), real numbers.
def eval_expr(s: str) -> float:
    if not isinstance(s, str):
        raise ValueError("Input must be string")

    tokens = _tokenize(s)
    rpn = _to_rpn(tokens)
    return _eval_rpn(rpn)

# ---- Helpers ----

_num_re = re.compile(r"""
    \s*(
        (?:
            (?:\d+\.\d*) |        # 123. or 123.45
            (?:\.\d+)    |        # .45
            (?:\d+)               # 123
        )
    )
""", re.VERBOSE)

_sym_re = re.compile(r"\s*([+\-*/^()])")

def _tokenize(s: str) -> List[Token]:
    tokens: List[Token] = []
    i = 0
    n = len(s)

    while i < n:
        # number
        m = _num_re.match(s, i)
        if m:
            tokens.append(float(m.group(1)))
            i = m.end()
            continue

        # symbol
        m = _sym_re.match(s, i)
        if m:
            tokens.append(m.group(1))
            i = m.end()
            continue

        # whitespace?
        if s[i].isspace():
            i += 1
            continue

        raise ValueError(f"Invalid token at position {i}: {s[i:]!r}")

    return tokens

# operator precedence and associativity
# Note: unary minus 'u-' is right-associative and has lower precedence than '^' but higher than * /
_OP_INFO = {
    '+': (1, 'L', 2),
    '-': (1, 'L', 2),
    '*': (2, 'L', 2),
    '/': (2, 'L', 2),
    '^': (4, 'R', 2),
    'u-': (3, 'R', 1),
}

def _to_rpn(tokens: List[Token]) -> List[Token]:
    output: List[Token] = []
    stack: List[str] = []

    prev_type = 'START'  # 'NUM', 'OP', 'LPAREN', 'RPAREN', 'START'

    for tok in tokens:
        if isinstance(tok, float):
            output.append(tok)
            prev_type = 'NUM'
            continue

        if tok in ('+', '-', '*', '/', '^'):
            # determine unary minus
            if tok == '-' and prev_type in ('START', 'OP', 'LPAREN'):
                op = 'u-'
            else:
                if prev_type in ('START', 'OP', 'LPAREN'):
                    # Unary plus unsupported; binary op cannot follow another op/(
                    if tok != '-':
                        raise ValueError("Operator position invalid")
                op = tok

            p1, assoc1, _ = _OP_INFO[op]
            while stack and stack[-1] != '(':
                top = stack[-1]
                p2, assoc2, _ = _OP_INFO[top]
                if (assoc1 == 'L' and p1 <= p2) or (assoc1 == 'R' and p1 < p2):
                    output.append(stack.pop())
                else:
                    break
            stack.append(op)
            prev_type = 'OP'
            continue

        if tok == '(':
            stack.append('(')
            prev_type = 'LPAREN'
            continue

        if tok == ')':
            # pop until '('
            found = False
            while stack:
                op = stack.pop()
                if op == '(':
                    found = True
                    break
                output.append(op)
            if not found:
                raise ValueError("Unmatched closing parenthesis")
            prev_type = 'RPAREN'
            continue

        raise ValueError("Unknown token type")

    # drain stack
    while stack:
        op = stack.pop()
        if op == '(':
            raise ValueError("Unmatched opening parenthesis")
        output.append(op)

    return output

def _eval_rpn(rpn: List[Token]) -> float:
    st: List[float] = []

    for tok in rpn:
        if isinstance(tok, float):
            st.append(tok)
            continue

        if tok not in _OP_INFO:
            raise ValueError("Invalid operator in RPN")

        _, _, arity = _OP_INFO[tok]

        if arity == 1:
            if len(st) < 1:
                raise ValueError("Insufficient operands")
            a = st.pop()
            st.append(-a)
            continue

        # binary ops
        if len(st) < 2:
            raise ValueError("Insufficient operands")
        b = st.pop()
        a = st.pop()

        if tok == '+':
            st.append(a + b)
        elif tok == '-':
            st.append(a - b)
        elif tok == '*':
            st.append(a * b)
        elif tok == '/':
            if b == 0.0:
                raise ValueError("Division by zero")
            st.append(a / b)
        elif tok == '^':
            # Python's pow handles floats; ValueError for invalid domains left to float (not required here)
            st.append(a ** b)
        else:
            raise ValueError("Unknown operator")

    if len(st) != 1:
        raise ValueError("Malformed expression")
    return float(st[0])


if __name__ == "__main__":
    tests = [
        "1+2*3",        # 7.0
        "-3^2",         # -9.0 (unary minus weaker than ^)
        "(1-3/4)",      # 0.25
        "2^(3^2)",      # 512.0 (right associative)
        "((3-8/3))",    # should parse without exception
        "1/0",          # ValueError
    ]

    for t in tests:
        try:
            res = eval_expr(t)
            print(res)
        except ValueError:
            print("ValueError")