24点运算

# 将扑克牌字符转换为对应的值   print_res里面其实已经找出来全部方法
def card_value(card):
    values = {'A': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9, '10': 10, 
              'J': 11, 'Q': 12, 'K': 13}
    if card in values:
        return values[card]
    return None

def find_24(hardcard,value_path,res):     # 采用dfs
    # print(value_path)
    if not hardcard:
        value, path = value_path
        if value == 24:
            res.append(path)
            # value_path.pop()
        return
    if value_path == []:
        card = hardcard[0]
        value_path= [card_value(card),[card]]
        find_24(hardcard[1:],value_path,res)
    else:
        card = hardcard[0]
        find_24(hardcard[1:],[value_path[0]*card_value(card),value_path[1]+["*"]+[card]],res)
        find_24(hardcard[1:],[value_path[0]-card_value(card),value_path[1]+["-"]+[card]],res)
        find_24(hardcard[1:],[value_path[0]+card_value(card),value_path[1]+["+"]+[card]],res)
        if card_value(card) != 0:
            find_24(hardcard[1:],[value_path[0]//card_value(card),value_path[1]+["/"]+[card]],res)
        # value_path.pop()


from itertools import permutations
hardcards = input().strip().split()
hardcards = permutations(hardcards)
print_res = []
for hardcard in hardcards:
    # print(hardcard)
    record = []
    res = []
    if "joker" in hardcard&nbs***bsp;"JOKER" in hardcard:
        print_res.append(["ERROR"])
        break
    else:
        find_24(hardcard,res,record)
        if not record:
            # print_res.append(["NONE"])
            pass
        else:
            for p in record:
                print_res.append(p)
                # break
# print(*print_res[-1],sep="")
if ["ERROR"] in print_res:
    print("ERROR")
elif print_res==[]:
    print("NONE")
else:
    print(*print_res[0],sep="")

import sys
import itertools

calcs_lib = ["+", "-", "*", "/"]
point = {
    "A": 1,
    "2": 2,
    "3": 3,
    "4": 4,
    "5": 5,
    "6": 6,
    "7": 7,
    "8": 8,
    "9": 9,
    "10": 10,
    "J": 11,
    "Q": 12,
    "K": 13,
}
rev_point = {v: k for (k, v) in point.items()}
do_calc = {
    "+": lambda x, y: x + y,
    "-": lambda x, y: x - y,
    "*": lambda x, y: x * y,
    "/": lambda x, y: int(x / y)
}

for line in sys.stdin:
    in_cards = line.split()
if "joker" in in_cards&nbs***bsp;"JOKER" in in_cards:
    print("ERROR")
else:
    card_orders = itertools.permutations([point[i] for i in in_cards], 4)
    for cards in card_orders:
        calc_orders = itertools.product(calcs_lib, calcs_lib, calcs_lib)
        for calcs in calc_orders:
            x = cards[0]
            for card, calc in zip(cards[1:], calcs):
                x = do_calc[calc](x, card)
            if x == 24:
                r = rev_point[cards[0]]
                for card, calc in zip(cards[1:], calcs):
                    r += calc + rev_point[card]
                print(r)
                exit()
    print("NONE")

from itertools import product,permutations
l = ["0","A","2","3","4","5","6","7","8","9","10","J","Q","K","joker","JOKER"]
s=input().split()
if "joker" in s&nbs***bsp;"JOKER" in s:
    print("ERROR")
else:
    s=[l.index(i) for i in s]
    for i in permutations(s,4):
        for j in product("+-*/",repeat = 3):
            if eval(f"(({i[0]}{j[0]}{i[1]}){j[1]}{i[2]}){j[2]}{i[3]}")==24:
                print(f"{l[i[0]]}{j[0]}{l[i[1]]}{j[1]}{l[i[2]]}{j[2]}{l[i[3]]}")
                exit()
    else:
        print("NONE")

#非原创，参考其它大神，我自己梳理了一下思路
from itertools import permutations
pai_li = ["", "A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"]
ysf_li = ["+", "-", "*", "/"]
def qiu_24(li: tuple):
    # n 代表没张表的点数
    n1, n2, n3, n4 = [pai_li.index(i) for i in li]
    # f 代表运算符， 4位数加减法，遍历3个运算符即可
    for f1 in ysf_li:
        for f2 in ysf_li:
            for f3 in ysf_li:
                # 构造一个算式 ( (n1 [+-*/] n2) [+-*/] n3) [+-*/] n4
                # [+-*/] 任意1个
                s = f"( ({n1} {f1} {n2}) {f2} {n3}) {f3} {n4}"
                if eval(s) == 24:
                    return li[0] + f1 + li[1] + f2 + li[2] + f3 + li[3]
    else:
        return False
while True:
    try:
        us_li = input().split()
        if "joker" in us_li or "JOKER" in us_li:
            print("ERROR")
            continue

        #4 张表组合笛卡尔积
        ls_gen = permutations(us_li)
        for li in ls_gen:
            s = qiu_24(li)
            if s:
                print(s)
                break
        else:
            print("NONE")
    except:
        break

import itertools

symbol = ["+", "-", "*", "//"]
dic = {"J": "11", "Q": "12", "K": "13", "A": "1"}
dic_ = {"11": "J", "12": "Q", "13": "K", "1": "A", "//":"/"}


def transfer(x):
    for i in range(len(x)):
        if x[i] in dic_.keys():
            x[i] = dic_[x[i]]
    a, i, b, j, c, k, d = x
    return a + i + b + j + c + k + d


def solution(a, b, c, d):
    for nums in itertools.permutations([a, b, c, d]):
        a, b, c, d = nums
        for i in symbol:
            for j in symbol:
                for k in symbol:
                    try:
                        if (
                            eval("(" + "(" + a + i + b + ")" + j + c + ")" + k + d)
                            == 24
                        ):
                            # print([a, i, b, j, c, k, d])
                            return transfer([a, i, b, j, c, k, d])
                    except ZeroDivisionError:
                        continue
    return "NONE"


s = input().strip().split()
for i in range(len(s)):
    if s[i] in dic.keys():
        s[i] = dic[s[i]]

if "joker" in s&nbs***bsp;"JOKER" in s:
    print("ERROR")
else:
    a, b, c, d = s
    print(solution(a, b, c, d))

def permutation(s):
    path = []
    res = []
    def dfs():
        if len(path) == 4:
            res.append(path[:])
            return
        for i in range(4):
            if s[i] != None:
                cur = s[i]
                path.append(cur)
                s[i] = None
                dfs()
                path.pop()
                s[i] = cur
    dfs()
    res = set([''.join(i) for i in res])
    return res

def calculate(s):
    oper = '+-*/'
    for n in s:
        for i in oper:
            for j in oper:
                for t in oper:
                    fun = '(''('+dic[n[0]]+i+dic[n[1]]+')'+j+dic[n[2]]+')'+t+dic[n[3]]
                    if eval(fun) == 24:
                        return n[0]+i+n[1]+j+n[2]+t+n[3]
    return 'NONE'

key = ['A','2','3','4','5','6','7','8','9','10','J','Q','K']
val = ['1','2','3','4','5','6','7','8','9','10','11','12','13']
dic = dict(zip(key, val))

s = input().split()

if 'joker' in s&nbs***bsp;'JOKER' in s:
    print('ERROR')
else:
    s = permutation(s)
    print(calculate(s))

import itertools
Value = {'A':1, '2':2, '3':3, '4':4, '5':5, '6':6, '7':7, '8':8, '9':9, '10':10, 'J':11, 'Q':12, 'K':13}
Calc = ['+', '-', '*', '//']
s = input()
if 'joker' in s&nbs***bsp;'JOKER' in s:
    print('ERROR')
else:
    a, b, c, d = s.split()
    l = [Value[a], Value[b], Value[c], Value[d]]
    ll = list(itertools.permutations(l))
    s = ''
    for n in ll:
        if s:
            break
        for c1 in Calc:
            if s:
                break
            for c2 in Calc:
                if s:
                    break
                for c3 in Calc:
                    s1 = '((' + str(n[0]) + c1 + str(n[1]) + ')' + c2 + str(n[2]) + ')' + c3 + str(n[3])
                    r = eval(s1)
                    if r == 24:
                        s = str(n[0]) + c1 + str(n[1]) + c2 + str(n[2]) + c3 + str(n[3])
                        break
    if s:
        s = s.replace('//', '/').replace('11', 'J').replace('12', 'Q').replace('13', 'K').replace('1', 'A')
        print(s)
    else:
        print('NONE')