21点和24点数学问题

已于 2024-06-22 10:38:16 修改
阅读量1k 收藏 26
点赞数 24
文章标签： 算法
于 2024-01-03 11:18:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rowangame/article/details/135358686
版权

21点问题

给定4个数字使用加、减、乘、除，小括号运算使等式等于21
参考解决方案：
1.全排列组合和笛卡尔积实现
2.迭代法实现

全排列组合和笛卡尔积实现

from itertools import permutations, product

# 记录运行的总次数
totalTimes: int = 0
# 结果集(除去重复的表达式)
expSet = set()
# 浮点数相等比较误差值
epsilon = 0.0000001

def solve_exp21(nums):
    if len(nums) != 4:
        print("Error:数字个数必须为4")
        return
    global totalTimes
    # 生成所有可能的排列和运算符组合
    for perm in permutations(nums):
        # print(perm)
        # 笛卡尔积(repeat=3?数字中间最多只有3个符号,可重复使用)
        for ops in product('+-*/', repeat=3):
            # d:digit o:ops
            fmt0 = "d" * 7
            fmt1 = "(dod)odod"
            fmt10 = "((dod)od)od"
            fmt11 = "(dod)o(dod)"
            fmt2 = "do(dod)od"
            fmt20 = "(do(dod))od"
            fmt21 = "do((dod)od)"
            fmt3 = "dodo(dod)"
            fmt30 = "(dod)o(dod)"
            fmt31 = "do(do(dod))"
            fmtlst = [fmt0, fmt1, fmt10, fmt11, fmt2, fmt20, fmt21, fmt3, fmt30, fmt31]
            for tmpFmt in fmtlst:
                totalTimes += 1
                tmpFmt = tmpFmt.replace("d","{}")
                tmpFmt = tmpFmt.replace("o","{}")
                tmpExp = tmpFmt.format(perm[0], ops[0], perm[1], ops[1], perm[2], ops[2], perm[3])
                value = eval(tmpExp)
                if abs(value - 21) < epsilon:
                    expSet.add(tmpExp)

参考结果：

totalTimes= 15360
[0] 7+(5*4)-6
[1] 7*(5+(4-6))
[2] 4*5-6+7
[3] 7-6+(5*4)
[4] 5*4-6+7
[5] 7*(4+(5-6))
[6] 7*((4-6)+5)
[7] 7*((5-6)+4)
[8] 6+5*(7-4)
[9] ((5*4)+7)-6
[10] 5*4+(7-6)
[11] (5*4)-6+7
[12] 6-(4-7)*5
[13] (7-6)+4*5
[14] (7-6)+5*4
[15] (5*(7-4))+6
[16] 7+(4*5)-6
[17] ((4+5)-6)*7
[18] ((4*5)-6)+7
[19] (4-(6-5))*7
[20] 6+(7-4)*5
[21] (7-6)+(5*4)
[22] 7*((5+4)-6)
[23] 6+(5*(7-4))
[24] (4*5)-6+7
[25] (4*5)+7-6
[26] 4*5+(7-6)
[27] (4+(5-6))*7
[28] 5*(7-4)+6
[29] 7+5*4-6
[30] 7*(5-(6-4))
[31] 5*4-(6-7)
[32] 4*5-(6-7)
[33] (4*5)-(6-7)
[34] ((5+4)-6)*7
[35] (7+(4*5))-6
[36] 7+((4*5)-6)
[37] 7+4*5-6
[38] 7*(4-(6-5))
[39] (7+(5*4))-6
[40] 7-(6-(4*5))
[41] 7-6+5*4
[42] 7+((5*4)-6)
[43] ((4*5)+7)-6
[44] (7-4)*5+6
[45] 7*((4+5)-6)
[46] 7-6+(4*5)
[47] 5*4+7-6
[48] 6-5*(4-7)
[49] 6-((4-7)*5)
[50] 7-6+4*5
[51] (5+(4-6))*7
[52] ((4-6)+5)*7
[53] 6-(5*(4-7))
[54] (4*5)+(7-6)
[55] (5-(6-4))*7
[56] (7-6)+(4*5)
[57] (5*4)-(6-7)
[58] 7-(6-(5*4))
[59] ((7-4)*5)+6
[60] (5*4)+7-6
[61] 4*5+7-6
[62] (5*4)+(7-6)
[63] 6+((7-4)*5)
[64] ((5-6)+4)*7
[65] ((5*4)-6)+7

24点问题

给定5个5数字使用 加、减、乘、除，小括号运算使等式等于24

