本博客为博主解题的部分记录，由于均为自己写的，所以答案并非最优解，有很多地方可以优化。
其他题解合集：
（python）牛客网（华为机试一）——入门
（python）牛客网（华为机试二）——简单
（python）牛客网（华为机试四）——较难

HJ5 进制转换

import sys
for data in sys.stdin:
    data = data.split()[0]
    print(int(data,16))

HJ6 质数因子

此题外循环边界界定尤其重要：tmp*tmp<=data

def solution(data):
    tmp = 2
    while(tmp*tmp<=data):
        while (data % tmp == 0):
            print(tmp, end=' ')
            data //= tmp
        tmp+=1
    if data -1:#当data本身就是一个质数时，data此时就是原本的data，需要输出
        print(data,end=' ')
 
data = int(input())
solution(data)

HJ8 合并表记录

此题要求按key值数值大小排序输出，因此可以直接以int信key值保存，然后最后对字典的键值列表排序。若存为string型key值，排序会按字符串排序。

import sys
dict_res = {}

for line in sys.stdin:
    line = line.split()
    if len(line)==1: continue
    k,v = int(line[0]),line[1]
    if k not in dict_res.keys():
        dict_res[k] = v
    else:
        dict_res[k] = str(int(dict_res[k])+int(v))

for i in sorted(dict_res.keys()):
    print(str(i),dict_res[i])

HJ9 提取不重复的整数

data = input().strip()
data = data[::-1]
res = []
for i in data:
    if i not in res:
        res.append(i)
        print(i,end='')

HJ10 字符个数统计

此题要求重复输入的不做计算，因此设置备忘录进行筛选

import sys
vis = []
for data in sys.stdin:
    data = data.strip()
    if data not in vis:
        vis.append(data)
        data = set(list(data))
        print(len(data))

HJ14 字符串排序

n = input()先把首个数字排掉

import sys
n = input()
res = []
for line in sys.stdin:
    line = line.strip()
    res.append(line)
    
for i in sorted(res):
    print(i)

HJ16购物单（待补充）

待补充

HJ21简单密码破解

import sys

KEY = {'1':'1','abc':'2','def':'3','ghi':'4','jkl':'5',
       'mno':'6','pqrs':'7','tuv':'8','wxyz':'9','0':'0'}

def solution(data):
    res = ''
    if data in ['1','0'] or 'a'<=data<='z': 
        for key in KEY.keys():
            if data in key:
                res = KEY[key]
                return res
    elif 'A'<=data<='Z':
        if data == 'Z':
            res = 'a'
        else:
            res = chr(ord(data.lower())+1)
        return res
    else:
        return data
    

for data in sys.stdin:
    res = ''
    if data !='n':
        data = data.strip()
        for i in data:
            res += solution(i)
        print(res) 

HJ26 字符串排序

首先，将字母和非字母分开，char_list存放字母（方便进行排序），tmp存放非字母，该是字母的位置存放False，将每个tmp存入res；
第二步，对char_list排序，排序时大写字母按照小写进行排序对应原题中按照输入顺序排序(即不会影响顺序)；
第三步，对res中的值按照下标进行填充，非字母的保持原样，字母的从char_list中取；
第四步，输出结果。

import sys
for line in sys.stdin:
    line = line.split()
    res = [] #结果集
    total_res = [] #最终结果
    char_list = [] #存放字母
    for item in line:
        tmp = [] #存放每组单词 False/非字母
        for i in item:
            if i.isalpha():
                char_list.append(i)
                tmp.append(False)
            else:
                tmp.append(i)
        res.append(tmp)
    #对char_list排序
    char_list.sort(key = lambda c:c.lower())
    #填充
    for item in range(len(res)):
        for i in range(len(res[item])):
            if not res[item][i]:#Flase
                res[item][i] = char_list[0]#对应char_list中的第一个元素，下方填充后即可删除
                char_list.pop(0)
    for item in res:
        i_tmp = ''.join(item)
        total_res.append(i_tmp)
    print(' '.join(total_res))

HJ34 图片整理

（原题题干注明使用c，python过于草率了）

import sys
for line in sys.stdin:
    line = line.strip()
    print(''.join(sorted(line)))

HJ35蛇形矩阵

首先按行给首位赋值；然后按列遍历赋值。赋值公式如代码：

import sys

