fork download 
  1. from fractions import Fraction
  2. import itertools
  3.  
  4. # 定义运算符
  5. OPS = ['+', '-', '*', '/']
  6.  
  7. def apply_op(a, b, op):
  8.     """应用运算符"""
  9.     if op == '+':
  10.         return a + b
  11.     elif op == '-':
  12.         return a - b
  13.     elif op == '*':
  14.         return a * b
  15.     elif op == '/':
  16.         if b == 0:
  17.             return None  # 除以零无效
  18.         return a / b
  19.  
  20. def format_expression(a, b, op):
  21.     """格式化两个操作数的表达式，处理交换律"""
  22.     # 对于加法和乘法，将操作数排序以处理交换律
  23.     if op in ['+', '*']:
  24.         a_str = f"({a})" if isinstance(a, str) and ' ' in a else str(a)
  25.         b_str = f"({b})" if isinstance(b, str) and ' ' in b else str(b)
  26.         # 简单的字符串排序来标准化
  27.         if a_str > b_str:
  28.             a_str, b_str = b_str, a_str
  29.         return f"{a_str} {op} {b_str}"
  30.     else:
  31.         a_str = f"({a})" if isinstance(a, str) and ' ' in a else str(a)
  32.         b_str = f"({b})" if isinstance(b, str) and ' ' in b else str(b)
  33.         return f"{a_str} {op} {b_str}"
  34.  
  35. def solve_24(numbers):
  36.     """主求解函数"""
  37.     solutions = set()
  38.  
  39.     # 1. 穷举所有数字的排列
  40.     for p in itertools.permutations(numbers):
  41.         a, b, c, d = [Fraction(n) for n in p]
  42.  
  43.         # 2. 穷举所有运算符的组合
  44.         for op1 in OPS:
  45.             for op2 in OPS:
  46.                 for op3 in OPS:
  47.                     ops = [op1, op2, op3]
  48.  
  49.                     # 3. 穷举所有五种括号结构
  50.                     # 结构1: ((a op1 b) op2 c) op3 d
  51.                     try:
  52.                         res1 = apply_op(a, b, op1)
  53.                         if res1 is not None:
  54.                             res2 = apply_op(res1, c, op2)
  55.                             if res2 is not None:
  56.                                 res3 = apply_op(res2, d, op3)
  57.                                 if res3 is not None and res3 == 24:
  58.                                     expr = format_expression(a, b, op1)
  59.                                     expr = format_expression(expr, c, op2)
  60.                                     expr = format_expression(expr, d, op3)
  61.                                     solutions.add(expr)
  62.                     except:
  63.                         pass
  64.  
  65.                     # 结构2: (a op1 (b op2 c)) op3 d
  66.                     try:
  67.                         res1 = apply_op(b, c, op2)
  68.                         if res1 is not None:
  69.                             res2 = apply_op(a, res1, op1)
  70.                             if res2 is not None:
  71.                                 res3 = apply_op(res2, d, op3)
  72.                                 if res3 is not None and res3 == 24:
  73.                                     inner_expr = format_expression(b, c, op2)
  74.                                     expr = format_expression(a, inner_expr, op1)
  75.                                     expr = format_expression(expr, d, op3)
  76.                                     solutions.add(expr)
  77.                     except:
  78.                         pass
  79.  
  80.                     # 结构3: a op1 ((b op2 c) op3 d)
  81.                     try:
  82.                         res1 = apply_op(b, c, op2)
  83.                         if res1 is not None:
  84.                             res2 = apply_op(res1, d, op3)
  85.                             if res2 is not None:
  86.                                 res3 = apply_op(a, res2, op1)
  87.                                 if res3 is not None and res3 == 24:
  88.                                     inner_expr1 = format_expression(b, c, op2)
  89.                                     inner_expr2 = format_expression(inner_expr1, d, op3)
  90.                                     expr = format_expression(a, inner_expr2, op1)
  91.                                     solutions.add(expr)
  92.                     except:
  93.                         pass
  94.  
  95.                     # 结构4: a op1 (b op2 (c op3 d))
  96.                     try:
  97.                         res1 = apply_op(c, d, op3)
  98.                         if res1 is not None:
  99.                             res2 = apply_op(b, res1, op2)
  100.                             if res2 is not None:
  101.                                 res3 = apply_op(a, res2, op1)
  102.                                 if res3 is not None and res3 == 24:
  103.                                     inner_expr1 = format_expression(c, d, op3)
  104.                                     inner_expr2 = format_expression(b, inner_expr1, op2)
  105.                                     expr = format_expression(a, inner_expr2, op1)
  106.                                     solutions.add(expr)
  107.                     except:
  108.                         pass
  109.  
  110.                     # 结构5: (a op1 b) op2 (c op3 d)
  111.                     try:
  112.                         res1 = apply_op(a, b, op1)
  113.                         res2 = apply_op(c, d, op3)
  114.                         if res1 is not None and res2 is not None:
  115.                             res3 = apply_op(res1, res2, op2)
  116.                             if res3 is not None and res3 == 24:
  117.                                 expr1 = format_expression(a, b, op1)
  118.                                 expr2 = format_expression(c, d, op3)
  119.                                 # 对于结构5，op2也可能是+或*，需要整体排序
  120.                                 final_expr = format_expression(expr1, expr2, op2)
  121.                                 solutions.add(final_expr)
  122.                     except:
  123.                         pass
  124.  
  125.     return list(solutions)
  126.  
  127. def main():
  128.     """主函数，处理输入输出"""
  129.     try:
  130.         # 输入处理
  131.         print("请输入4个正整数（小于20），用空格分隔:")
  132.         nums = list(map(int, input().split()))
  133.  
  134.         if len(nums) != 4 or any(n <= 0 or n >= 20 for n in nums):
  135.             print("输入无效，请输入4个1到19之间的正整数。")
  136.             return
  137.  
  138.         solutions = solve_24(nums)
  139.  
  140.         if not solutions:
  141.             print("No solution")
  142.         else:
  143.             # 为了输出顺序一致，对解进行排序
  144.             solutions.sort()
  145.             for sol in solutions:
  146.                 # 将分数转换为更易读的格式
  147.                 formatted_sol = sol.replace('Fraction(', '').replace(')', '')
  148.                 print(formatted_sol)
  149.  
  150.     except (ValueError, IndexError):
  151.         print("输入格式错误，请确保输入了4个数字。")
  152.  
  153. if __name__ == "__main__":
  154.     main()
Success #stdin #stdout 0.18s 16160KB
comments (?)
stdin 
2 3 3 5
stdout 
请输入4个正整数（小于20），用空格分隔:
((2 + 5 * 3 + 3
((3 * 5 - 3 * 2
https://ideone.com/BufahP
language:
Python 3 (python  3.12)
created:
1 day ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!