华为机试题：HJ89 24点运算（python）

最新推荐文章于 2024-03-20 10:12:31 发布

胖墩会武术

最新推荐文章于 2024-03-20 10:12:31 发布

阅读量605

点赞数 1

分类专栏：华为机试题文章标签： python 开发语言

本文链接：https://blog.csdn.net/shinuone/article/details/129506266

版权

华为机试题专栏收录该内容

62 篇文章 46 订阅

订阅专栏

文章目录

（1）题目描述
（2）Python3实现
（3）知识点详解

（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'>
'''

常用的强转类型	说明
`int(input())`	强转为整型（输入必须时整型）
`list(input())`	强转为列表（输入可以是任意类型）

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，则输入必须是整数，且整数必须以字符串的形式进行输入。

输入	返回值	举例	输出
`int('整数', base=16)`	输入整数指定为16进制，转换为10进制整数（同理：其余进制）	`print(int('20', 16))` 和 `print(int('0XAA', 16))`	32 和 170
（1）输入为空或整数	\	\	\
`int()`	\	`print(int())`	0
`int(浮点数)`	\	`print(int(-2.1))`	-2
（2）输入为字符串	\	\	\
`int(字符串)`	\	`print(int('-2'))`	-2
`int(字符串(浮点数))`	需先将str转换为float，再转换为int，否则报错。	`print(int(float('-2.1')))`	-2

十进制转换为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

十进制	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
16进制	0	1	2	3	4	5	6	7	8	9	A	B	C	D	E	F
2进制	0000	0001	0010	0011	0100	0101	0110	0111	1000	1001	1010	1011	1100	1101	1110	1111

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）

序号	函数	说明
0	`list1 = []`	创建空列表
0	`list1 = list()`	创建空列表
1	`list2 = [元素]`	创建列表。输入参数可以是任意类型
1	`list2 = list(元素)`	创建列表。输入参数可以是任意类型
——	——	——
2	`list[index]`	索引（负数表示倒叙）
3	`list[start, end]`	切片（获取指定范围元素）
4	`list[::-1]`	逆序输出（步长为1）
——	——	——
5	`list.append(元素)`	在列表末尾添加任意类型的一个元素
6	`list.extend(元素)`	添加可迭代序列
7	`list.insert(index, 元素)`	在指定位置插入一个元素
——	——	——
8	`list.remove(元素)`	删除指定元素。（1）若有多个相同元素，则只删除第一个元素。（2）若不存在，则系统报错。
9	`list.pop(index)`	删除指定位置元素。默认删除最后一项。
10	`del list(index)`	删除指定位置元素
11	`list.clear()`	清空内容，返回空列表
——	——	——
12	`list.index(元素)`	索引元素位置。（1）若有多个相同元素，则只返回第一个元素的位置。（2）若不存在，则系统报错。
13	`list.count(元素)`	计算指定元素出现的次数
14	`list.reverse()`	逆序输出
15	`list.sort(*, key=None, reverse=False)`	（1）默认从小到大排列。（2）reverse=True 表示从大到小排序。
——	——	——
（1）	`len(list)`	元素个数
（2）	`type(list)`	查看数据类型
（3）	`max(list)`	返回最大值（不能有嵌套序列）
（4）	`min(list)`	返回最小值（不能有嵌套序列）
（5）	`list(tuple)`	将元组转换为列表
（6）	`list1 + list2`	+ 操作符（拼接）
（7）	`list * 3`	* 操作符（重复）
（8）	`元素 in list`	（in / not in）成员操作符（判断给定值是否在序列中）
（9）	`for i in list:`	遍历

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）

序号	函数	说明
0	`dict1 = {}`	创建空字典
0	`dict1 = dict()`	创建空字典
1	`dict2 = {key1: value1, key2: value2}`	创建字典
1	`dict2 = dict({key: value, key2: value2})`	创建字典
——	——	——
2	`dict.keys()`	查看字典中所有的key值
3	`dict.values()`	查看字典中所有的value值
4	`dict.items()`	查看字典中所有的key-value值
5	`dict(key)`	获取指定key对应的value值。若key值不存在，程序会报错。
6	`dict.get(key, default=None)`	获取指定key对应的value值。若key不存在，返回设置的default。
7	`dict.copy()`	浅拷贝
——	——	——
8	`dict(key) = value`	若key存在，更新value值。若不存在，新增key-value值。
9	`dict1.update(dict2)`	添加元素（可同时添加多对）。若key存在，则更新value值。
10	`dict.setdefault(key, default=None)`	若key存在，既不新增也不更新value值。若key不存在，将会添加键，并将value值设为default。
——	——	——
11	`dict.pop(key)`	弹出指定的key-value值
12	`dict.popitem()`	删除最后一个key-value
13	`dict.clear()`	清空字典内容，返回空字典
14	`del dict[key]`	删除指定的key-value值。
——	——	——
（1）	`len(dict)`	列表元素个数
（2）	`type(dict)`	查看数据类型
（3）	`'key1' in dict` or `'key1' in dict.keys`	判断给定值是否在字典的key中（默认：dict.keys()）
（4）	`'value1' in dict.values()`	判断给定值是否在字典的value中
（5）	`'dict.has_key('name')`	判断字典中是否有指定的key元素
（5）	`for i in dict:`	遍历字典的key值（默认：dict.keys()）

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
"""