闲得无聊，写了个算24点的程序，思想很简单，使用递归，从数组中取出第一个数，然后遍历取出第二个数，将这两个数学做任意四则运算后，放到剩下的数组里，直到只剩最后一个数。

    1. def f(L):
    2.     n=len(L)
    3.     if n==1:
    4.         if abs(L[0]-24)<0.001:
    5.             return True
    6.         else:
    7.             return False
    8.     a=L[0]
    10.     for b in L[1:]:
    11.         s=a+b
    12.         LL=L[1:]
    13.         LL.remove(b)
    14.         if f([s]+LL)==True:
    15.             print('{}+{}={}'.format(a,b,s))
    16.             return True
    18.         s=a-b
    19.         LL=L[1:]
    20.         LL.remove(b)
    21.         if f([s]+LL)==True:
    22.             print('{}+{}={}'.format(a,b,s))
    23.             return True
    25.         s=b-a
    26.         LL=L[1:]
    27.         LL.remove(b)
    28.         if f([s]+LL)==True:
    29.             print('{}-{}={}'.format(b,a,s))
    30.             return True
    32.         s=a*b
    33.         LL=L[1:]
    34.         LL.remove(b)
    35.         if f([s]+LL)==True:
    36.             print('{}*{}={}'.format(a,b,s))
    37.             return True
    39.         if a :
    40.             s=b/a
    41.             LL=L[1:]
    42.             LL.remove(b)
    43.             if f([s]+LL)==True:
    44.                 print('{}/{}={}'.format(b,a,s))
    45.                 return True
    47.         if b :
    48.             s=a/b
    49.             LL=L[1:]
    50.             LL.remove(b)
    51.             if f([s]+LL)==True:
    52.                 print('{}/{}={}'.format(a,b,s))
    53.                 return True
    1. >>> f([3,3,8,8])
    3. 8/0.3333333333333335=23.99999999999999
    4. 3-2.6666666666666665=0.3333333333333335
    5. 8/3=2.6666666666666665