（1）题目描述

（2）Python3实现

card = ['A','2','3','4','5','6','7','8','9','10','J','Q','K']
order = range(1,14)
card_order = dict(zip(card, order))

def dfs(arr,target,temp):
    if len(arr)<=0:
        return None
    if len(arr)==1:
        if arr[0] == target:
            return card[arr[0]-1]+temp
        else:
            return None
    for i in range(len(arr)):
        newArr = arr[:i] + arr[i+1:]
        first = dfs(newArr, target-arr[i], '+'+card[arr[i]-1]+temp)
        if first:
            return first
        second = dfs(newArr, target+arr[i], '-'+card[arr[i]-1]+temp)
        if second:
            return second
        third = dfs(newArr, target*arr[i], '/'+card[arr[i]-1]+temp)
        if third:
            return third
        fourth = dfs(newArr, target/arr[i], '*'+card[arr[i]-1]+temp)
        if fourth:
            return fourth

while True:
    try:
        cards = input().split()
        if len(cards)<4 or 'joker' in cards or 'JOKER' in cards:
            print('ERROR')
        vals = [card_order[x] for x in cards]

        ans = dfs(vals, 24.0, '')

        if ans is not None:
            print(ans)
        else:
            print('NONE')
    except:
        break  

（3）知识点详解

1、input()：获取控制台（任意形式）的输入。输出均为字符串类型。

str1 = input()
print(str1)
print('提示语句:', str1)
print(type(str1))

'''
asd123!#
提示语句: asd123!#
<class 'str'>
'''

1.1、input() 与 list(input()) 的区别、及其相互转换方法

• 相同点：两个方法都可以进行for循环迭代提取字符，提取后都为字符串类型。
• 不同点：str = list(input()) 将输入字符串转换为list类型，可以进行相关操作。如： str.append()

• 将列表转换为字符串：str_list = ['A', 'aA', 2.0, '', 1]

• 方法一：print(''.join(str))
• 方法二：print(''.join(map(str, str_list)))

备注：若list中包含数字，则不能直接转化成字符串，否则系统报错。

• 方法一：print(''.join([str(ii) for ii in str_list]))
• 方法二：print(''.join(map(str, str_list)))
  map()：根据给定函数对指定序列进行映射。即把传入函数依次作用到序列的每一个元素，并返回新的序列。

（1） 举例说明：若list中包含数字，则不能直接转化成字符串，否则系统报错。

str = ['25', 'd', 19, 10]
print(' '.join(str))

'''
Traceback (most recent call last):
 File "C:/Users/Administrator/Desktop/test.py", line 188, in <module>
   print(' '.join(str))
TypeError: sequence item 3: expected str instance, int found
'''

（2）举例说明：若list中包含数字，将list中的所有元素转换为字符串。

str_list = ['A', 'aA', 2.0, '', 1]
print(''.join(str(ii) for ii in str_list))
print(''.join([str(ii) for ii in str_list]))
print(''.join(map(str, str_list))) 		# map()：根据给定函数对指定序列进行映射。即把传入函数依次作用到序列的每一个元素，并返回新的序列。

'''
AaA2.01
AaA2.01
AaA2.01
'''

2、print() ：打印输出。

【Python】print()函数的用法

x, y = 1, 9
print('{},{}' .format(x, y))	# 打印方法一
print('*'*10)					# 打印分割符
print(x, ',', y)				# 打印方法二

'''
1,9
**********
1 , 9
'''

3、整型int() ：将指定进制（默认十进制）的一个字符串或数字转换为十进制整型（强转）。

• Python2 有 long int 类型，而Python3 整型没有范围限制，故可以当作 long int 使用。
• 布尔类型 bool 是整型的子类型，包括两种：True == 1、False == 0。

函数说明：int(x, base=10)
输入参数：

• x：字符串或数字（整数、浮点数）。
• base：默认十进制。
  备注1：若带参数base，表示将 （二进制、十进制、十六进制）的 x 转换为十进制。
  备注2：若带参数base，则输入必须是整数，且整数必须以字符串的形式进行输入。

十进制转换为16进制

十六进制范围：0 ~ 65536（0000 ~ FFFF）
方法：

