华为题库刷题记录

浅记录一下

只刷了一小部分，后面再补了

题源牛客-华为机考

HJ3 明明的随机数

将每一次输入的m值存储temp里时最好转换为整形，方便后面按小到大排序输出
解决重复数问题可以通过创建空数组，依次添加判断

n = int(input())
temp = []
ans = []
for i in range(n):
    m = input()
    temp.append(int(m))
for each in temp:
    if each not in ans:
        ans.append(each)
for i in sorted(ans):
    print(i)

HJ4 字符串分隔

输入一个字符串，请按长度为8拆分每个输入字符串并进行输出；

•长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。
输入描述：

连续输入字符串(每个字符串长度小于等于100)
输出描述：

依次输出所有分割后的长度为8的新字符串
示例1

输入：

abc

输出：

abc00000

解答大于8时通过循环输出，str[:8]：前八项输出，下标（0~7），输出后更新str—>第八项（下标）及第八项往后的字符串；

不足八位：补上8减字符串长度

str = input()
empty = ""
while len(str) > 8:
    print(str[:8])
    str = str[8:]
str = str + '0'*(8-len(str))
print(str)

HJ5 进制转换

思路一：
1、输入的字符串str1截取’0x’之后的字符放入str2，以str2生成的列表放入list1，方便转换后索引
2、A~F对应关系罗列字典（通过key索引value）
3、列表中字符转换整数（数字）存入list3
4、list3[-(i+1)]，从最后一位开始计算，16^i

str1 = str(input())
str2 = str1[2:]
list1 = list(str2)
dict1 = {'A':'10','B':'11','C':'12','D':'13','E':'14','F':'15'}
list2 = [dict1[i] if i in dict1 else i for i in list1]
list3 = []
Sum = 0
for i in list2:
    list3.append(int(i))
for i in range(len(list3)):
    Sum += list3[-(i+1)]*pow(16,i)
print(Sum)

二、python毕竟是python，简洁不花里胡哨，直接进制转换
int函数，第一个参数是一个字符串，第二个参数是字符串的进制

​print(int(input(), 16))

HJ6 质数因子

假设输入的正整数num有质因数abcdef…
那么可以写成num = abcdf*…
若f是最大质因数，则num除去先前的质因子之后的数应该是小于等于mm
计算方法：
以180为例
从2开始，最小质因子开始循环
180能被2整除---->90
存放第一个质因子2---->res（后面需要join（）函数拼接，需要装换为字符串）
再接着90往下循环，直到num不能被2整除，prfc+1
继续循环直到不能被3整除，prfc+1
因为前面整除2的数都被筛掉了，prfc = 4也不会满足第二个循环条件，其他类似
直到180//2//2//3//3 = 5 < 55 | num----->res[ ]
最后注意输出答案以空格为分开
join（）函数用法
‘sep’.join(seq)
sep：分隔符，可以为’ , ‘、’ : '空格等等
seq：要连接的元素序列、字符串、元组、字典

num = int(input())
#primefactors质数因子
prfc = 2
res = []
while num >= prfc * prfc:
    while num % prfc == 0:
        num = num // prfc
        res.append(str(prfc))
    prfc +=1
if num > 1:
    res.append(str(num))
print(' '.join(res))

HJ7 取近似值

n = float(input())
m = int(n)
if n - m >= 0.5:
    print(m+1)
else:
    print(m)

HJ8 合并表记录

代码来源大佬题解，这份答案写的挺好
split()默认两个参数，分别是分隔符和分隔数量，作用是将一个字符串按照分隔符分隔成一个list[ ]
split() 不传递参数时默认空格分隔，且无数量限制

get()函数在这里有两个参数，第一个是确定要分配值的键，第二个是拟定给键分配一个初值
get（key，0）-----获取key对应的value，并令初值为0

sorted（）函数 sorted（list，key），key—排序规则
默认生成新的list（不覆盖原有排序），按key从小到大排，相当于sorted（list，reverse = False）

以题目示例为例
输入0 1时，以首项为键，后输入为值，以此构建字典索引

