请使用 59 48 58 32 30 31 30 得出“6512345”，全数学计算

python
import itertools, math, operator, functools

nums=[59,48,58,32,30,31,30]

# Let's try expressions of the form a*b*c*d + e*f*g  (partition 4 and 3)
target=6512345

def prod(seq):
    p=1
    for x in seq:
        p*=x
    return p

sols=[]
for comb4 in itertools.combinations(range(7),4):
    A=[nums[i] for i in comb4]
    B=[nums[i] for i in range(7) if i not in comb4]
    p1=prod(A)
    p2=prod(B)
    if p1+p2==target:
        sols.append((A,B,"+"))
    if p1-p2==target:
        sols.append((A,B,"-"))
    if p2-p1==target:
        sols.append((B,A,"-"))
    # with multiplication scale etc can try p1*k + p2 where k small integers??

len(sols), sols[:3]

(0, [])

python
sols=[]
for comb3 in itertools.combinations(range(7),3):
    A=[nums[i] for i in comb3]
    B=[nums[i] for i in range(7) if i not in comb3]
    p1=prod(A)
    p2=prod(B)
    if p1+p2==target:
        sols.append((A,B,"+"))
    if p1-p2==target:
        sols.append((A,B,"-"))
    if p2-p1==target:
        sols.append((B,A,"-"))
sols[:3], len(sols)

([], 0)

python
sols=[]
for comb5 in itertools.combinations(range(7),5):
    A=[nums[i] for i in comb5]
    B=[nums[i] for i in range(7) if i not in comb5]
    p1=prod(A)
    p2=prod(B)
    if p1+p2==target:
        sols.append((A,B,"+"))
    if p1-p2==target:
        sols.append((A,B,"-"))
    if p2-p1==target:
        sols.append((B,A,"-"))
len(sols)

0

python
solutions=[]
target=6512345
for split in range(1,7):
    for comb in itertools.combinations(range(7),split):
        A=[nums[i] for i in comb]
        B=[nums[i] for i in range(7) if i not in comb]
        p1=prod(A)
        p2=prod(B)
        for k in range(-20,21):
            if k*p1 + p2 == target:
                solutions.append((k,A,B))
solutions[:5], len(solutions)

([], 0)

python
from functools import lru_cache
import itertools

nums=[59,48,58,32,30,31,30]
target=6512345

def canonical(state):
    return tuple(sorted(state))

@lru_cache(None)
def gen(state):
    state=tuple(state)
    if len(state)==1:
        v=state[0]
        return {v: str(v)}
    res={}
    n=len(state)
    # enumerate non-empty proper subsets, but avoid duplicates by ensuring lowest index in left subset is at position 0
    # We'll use indices
    for r in range(1, n//2+1):  # to avoid mirror duplicates we restrict size up to n//2 and then handle symmetric partitions once with additional rule
        for left_idx in itertools.combinations(range(n), r):
            # symmetry breaking:

(False, 55865)

python
target=6512345
nums=[59,48,58,32,30,31,30]

def concat(lst):
    s=''.join(str(x) for x in lst)
    return int(s)

# Try partitions into groups and +/- between groups? Exclude order maybe we keep original order
from itertools import product

# Keep original order, choose cut positions between numbers (6 slots) either cut or not to create groups, then apply +,- ops between groups.
best=None
count=0
for cuts in product([0,1], repeat=len(nums)-1): # 1=cut here, 0=concat
    groups=[]
    cur=[nums[0]]
    for i,b in enumerate(cuts):
        if b==0:
            cur.append(nums[i+1])
        else:
            groups.append(cur)
            cur=[nums[i+1]]
    groups.append(cur)
    # Evaluate concatenated integers for each group
    vals=[concat(g) for g in

0

python
import itertools, math
from functools import lru_cache

nums=[59,48,58,32,30,31,30]
target=6512345

def concat(lst):
    return int(''.join(str(x) for x in lst))

def all_expr(vals):
    @lru_cache(None)
    def f(state):
        if len(state)==1:
            return {state[0]: str(state[0])}
        res={}
        n=len(state)
        for k in range(1,n):
            left=state[:k]
            right=state[k:]
            ld=f(left); rd=f(right)
            for lv, le in ld.items():
                for rv, re in rd.items():
                    for sym, val in [('+', lv+rv), ('-', lv-rv), ('*', lv*rv)]:
                        if abs(val)>10**9:
                            continue
                        expr=f"({le}{sym}{re})"
                        if val not in res:
                            res[val]=expr
                    if rv!=0 and lv%rv==0:
                        val=lv//rv
                        expr=f"({le}/{re})"
                        if val not in res:
                            res[val]=expr
        return res
    return f(tuple(vals))

def find_solution():
    from itertools import permutations, product
    count=0
    for perm in itertools.permutations(nums):
        # make cuts
        for masknum in range(1<<6):  # 0..63
            groups=[]; cur=[perm[0]]
            for i in range(6):
                b=(masknum>>i)&1
                if b==0:
                    cur.append(perm[i+1])
                else:
                    groups.append(cur); cur=[perm[i+1]]
            groups.append(cur)
            vals=[concat(g) for g in groups]
            exprs=all_expr(vals)
            if target in exprs:
                return perm, groups, vals, exprs[target]
        count+=1
        if count%200==0:
            pass
    return None

sol=find_solution()
sol

python
def compute():
    T = (59 - 48) - (31 - 30)  # 10
    d6 = (58 - 32) - ((32 - 30) * T)  # 26 - 2*10 =6
    d5 = T // (32 - 30)  # 10/2 =5
    d1 = (31 - 30)  # 1
    d2 = (32 - 30)  # 2
    d3 = 30 // T  # 3
    d4 = (32 - 30) + (32 - 30)  # 4
    d0 = d5  # 5
    R = ((((((d6)*T + d5)*T + d1)*T + d2)*T + d3)*T + d4)*T + d0
    return T,d6,d5,d1,d2,d3,d4,d0,R

compute()

(10, 6, 5, 1, 2, 3, 4, 5, 6512345)