华为OD机试题

"""
最长回文字符串问题
"""
# 说明：方法很多，这个是最简单，也是最容易理解的一个，利用了动态规化。
# 先确定回文串的右边界i，然后以右边界i向左找回文串。
# 假设在i之前的最长回文子串长度是max_over_str，此时需要分别检查i+1左侧字符串长度为max_over_str+2和max_over_str+1子串是不是回文串。
# 如果max_over_str+2是回文串，那么字符串的最大长度变成max_over_str+2，对于max_over_str+1同理。

def sloutions(str):
    lens = len(str)
    start = 0
    max_over_str = 0
    for i in range(lens):
        if i - start >= 1 and str[i - max_over_str - 1:i + 1] == str[i - max_over_str - 1:i + 1][::-1]:
            start = i - max_over_str - 1
            max_over_str += 2
        if i - start >= 0 and str[i - max_over_str:i + 1] == str[i - max_over_str:i + 1][::-1]:
            start = i - max_over_str
            max_over_str += 1

    return str[start:start + max_over_str]

　　

"""
磁盘容量大小排序
磁盘的容量单位有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%通过。题型覆盖面广，这只是极个别题型，欢迎留言补充。
####