n = int(input())
arr = []
dict1 = {}
for i in range(n):
    arr = input().split()
    key = int(arr[0])
    value = int(arr[1])
    dict1[key] = dict1.get(key,0) + value

for i in sorted(dict1):
    print(i,dict1[i])

HJ9提取不重复的整数

n = str(input())
m = n[::-1]
temp = ''
for i in m:
    if i not in temp:
        temp += i
print(temp)

m = n[::-1] 切片逆序输出（不要用sorted翻转）
之后字符串+拼接输出

HJ10 字符个数统计

算法和上述的一些题目一样，就不赘述了

str1 = input()
temp = ""
count = 0
for i in str1:
    if i not in temp:
        temp += i
        count += 1
print(count)

HJ11 数字颠倒

n = input()
print(n[::-1])

HJ12 字符串反转

代码同上

HJ13 句子逆序

所有单词之间用一个空格隔开
split（）函数，不传入参数默认空格
[::-1]从后往前倒序重排

sentence = input().split()
arr = sentence[::-1]
ans = ''
for word in arr:
    ans = ans + word + ' '
print(ans)

HJ14 字符串排序

n = int(input())
list1 = []
for i in range(n):
    str1 = input()
    list1.append(str1)
for word in sorted(list1):
    print(word)

HJ15 求int型正整数在内存中存储时1的个数

以一个十进制数转二进制为例来分析过程
15
15/2=7…1
7/2=3…1
3/2=1…1
1/2=0…1
所以1111（从下往上）即15的二进制表达

n = int(input())
list1 = []
while n // 2 >= 0 and n != 0:
    list1.append(n%2)
    n = n // 2
print(list1.count(1))

或者使用进制转换函数
其他进制转换十进制可以用int（num，num所属的进制数）
如二进制转十进制

num = '0101'
print(int(num,2))
#输出5

若将十进制转换为其他有：
十进制—>十六进制 hex()
十进制—>八进制 oct()
十进制—>二进制 bin()
所以本题第二种写法

n = int(input())
m = str(bin(n))
print(m.count('1'))

HJ16 购物单

#购物单  进阶动态规划问题
#代码原文链接：https://blog.csdn.net/COCO56/article/details/124463397  原文大佬用了三种方法，代码非常漂亮

"""
输入 N m
从第二行到第m+1行，输入价格 重要度 主件/附件从属
v p q
50 5
20 3 5
20 3 5
10 3 0
10 2 0
10 1 0
输出
130
说明：
由第1行可知总钱数N为50以及希望购买的物品个数m为5；
第2和第3行的q为5，说明它们都是编号为5的物品的附件；
第4~6行的q都为0，说明它们都是主件，它们的编号依次为3~5；
所以物品的价格与重要度乘积的总和的最大值为10*1+20*3+20*3=130
"""
N , m = map(int,input().split())
main_obj = {}    #主件
accessory = {}    #附件
for i in range(1,m+1):
    v,p,q = map(int,input().split())
    if q == 0 :    #是主件
        main_obj[i] = [v,v*p]     #写入主件价格，和购买改主件带来的满意度 //相当于{3:[10,30]}
    else:
        if q in accessory:        #如果是附件
            accessory[q].append([v,v*p])  #附件2  {5:[[20,60][20,60]]}  索引附件1的话:accessory[5][0][0]
        else:
            accessory[q] = [[v,v*p]] #列表存储 附件1{5:[[20,60]]}
