华为OD机试题
最长回文字符串问题
def fun(strs): lens = len(strs) start = 0 # 初始步长 max_len = 0 if strs == strs[::-1]: return strs else: # 不断增加步长，比较回文 # 每次增加步长，循环查找有没有比这个步长更长的回文，如果有，继续找，直到找完所有的回文为止 for i in range(lens): # 优先查看两个增加两个长度的回文是否存在 if i-max_len >=1 and strs[i-max_len-1:i+1] == strs[i-max_len-1:i+1][::-1]: start = i - max_len - 1 max_len += 2 # 如果增加两个长度的没找到，再查看两个增加一个长度的回文是否存在 elif i-max_len>=0 and strs[i-max_len:i+1] == strs[i-max_len:i+1][::-1]: start = i - max_len max_len += 1 return max_len,strs[start:start+max_len] # abcbaaa tmp = input().strip() print(fun(tmp))
第二种解法，求最大回文
while True: try: s = input() #输入 len_s = len(s) result=0 #初始化最后的结果 for n in range(len_s): #从第一个字符开始搜索最长的字符串 max_length = result+1 #max_length代表搜索字符串的长度，所以只搜索大于result的字符串 while n+max_length<=len_s: #代表搜索完以第n+1个字符串开头的所有字符串 if s[n:n+max_length] == s[n:n+max_length][::-1]: #如果满足是回文字符串 result = max_length #则此时最大的字符串长度变为max_length max_length +=1 #每次增加字符串的长度1 if result !=0: #防止空字符串 print(result) except: break
"""
磁盘容量大小排序
磁盘的容量单位有M、G、T，其关系为 1T = 1000G、1G = 1000M，如样例所示先输入磁盘的个数，
再依次输入磁盘的容量大小，然后按照从小到大的顺序对磁盘容量进行排序并输出。
"""
# 难点说明：
# 特殊条件，小数，同类值，边界值等需要充分考虑，否则用例调试通过率很低的。以下代码仅供参考，实际情况也可能未考虑完整
lis = []
def sloution():
dic = {}
try:
num = input().strip()
for i in range(int(num)):
lis.append(input().strip())
except:
pass
for index, i in enumerate(lis):
if "M" in i:
dic[(index, i)] = float(i[:-1])
if "G" in i:
dic[(index, i)] = (float(i[:-1])) * 1000
if "T" in i:
dic[(index, i)] = (float(i[:-1])) * 1000 * 1000
tmp = sorted(dic.items(), key=lambda x: (x[1], x[0]))
for i in tmp:
print(i[0][1])
"""
找出一个字符串中出现次数最多的字符，并输出该字符以及它出现的次数。true区分大小写，false不分大小写
"dahsjkdDSKLFSds true"
"dasdas false"
"""
# 说明：还是边界值的考虑，思路自己可以扩展
from collections import Counter
try:
while True:
tmp = input().strip()
if ' ' in tmp:
string, flag = tmp.split()
if flag == "false":
string = string.lower()
dic = dict(Counter(string))
dic = sorted(dic.items(), key=lambda x: (x[1]), reverse=False)
key = dic.pop()
print(key[0], key[1])
break
except:
pass
"""
如果一个整数可以分解成两个质数的和，求这样的质数的组数，比如18可以分解成7+11、5+13，即两组。
支持一次输入多行，以0结束输入，输出以"end"字符串结束，下面是样例
输入：
2
5
10
18
0
输出：
0
1
2
2
end
"""
import math
def issushu(num):
"""
判断是否是素数
"""
if num == 1:
return False
elif num == 2:
return True
else:
for i in range(2, int(math.sqrt(num)) + 1):
if num % i == 0:
return False
return True
def sushu(num):
"""
查找num范围内的所有素数
"""
lis = []
for i in range(2, num + 1):
if issushu(i):
lis.append(i)
return lis
# 按要求输入一个数，并返回结果
while True:
val = []
try:
num = int(input().strip())
if num == 0:
print("end")
break
lis = sushu(num)
for i in range(len(lis)):
for j in range(i + 1, len(lis)):
if num == lis[i] + lis[j]:
val.append((lis[i], lis[j]))
print(val)
print(len(val))
val.clear()
except:
break
"""
输入一个字符串 和一个标志
例子： aA1bB2cC3 1
假如这个标志是 1 就把字符串中小写字母反转输出 cA1bB2aC3
假如这个标志是 2 就把字符串中大写写字母反转输出 aC1bB2cA3
假如这个标志是 3 就把字符串中数字的位置反转输出 aA3bB2aC1
"""
# 搞出一个后面就全出来了，主要是在于替换。是换成列表，删除，增加；还是源字符串上删除，增加。一定要注意处理好索引的问题
try:
strs,num = input().strip().split(" ")
lis = list(strs)
lis_index = []
key_num = []
if num == "1":
for i in lis:
if i.islower():
lis_index.append(lis.index(i))
key_num.append(i)
key_num = key_num[::-1]
strs = ''.join(lis)
for i in strs:
if i.islower():
strs = strs.replace(i," ",1)
for i in key_num:
strs = strs.replace(" ",i,1)
print(strs)
lis_index.clear()
key_num.clear()
if num == "2":
pass
except:
pass
"""
水仙花数
“水仙花数”是指一个三位数，它的各位数字的立方和等于其本身。
现在要求输出所有在m和n范围内的水仙花数。
输入
300 380
输出
370 371
"""
input_lis = list(map(int, input().split()))
if input_lis[0] < 100:
input_lis[0] = 100
if input_lis[0] > 999:
input_lis[0] = 999
if input_lis[1] < 100:
input_lis[1] = 100
if input_lis[1] > 999:
input_lis[1] = 999
if input_lis[0] > input_lis[1]:
input_lis[0], input_lis[1] = input_lis[1], input_lis[0]
result = []
for i in range(input_lis[0], input_lis[1] + 1):
a, b, c = [k for k in str(i)]
if i == int(a) ** 3 + int(b) ** 3 + int(c) ** 3:
result.append(i)
else:
print(" ".join(str(i) for i in result))
"""
给定一个正整数数组，最大为100个成员，从第一个成员开始，
走到数组最后一个成员最少的步骤数。第一步必须从第一元素开始，1<=步长<len/2,
第二步开始以所在成员的数字走相应的步数，如果目标不可达返回-1，只输出最少的步骤数。
输入
7 5 9 4 2 6 8 3 5 4 3 9
输出
2
说明
第一步：第一个可选步长选择2，第一个成员7走第2个成员，第二步，第2个成员为9，经过9个成员到最后
"""
step_min = []
step_count = 2
def fist_step(num):
for i in range(int(len(num) / 2)):
# 第二步索引值
a = num[i] + i + 1
if a == len(num):
step_min.append(step_count)
return
if len(num) > a:
last_num = num[i + num[i]:]
last_step(last_num)
step_min.append(-1)
def last_step(last_num):
global step_count
step_count = step_count + 1
step_long = last_num[0]
if step_long == len(last_num) - 1:
step_min.append(step_count)
step_count = 2
return
elif step_long > len(last_num) - 1:
step_count = 2
pass
else:
last_num = last_num[step_long:]
return last_step(last_num)
m = [7, 5, 9, 4, 2, 6, 8, 3, 5, 4, 3, 9]
b = fist_step(m)
print(step_min)
step_min_step = min(step_min)
print(step_min_step)
"""
题目三：
先输入一个行数
比如说是2 再输入两个字符串(用逗号隔开)
4,5,4
5,4,5
然后输入操作的步骤数目
比如说是2，每一次输入标志了上面二维数组里面的两个数字
0,0,0,2 00代表了第1行第一列的4 02和第一行第三列的4
(如果这两个数字能用三根短线连起来，并且相等，那么就把这两个位置上的数字变成0)
1,0,0,1 同上(10是5 01也是5)
如果输入的多组操作，都能正常完成数字的消除，就返回0k
如果有一组操作存在错误，就返回这个操作的下标。
分析错误的原因：操作里面指明的位置在二维数组里面没有,下标越界，两个下标的值不相等，或者就是不能用三个短线把这两个数连起来
"""
----pass
"""
流水线效率优化问题
m条流水线，n个工序，每个工序用时t1,t2,...,tn,可以并行执行
求耗时最短问题
"""
---pass
"""
url字符串拼接问题
输入一个字符串，逗号隔开
保证两个字符能够凭借成一个完整的url
# 题型有坑，调试死活只通过75%
输入
/dad/,/da
输出
/dad/da
"""
#####
注：
以上题型均为个人整理，实际考试中不一定能保证用例100%通过。题型覆盖面广，这只是极个别题型，欢迎留言补充。
####