迭代法实现

def solve24(dgs: list, numLen: int, exp: list):
    global totalTimes
    totalTimes += 1
    # 验证结果值
    if numLen == 1:
        boFound = abs(dgs[0] - 24) < epsilon
        if boFound:
            # 用求表达式的值函数验证结果
            real = eval(exp[0])
            print("boFound:", exp[0], dgs, f"real={real} {real==dgs[0]}")
            expSet.add(exp[0])
        return boFound

    # 分析表达式的每一个数字的+-*/是否可以得到目标值,且从第0,1,...个索引值开始两两计算并合并
    for i in range(numLen - 1):
        tmpDgs = []
        tmpExp = []
        # 分析加法能否满足条件(第i个值和第i+1个值)
        tmpV = dgs[i] + dgs[i + 1]
        tmpVExp = getExp(exp[i], exp[i + 1], "+")
        j = 0
        while j < numLen:
            if j in [i, i + 1]:
                tmpDgs.append(tmpV)
                tmpExp.append(tmpVExp)
                j += 1
            else:
                tmpDgs.append(dgs[j])
                tmpExp.append(f"{exp[j]}")
            j += 1
        if not solve24(tmpDgs, len(tmpDgs), tmpExp):
            tmpDgs.clear()
            tmpExp.clear()

        # 分析减法能否满足条件(第i个值和第i+1个值)
        tmpV = dgs[i] - dgs[i + 1]
        tmpVExp = getExp(exp[i], exp[i + 1], "-")
        j = 0
        while j < numLen:
            if j in [i, i + 1]:
                tmpDgs.append(tmpV)
                tmpExp.append(tmpVExp)
                j += 1
            else:
                tmpDgs.append(dgs[j])
                tmpExp.append(f"{exp[j]}")
            j += 1
        if not solve24(tmpDgs, len(tmpDgs), tmpExp):
            tmpDgs.clear()
            tmpExp.clear()

        # 分析乘法能否满足条件(第i个值和第i+1个值)
        tmpV = dgs[i] * dgs[i + 1]
        tmpVExp = getExp(exp[i], exp[i + 1], "*")
        j = 0
        while j < numLen:
            if j in [i, i + 1]:
                tmpDgs.append(tmpV)
                tmpExp.append(tmpVExp)
                j += 1
            else:
                tmpDgs.append(dgs[j])
                tmpExp.append(f"{exp[j]}")
            j += 1
        if not solve24(tmpDgs, len(tmpDgs), tmpExp):
            tmpDgs.clear()
            tmpExp.clear()

        # 分析除法能否满足条件(第i个值和第i+1个值)
        if dgs[i + 1] != 0:
            tmpV = dgs[i] / dgs[i + 1]
            tmpVExp = getExp(exp[i], exp[i + 1], "/")
            j = 0
            while j < numLen:
                if j in [i, i + 1]:
                    tmpDgs.append(tmpV)
                    tmpExp.append(tmpVExp)
                    j += 1
                else:
                    tmpDgs.append(dgs[j])
                    tmpExp.append(f"{exp[j]}")
                j += 1
            if not solve24(tmpDgs, len(tmpDgs), tmpExp):
                tmpDgs.clear()
                tmpExp.clear()

参考结果：

[0] 5*(5-5/5/5)
[1] (5*5*5-5)/5
[2] 5*(5-5/(5*5))
[3] (5-5/5/5)*5
[4] (5-5/(5*5))*5

扩展:给定8个8数字使用 加、减、乘、除，小括号运算使等式等于1000

迭代法实现