• （1）十进制数除16（取余数1），得商1
• （2）商1除16（取余数2），得商2
• （3）商2除16（取余数3），得商3
• （4）最后商3等于0（取余数4）。
• 最终结果为倒序余数= [余数4, 余数3, 余数2, 余数1]。

举例（整数：65036）：
（1）65036 除 16，商4064，余数 12（十六进制C）
（2）4064 除 16，商254，余数 0（十六进制0）
（3）254 除 16，商15，余数 14（十六进制E）
（4）15除16，商0，余数 15（十六进制F）。
（5）结束：得16进制为 = FE0C

3.1、bin()：十进制整数转换为二进制码。返回值为字符串。

函数说明：bin(整型)

print(bin(-3))
print(type(bin(-3)))

'''
-0b11
<class 'str'>
'''

3.2、ord()： ASCII字符转换为十进制整数（Unicode字符 —— Unicode数值）。

函数说明：ord(字符)

print(ord('A'))
print(type(ord('A')))

'''
65
<class 'int'>
'''

3.3、chr()：将10进制或16进制数转换为ASCII字符。（Unicode数值 —— Unicode字符）。

函数说明：chr(number)

print(chr(97))
print(type(chr(97)))

'''
a
<class 'str'>
'''

4、str.split()：通过指定分隔符（默认为空格）对字符串进行切片，并返回分割后的字符串列表（list）。

函数说明：str.split(str=".", num=string.count(str))[n]
参数说明：

• str： 表示分隔符，默认为空格，但是不能为空。若字符串中没有分隔符，则把整个字符串作为列表的一个元素。
• num：表示分割次数。如果存在参数num，则仅分隔成 num+1 个子字符串，并且每一个子字符串可以赋给新的变量。
• [n]： 表示选取第n个切片。
  • 注意：当使用空格作为分隔符时，对于中间为空的项会自动忽略。

s = 'www.dod.com.cn'
print('分隔符(默认): ', s.split())                    # 【输出结果】分隔符(默认):  ['www.dod.com.cn']
print('分隔符(.): ', s.split('.'))                   # 【输出结果】分隔符(.):  ['www', 'dod', 'com', 'cn']
print('分割1次, 分隔符(.): ', s.split('.', 1))        # 【输出结果】分割1次, 分隔符(.):  ['www', 'dod.com.cn']
print('分割2次, 分隔符(.): ', s.split('.', 2))        # 【输出结果】分割2次, 分隔符(.):  ['www', 'dod', 'com.cn']
print('分割2次, 分隔符(.), 取出分割后下标为1的字符串: ', s.split('.', 2)[1])      # 【输出结果】分割2次, 分隔符(.), 取出分割后下标为1的字符串:  dod
print(s.split('.', -1))                             # 【输出结果】['www', 'dod', 'com', 'cn']
###########################################
# 分割2次, 并分别保存到三个变量
s1, s2, s3 = s.split('.', 2)
print('s1:', s1)                                    # 【输出结果】s1: www
print('s2:', s1)                                    # 【输出结果】s2: www
print('s3:', s2)                                    # 【输出结果】s3: dod
###########################################
# 连续多次分割
a = 'Hello<[www.dodo.com.cn]>Bye'
print(a.split('['))                                 # 【输出结果】['Hello<', 'www.dodo.com.cn]>Bye']
print(a.split('[')[1].split(']')[0])                # 【输出结果】www.dodo.com.cn
print(a.split('[')[1].split(']')[0].split('.'))     # 【输出结果】['www', 'dodo', 'com', 'cn']

5、list列表的常用操作（15+9函数）—— 列表是一个有序可变序列。

一般来说，有序序列类型都支持索引，切片，相加，相乘，成员操作。

• 不可变数据类型： 布尔类型（bool）、整型（int）、字符串（str）、元组（tuple）
• 可变数据类型： 列表（list）、集合（set）、字典（dict）

6、range() ：输出指定范围内的所有值（前闭后开）。

函数说明：range(start=0，stop，step=1)
输入参数：

• start：序列的起始点，默认值0。
• stop：序列的终止点。
• step：滑动步长，默认为1。正数表示迭代上升，负数表示迭代下降。

备注：前闭后开[A，B)，即可以取到A值，但取不到B值。

# （1）指定stop=9, start默认为0，step默认为1
for i in range(9):
    print('A =', i)
