如何串联初始数据、符号反转与运算逻辑实现数字组合算术匹配

需求说明 #

初始数据格式如下：

initial_data = [
"518-2", '533-3', '534-0',
'000-3', '000-4']

需要对每个条目执行以下操作：

• 拆分连字符前后内容：前半部分为单个数字组成的序列，后半部分为目标结果
• 对序列中的每个数字可添加正负号
• 用加、减、乘、除、阶乘、幂运算、开方等运算组合，找出运算结果等于目标值的等式
• 最终生成符合以下格式的CSV文件：

  number, solution, number_of_solutions
  000-3,(0! + 0!) + 0! = 3,2
  000-4,,0
  533-3,5 - (3! / 3) = 3,5
  

现有代码模块 #

符号反转函数 #

用于生成数字的所有正负组合：

from itertools import product

def inverter(data):
    inverted_data = [-x for x in data]
    res = list(product(*zip(data, inverted_data)))
    return res

运算函数集合 #

import numpy as np
from math import factorial

def plus(a, b):
    return a + b

def minus(a, b):
    return a - b

def mult(a, b):
    return a * b

def div(a, b):
    if b != 0 and a % b == 0:
        return a // b
    return np.nan

def factorial_op(num):
    try:
        return factorial(int(num))
    except ValueError:
        return np.nan

def power_to(a, b):
    try:
        return int(a ** b)
    except (ValueError, ZeroDivisionError):
        return np.nan

def root(a, b):
    try:
        result = b ** (1 / a)
        return int(result) if result.is_integer() else np.nan
    except (TypeError, ZeroDivisionError, ValueError):
        return np.nan

组合与求解函数（存在缺陷） #

import itertools

def combinations(nums, funcs):
    """生成数字序列与运算符的所有合法组合"""
    t = []
    for i in range(len(nums)-1):
        t.append(nums)
        t.append(funcs)
    t.append(nums)
    return list(itertools.product(*t))

def solve(instance):
    instance = list(instance)
    for i in range(len(instance)//2):
        b = instance.pop()
        func = instance.pop()
        a = instance.pop()
        instance.append(func(a, b))
    return instance[0]

当前存在的问题 #

• main函数仅支持硬编码单个测试用例，无法批量处理initial_data中的所有条目
• 无法将initial_data的数据流转到inverter模块生成正负组合
• 运算函数逻辑有缺陷（比如阶乘作为单目运算，当前代码按双目运算处理）
• 输出仅打印函数对象和结果，无法生成符合要求的等式字符串与CSV文件

完整整合解决方案 #

步骤1：数据解析函数 #

def parse_entry(entry):
    """拆分初始数据条目为数字列表和目标值"""
    num_str, target_str = entry.split('-')
    nums = [int(c) for c in num_str]
    target = int(target_str)
    return num_str + '-' + target_str, nums, target

步骤2：修正运算逻辑与等式生成 #

为每个运算函数匹配符号，同时处理阶乘等单目运算的组合逻辑：

# 运算符号映射，用于生成可读等式
OP_SYMBOLS = {
    plus: '+',
    minus: '-',
    mult: '*',
    div: '/',
    power_to: '**',
    root: 'root',
    factorial_op: '!'
}

def generate_full_combinations(nums):
    """生成所有可能的数字正负组合、阶乘应用组合、双目运算符组合"""
    # 生成数字正负组合
    num_sign_combs = inverter(nums)
    # 生成每个数字是否应用阶乘的组合（True/False）
    fact_combs = list(itertools.product([True, False], repeat=len(nums)))
    # 双目运算符集合
    bin_ops = [plus, minus, mult, div, power_to, root]
    # 生成n-1个运算符的所有组合
    op_combs = list(itertools.product(bin_ops, repeat=len(nums)-1))
    
    full_combs = []
    for num_comb in num_sign_combs:
        for fact_comb in fact_combs:
            processed_nums = []
            valid = True
            # 应用阶乘并验证合法性
            for num, apply_fact in zip(num_comb, fact_comb):
                if apply_fact:
                    val = factorial_op(num)
                    if np.isnan(val):
                        valid = False
                        break
                    processed_nums.append(val)
                else:
                    processed_nums.append(num)
            if not valid:
                continue
            # 组合运算符
            for op_comb in op_combs:
                full_combs.append((num_comb, fact_comb, op_comb, processed_nums))
    return full_combs

def calculate_result(processed_nums, op_comb):
    """计算运算组合的结果，异常返回nan"""
    result = processed_nums[0]
    for i in range(len(op_comb)):
        op = op_comb[i]
        next_num = processed_nums[i+1]
        val = op(result, next_num)
        if np.isnan(val):
            return np.nan
        result = val
    return result

def build_equation_str(num_comb, fact_comb, op_comb):
    """生成可读的等式字符串"""
    parts = []
    # 处理每个数字的正负和阶乘标记
    for num, apply_fact in zip(num_comb, fact_comb):
        num_str = str(num) if num >= 0 else f"({num})"
        if apply_fact:
            num_str += "!"
        parts.append(num_str)
    # 插入运算符
    eq_parts = []
    for i in range(len(parts)):
        eq_parts.append(parts[i])
        if i < len(op_comb):
            eq_parts.append(OP_SYMBOLS[op_comb[i]])
    return " ".join(eq_parts)

步骤3：批量处理所有条目并生成CSV #

import csv

def process_all_entries(initial_data):
    results = []
    for entry in initial_data:
        entry_id, nums, target = parse_entry(entry)
        full_combs = generate_full_combinations(nums)
        valid_equations = set()  # 用集合去重
        
        for num_comb, fact_comb, op_comb, processed_nums in full_combs:
            result = calculate_result(processed_nums, op_comb)
            if result == target:
                eq_str = build_equation_str(num_comb, fact_comb, op_comb)
                valid_equations.add(f"{eq_str} = {target}")
        
        eq_list = list(valid_equations)
        count = len(eq_list)
        solution_str = "; ".join(eq_list) if count > 0 else ""
        results.append([entry_id, solution_str, count])
    return results

def write_to_csv(results, filename="solutions.csv"):
    """将结果写入CSV文件"""
    with open(filename, 'w', newline='', encoding='utf-8') as f:
        writer = csv.writer(f)
        writer.writerow(["number", "solution", "number_of_solutions"])
        writer.writerows(results)

def main():
    initial_data = [
        "518-2", '533-3', '534-0',
        '000-3', '000-4'
    ]
    results = process_all_entries(initial_data)
    write_to_csv(results)
    print("CSV文件已生成")

if __name__ == "__main__":
    main()

关键说明 #

1. 数据流转：通过parse_entry拆分初始数据，再传入generate_full_combinations生成所有可能的数字正负、阶乘应用、运算符组合
2. 去重处理：用集合存储合法等式，避免重复结果
3. CSV生成：直接将结果按要求格式写入CSV文件
4. 运算修正：区分单目阶乘运算和双目运算，修正了阶乘、开方等函数的异常处理逻辑

内容的提问来源于stack exchange，提问作者PersonPr7