如何实现Python函数，为1-9数字匹配+-运算符使结果为100？

嘿，我来帮你搞定这两个问题！

其实核心逻辑很简单：根据输入的运算符类型，执行对应的运算就行。这里给你两种常用的实现方式：

1. 分支判断法（新手友好，直观易懂） #

先拿到要计算的两个数和运算符，然后用if-elif-else或者Python 3.10+的match-case来匹配运算符，执行对应的计算逻辑。举个例子：

def calculate(num1, num2, operator):
    if operator == '+':
        return num1 + num2
    elif operator == '-':
        return num1 - num2
    elif operator == '*':
        return num1 * num2
    elif operator == '/':
        if num2 == 0:
            raise ValueError("除数不能为0哦！")
        return num1 / num2
    else:
        raise ValueError(f"抱歉，不支持这个运算符：{operator}")

# 测试一下
print(calculate(10, 2, '/'))  # 输出5.0

2. 字典映射法（更优雅，适合多运算符场景） #

把运算符作为字典的键，对应的运算逻辑（比如lambda函数）作为值，直接通过字典查找执行，代码会更简洁：

def calculate(num1, num2, operator):
    ops = {
        '+': lambda a, b: a + b,
        '-': lambda a, b: a - b,
        '*': lambda a, b: a * b,
        '/': lambda a, b: a / b if b != 0 else None
    }
    if operator not in ops:
        raise ValueError(f"不支持的运算符：{operator}")
    result = ops[operator](num1, num2)
    if result is None:
        raise ValueError("除数不能为0！")
    return result

两种方法各有优劣，分支法适合刚入门的朋友理解，映射法在运算符多的时候更易维护。

这个问题的关键是：每个数字之间有三种选择——加+、减-、或者和前面的数字拼接成多位数（比如1和2变成12）。我们可以用递归回溯的方式遍历所有可能的组合，筛选出结果等于100的表达式。

完整实现代码 #

def find_target_expressions():
    digits = list('123456789')
    valid_expressions = []

    def backtrack(pos, current_expr, current_total, last_number):
        # 处理完所有数字了，检查结果是不是100
        if pos == len(digits):
            if current_total == 100:
                valid_expressions.append(current_expr)
            return
        
        current_digit = digits[pos]
        # 选项1：和前面的数字拼接（注意第一个数字不能拼接）
        if pos > 0:
            new_number = last_number * 10 + int(current_digit)
            # 这里要调整当前总和：比如之前是+12，现在变成+123，相当于总和加上(123-12)
            # 如果之前是-12，现在变成-123，相当于总和减去(123-12)
            if current_expr[-1] == '+':
                new_total = current_total - last_number + new_number
            else:  # 最后一个运算符是'-'
                new_total = current_total + last_number - new_number
            backtrack(pos + 1, current_expr + current_digit, new_total, new_number)
        
        # 选项2：添加+号
        backtrack(pos + 1, current_expr + '+' + current_digit, current_total + int(current_digit), int(current_digit))
        
        # 选项3：添加-号
        backtrack(pos + 1, current_expr + '-' + current_digit, current_total - int(current_digit), int(current_digit))
    
    # 从第一个数字开始启动回溯
    backtrack(1, digits[0], int(digits[0]), int(digits[0]))
    return valid_expressions

# 调用函数并打印所有符合条件的表达式
for expr in find_target_expressions():
    print(f"{expr} = 100")

代码说明 #

• backtrack是递归回溯的核心函数，参数分别是：当前处理到第几个数字、当前拼接的表达式、当前表达式的计算结果、表达式中最后一个独立的数字（用来处理拼接场景的总和调整）。
• 拼接数字时，为什么要调整总和？比如之前的表达式是1+2，总和是3，现在把2和3拼接成23，表达式变成1+23，总和应该是24，相当于3 - 2 + 23 = 24，这样就能正确更新总和了。
• 最后当所有数字处理完，判断总和是否为100，是的话就把这个表达式加入结果列表。

运行结果 #

运行后会输出所有符合条件的表达式，比如：

1+2+34-5+67-8+9 = 100
1+23-4+5+6+78-9 = 100
12+3+4+5-6-7+89 = 100
123-4-5-6-7+8-9 = 100
...（还有其他几个符合条件的表达式）

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