'''
A = 0
A = 1
A = 2
A = 3
A = 4
A = 5
A = 6
A = 7
A = 8
'''
# （2）指定start=2, stop=9, step默认为1
for i in range(2, 9):
    print('B =', i)
'''
B = 2
B = 3
B = 4
B = 5
B = 6
B = 7
B = 8
'''
# （3）指定start=2, stop=9, step=-2
for i in range(9, 2, -2):
    print('C =', i)
'''
C = 9
C = 7
C = 5
C = 3
'''

7、len()：返回字符串、列表、字典、元组等的长度。

函数说明：len(object)

str_temp = "Hello, boy !"
print(len(str_temp))                    # 【输出结果】12
#############################################
list_temp = ['h', 'e', 'l', 'l', 'o']
print(len(list_temp))                   # 【输出结果】5
#############################################
dict_temp = {
    
    'num': 520, 'name': "do do"}
print(len(dict_temp))                   # 【输出结果】2
#############################################
tuple_temp = ('G', 'o', 'o', 'd')
print(len(tuple_temp))                  # 【输出结果】4

8、dict字典的常用操作（14+4函数）—— 字典是一个无序可变序列。

（2）键必须是唯一的（不可变数据类型），但值可以取任意数据类型。
（3）不支持索引、切片、重复和连接操作。

• 不可变数据类型： 布尔类型（bool）、整型（int）、字符串（str）、元组（tuple）
• 可变数据类型： 列表（list）、集合（set）、字典（dict）

9、zip()：组合序列。将多个可迭代对象的第 i 个元素组合在一起（压缩），得到一个元祖，最后输出N个元组。—— 返回一个迭代器，结果需指定数据结构进行转换后输出。

函数说明：res = zip(iterable_1, iterable_2,..., iterable_n)
输入参数：

• iteration：n个可迭代对象。
• res：返回一系列元组的迭代器，第 i 个元组包含各输入iterables的第 i 个元素。

解压缩：unzip（把组合序列进行反向分解） —— python没有unzip函数
函数说明：zip(*res)
输入参数：

• *：表示解包运算符。
• res：由zip()生成的结果。

# （1）不传递参数，返回空的迭代器
print('1:', zip())									# <zip object at 0x00000205F02A3480>
print('1:', list(zip()))							# []
######################################################################
# （2）传递一个参数，返回tuple的迭代器。
print('2:', list(zip([1, 2, 3])))					# [(1,), (2,), (3,)]
######################################################################
# （3）传递两个参数，返回tuple的迭代器。
a3 = ['a', 'c', 'b']
b3 = ['2', '1']
print('3:', list(zip(a3, b3)))						# [('a', '2'), ('c', '1')]
print('3:', dict(zip(a3, b3)))						# {'a': '2', 'c': '1'}
######################################################################
# 4.1、传递长度不等的参数（截取最短，删除冗余）
print('4:', list(zip(range(3), range(100))))		# [(0, 0), (1, 1), (2, 2)]

# 4.2、传递长度不等的参数，若想要以最长的进行迭代处理，缺少部分补None
import itertools as it
fruits = ['apple', 'banana', 'melon', 'strawberry']
prices = [10, 20, 30]
print(list(it.zip_longest(fruits, prices)))			# [('apple', 10), ('banana', 20), ('melon', 30), ('strawberry', None)]
######################################################################
# （5）并行排序（以第一个输入参数进行排序）
print('5:', sorted(list(zip(a3, b3))))				# [('a', '2'), ('c', '1')]
print('5:', sorted(list(zip(b3, a3))))				# [('1', 'c'), ('2', 'a')]
######################################################################
# （6）解压缩序列：解包运算符*。
result = zip(a3, b3)
origin = list(zip(*result))		# 创建两个不同的元祖（数字和字母）
print('6:', origin[0])								# ('a', 'c')
print('6:', origin[1])								# ('2', '1')
######################################################################
# （7）将数据成对进行计算
total_sales = [52000.00, 51000.00, 48000.00]
prod_cost = [46800.00, 45900.00, 43200.00]
for sales, costs in zip(total_sales, prod_cost):
	profit = sales - costs
	print(f'Total profit: {
      
      profit}')
	
"""
Total profit: 5200.0
Total profit: 5100.0
Total profit: 4800.0
"""