def solve1000(dgs: list, numLen: int, exp: list):
    global totalTimes
    totalTimes += 1
    # 验证结果值
    if numLen == 1:
        boFound = abs(dgs[0] - 1000) < epsilon
        if boFound:
            # 用求表达式的值函数验证结果
            real = eval(exp[0])
            print("boFound:", exp[0], dgs, f"real={real} {real==dgs[0]}")
            expSet.add(exp[0])
        return boFound

    # 分析表达式的每一个数字的+-*/是否可以得到目标值,且从第0,1,...个索引值开始两两计算并合并
    for i in range(numLen - 1):
        tmpDgs = []
        tmpExp = []
        # 分析加法能否满足条件(第i个值和第i+1个值)
        tmpV = dgs[i] + dgs[i + 1]
        tmpVExp = getExp(exp[i], exp[i + 1], "+")
        j = 0
        while j < numLen:
            if j in [i, i + 1]:
                tmpDgs.append(tmpV)
                tmpExp.append(tmpVExp)
                j += 1
            else:
                tmpDgs.append(dgs[j])
                tmpExp.append(f"{exp[j]}")
            j += 1
        if not solve1000(tmpDgs, len(tmpDgs), tmpExp):
            tmpDgs.clear()
            tmpExp.clear()

        # 分析减法能否满足条件(第i个值和第i+1个值)
        tmpV = dgs[i] - dgs[i + 1]
        tmpVExp = getExp(exp[i], exp[i + 1], "-")
        j = 0
        while j < numLen:
            if j in [i, i + 1]:
                tmpDgs.append(tmpV)
                tmpExp.append(tmpVExp)
                j += 1
            else:
                tmpDgs.append(dgs[j])
                tmpExp.append(f"{exp[j]}")
            j += 1
        if not solve1000(tmpDgs, len(tmpDgs), tmpExp):
            tmpDgs.clear()
            tmpExp.clear()

        # 分析乘法能否满足条件(第i个值和第i+1个值)
        tmpV = dgs[i] * dgs[i + 1]
        tmpVExp = getExp(exp[i], exp[i + 1], "*")
        j = 0
        while j < numLen:
            if j in [i, i + 1]:
                tmpDgs.append(tmpV)
                tmpExp.append(tmpVExp)
                j += 1
            else:
                tmpDgs.append(dgs[j])
                tmpExp.append(f"{exp[j]}")
            j += 1
        if not solve1000(tmpDgs, len(tmpDgs), tmpExp):
            tmpDgs.clear()
            tmpExp.clear()

        # 分析除法能否满足条件(第i个值和第i+1个值)
        if dgs[i + 1] != 0:
            tmpV = dgs[i] / dgs[i + 1]
            tmpVExp = getExp(exp[i], exp[i + 1], "/")
            j = 0
            while j < numLen:
                if j in [i, i + 1]:
                    tmpDgs.append(tmpV)
                    tmpExp.append(tmpVExp)
                    j += 1
                else:
                    tmpDgs.append(dgs[j])
                    tmpExp.append(f"{exp[j]}")
                j += 1
            if not solve1000(tmpDgs, len(tmpDgs), tmpExp):
                tmpDgs.clear()
                tmpExp.clear()

参考结果:

totalTimes= 93393622
[0] 8+(8-8/(8+8)+8)*8*8
[1] 8*(8*8+8*8)-8-(8+8)
[2] ((8+8)*8-(8+8)/8)*8-8
[3] 8*(8*(8+8)-8/8)-8-8
[4] 8*(8-8/(8+8)+8)*8+8
[5] 8-8*8*(8/(8+8)-8-8)
[6] (8+8)*8*(8-8/8/8)-8
[7] 8-((8+8)/8-8*8)*(8+8)
[8] (8*(8+8)-8/8)*8-8-8
[9] 8-(8+8)*((8+8)/8-8*8)
[10] (8+8)*(8-8/8/8)*8-8
[11] 8-8*8*(8/(8+8)-(8+8))
[12] 8*(8*(8+8)-(8+8)/8)-8
[13] (8-8/(8*8))*8*(8+8)-8
[14] (8*8+8*8)*8-8-8-8
[15] (8*(8+8)-8/8)*8-(8+8)
[16] (8+8)*8*(8-8/(8*8))-8
[17] 8*8*(8-8/(8+8)+8)+8
[18] (8+8)/8*(8*8*8-8)-8
[19] 8+(8*8-(8+8)/8)*(8+8)
[20] (8-(8/(8+8)-8))*8*8+8
[21] (8*8*8-8)/8*(8+8)-8
[22] (8*8+8*8)*8-(8+8+8)
[23] 8*8*(8-(8/(8+8)-8))+8
[24] 8+8*(8-8/(8+8)+8)*8
[25] 8*8*(8+8-8/(8+8))+8
[26] (8*(8+8)-(8+8+8)/8)*8
[27] (8*8+8*8)*8-8-(8+8)
[28] 8+(8+8-8/(8+8))*8*8
[29] (8-8/8/8)*(8+8)*8-8
[30] 8*(8*8+8*8)-(8+8+8)
[31] 8*(8*(8+8)-8/8)-(8+8)
[32] 8+8*(8+8-8/(8+8))*8
[33] 8-8*(8/(8+8)-(8+8))*8
[34] 8*((8+8)*8-8/8)-8-8
[35] (8+8)*(8*8*8-8)/8-8
[36] ((8+8)*8-8/8)*8-8-8
[37] (8+8)*(8*8-(8+8)/8)+8
[38] 8*(8+8)*(8-8/8/8)-8
[39] 8-(8/(8+8)-8-8)*8*8
[40] ((8+8)*8-8/8)*8-(8+8)
[41] (8*8+8*8)*8-(8+8)-8
[42] 8*(8+8)*(8-8/(8*8))-8
[43] 8+8*8*(8-8/(8+8)+8)
[44] 8-8*(8/(8+8)-8-8)*8
[45] 8*((8+8)*8-(8+8)/8)-8
[46] (8*8*8-8)/(8/(8+8))-8
[47] 8*((8+8)*8-(8+8+8)/8)
[48] (8-8/(8+8)+8)*8*8+8
[49] 8-(8/(8+8)-(8+8))*8*8
[50] (8+8-8/(8+8))*8*8+8
[51] 8+8*8*(8+8-8/(8+8))
[52] (8-8/8/8)*8*(8+8)-8
[53] (8*(8+8)-(8+8)/8)*8-8
[54] 8*(8*(8+8)-(8+8+8)/8)
[55] 8*(8-(8/(8+8)-8))*8+8
[56] 8*(8-8/8/8)*(8+8)-8
[57] (8+8)/(8/(8*8*8-8))-8
[58] (8*8*8-8)*(8+8)/8-8
[59] 8+8*8*(8-(8/(8+8)-8))
[60] 8+(8+8)*(8*8-(8+8)/8)
[61] 8*(8+8-8/(8+8))*8+8
[62] ((8+8)*8-(8+8+8)/8)*8
[63] 8*(8-8/(8*8))*(8+8)-8
[64] 8*(8*8+8*8)-8-8-8
[65] 8*(8*8+8*8)-(8+8)-8
[66] 8+8*(8-(8/(8+8)-8))*8
[67] 8+(8-(8/(8+8)-8))*8*8
[68] (8*8-(8+8)/8)*(8+8)+8
[69] (8-8/(8*8))*(8+8)*8-8
[70] (8+8)*(8-8/(8*8))*8-8
[71] 8*((8+8)*8-8/8)-(8+8)