dp = [0]*(N+1)     #最后求dp[50],因为下标从0开始，第50项为dp[49],所以此处为N+1
#这里的main_parts.items(),输出为 {3:[10,30],4:[10,20],5:[10,10]}
#循环对应的key 和value为
#        3    [10,30]
#        4    [10,20]
#        5    [10,10]
for key,value in main_obj.items():    #遍历主件字典
    price = []    #花费数额
    satis = []    #获得的满意度
    price.append(value[0])  # 购买该主件的价格     value[0]=main_obj[key][0][0]
    satis.append(value[1])  # 花费该价格获得的满意度
    if key in accessory:    # 如果该主件还有附件
        price.append(price[0] + accessory[key][0][0])    #主件加上附件1的价格
        satis.append(satis[0] + accessory[key][0][1])    #主件加上购买附件1的满意度
        if len(accessory[key]) > 1 :  #如果有两个附件
            price.append(price[0] + accessory[key][1][0])    #主件加上附件2的价格
            satis.append(satis[0] + accessory[key][1][1])  # 主件加上购买附件2的满意度
            price.append(price[0] + accessory[key][0][0] + accessory[key][1][0])   #主件+附件1+附件2价格
            satis.append(satis[0] + accessory[key][0][1] + accessory[key][1][1])  # 主件+附件1+附件2的满意度
    # 从最大金额到0，购买物的价格是10的整数倍，减少循环  下边的循环比较b站毒蛇大叔的视频讲的挺好
    for j in range(N,-1,-10):
        for i,_ in enumerate(price):   #枚举当前存储的价格，返回升序后的索引下标i, _ 是返回的价格，通过下标i可以获取，所以就随意一些了
            if j - price[i] >= 0:       #当前现金可以买下,类似01背包问题
                dp[j] = max(dp[j],dp[j - price[i]] + satis[i]) #枚举，获得索引值和遍历的对象
print(dp[N])

HJ17 坐标移动

关键在于判断合法坐标，是否为AWSD+数字（两位以内组成）
isdigit（）
判断单个字符是否为数字
判断字符串中是否仅含有数字
如str = A10
str[1:].isdigit()--------返回True
返回用的format（）函数，前边的{0}，{1}----相当于x , y的占位符，指定位置映射x , y的值

#坐标coordinate
coor = input().split(';')
x,y = 0,0
for each in coor:
    if 2 <=len(each) <= 3:
        if each[:1] == 'A' and each[1:].isdigit():
            x -= int(each[1:])
        if each[:1] == 'D' and each[1:].isdigit():
            x += int(each[1:])
        if each[:1] == 'W' and each[1:].isdigit():
            y += int(each[1:])
        if each[:1] == 'S' and each[1:].isdigit():
            y -= int(each[1:])
print('{0},{1}'.format(x,y))

HJ21 简单密码

ord()----将字符转换为ascll码值，ascll+1来实现移位，在通过函数lower()转换小写，或者直接lower（）再通过ascll码+1移位，注意最后一位‘Z’–90，但91不是‘a’，a的ascll码97，注意一下
小写字母和数值转换可以把输入的字典key搬出来遍历，再写入对应key的value
本例最后一个if有点多余，直接temp +=i应该也一样

code = input()
temp = ''
dict1 = {'abc':2,'def':3,'ghi':4,'jkl':5,'mno':6,'pqrs':7,'tuv':8,'wxyz':9}
for i in code:
    if 65 <= ord(i) <= 89:
        temp += chr(ord(i)+1).lower()
    if ord(i) == 90:
        temp += 'a'
    for key in dict1:
        if i in key:
            temp += str(dict1.get(key))
    if i.isdigit():
        temp += i
print(temp)

HJ22 汽水瓶

每三个空瓶可以换一批汽水
但即使只有两个空瓶，可以通过借一个空瓶换一瓶汽水，喝完再还一个空瓶
所以这道题最优解可以看作有多少份‘两个空瓶’，就可以喝多少汽水
即n/2