def solution(n):
    N = [[0 for i in range(n)]for j in range(n)]
    N[0][0] = 1
    for i in range(n): #给每行首位赋值
        if i !=0:
            N[i][0] = N[i-1][0]+i
    for j in range(1,n): #按列遍历,首列除外
        for i in range(n-1): 
            if i+j<n:
                #每个元素是左下角元素加1
                N[i][j] = N[i+1][j-1]+1
    return N
                

for line in sys.stdin:
    if line!='n':
        line = line.strip()
        res = solution(int(line))
        for i in range(len(res)):
            tmp = []
            for j in range(len(res[i])):
                if res[i][j] !=0:
                    tmp.append(str(res[i][j]))
            print(' '.join(tmp))

HJ36 字符串加密

import sys
def solution(key_word,word):
    key_word_t = list(set(key_word.lower()))
    key_word_t.sort(key=key_word.index)
    l_dict,L_dict = get_dict(key_word_t)
    res = ''
    for i in word:
        try:
            res +=l_dict[i]
        except:
            res +=res+L_dict[i]
    return res
    
def get_dict(data):
    Data = [i.upper() for i in data]
    l_asc = ord('a')
    L_asc = ord('A')
    l_list = []
    L_list = []
    for i in range(26):
        l_list.append(chr(i+l_asc))
        L_list.append(chr(i+L_asc))
        if chr(i+l_asc) not in data:
            data.append(chr(i+l_asc))
        if chr(i+L_asc) not in Data:
            Data.append(chr(i+L_asc))
    l_dict = dict(zip(l_list,data))
    L_dict = dict(zip(L_list,Data))
    return l_dict,L_dict
while True:
    try:
        key_word = input().strip()
        word = input().strip()
        if key_word and word:
            res = solution(key_word,word)
            print(res)
    except:
        break

HJ38 求小球落地5次后所经历的路程和第5次反弹的高度

height = int(input().strip())
s = height
for i in range(4):
    height /= 2
    s += height*2
height /= 2
print(round(s,6))
print(round(height,6))

HJ40 统计字符

while True:
    try:
        data = input().strip()
        count_e = data.count(' ')
        count_d = 0
        count_l = 0
        count_o = 0
        for i in data:
            if i.isdigit():count_d+=1
            elif i.isalpha():count_l +=1
            else:
                if i != ' ':count_o +=1
        print(count_l)
        print(count_e)
        print(count_d)
        print(count_o)
    except:
    	break

HJ43 迷宫问题（待补充）

待补充

HJ45 名字的漂亮度

首先，对字符串中字符个数进行统计然后按照降序排序；
第二步，按照排序好的顺序赋值，值每次递减1，从26开始
第三步，遍历字符串，将字符的值累加计算

import sys

def get_dict(line):
    count_d = {}
    set_w = list(set(list(line)))
    for i in set_w:
        count_d[i] = line.count(i)
    count_d = sorted(count_d.items(),key= lambda item:item[1],reverse=True)
    key_w = [i[0] for i in count_d]
    value_w = [i for i in range(26,26-len(set_w),-1)]
    dict_t = dict(zip(key_w,value_w))
    return dict_t
while True:
    try:
        n = int(input().strip())
        for i in range(n):
            line = input()
            dict_t = get_dict(line)
            sum = 0
            for i in line:
                sum +=dict_t[i]
            print(sum)
    except:
        break

HJ46 按字节截取字符串

import sys
while True:
    try:
        data = input().strip()
        n = int(input().strip())
        print(data[:n])
    except:
        break

HJ48 从单链表中删除指定值的节点（待补充）

待补充

HJ49 多线程

在线程外部循环：博主这个太慢了T-T
在内部循环：无法保证输出顺序

import threading
class mythreads(threading.Thread):
    def __init__(self,ID):
        threading.Thread.__init__(self)
        self.ID = ID
    def run(self):
        if self.ID==1:
            print('A',end='')
        elif self.ID == 2:
            print('B',end='')
        elif self.ID == 3:
            print('C',end='')
        else:
            print('D',end='')   
while True:
    try:
        n = int(input().strip())
        for i in range(n):
            thread1 = mythreads(1)
            thread2 = mythreads(2)
            thread3 = mythreads(3)
            thread4 = mythreads(4)
            thread1.start()
            thread2.start()
            thread3.start()
            thread4.start()
            thread1.join()
            thread2.join()
            thread3.join()
            thread4.join()
        print() #需要输出换行，否则多用例情况不通过
    except:
        break

HJ52 计算字符间的距离

动态规划