全部代码:

"""
21,24点问题:
1.全排列组合和笛卡尔积实现
2.迭代法实现
注:当前算法并没有将问题的所有解全部列出来
  求所有解参考方案:需要对每个不同的数字进行掉换然后重新再计算(问题复杂度上升几个数量级)
"""
from itertools import permutations, product

# 记录运行的总次数
totalTimes: int = 0
# 结果集(除去重复的表达式)
expSet = set()
# 浮点数相等比较误差值
epsilon = 0.0000001

def solve_exp21(nums):
    if len(nums) != 4:
        print("Error:数字个数必须为4")
        return
    global totalTimes
    # 生成所有可能的排列和运算符组合
    for perm in permutations(nums):
        # print(perm)
        # 笛卡尔积(repeat=3?数字中间最多只有3个符号,可重复使用)
        for ops in product('+-*/', repeat=3):
            # d:digit o:ops
            fmt0 = "d" * 7
            fmt1 = "(dod)odod"
            fmt10 = "((dod)od)od"
            fmt11 = "(dod)o(dod)"
            fmt2 = "do(dod)od"
            fmt20 = "(do(dod))od"
            fmt21 = "do((dod)od)"
            fmt3 = "dodo(dod)"
            fmt30 = "(dod)o(dod)"
            fmt31 = "do(do(dod))"
            fmtlst = [fmt0, fmt1, fmt10, fmt11, fmt2, fmt20, fmt21, fmt3, fmt30, fmt31]
            for tmpFmt in fmtlst:
                totalTimes += 1
                tmpFmt = tmpFmt.replace("d","{}")
                tmpFmt = tmpFmt.replace("o","{}")
                tmpExp = tmpFmt.format(perm[0], ops[0], perm[1], ops[1], perm[2], ops[2], perm[3])
                value = eval(tmpExp)
                if abs(value - 21) < epsilon:
                    expSet.add(tmpExp)

# 将表达式内的括号运算变成一个数字符号(用于是否需要加小上括号运算)
def squeezeExp(exp: str):
    while True:
        eIdx = exp.find(")")
        sIdx = exp[0:eIdx].rfind("(")
        if eIdx == -1:
            break
        exp = exp[0:sIdx] + "x" + exp[eIdx + 1:]
    return exp

