问试图为一个孩子的谜题编写一个解决方案--有些计算似乎不合适。

EN

import numpy as np
import pandas as pd
import operator
import random

# defining the sequences of each cube - l1 to l3 the first 3 numeric cubes, s1 the last cube, f1 and f2 the function cubes
l1 = [3, 2, 1, 4]
l2 = [2, 1, 3, 4]
l3 = [2, 4, 1, 3]
s1 = [3, 1, 4, 2]
f1 = ['*', '-', '+', '/']
f2 = ['-', '/', '+', '*']

# Getting all possible and put them in a dataframe
shuf1 = pd.DataFrame([l1[len(l1)-i:] + l1[0:len(l1)-i] for i in range(len(l1))])
shuf_f1 = pd.DataFrame([f1[len(f1)-i:] + f1[0:len(f1)-i] for i in range(len(f1))])
shuf2 = pd.DataFrame([l2[len(l2)-i:] + l2[0:len(l2)-i] for i in range(len(l2))])
shuf_f2 = pd.DataFrame([f2[len(f2)-i:] + f2[0:len(f2)-i] for i in range(len(f2))])
shuf3 = pd.DataFrame([l3[len(l3)-i:] + l3[0:len(l3)-i] for i in range(len(l3))])
shuf4 = pd.DataFrame([s1[len(s1)-i:] + l1[0:len(s1)-i] for i in range(len(s1))])

#define operators you want to use
allowed_operators={
    "+": operator.add,
    "-": operator.sub,
    "*": operator.mul,
    "/": operator.truediv}

# these lists are for iteration purposes later on
v1 = [0,1,2,3]
v2 = [0,1,2,3]
v3 = [0,1,2,3]
v4 = [0,1,2,3]
v5 = [0,1,2,3]
v6 = [0,1,2,3]
v7 = [0,1,2,3]

# opening some empty "boxes" for later use
test_results = []
temp_list = np.array([0, 0])

for v in v6:
    for w in v5:
        for z in v4:
            for u in v3:
                for y in v2:
                    for x in v1:
                        for r in v7:
                            for i in range(len(l1)):
                                
                                # Setting the face of each cube
                                a=shuf1.iloc[i,r]
                                b=shuf2.iloc[i,x]
                                c=shuf3.iloc[i,y]
                                d=shuf4.iloc[i,u]
                                string_operator=shuf_f1.iloc[i,z]
                                string_operator2=shuf_f2.iloc[i,w]
                                
                                # Doing the calculations
                                result=allowed_operators[string_operator](a,b)
                                result2=allowed_operators[string_operator2](result,c)
                                logic_test = result2 == shuf4.iloc[i,v]
                                test_results.append(result2 == logic_test)
                                
                                # feed results to list
                                newrow = []
                                second_box = str(a) + str(string_operator) + str(b) + str(string_operator2) + str(c) + "=" + str(d)
                                newrow.append(second_box)
                                newrow.append(logic_test)
                                temp_list = np.vstack([temp_list, newrow])
# Append to dataframe
solution_list = pd.DataFrame(temp_list, columns = ['Operation','Result'])

# Print out outcomes
print(solution_list.head(10))
print(solution_list.info())
preview = solution_list[solution_list['Result'] == 'True']
print(preview.head(20))

# Locate the index of the sequence of 4 consequtive positive solutions
quadruple_sequence = np.where((solution_list['Result'] == 'True') & (solution_list['Result'].shift() == 'True') & (solution_list['Result'].shift(periods=2) == 'True') & (solution_list['Result'].shift(periods=3) == 'True'))[0]
print(quadruple_sequence.size)
print(quadruple_sequence)

# Print out the 4 sequence
solution_list.iloc[quadruple_sequence]

  Operation Result
0         0      0
1   3*2-2=3  False
2   4/4*3=2  False
3   1+3+1=4  False
4   2-1/4=1  False

    Operation   Result
2164    2/2/1=1 True
2420    2/2/1=4 True
2676    2/2/1=2 True
2932    2/2/1=3 True