while True:
    try:
        str1=input()
        str2=input()
        dp=[[x for x in range(len(str1)+1)] for y in range(len(str2)+1)]
        for i in range(1,len(str1)+1):dp[0][i]=i
        for j in range(1,len(str2)+1):dp[j][0]=j
        for i in range(1,len(str1)+1):
            for j in range(1,len(str2)+1):
                if str1[i-1]==str2[j-1]:
                    dp[j][i]=dp[j-1][i-1]
                else:
                    dp[j][i]=min(dp[j-1][i-1],dp[j-1][i],dp[j][i-1])+1
        print(dp[-1][-1])
    except:
        break

HJ55 挑7

while True:
    try:
        d = int(input().strip())
        count = 0
        for i in range(1,d+1):
            stri = str(i)
            if '7' in stri or i%7==0:
                count +=1
        print(count)
    except:
        break

HJ57 高精度整数加法

while True:
    try:
        a = int(input().strip())
        b = int(input().strip())
        print(a+b)
    except:
        break

HJ59 找出字符中第一个只出现一次的字符

def solution(a):
    list_a = list(set(list(a)))
    list_a = sorted(list_a,key=list(a).index)
    count = []
    for i in list_a:
        if a.count(i)==1:count.append(i)
    if count==[]:return -1
    for i in list_a:
        try:
            if i in count:return i
        except:
            pass
    return -1
while True:
    try:
        a = input().strip()
        print(solution(a))
    except:
        break

HJ60 查找组成一个偶数最接近的两个素数

注意：326 = 163+163，所以最下方循环中是i<=in_a/2

def solution(in_a):
    list_res = [i for i in range(2,in_a+1)]
    for i in reversed(list_res):
        tmp = 2
        while tmp<i:
            if i%tmp == 0:
                list_res.remove(i)
                break
            tmp+=1
    res = []
    for i in list_res:
        if i <=in_a/2 and in_a-i in list_res:res.append([i,in_a-i])
    res.sort(key=lambda item:item[1]-item[0])
    return res
while True:
    try:
        in_a = int(input().strip())
        res = solution(in_a)
        print(res[0][0])
        print(res[0][1])
    except:
        break

HJ63 DNA序列

res = [序列，max_GC-Ratio],每次只保存res，节约空间

def solution(data,n):
    len_d = len(data)
    max_res = 0
    res = [data[:n],max_res]
    for i in range(len_d-n):
        item_d = data[i:i+n]
        deta = (item_d.count('C')+item_d.count('G'))/len_d
        if max_res < max(max_res,deta):
            max_res = max(max_res,deta)
            res = [item_d,max_res]
    return res[0]
data = input().strip()
n = int(input().strip())
res = solution(data,n)
print(res)

HJ64 MP3光标位置

列表处理尤为重要：
注意以下特殊情况及一般情况列表左右边界的处理：
特殊1：当光标在歌1，但按键为U，此时跳到最后一首歌，且列表左右边界为如下：
l_t = -min(4,n)
r_t = n
特殊2：当光标在歌n，但按键为D，此时跳到第一首歌，且列表左右边界为如下：
l_t = 0
r_t = min(4,n)
一般情况下：
一般1：当光标在当前列表的首位，但按键为U，此时列表向上移动一位，左右边界各-1
一般2：当光标在当前列表的首位，但按键为U，此时列表向上移动一位，左右边界各+1
其余情况：列表不变
光标处理：注意在队首队尾的特殊情况下光标指向歌曲数目的正确更替即可。

def solution(n,data):
    def get_res(cur,c_data=''):
        if c_data=='':cur=1
        elif cur==1 and c_data=='U':cur = n
        elif cur==n and c_data=='D':cur = 1
        else:
            if c_data == 'U':cur -=1
            else:cur +=1
        return cur
    if n ==1:
        return [1],1
    total = [i for i in range(1,n+1)]
    l_t = 0
    r_t = min(4,n)
    res_list = total[l_t:r_t]
    res = get_res(0)
    for i in data:
        if i=='U' and res==1:
            l_t = -min(4,n)
            r_t = n
        elif i=='D' and res==n:
            l_t = 0
            r_t = min(4,n)
        else:
            if i=='U':
                if res==res_list[0]:
                    l_t -= 1
                    r_t -= 1
            else: #D
                if res==res_list[-1]:
                    l_t += 1
                    r_t += 1
        res_list = total[l_t:r_t]
        res = get_res(res,i)
    return res_list,res