# 统计运算符数量(用于是否需要加上括号运算)
def histSymbols(exp):
    CON_SYMS = ["+", "-", "*", "/"]
    rlts = [0] * len(CON_SYMS)
    for index in range(len(CON_SYMS)):
        tmpSym = CON_SYMS[index]
        tmpCnt = 0
        for tmpC in exp:
            if tmpC == tmpSym:
                tmpCnt += 1
        rlts[index] = tmpCnt
    totalSys = 0
    for tmpCnt in rlts:
        totalSys += tmpCnt
    return rlts, totalSys

# 生成计算表达式(在支持四则运算优先级的情况下,减少冗余括号)
def getExp(exp1: str, exp2: str, opTag: str):
    if opTag == "+":
        return f"{exp1}+{exp2}"
    elif opTag == "-":
        squExpA = squeezeExp(exp1)
        squExpB = squeezeExp(exp2)
        expA = exp1
        expB = exp2
        if len(squExpB) > 1:
            # 全*/号不需要加括号
            symsHist, total = histSymbols(squExpB)
            if symsHist[2] + symsHist[3] != total:
                expB = "(" + expB + ")"
        return f"{expA}-{expB}"
    elif opTag == "*":
        squExpA = squeezeExp(exp1)
        squExpB = squeezeExp(exp2)
        expA = exp1
        expB = exp2
        if len(squExpA) > 1:
            symsHist, total = histSymbols(squExpA)
            if symsHist[2] + symsHist[3] != total:
                expA = "(" + expA + ")"
        if len(squExpB) > 1:
            symsHist, total = histSymbols(squExpB)
            if symsHist[2] + symsHist[3] != total:
                expB = "(" + expB + ")"
        return f"{expA}*{expB}"
    elif opTag == "/":
        squExpA = squeezeExp(exp1)
        squExpB = squeezeExp(exp2)
        expA = exp1
        expB = exp2
        if len(squExpA) > 1:
            symsHist, total = histSymbols(squExpA)
            if symsHist[2] + symsHist[3] != total:
                expA = "(" + expA + ")"
        if len(squExpB) > 1:
                expB = "(" + expB + ")"
        return f"{expA}/{expB}"


def solve24(dgs: list, numLen: int, exp: list):
    global totalTimes
    totalTimes += 1
    # 验证结果值
    if numLen == 1:
        boFound = abs(dgs[0] - 24) < epsilon
        if boFound:
            # 用求表达式的值函数验证结果
            real = eval(exp[0])
            print("boFound:", exp[0], dgs, f"real={real} {real==dgs[0]}")
            expSet.add(exp[0])
        return boFound

    # 分析表达式的每一个数字的+-*/是否可以得到目标值,且从第0,1,...个索引值开始两两计算并合并
    for i in range(numLen - 1):
        tmpDgs = []
        tmpExp = []
        # 分析加法能否满足条件(第i个值和第i+1个值)
        tmpV = dgs[i] + dgs[i + 1]
        tmpVExp = getExp(exp[i], exp[i + 1], "+")
        j = 0
        while j < numLen:
            if j in [i, i + 1]:
                tmpDgs.append(tmpV)
                tmpExp.append(tmpVExp)
                j += 1
            else:
                tmpDgs.append(dgs[j])
                tmpExp.append(f"{exp[j]}")
            j += 1
        if not solve24(tmpDgs, len(tmpDgs), tmpExp):
            tmpDgs.clear()
            tmpExp.clear()

        # 分析减法能否满足条件(第i个值和第i+1个值)
        tmpV = dgs[i] - dgs[i + 1]
        tmpVExp = getExp(exp[i], exp[i + 1], "-")
        j = 0
        while j < numLen:
            if j in [i, i + 1]:
                tmpDgs.append(tmpV)
                tmpExp.append(tmpVExp)
                j += 1
            else:
                tmpDgs.append(dgs[j])
                tmpExp.append(f"{exp[j]}")
            j += 1
        if not solve24(tmpDgs, len(tmpDgs), tmpExp):
            tmpDgs.clear()
            tmpExp.clear()

        # 分析乘法能否满足条件(第i个值和第i+1个值)
        tmpV = dgs[i] * dgs[i + 1]
        tmpVExp = getExp(exp[i], exp[i + 1], "*")
        j = 0
        while j < numLen:
            if j in [i, i + 1]:
                tmpDgs.append(tmpV)
                tmpExp.append(tmpVExp)
                j += 1
            else:
                tmpDgs.append(dgs[j])
                tmpExp.append(f"{exp[j]}")
            j += 1
        if not solve24(tmpDgs, len(tmpDgs), tmpExp):
            tmpDgs.clear()
            tmpExp.clear()

        # 分析除法能否满足条件(第i个值和第i+1个值)
        if dgs[i + 1] != 0:
            tmpV = dgs[i] / dgs[i + 1]
            tmpVExp = getExp(exp[i], exp[i + 1], "/")
            j = 0
            while j < numLen:
                if j in [i, i + 1]:
                    tmpDgs.append(tmpV)
                    tmpExp.append(tmpVExp)
                    j += 1
                else:
                    tmpDgs.append(dgs[j])
                    tmpExp.append(f"{exp[j]}")
                j += 1
            if not solve24(tmpDgs, len(tmpDgs), tmpExp):
                tmpDgs.clear()
                tmpExp.clear()

