华为笔试题

第一题：

题目描述：

连续输入字符串（输入字符串个数为N，每个字符串长度不大于100，输入字符串间按照空格键分隔），请按长度为8拆分每个字符串后输出到新的字符串数组，输出的字符串按照升序排列。

长度不是8整数的字符串请在后面补数字0，空字符不处理。

输入样例1：

2 abc 123456789
输出样例1：

12345678 90000000 abc00000
处理代码：

1 # *** 辅助函数 *** #
2 def decode(str_):
3 d1 = []
4 num = int(len(str_) / 8) # 商
5 num_yu = len(str_) % 8 # 余数
6
7 for j in range(num):
8 d1.append(str_[j*8:(j+1)8])
9
10 if num_yu != 0:
11 str_now = str_[-1num_yu:]
12 str_now = str_now[::-1].zfill(8)
13 d1.append(str_now[::-1])
14
15 return d1
16
17
18 # # *** 数据输入 model 1 *** #
19 while True:
20 try:
21 d0 = input().split()
22
23 # ① 输出数据的原始队列
24 str_out = []
25 for i in range(int(d0[0])):
26
27 # ② 获取解码后的数据
28 str_out.extend(decode(d0[i + 1]))
29
30 # ③ 对原始队列进行排序
31 str_out.sort()
32
33 # ④ 构建输出格式
34 str_now = ‘’
35 for i in str_out:
36 str_now += i + ’ ’
37
38 # ⑤ 数据输出
39 if len(str_now[:-1]):
40 print(str_now[:-1])
41
42 except Exception:
43 break
44
45
46 # # *** 数据输入 model 2 *** #
47 # import sys
48 # for line in sys.stdin:
49 # d0 = line.strip(’\n’).split() # 这种输入法，会自动携带换行符’\n’
50 #
51 # # ① 输出数据的原始队列
52 # str_out = []
53 # for i in range(int(d0[0])):
54 # # ② 获取解码后的数据
55 # str_out.extend(decode(d0[i+1]))
56 # # ③ 对原始队列进行排序
57 # str_out.sort()
58 # # ④ 构建输出格式
59 # str_now = ‘’
60 # for i in str_out:
61 # str_now += i + ’ ’
62 #
63 # # ⑤ 数据输出
64 # if len(str_now[:-1]):
65 # print(str_now[:-1])
66

第二题：

题目描述：

给定一个字符串，字符串包含数字、大小写字母以及括号（包括大括号、中括号和小括号），括号可以进行嵌套，即括号里面可以出现数字和括号。

按照如下的规则对字符串进行展开，不需要考虑括号不成对不匹配问题，用例保证括号匹配，同时用例保证每个数字后面都有括号，不考虑数字后面没有括号的这种情况，即2a2(b)这种情况不考虑。

输入样例1：

abc3(mlg)
输出样例1：

glmglmglmcba

输入样例2：

abc3(A)4(mufasa)
输出样例2：

asafumasafumasafumasafumAAAcba

输入样例3：

abd2(3{4[q]w}e)
输出样例3：

asafumasafumasafumasafumAAAcba

处理代码：

1 # *** 辅助函数 *** #
2 DICTCHAR = {’(’: ‘)’, ‘[’: ‘]’, ‘{’: ‘}’}
3
4 def decode(d0):
5
6 # 第一步：先检录出所有的数字
7 d1 = [] # 所有数字的【位置，数值，后续的开始符号】
8 for i in range(len(d0)):
9 if 48 <= ord(d0[i]) <= 57: # 0-9
10 d1.append([i, int(d0[i]), d0[i+1]])
11 # print(d1)
12
13 # 第二步：从后往前（逆序）进行解码
14 for item in d1[::-1]:
15 # ① 先确定需要重复的范围
16 start = item[0] + 2
17 end = start + d0[start:].index(DICTCHAR[item[-1]])
18
19 # ② 接入原始头
20 str_now = ‘’
21 str_now += d0[:item[0]]
22
23 # ③ 字符串重复区域
24 for i in range(item[1]):
25 str_now += d0[start: end]
26
27 # ④ 接入原始尾
28 str_now += d0[end + 1:] # 如果后续没有自动跳过了
29
30 # ⑤ 更新原始d0字符串
31 d0 = str_now
32 return d0
33
34 # # *** 数据输入 model 1 *** #
35 # while True:
36 # try:
37 # d0 = input()
38 # str_ = decode(d0)
39 # print(str_[::-1])
40 # except Exception:
41 # break
42
43
44 # *** 数据输入 model 2 *** #
45 import sys
46 for line in sys.stdin:
47 d0 = line.strip(’\n’) # 这种输入法，会自动携带换行符’\n’
48 str_ = decode(d0)
49 print(str_[::-1])