while True:
    try:
        n = int(input())
        if n == 0:
            break
        else:
            print(n//2)
    except:
        break

HJ23 删除字符串中出现次数最少的字符

通过遍历输入字符串，每扫描一次重复的key，value+1
通过min（）函数取出最小value
再遍历str1中的字符作为key来索引所对应的value是否最小
如aabcddd，a在dict1中为{‘a’:2}，取出最小字符，由于要输出的不是最少
再遍历一遍str1，将不属于最少字符提取出来，这里也可以用replace（）函数替换
str1.replace（需要替换的值，替换后的值）

str1 = input()
dict1 = {}
ans = ''
str2 = ''
for i in str1:
    if i in dict1:
        dict1[i] = dict1.get(i) + 1
    else:
        dict1[i] = 1
Min = min(dict1.values())
for i in str1:
    if dict1[i] == Min:
        ans += i
for each in str1:
    if each not in ans:
        str2 += each
print(str2)

str1 = input()
dict1 = {}
for i in str1:
    if i in dict1:
        dict1[i] = dict1.get(i) + 1
    else:
        dict1[i] = 1
Min = min(dict1.values())
for i in str1:
    if dict1[i] == Min:
        str1 = str1.replace(i,'')   #使用replace函数替换最少字符再覆盖str1
print(str1)

HJ24 合唱队

def left_LICS(nums):
    dp = [1]*len(nums)   #若左边没有比自己小的数，则为自己本身，所以初始值为1
    for i in range(len(nums)):
        for j in range(i):      # 遍历自己左侧的数
            if nums[i] > nums[j] and dp[i] < dp[j] + 1:   #明确dp[i]的含义，第i位时所能获得的最长序列
                dp[i] = dp[j] + 1       #i位左侧的数比第i位小，并且左侧的这个数所能达到的最长序列+1能使得dp[i]此时为最长序列
    return dp                          #如[2,8,9,3,5,7,10] i=6时，序列有[2,3,5,7,10]和[2,8,9,10],当前者最长所以dp[i] = 5
                                       #[1,1,1,1,1,1,1]-->[1,2,3,2,3,4,5]
n = int(input())
nums = list(map(int,input().split(' ')))
left_lines = left_LICS(nums)   #自左向右递增
right_lines = left_LICS(nums[::-1])[::-1]  #只右向左递增，可以看作倒序的序列做自左向右递增，再将结果倒序
sum_lines = []          #合唱队形长度序列,需要出列的人数即总人数减去合唱人数
for i in range(len(left_lines)):
    sum_lines.append(left_lines[i] + right_lines[i] -1)   #第i位自身加了两次，需要-1
print(n-max(sum_lines))

HJ27 查找兄弟单词

while True:
    try:
        list1 = input().split()
        n = int(list1[0])
        word_list = list1[1:-2]
        x_target = list1[-2]
        k = int(list1[-1])
        count = 0
        bro_word = []
        for i in word_list:
            if i != x_target and sorted(i) == sorted(x_target):
                count += 1
                bro_word.append(i)
        print(count)
        bro_word.sort()
        print(bro_word[k-1])
    except:
        break

HJ35 蛇形矩阵

思路
1 3 6 10
2 5 9
4 8
7
可以旋转变成
1
2 3
4 5 6
7 8 9 10
然后截取每一行的最后一个数作为一行输出
代码
第一个for循环生成矩阵matr[[0],[0][0],[0][0][0],[0][0][0][0]]
第二个for循环—行
第三个for循环—列
从1开始依次赋值

n = int(input())
matr = []   
count = 0
list1 = []
ans = []
for i in range(1,n + 1):
    matr.append([0]*i)
for i in range(n):
    for j in range(i+1):
        count += 1
        matr[i][j] += count
for i in range(n):
    for each in matr:      #遍历matr
        if each:				#当each非空时为真
            list1.append(each.pop(-1))    #取出最后一项后删除
    ans.append(' '.join(map(str,list1)))  #join不支持int，map将str函数作用list内每一个元素上，得到一个新的list返回
    list1 = []
for line in ans:
    print(line)
    

HJ40 统计字符

str1 = input()
space = 0
alp = 0
num = 0
els = 0
for i in range(len(str1)):
    if str1[i].isalpha():
        alp += 1
    elif str1[i].isdigit():
        num += 1
    elif str1[i] == ' ':
        space += 1
    else:
        els += 1
print(alp)
print(space)
print(num)
print(els)

HJ45 名字的漂亮度

给每个字母赋值，求最大漂亮度
出现最多的字母赋值26，以此类推
比如asdfadadsa a:4 d:3 s:2 f:1 要使得漂亮度最大，则adsf分别赋值26 25 24 23

while True:
    try:
        n = int(input())
        for i in range(n):
            name = input()
            dict1 = {}
            beauty = 0
            #每个字母出现的次数
            for j in name:
                if j not in dict1:
                    dict1[j] = name.count(j)
            #根据出现次数降序排列
            times = sorted(dict1.values(),reverse=True)
            flag = 0
            for j in times:
                beauty += (26-flag)*j
                flag +=1
            print(beauty)

    except:
        break

HJ48 从单向链表中删除指定值的节点

while True:
    try:
        num = input().split()
        head = num[1]
        nodes = num[2:-1]   #从输入的第3项到倒数第二项为所有节点
        #两两一组，每一组的第一个节点插入到第二个节点后面
        dele = num[-1]   #最后一项为要删除的节点值
        list_ans = [head]  #单项链表头节点
        for i in range(0,len(nodes),2):
            first_node = nodes[i]   #每一组的第一个节点
            index1 = list_ans.index(nodes[i+1])+1 #i+1即该组第二个节点，获取第二个节点右侧下标值
            list_ans.insert(index1,first_node)
        list_ans.remove(dele)
        print(' '.join(list_ans))
    except:
        break

HJ53 杨辉三角变形

# n 1  2  3  4  5  6  7  8  9  10
#  -1 -1  2  3  2  4  2  3  2  4
n = int(input())
arr = [2,3,2,4]
if n <= 2:
    print(-1)
elif n % 4 == 3:
    print(2)
elif n % 4 == 0:
    print(3)
elif n % 4 == 1:
    print(2)
else:
    print(4)

HJ54 表达式求值

while True:
    try:
        str1 = input()
        valid_str = '+-*/()1234567890'
        if len(str1) > 100:
            print("超出规定长度")
        else:
            for i in str1:
                if i not in valid_str:
                    print("字符不合法")
            print(eval(str1))
    except:
        break
            

HJ56 完全数计算

while True:
    try:
        n = int(input())
        count = 0
        for i in range(1,n+1):
            Sum = 0
            half_i = i//2
            for j in range(1,half_i + 1):
                if i % j == 0:
                    Sum +=j
            if Sum == i:
                count += 1
        print(count)
    except:
        break

HJ58 输入n个整数，输出其中最小的k个

n = input().split()
i = int(n[0])
temp = []
m = input().split()
for i in m:
    temp.append(int(i))
temp = sorted(temp)
for i in range(int(n[1])):
    print(temp[i],end=' ')

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

def sushu(num):
    if num == 1:
        return False
    if num == 2:
        return True
    list1 = []   #list1为空，说明时素数
    for i in range(2,num):
        if num % i == 0:
            list1.append(i)
    if not list1:
        return True
    else:
        return False

while True:
    try:
        n = int(input())
        num = n // 2
        #从中间往后遍历
        for i in range(num):
            a = num - i
            b = num + i
            if sushu(a) and sushu(b):
                print(a)
                print(b)
                break
    except:
        break

HJ61 放苹果

# m：苹果数量，n：盘子数量
#边界条件  m=0 func(m,n)=1;  n=0,func(m,n)=0; n=1,func(m,n)=1
#如果 m < n , 即使每个盘子放一个苹果，还有m-n个盘子空着，所有分法为func(m,m)
#如果 m >= n
#至少有一个空盘，则分法有func(m,n-1)
#没有空盘，则分法为，func(m-n,n)
def func(m,n):
    if m == 0:
        return 1
    elif n == 0:
        return 0
    elif n == 1:
        return 1
    elif m < n:
        return func(m,m)
    elif m >= n:
        return func(m,n - 1) + func(m - n,n)
m,n = map(int,input().strip().split())
print(func(m,n))

HJ62 查找输入整数二进制中1的个数

while True:
    try:
        n = int(input())
        print(bin(n).count('1'))
    except:
        break

HJ72 百钱买百鸡问题

# 公，母，雏 a,b,c
#a + b + c = 100
#5a + 3b +c/3 = 100
#合并消掉一项，得出两项关系
#即 14a + 8b = 200 ----> b = 25 - 7/4*a
#a必须是4的倍数
while True:
    try:
        n = input()
        a=0
        i = 1
        while 25 - 7/4*a >=0:
            b = 25 - 7/4*a
            c = 100 - b - a 
            print(int(a),int(b),int(c))
            a = i*4
            i += 1
    except:
        break
    

HJ73 计算日期到天数转换

import datetime
while True:
    try:
        date = list(map(int,input().split()))
        year,month,day = date[0],date[1],date[2]
        date = datetime.datetime(year,month,day)
        ans_day = date.strftime('%j').lstrip('0')
        #%j：返回当天是当年的第几天，如第81天-->080
        #lstrip()根据传入参数从左边开始删除参数内容
        print(ans_day)
    except:
        break

HJ76 尼科彻斯定理

num = int(input())
list1 = []
n = num*num
str1 = []   #join()只能连接字符串
if num % 2==0:
    for i in range(1,num,2):
        list1.append(n - i)
        list1.append(n + i)
else:
    for i in range(2,num,2):
        list1.append(n - i)
        list1.append(n + i)
    list1.append(n)
list1 = sorted(list1)
for i in range(len(list1)):
    str1.append(str(list1[i]))
print('+'.join(str1))

HJ80 整型数组合并

while True:
    try:
        first_num = int(input())
        first_list = list(map(int,input().split()))
        sec_num = int(input())
        sec_list = list(map(int,input().split()))
        list1 = []
        ans = []
        for each in first_list:
            if each not in list1:
                list1.append(each)
        for each in sec_list:
            if each not in list1:
                list1.append(each)
        list1 = sorted(list1)
        for i in range(len(list1)):
            ans.append(str(list1[i]))
        print(''.join(ans))
    except:
        break

HJ81 字符串字符匹配

str1 = input()
str2 = input()
flag = 0
for i in str1:
    if i in str2:
        flag += 1
if flag == len(str1):
    print('true')
else:
    print('false')

HJ82 将真分数分解为埃及分数

#80/110  55+22+2+1 = 80
while True:
    try:
        n,m = map(int,input().split('/'))
        n *= 10
        m *= 10
        #遇到分母为素数，乘以10可以有利于分解，分解出来能被分母整除的数存入list1
        list1 = []
        str1 = ''
        #倒序遍历会比较快，从n~0，range最后取到1结束
        while n:
            for i in range(n,0,-1):
                if m % i == 0:
                    list1.append(f'1/{int(m/i)}')
                    n -= i
                    break
        print('+'.join(list1))
    except:
        break

HJ83 二维数组操作

while True:
    try:
        m,n = map(int,input().split())
        x1,y1,x2,y2 = map(int,input().split())
        i_m,i_n = int(input()),int(input())
        x,y = map(int,input().split())
        #1,数据表行列范围都是[0,9],若满足输出'0',否则输出'-1'
        print('0' if(0<= m <= 9) and (0<= n <= 9) else '-1')
        #2,交换的坐标行列数要在输入的表格大小行列数范围[0,m)x[0,n)内
        print('0' if(0 <= x1 < m) and (0 <= y1 < n) and (0<= x2 <m) and (0 <= y2 < n) else '-1')
        # 3.1，插入的x坐标要在 [0, m) 范围内
        print('0' if(0 <= i_m < m) and (m < 9) else '-1')
        # 3.2，插入的y坐标要在 [0, n) 范围内
        print('0' if(0 <= i_n < n) and (n<9) else '-1')
        # 4，要检查的位置 (x,y) 要在 [0, m)x[0, n) 内
        print('0' if(0 <= x < m) and (0 <= y < n) else '-1')
    except:
        break

HJ84 统计大写字母个数

while True:
    try:
        str1 = input()
        str2 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
        count =0
        for i in str1:
            if i in str2:
                count += 1
        print(count)
    except:
        break

HJ85 最长回文子串

while True:
    try:
        str1 = input()
        list1 = [] #存放每一次遍历的回文串长度
        for i in range(len(str1) - 1):
            for j in range(i+1,len(str1)+1):
                if str1[i:j] == str1[i:j][::-1]:
                    list1.append(j-i)
        if list1 != '':
            print(max(list1))

    except:
        break

HJ86 求最大连续bit数

n = int(input())
m = str(bin(n))
list1 = []
count = 0
for i in m:
    if i == '1':
        count += 1
    else:
        count = 0
    list1.append(count)
print(max(list1))

HJ87 密码强度等级

str1 = input()
str2 = ''  #存放str1中的字母
count = 0  #计算str1中的数字个数
count2 = 0 #计算str1中符号个数
point_len = 0  #长度得分
point_alp = 0  #字母得分
point_num = 0  #数字得分
point_symbol = 0 #符号得分
point_award = 0  #奖励得分
total = 0      #合计得分
#长度得分
for i in str1:
    if len(str1) <= 4:
        point_len = 5
    elif 5 <=len(str1) <= 7:
        point_len = 10
    elif len(str1) >= 8:
        point_len = 25
#字母得分
for i in str1:
    if i.isalpha():
        str2 += i 
if str2 == '':
    point_alp = 0
elif str2.isupper() or str2.islower():
    point_alp =10
else:
    point_alp =20
#数字得分
for i in str1:
    if i.isdigit():
        count += 1
if count == 0:
    point_num = 0
elif count == 1:
    point_num = 10
else:
    point_num = 20
#符号得分
for i in str1:
    if 0x21 <=ord(i) <= 0x2F or 0x3A <= ord(i) <= 0x40 or 0x5B <= ord(i) <= 0x60 or 0x7B <=ord(i) <= 0x7E:
        count2 += 1
if count2 == 0:
    point_symbol = 0
elif count2 == 1:
    point_symbol = 10
else:
    point_symbol =25
#奖励
if point_alp > 0 and point_num > 0 and point_symbol == 0:
    point_award = 2
elif 0 < point_alp <20 and point_num > 0 and point_symbol > 0:
    point_award = 3
elif point_alp == 20 and point_num == point_num > 0 and point_symbol > 0:
    point_award = 5
total = point_len + point_alp +point_num + point_symbol + point_award
if total >=90:
    print('VERY_SECURE')
elif total >= 80:
    print('SECURE')
elif total >= 70:
    print('VERY_STRONG')
elif total >= 60:
    print('STRONG')
elif total >= 50:
    print('AVERAGE')
elif total >= 25:
    print('WEAK')
else:
    print('VERY_WEAK')

HJ91 走方格的方案数

#递归算法，走到坐标（n，m）,可以从（n，m-1）往右走，也可以从（n-1，m）往下走
num = list(map(int,input().split()))
n = num[0]
m = num[1]
def func(n,m):
    if n == 0 or m == 0:
        return 1
    return func(n,m-1) + func(n-1,m)
print(func(n,m))

#动态规划算法
#二维数组的创建 横坐标是m，纵坐标是n
while True:
    try:
        n,m = map(int,input().split())
        dp = [[1 for _ in range(n+1)] for _ in range(m+1)]
        for i in range(1,m+1):
            for j in range(1,n+1):
                dp[i][j] = dp[i-1][j] + dp[i][j-1]
        print(dp[m][n])
    except:
        break

HJ94 候选人投票

while True:
    try:
        nums = int(input())   #候选人数的人数
        names = input().split()   #候选人名字
        vote_nums = int(input())  #投票人人数
        vote = input().split()    #输入投票
        dict1 = {}
        Invalid = 0
        for i in names:       
            if i not in dict1:
                dict1[i] = 0      #建立字典
        for i in vote:
            if i in dict1:
                dict1[i] = dict1.get(i) +1   #与字典中key相同时获取value 然后+1
            else:
                Invalid += 1
        for i in dict1:
            print(i + ' : ' + str(dict1[i]))
        print('Invalid' + ' : ' + str(Invalid))
    except:
        break

HJ96 表示数字

str1 = input()
str_pre = ''      #已经遍历过得字符写入
ans = ''
for i in str1:
    if i.isdigit():   #如果第i位是数字
        if str_pre.isdigit() != True:   #如果第i位前一位不是数字
            ans += '*'                  #输出结果字符加'*' 
        ans += i                        #然后再将i写入输出ans
    else:                               #如果第i位不是数字
        if str_pre.isdigit():           #但第i位的前一位是数字
            ans += '*'                  #数字后方加'*'
        ans += i                        #再写入i
    str_pre = i                         #作为下一次循环的前一位判断
if str1[-1].isdigit():                  #补上最后一项
    ans += '*'
print(ans)

HJ97 记负均正

while True:
    try:
        n = int(input())
        nums = list(map(int,input().split()))
        count = 0
        list1 = []    #存放正整数
        for i in nums:
            if i < 0:
                count += 1
            if i > 0:
                list1.append(i)
        if len(list1) == 0:
            list1 = [0]
        print('{0} {1}'.format(count,round(sum(list1)/len(list1),1)))
    except:
        break

HJ99 自守数

n = int(input())
m = 0
count = 0
for i in range(n+1):
    m = i*i 
    if str(m)[-len(str(i)):] == str(i):
        count +=1
print(count)

HJ100 等差数列

#朴素求解
while True:
    try:
        n = int(input())
        list1 =[]
        temp = 2
        if n == 0:
            break
        for i in range(1,n+1):
            if i == 1:
                list1.append(2)
            else:
                list1.append(temp)
            temp += 3
        print(sum(list1))
    except:
        break

#an = a1 + (n-1)d     Sn = n*(a1+an)/2=n*a1 + n*(n-1)d/2
while True:
    try:
        n = int(input())
        total = 0
        if n == 0:
            break
        total = n*2 + n*(n-1)*3/2
        print('%.0f'%total)
    except:
        break

HJ101 输入整型数组和排序标识，对其元素按照升序或降序进行排序

while True:
    try:
        n = int(input())
        nums = list(map(int,input().split()))
        list1 = []
        flag = input()
        if flag == '0':
            nums = sorted(nums)
        if flag == '1':
            nums = sorted(nums,reverse=True)
        for i in nums:
            list1.append(str(i))
        print(' '.join(list1))
    except:
        break

HJ102 字符统计

while True:
    try:
        str1 = input()
        dict1 = {}
        for i in str1:
            if i in dict1:
                dict1[i] += 1
            else:
                dict1[i] = 1  
        #sorted(dict1.items(),key=lambda x:(-x[1],x[0]))
        #dict_items([('a', 1), ('d', 2), ('f', 3)])
        #sorted(iterable，key，reverse) 参数key可以指定根据那个字段进行排序
        #key=lambda 元素: 元素[1] 根据元素第2位进行排序  注：前加负号为倒序
        #key=lambda x:(-x[1],x[0])，先根据元素第2位逆序，再根据元素第1位顺序
        for key,value in sorted(dict1.items(),key=lambda x:(-x[1],x[0])):
            print(key,end='')
    except:
        break
            

HJ105 记负均正II

#关键在于处理多组输入
#当输入最后一行并回车后，按组合键ctrl+D，表示EOF，即End of File、文件尾的意思
#input()函数遇到EOF的异常，Python的异常处理机制将捕获到此异常，执行except中语句
count = 0
int_num = []  #positive integer
while True:
    try:
        n = int(input())
        if n < 0:
            count += 1
        else:
            int_num.append(n)
    except EOFError:
        print(count)
        if len(int_num) == 0:
            print('0.0')
        else:
            print(round(sum(int_num)/len(int_num),1))
        break

HJ106 字符逆序

while True:
    try:
        str1 = input()
        print(str1[::-1])
    except:
        break

HJ107 求解立方根（二分查找）

while True:
    try:
        n = float(input())
        e = 0.0001
        low = min(-1,n)
        high = max(1,n)
        mid = (low + high)/2
        while abs(mid**3 - n) >= e:
            if mid**3 < n:
                low = mid
            else:
                high = mid
            mid = (low + high)/2
        print(round(mid,1))
    except:
        break

HJ108 求最小公倍数

#直接挨个遍历容易超时，那就减少遍历次数
#从最小的输入值开始遍历，步长为最小输入值
while True:
    try:
        n,m = map(int,input().split())
        for i in range(min(n,m),n*m + 1,min(n,m)):
            if i % n == 0 and i % m == 0:
                print(i)
                break
    except:
        break