def solve1000(dgs: list, numLen: int, exp: list):
    global totalTimes
    totalTimes += 1
    # 验证结果值
    if numLen == 1:
        boFound = abs(dgs[0] - 1000) < epsilon
        if boFound:
            # 用求表达式的值函数验证结果
            real = eval(exp[0])
            print("boFound:", exp[0], dgs, f"real={real} {real==dgs[0]}")
            expSet.add(exp[0])
        return boFound

    # 分析表达式的每一个数字的+-*/是否可以得到目标值,且从第0,1,...个索引值开始两两计算并合并
    for i in range(numLen - 1):
        tmpDgs = []
        tmpExp = []
        # 分析加法能否满足条件(第i个值和第i+1个值)
        tmpV = dgs[i] + dgs[i + 1]
        tmpVExp = getExp(exp[i], exp[i + 1], "+")
        j = 0
        while j < numLen:
            if j in [i, i + 1]:
                tmpDgs.append(tmpV)
                tmpExp.append(tmpVExp)
                j += 1
            else:
                tmpDgs.append(dgs[j])
                tmpExp.append(f"{exp[j]}")
            j += 1
        if not solve1000(tmpDgs, len(tmpDgs), tmpExp):
            tmpDgs.clear()
            tmpExp.clear()

        # 分析减法能否满足条件(第i个值和第i+1个值)
        tmpV = dgs[i] - dgs[i + 1]
        tmpVExp = getExp(exp[i], exp[i + 1], "-")
        j = 0
        while j < numLen:
            if j in [i, i + 1]:
                tmpDgs.append(tmpV)
                tmpExp.append(tmpVExp)
                j += 1
            else:
                tmpDgs.append(dgs[j])
                tmpExp.append(f"{exp[j]}")
            j += 1
        if not solve1000(tmpDgs, len(tmpDgs), tmpExp):
            tmpDgs.clear()
            tmpExp.clear()

        # 分析乘法能否满足条件(第i个值和第i+1个值)
        tmpV = dgs[i] * dgs[i + 1]
        tmpVExp = getExp(exp[i], exp[i + 1], "*")
        j = 0
        while j < numLen:
            if j in [i, i + 1]:
                tmpDgs.append(tmpV)
                tmpExp.append(tmpVExp)
                j += 1
            else:
                tmpDgs.append(dgs[j])
                tmpExp.append(f"{exp[j]}")
            j += 1
        if not solve1000(tmpDgs, len(tmpDgs), tmpExp):
            tmpDgs.clear()
            tmpExp.clear()

        # 分析除法能否满足条件(第i个值和第i+1个值)
        if dgs[i + 1] != 0:
            tmpV = dgs[i] / dgs[i + 1]
            tmpVExp = getExp(exp[i], exp[i + 1], "/")
            j = 0
            while j < numLen:
                if j in [i, i + 1]:
                    tmpDgs.append(tmpV)
                    tmpExp.append(tmpVExp)
                    j += 1
                else:
                    tmpDgs.append(dgs[j])
                    tmpExp.append(f"{exp[j]}")
                j += 1
            if not solve1000(tmpDgs, len(tmpDgs), tmpExp):
                tmpDgs.clear()
                tmpExp.clear()

def solve24_test():
    global totalTimes
    totalTimes = 0
    expSet.clear()
    dgs = [5] * 5
    numLen = len(dgs)
    exp = ["5"] * 5
    solve24(dgs, numLen, exp)
    print("totalTimes=", totalTimes)
    index = 0
    for tmpExp in expSet:
        print("[%d] %s" % (index, tmpExp))
        index += 1

def solve1000_test():
    global totalTimes
    totalTimes = 0
    expSet.clear()
    dgs = [8] * 8
    numLen = len(dgs)
    exp = ["8"] * 8
    solve1000(dgs, numLen, exp)
    print("totalTimes=", totalTimes)
    index = 0
    for tmpExp in expSet:
        print("[%d] %s" % (index, tmpExp))
        index += 1