while True:
    try:
        n = int(input().strip())
        data = input().strip()
        res_list,res = solution(n,data)
        res_list = [str(i) for i in res_list]
        print(' '.join(res_list))
        print(res)
    except:
        break

HJ65 查找两个字符串a,b的最长公共子串

def solution(a,b):
    if len(a)==0 or len(b)==0:return ''
    if len(a)>len(b):a,b = b,a 
    if a in b:return a
    len_a = len(a)
    while len_a>0:
        for i in range(len(a)-len_a+1):
            a_t = a[i:i+len_a]
            if a_t in b:
                return a_t 
        len_a-=1
    return ''
while True:
    try:
        a = input().strip()
        b = input().strip()
        res = solution(a,b)
        print(res)
    except:
        break

HJ67 24点游戏算法

迭代方法。注意total有小数时返回false

def solution(data,total=24):
    if len(data)==1:return data[0]==total
    if total<0 or int(total) != total: return False
    for i in range(len(data)):
        l = data[:i]+data[i+1:]
        v = data[i]
        if solution(l,total+v)or solution(l,total-v)or solution(l,total*v)or solution(l,total/v):
            return True
    return False
while True:
    try:
        data = list(map(int,input().split()))
        res = solution(data)
        if res == True:print('true')
        else: print('false')
    except:
        break

HJ69 矩阵乘法

def solution(M1,M2,r1,c,r2):
    M = []
    for i in range(r1):
        M.append([])
        for j in range(r2):
            tmp=0
            for n in range(c):
                tmp += M1[i][n]*M2[n][j]
            M[i].append(tmp) 
    return M
while True:
    try:
        r1 = int(input())
        c = int(input())
        r2 = int(input())
        M1 = []
        M2 = []
        for i in range(r1):M1.append(list(map(int,input().split()))) 
        for i in range(c):M2.append(list(map(int,input().split())))
        res = solution(M1,M2,r1,c,r2)
        for i in range(len(res)):
            tmp = ' '.join(map(str,res[i]))
            print(tmp)
    except:
        break

HJ70 矩阵乘法计算量估计

纪念一下本题为博主在牛客网的第一个98%，可太菜了QAQ

注意：本题计算方式：结果矩阵元素个数*每个元素所需计算次数。由于博主用的python，python没有专门的栈结构，所以用列表来模拟栈结构。

def get_count_size(A_data,B_data):
    m1,n1 = A_data[0],A_data[1]
    n2 = B_data[1]
    return m1*n2*n1,[m1,n2]

def solution(in_d,in_list):
    count = 0
    #模拟栈
    stack = []
    for i in in_d:
        if i == '(':pass
        elif 'A'<=i<='Z':
            stack.append(in_list[0])
            in_list.pop(0)
        else:#右括号
            if len(stack)>=2:
                B = stack.pop()
                A = stack.pop()
                tmp,size = get_count_size(A,B)
                stack.append(size)
                count+=tmp
    return count
        
while True:
    try:
        n = int(input())
        in_list = []
        for i in range(n):in_list.append(list(map(int,input().split())))
        in_d = input().strip()
        res = solution(in_d,in_list)
        print(res)
    except:
        break

HJ71 字符串通配符（动态规划待补充）

可使用动态规划、递归
待补充

HJ88 扑克牌大小

if-else大法好

Standard = ['3','4','5','6','7','8','9','10','J','Q','K','A','2','joker','JOKER']
def solution(in_l1,in_l2,in_1,in_2):
    def is_valid(in_l1,in_l2):
        f = []
        for i in [in_l1,in_l2]:
            if len(i)==len(set(i)):
                if 'joker' in i and len(i)==2:flag=6#王
                else:flag = 1#个子
            elif len(i)==2 and len(set(i))==1:flag = 2#对子
            elif len(i)==3:flag=3#三个
            elif len(i)==4:flag=4#炸弹
            else: flag=5#顺子
            f.append(flag)
        if 4 in f or 6 in f:
            return True,f
        elif f[0]==f[1]:return True,f
        else:return False,f
    tmp,flag = is_valid(in_l1, in_l2)
    if not tmp: return'ERROR'
    if flag[0] in [1,2,3] and 4 not in flag and 6 not in flag:
        #个子 对子 三个看牌面
        index1=Standard.index(in_l1[0])
        index2=Standard.index(in_l2[0])
        return in_1 if index1>=index2 else in_2
    elif 4 in flag or 6 in flag:
        #炸弹 对王
        if 6 in flag:return in_1 if flag[0]==6 else in_2
        #一个炸弹
        elif 4 in flag and flag[0]!=flag[1]:return in_1 if flag[0]==4 else in_2
        #都是炸弹
        else: return in_1 if Standard.index(in_l1[0])>= Standard.index(in_l2[0]) else in_2
    else:
        #顺子 比较最小牌面
        min_1 = [Standard.index(i) for i in in_l1]
        min_2 = [Standard.index(i) for i in in_l2]
        return in_1 if min_1>=min_2 else in_2
            