第三题：

一张N*M的地图上每个点的海拔高度不同；从当前点只能访问上、下、左、右四个点中还没有到达过的点，且下一步选择的点的海拔高度必须高于当前点；求从地图中点A到点B总的路径条数初以10**9的余数。

地图左上角坐标为（0,0），右下角坐标为（N-1,M-1）。

输入描述：

第一行输入两个整数N,M(0<N<=600, 0<M<=600)用空格隔开；接下来N行输入，每行M个整数用空格隔开，代表对应位置的海拔高度（0<=海拔高度<=360000）；最后一行四个整数X,Y,Z,W；前两个代表A的坐标（X,Y）；后面两个代表B的坐标（Z,W）；输入保证A,B坐标不同，且坐标合法。

输入样例1：

4 5
0 1 0 0 0
0 2 3 0 0
0 0 4 5 0
0 0 7 6 0
0 1 3 2

输出样例1：

2

输入样例2：

4 5
0 1 2 1 0
0 2 3 2 1
0 0 4 5 2
0 8 7 8 9
0 4 3 4

输出样例2：

10

处理程序：

1 import copy
2
3
4 # *** 辅助函数 *** #
5 def path2run(N, M, graph, single_path, node_next): # 判断下个位点是否可行
6 node_pre = single_path[-1]
7 if node_next in single_path: # 是否以前走过
8 return 0
9 if node_next[0] < 0 or node_next[1] < 0: # 是否越界（左、上）
10 return 0
11 if node_next[0] > (N - 1) or node_next[1] > (M - 1): # 是否越界（右、下）
12 return 0
13 if graph[node_pre[0]][node_pre[1]] >= graph[node_next[0]][node_next[1]]: # 是否梯度上升
14 return 0
15 else:
16 return 1
17
18
19 def path2end(node_end, node_next): # 判断是否为终点
20 if node_end == node_next:
21 return 1
22 else:
23 return 0
24
25
26 def next_node(node_pre, type): # 生成下一个节点位置
27 [xp, yp] = node_pre
28 if type == 0:
29 node_next = [xp, yp - 1]
30 elif type == 1:
31 node_next = [xp + 1, yp]
32 elif type == 2:
33 node_next = [xp, yp + 1]
34 elif type == 3:
35 node_next = [xp - 1, yp]
36 return node_next
37
38 # *** 数据输入 *** #
39 [N, M] = list(map(int, input().split()))
40 graph = []
41 for i in range(N):
42 graph.append(list(map(int, input().split())))
43 [X, Y, Z, W] = list(map(int, input().split()))
44 node_start = [X, Y]
45 node_end = [Z, W]
46
47 # *** 数据处理 *** #
48 path_mid = [[node_start]]
49 path_target = []
50
51 while True:
52
53 num = len(path_mid)
54
55 for i in range(num): # 进行新路段的前进
56 single_path = path_mid[i]
57 node_pre = single_path[-1]
58 for j in range(4): # 下一个节点规划
59 node_next = next_node(node_pre, j)
60
61 # 判断是否终点
62 if path2end(node_end, node_next):
63 path_now = copy.deepcopy(single_path)
64 path_now.append(node_next)
65 path_target.append(path_now)
66 continue
67
68 # 判断是否可行
69 if path2run(N, M, graph, single_path, node_next):
70 path_now = copy.deepcopy(single_path)
71 path_now.append(node_next)
72 path_mid.append(path_now)
73 continue
74
75 for i in range(num - 1, -1, -1): # 进行旧路段的删除
76 path_mid.pop(i)
77
78 if len(path_mid) == 0:
79 break
80
81 # *** 数据输出 *** #
82 # print(path_target)
83 # print(len(path_target))
84 print(len(path_target)%10**9)

转载 万雨