def solve_exp_test():
    global totalTimes
    totalTimes = 0
    expSet.clear()
    # 测试
    nums = [4, 5, 6, 7]
    solve_exp21(nums)
    print("totalTimes=", totalTimes)
    index = 0
    for tmpExp in expSet:
        print("[%d] %s" % (index, tmpExp))
        index += 1

if __name__ == "__main__":
    # solve24_test()
    # solve1000_test()
    solve_exp_test()
负熵笔记
关注
  • 24
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
小学数学毕业测试题21往年数学知识点.doc
10-14
小学数学毕业测试题21包含了多个数学知识点，主要涉及计算、比例、几何、代数以及应用题。以下是这些知识点的详细解析： 1. **计算**： - 口算题目练习了基本的加法、除法和乘法，如56+47，12.6÷3，0.36÷0.9等，...
leetcode(力扣)新21点解法详解
Xiao爱好的博客
06-03 1229
题目要求： 爱丽丝参与一个大致基于纸牌游戏 “21点” 规则的游戏，描述如下： 爱丽丝以 0 分开始，并在她的得分少于 K 分时抽取数字。 抽取时，她从 [1, W] 的范围中随机获得一个整数作为分数进行累计，其中 W 是整数。 每次抽取都是独立的，其结果具有相同的概率。 当爱丽丝获得不少于 K 分时，她就停止抽取数字。 爱丽丝的分数不超过 N 的概率是多少？ 示例 1： 输入：N = 10, K = 1, W = 10 输出：1.00000 说明：爱丽丝得到一张卡，然后停止。 示例 2： 输入
matlab 检测纸牌,纸牌游戏21点 数学建模
weixin_35689681的博客
03-24 1075
纸牌游戏21点(Blackjack).构造并实施21点游戏的蒙特卡洛模拟21点游戏规则如下：大多数赌场使用6副牌或8副牌玩这种游戏，以防止“数牌点”，在你的模拟中使用两副牌(共104张)。只有2位参与者，你和庄家。游戏开始时每人得到两张牌，对于牌面为2~10的牌，点数和面数相同；对于为人脸(J、Q、K)的牌，点数为10；牌面为A的牌，点数为1或者11.游戏的目的是得到总数尽量接近21点的牌，不得超...
Kaggle Python经典21点问题
qq_41495340的博客
04-19 363
kaggle python
每日一解 动态规划与新21点
new_DYX的博客
06-03 349
题目——新21点 爱丽丝参与一个大致基于纸牌游戏 “21点” 规则的游戏，描述如下： 爱丽丝以 0 分开始，并在她的得分少于 K 分时抽取数字。 抽取时，她从 [1, W] 的范围中随机获得一个整数作为分数进行累计，其中 W 是整数。 每次抽取都是独立的，其结果具有相同的概率。 当爱丽丝获得不少于 K 分时，她就停止抽取数字。 爱丽丝的分数不超过 N 的概率是多少？ 提示条件： 0 <= K <= N <= 10000 1 <= W <= 10000 来源：力扣（LeetCod
java二十一点游戏_GitHub - weiyinfu/point24: 24点游戏
weixin_39807067的博客
03-02 671
24点游戏规则如下：给定四个1~9之间的整数，这些整数之间可以进行四则运算，每个数字只能且必须使用一次，最终凑出24来。例如：1 5 5 5 。二十四点游戏有时又被称作二十一点游戏，也就是凑出21来。因为问题规模非常小(远远小于10000)，所以我们可以对二十四点游戏进行一些暴力性的探索，查看一下二十四点游戏有哪些道道。探究一：给定一个有解的问题，最多能有多少种解法下面的数字表示问题的解法种数可能...
小学数学毕业测试题24往年数学知识点.doc
10-14
这份小学升中学业数学模拟试卷24包含了多个数学知识点，主要涵盖整数、小数、比和比例、分数、百分比、几何图形、运算规则、简单方程、面积计算、百分比的应用、以及实际问题解决等内容。以下是这些知识点的详细解释...
七年级数学联考答案数学知识点.doc
10-14
- 这类题目的解决通常需要将数学知识与实际情境相结合，比如距离和方向的问题，可能涉及加减运算和单位换算。 - 耗油量的计算则涉及到乘法和比较，可能要求学生理解并运用基本的数学模型。 总的来说，这份试卷...
八年级数学联考答案数学知识点.doc
10-14
文档标题和描述中提到的是"八年级数学联考答案数学知识点"，标签也强调了"往年数学知识点"，因此我们来详细分析这份试卷中的数学知识点。 试卷结构包括选择题、填空题和解答题，涵盖了多个数学概念。下面分别解析...
BlackJack 21点 策略练习源代码
07-17
开发者根据电影《决战21点》中的算法来设计和编写了这款工具，这部电影讲述了数学天才们利用统计学和概率论在赌场中战胜庄家的故事。 首先，我们要理解21点游戏的基本规则：玩家的目标是使手中的牌面总和接近21点，...
21点算法
热门推荐
snowlevel的博客
09-08 2万+
转:决战21点算牌法  (2008-08-05 15:58:00)  转载▼ 标签：  杂谈    发牌员---庄家---先发给玩家两张牌,把这两张牌加起来---2到10是面值,10以上的花牌(face cards,就是J,Q,K)都算10,A算11,如果要爆掉的话就算成1---越接近21越好,超过就爆了,算输的。如果你头两张牌正好是21点，就被称作Blackjack(就是21点
【每日一题】新21点——概率题目
遍地跑小鸡的博客
06-03 898
2020/06/03 一道穿了概率外衣的dp问题 思路核心在于如何理解题意，这个概率是如何计算得到的。 有两种思路，第一种思路从前往后进行推导，但是我没成功。暂且不表。 主要讲一下比较好的第二种思路。既然是一道概率题，我们首先把游戏结束时的成功的事件设置为1。成功事件是指，最后结果大于等于K且小于等于N的事件，与之相应的失败时间是最后结果大于N。 由于最后的状态只与前一个状态有关，因此我们设置状态dp[i]表示当前数值为i时，成功的概率。 显然dp[K: min(N,K+W)+1] = 1，其余状态都初始
21点代码python_利用蒙特卡洛方法实现21点问题的最优解(内含python源码)
weixin_35970228的博客
02-15 891
想要获取完整代码，请访问面包多进行支持哦，仅需一口奶茶的钱！一、实验目的实现基于蒙特卡洛法的21点问题的最优解，了解强化学习的基本原理，理解蒙特卡洛法并编写相应的代码。二、实验内容赌场上流行的21点纸牌游戏的目的是获得其数值之和尽可能大而不超过21的牌。所有的人形牌面都算作10，而A可以算作1或11。我们的实验仅考虑每个玩家独立与庄家竞争的版本。游戏开始时，庄家和玩家都有两张牌。庄家的一张牌面朝上...
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
weixin_65180740的博客
07-24 924
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
算法训练营第47天|1143.最长公共子序列|1035.不相交的线|53. 最大子序和|392.判断子序列
bless_______的博客
07-24 221
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。如果text1[i - 1] 与 text2[j - 1]相同，那么找到了一个公共元素，所以dp[i][j] = dp[i - 1][j - 1] + 1;未想到特殊情况，即s或t为空串的情况，因为返回的是数组值，但是如果是空串就不会建立数组。
2.6基本算法之动态规划6045:开餐馆
最新发布
Andy_SCP001的博客
07-24 233
北大信息学院的同学小明毕业之后打算创业开餐馆.现在共有n 个地点可供选择。我们用一个整数序列m1, m2, ... mn 来表示他们的相对位置。由于地段关系,开餐馆的利润会有所不同。为了避免自己的餐馆的内部竞争,餐馆之间的距离必须大于k。//f[i]:从第1个位置到开第i个位置开餐馆能获得的最大利润。j++){//从j个地点到第i个地点开餐馆。//n个地点开一家店。//每个餐馆开的位置。//边界条件:只有一个地点,只开一家店。//n个地点开很多家店。
算法-KMP字符串匹配
xx_xb的博客
07-23 295
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
2766. 重新放置石块 Medium
珞米的博客
07-24 529
第 i = 0 步操作中，我们将位置 1 处的石块移到位置 2 处，有石块的位置为 [2,2,3,3]。第 i = 1 步操作中，我们将位置 3 处的石块移到位置 2 处，有石块的位置为 [2,2,2,2]。第 i = 0 步操作中，我们将位置 1 处的石块移到位置 2 处，位置 2,6,7,8 有石块。第 i = 1 步操作中，我们将位置 7 处的石块移到位置 9 处，位置 2,6,8,9 有石块。第 i = 2 步操作中，我们将位置 2 处的石块移到位置 5 处，位置 5,6,8,9 有石块。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值