本博客为博主解题的部分记录，由于均为自己写的，所以答案并非最优解，有很多地方可以优化。
其他题解合集：
（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 进制转换HJ6 质数因子HJ8 合并表记录HJ9 提取不重复的整数HJ10 字符个数统计HJ14 字符串排序HJ16购物单（待补充）HJ21简单密码破解HJ26 字符串排序HJ34 图片整理HJ35蛇形矩阵HJ36 字符串加密HJ38 求小球落地5次后所经历的路程和第5次反弹的高度HJ40 统计字符HJ43 迷宫问题（待补充）HJ45 名字的漂亮度HJ46 按字节截取字符串HJ48 从单链表中删除指定值的节点（待补充）HJ49 多线程HJ52 所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。