[in_1,in_2] = input().strip().split('-')
in_l1 =in_1.split()
in_l2= in_2.split()
res = solution(in_l1,in_l2,in_1,in_2)
print(res)

HJ90 合法IP

非法：小于0，大于256，有空格，超过三位数

import sys
for line in sys.stdin:
    line = line.strip()
    data = line.split('.')
    flag=1
    for i in data:
        if ' ' in i or len(i)>=4 or '-' in i or int(i)>256:
            print('NO')
            flag=0
            break
    if flag==1:print('YES')

HJ96 表示数字

import sys
def solution(data,i_start=0,res=''):
    def is_no_digit(tmp):
        for i in tmp:
            if i.isdigit():return False
        return True
    if i_start == len(data):return res
    for i in reversed(range(len(data)-i_start)):
        tmp = data[i_start:i_start+i+1]
        if tmp:
            if tmp.isdigit(): #全是数字
                res+=('*'+tmp+'*')
                break
            elif is_no_digit(tmp):#不包含数字
                res += tmp
                break
    return solution(data,i_start+i+1,res)
            
for line in sys.stdin:
    data = line.strip()
    res = solution(data)  
    print(res)

HJ98 自动售货系统（待补充）

题目太长太长，后面有空再写

HJ99 自守数

import sys
for line in sys.stdin:
    data = int(line.strip())
    count=0
    for n in range(data+1):
        if str(n*n).endswith(str(n)):count+=1
    print(count)

HJ102 字符统计

巩固排序sort sorted用法

import sys
def solution(data):
    res = {}
    d_set = set(list(data))
    for item in d_set:
        num_i = data.count(item)
        if num_i not in res.keys():
            res[num_i] = []
        res[num_i].append(item)
    for item in res.keys():
        res[item] = sorted(res[item],key=lambda i:ord(i))#ASCII升序
    return sorted(res.items(),key=lambda item:item[0],reverse=True)#次数降序
        
for line in sys.stdin:
    data = line.strip()
    res = solution(data)
    for v_list in res:
        for i in v_list[1]:
            print(i,end='')
    print()

HJ103Redraiment的走法

最长上升子序列问题，动态规划

def solution(n,data):
    dp = [1 for i in range(len(data))]
    res=0
    for i in range(n):
        for j in range(i):
            if data[i]>data[j]:
                dp[i]=max(dp[i],dp[j]+1)
        res = max(res,dp[i])
    return res
while True:
    try:
        n,data = int(input()),list(map(int,input().strip().split()))
        res = solution(n,data)
        print(res)
    except:
        break

HJ107 求解立方根

牛顿迭代法 f(x)=x^3-y,f(x)=0的解： xn+1=xn-f(xn)/f’(xn) （本题y=216）

n=float(input())
e=0.0001#精度设置
x=n#初始化解为输入值
while abs(x**3-n)>e:
    x = x-(x**3-n)/(3*x*x)
print(round(x,1))

青古の每篇一歌
《是风动》
你是我身外，化白云任去来
推开孤城万里，吹渡春风几千载

最后

以上就是眯眯眼朋友最近收集整理的关于（python）牛客网（华为机试三）——中等HJ5 进制转换HJ6 质数因子HJ8 合并表记录HJ9 提取不重复的整数HJ10 字符个数统计HJ14 字符串排序HJ16购物单（待补充）HJ21简单密码破解HJ26 字符串排序HJ34 图片整理HJ35蛇形矩阵HJ36 字符串加密HJ38 求小球落地5次后所经历的路程和第5次反弹的高度HJ40 统计字符HJ43 迷宫问题（待补充）HJ45 名字的漂亮度HJ46 按字节截取字符串HJ48 从单链表中删除指定值的节点（待补充）HJ49 多线程HJ52 的全部内容，更多相关（python）牛客网（华为机试三）——中等HJ5内容请搜索靠谱客的其他文章。