牛客网华为算法练习题-Python编写

前段时间闲的无聊，就在牛客网用Python对华为算法练习题进行的编写，随便写写。

#HJ1 计算字符串最后一个单词的长度，单词以空格隔开。
"""
word = input("请输入单词，并以空格间断:")
new_word = word.split(' ')
print(len(new_word[-1]))
"""

#HJ2 写出一个程序，接受一个由字母和数字组成的字符串，和一个字符，然后输出输入字符串中含有该字符的个数。不区分大小写。
"""
str_word = "asdfwereqqwdc"
check_word = 'e'
sum_num = 0
for i in str_word:
    if check_word == i:
        sum_num+=1
print(sum_num)
"""

#HJ3 明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，他先用计算机生成了N个1到1000之间的随机整数（N≤1000），
#对于其中重复的数字，只保留一个，把其余相同的数去掉，不同的数对应着不同的学生的学号。然后再把这些数从小到大排序，按照排好的顺序去找同学做调查。
#请你协助明明完成“去重”与“排序”的工作(同一个测试用例里可能会有多组数据，希望大家能正确处理)。
"""
from random import choice
number_n = [i+1 for i in range(0,1000)]
number_p = [choice(number_n) for i in range(0,20)]
number_o = []
for i in number_p:
    if i not in number_o:
        number_o.append(i)
number_o.sort()
print(number_o)
"""


#HJ4 连续输入字符串，请按长度为8拆分每个字符串后输出到新的字符串数组； 长度不是8整数倍的字符串请在后面补数字0，空字符串不处理
"""
number_input = input("请输入字符串：")
if len(number_input) == 8:
    print(number_input)
elif len(number_input) < 8:
    print(number_input+'0'*(8-len(number_input)))
else:
    print(number_input[0:8])
    for i in number_input[8:]:
        print(i + '0' * (8 - len(i)))
"""


#HJ19 开发一个简单错误记录功能小模块，能够记录出错的代码所在的文件名称和行号。
"""
file_record = open(r'D:\Project\Exercise\华为练习\record.txt','r')
last_name = []
for i in file_record.readlines():
    ii = i.split('\\')[-1]
    last_name.append(ii)
last_name_set = []
[last_name_set.append(i) for i in last_name if i not in last_name_set]
for i in last_name_set:
    op = 0
    for j in last_name:
        print(i)
        print(j)
        if i == j:
            op +=1
    print(i[-16:]+' '+str(op))
"""

#HJ20 判断密码强度
"""
# 判断密码长度
def passwd_len(str):
    if len(str) > 8:
        return True
    else:
        return False

# 判断密码组成
def passwd_consist(str):
    digit, upper, lower, other = 0, 0, 0, 0
    for i in str:
        if i.isdigit():
            digit = 1
        elif i.isupper():
            upper = 1
        elif i.islower():
            lower = 1
        else:
            other = 1
    sum = digit + upper + lower + other

    if sum >= 3:
        return True
    else:
        return False

# 判断密码重复
def passwd_rep(str):
    # 一次拿出一个长度为3的子串，则只需循环len(str)-3次即可遍历完字符串
    for i in range(len(str) - 3):
        # 如果相同子串的数量大于1，即子串重复，返回False
        if str.count(str[i:i + 3]) > 1:
            return False
    return True


while True:
    s = input('请输入密码:')
    if s == 'q':
        break
    if passwd_len(s) and passwd_consist(s) and passwd_rep(s):
        print('OK')
    else:
        print('NG')
"""


#HJ21 密码是我们生活中非常重要的东东，我们的那么一点不能说的秘密就全靠它了。哇哈哈.接下来渊子要在密码之上再加一套密码，虽然简单但也安全。
#假设渊子原来一个BBS上的密码为zvbo9441987, 为了方便记忆，他通过一种算法把这个密码变换成YUANzhi1987，这个密码是他的名字和出生年份，
#怎么忘都忘不了，而且可以明目张胆地放在显眼的地方而不被别人知道真正的密码。
#他是这么变换的，大家都知道手机上的字母： 1 - -1， abc - -2,def --3, ghi - -4, jkl - -5, mno - -6, pqrs - -7, tuv - -8
#wxyz - -9, 0 - -0, 就这么简单，渊子把密码中出现的小写字母都变成对应的数字，数字和其他的符号都不做变换，
#声明：密码中没有空格，而密码中出现的大写字母则变成小写之后往后移一位，如：X，先变成小写，再往后移一位，不就是y了嘛，简单吧。记住，z往后移是a哦。
"""
zmu = 'abcdefghijklmnopqrstuvwxyz'
zmu_s = {'2':[97,98,99],'3':[100,101,102],'4':[103,104,105],'5':[106,107,108],'6':[109,110,111],'7':[112,113,114,115],'8':[116,117,118],'9':[119,120,121,122]}
key_word = input('请输入需要转换密码：')
nek_word = ''
for i in key_word:
    if  i == 'Z':
        nek_word = nek_word + 'a'
    elif i.isupper():
        nek_word = nek_word + str(chr(ord(i.lower()) + 1))
    elif i.islower():
        for h in zmu_s.keys():
            if ord(i) in zmu_s[h]:
                nek_word=nek_word+h
    else:
        nek_word = nek_word + i
print('初始密码为：'+nek_word)
"""

#HJ17 开发一个坐标计算工具， A表示向左移动，D表示向右移动，W表示向上移动，S表示向下移动。从（0,0）点开始移动，从输入字符串里面读取一些坐标，并将最终输入结果输出到输出文件里面
"""
x,y = 0,0
fx = ['A','D','W','S','a','d','w','s']
number = input('请输入坐标位置,以ADWS开头,两位数字结尾,坐标间以;隔开.如A12;S12:')
new_number = number.split(';')
for i in new_number:
    if i[0] in fx and len(i[1:]) == 2 and i[1:].isalnum():
        print(i)
        if i[0] == 'A' or i[0] == 'a':
            x+=-int(i[1:])
            #print(x)
        elif i[0] == 'D' or i[0] == 'd':
            x+=int(i[1:])
            #print(x)
        elif i[0] == 'W' or i[0] == 'w':
            y+=int(i[1:])
            #print(y)
        elif i[0] == 'S' or i[0] == 's':
            y += -int(i[1:])
            #print(y)
    else:
        continue
print(x,y)
"""

#HJ22 有这样一道智力题：“某商店规定：三个空汽水瓶可以换一瓶汽水。小张手上有十个空汽水瓶，她最多可以换多少瓶汽水喝？”答案是5瓶，方法如下：先用9个空瓶子换3瓶汽水，喝掉3瓶满的，
# 喝完以后4个空瓶子，用3个再换一瓶，喝掉这瓶满的，这时候剩2个空瓶子。然后你让老板先借给你一瓶汽水，喝掉这瓶满的，喝完以后用3个空瓶子换一瓶满的还给老板。如果小张手上有n个空汽水瓶，
# 最多可以换多少瓶汽水喝？
"""
empty_bottle = int(input("请输入空瓶数量:"))
drink = []
y=0
while empty_bottle >=3:
    # 获得商
    x = divmod(empty_bottle, 3)[0]
    # 获得余数
    y = divmod(empty_bottle, 3)[1]
    drink.append(x)
    empty_bottle = x + y
if  empty_bottle == 2:
    drink.append(1)
print(sum(drink))
"""

#HJ34 Lily上课时使用字母数字图片教小朋友们学习英语单词，每次都需要把这些图片按照大小（ASCII码值从小到大）排列收好。请大家给Lily帮忙，通过C语言解决
"""
import numpy as np
key_q = 'Ihave1nose2hands10fingers'
key_q_asc = []
key_q_last = ''
for i in key_q:
    if i.isalpha():
        key_q_asc.append(int(ord(i))) #将字母转化为数字
    elif i.isdigit():
        key_q_asc.append(i)
key_q_asc_arg = np.argsort(key_q_asc) #找到排序后的下标
for i in key_q_asc_arg:
    key_q_last+=key_q[i]
print(key_q_last)
"""


#HJ108 正整数A和正整数B 的最小公倍数是指 能被A和B整除的最小的正整数值，设计一个算法，求输入A和B的最小公倍数。
"""
def min_gb(a,b):
    number_min = 0
    while True:
        number_min +=1
        if number_min % a == 0 and number_min % b == 0:
            print('{}和{}的最小公倍数为:{}'.format(a,b,number_min))
            break
        else:
            continue
    pass
min_gb(5,1)
"""

#HJ63 一个DNA序列由A/C/G/T四个字母的排列组合组成。G和C的比例（定义为GC-Ratio）是序列中G和C两个字母的总的出现次数除以总的字母数目（也就是序列长度）。
# 在基因工程中，这个比例非常重要。因为高的GC-Ratio可能是基因的起始点。
#给定一个很长的DNA序列，以及要求的最小子序列长度，研究人员经常会需要在其中找出GC-Ratio最高的子序列
"""
dna_xl = 'AACTGTGCACGACCTGA'
number = int(input('输入查找字符串数:'))
dna_xl_dict = {}
for i in range(len(dna_xl)-number):
    cg_count = 0
    for j in dna_xl[i:i+number]:
        if j == 'C' or j == 'G':
            cg_count +=1
    dna_xl_dict[dna_xl[i:i+number]]=cg_count/len(dna_xl[i:i+number])
a = sorted(dna_xl_dict.items(),key=lambda x:x[1])
print(a[-1])
"""


#HJ60 任意一个偶数（大于2）都可以由2个素数组成，组成偶数的2个素数有很多种情况，本题目要求输出组成指定偶数的两个素数差值最小的素数对
"""
number = int(input('请输入一个大于2的偶数:'))
dict_s = {}
def sushu_check(x):
    for i in range(2,x):
        if (x%i) == 0:
            break
            return False
    else:
        return True
for j in range(1,number):
    result  =sushu_check(j)
    result_y = sushu_check(number-j)
    if result and result_y:
        if j < number-j:
            dict_s['[{},{}]'.format(j,number-j)] = abs(number-2*j)
        else:
            dict_s['[{},{}]'.format(number-j,j)] = abs(number-2*j)
a = sorted(dict_s.items(), key=lambda x: x[1])
print(a[0])
"""

#实现删除字符串中出现次数最少的字符，若多个字符出现次数一样，则都删除。输出删除这些单词后的字符串，字符串中其它字符保持原来的顺序。
#注意每个输入文件有多组输入，即多个字符串用回车隔开
"""
zfc = input('输入字符串,以空格分开:')
zfc_list = zfc.split(' ')
zfc_n = []
for z in zfc_list:
    time_z =[]
    zz = ''
    for i in z:
        time_z.append(z.count(i))
    for j in range(len(time_z)):
        if time_z[j] != sorted(time_z)[0]:
            zz+=z[j]
    zfc_n.append(zz)
print(zfc_n)
"""

#HJ84 找出给定字符串中大写字符(即'A'-'Z')的个数
"""
zfc = input('输入字符串:')
upper_count = 0
for i in zfc:
    if i.isupper():
        upper_count+=1
print('大写字母个数为:{}'.format(upper_count))
"""

#HJ 87密码按如下规则进行计分，并根据不同的得分为密码进行安全等级划分。
#一、密码长度:  5 分: 小于等于4 个字符  10 分: 5 到7 字符  25 分: 大于等于8 个字符
#二、字母:  0 分: 没有字母  10 分: 全都是小（大）写字母  20 分: 大小写混合字母
#三、数字:  0 分: 没有数字  10 分: 1 个数字  20 分: 大于1 个数字
#四、符号:  0 分: 没有符号  10 分: 1 个符号  25 分: 大于1 个符号
#五、奖励:  2 分: 字母和数字  3 分: 字母、数字和符号  5 分: 大小写字母、数字和符号
#最后的评分标准:  >= 90: 非常安全  >= 80: 安全（Secure） >= 70: 非常强  >= 60: 强（Strong）  >= 50: 一般（Average）  >= 25: 弱（Weak）  >= 0:  非常弱
"""
#密码长度判断
def lenth_check(str_check):
    if len(str_check) <= 4:
        return 5
    elif len(str_check) >= 8:
        return 25
    else:
        return 10
#密码字母判断
def zm_check(str_check):
    zm_count,upper_count,lower_count = 0,0,0
    for i in str_check:
        if i.isalpha():
            zm_count+=1
            if i.isupper():
                upper_count+=1
            else:
                lower_count+=1
    if zm_count == 0:
        return  0
    elif zm_count == upper_count or zm_count == lower_count:
        return 10
    elif zm_count>0 and upper_count> 0 and lower_count>0:
        return 20
#密码数字判断
def digit_check(str_check):
    digit_count = 0
    for i in str_check:
        if i.isdigit():
            digit_count +=1
    if digit_count == 0:
        return 0
    elif digit_count == 1:
        return 10
    else:
        return 20
#密码符号判断
def fh_check(str_check):
    string_fh= "~!@#$%^&*()_+-*/<>,.[]\/"
    fh_count = 0
    for i in str_check:
        if i in string_fh:
            fh_count+=1
    if fh_count == 0:
        return 0
    elif fh_count == 1:
        return 10
    else:
        return 20
#密码奖励判断
def jl_check(str_check):
    zm_fs = zm_check(str_check)
    digit_fs = digit_check(str_check)
    fh_fs = fh_check(str_check)
    if zm_fs == 10 and digit_fs >0 and fh_fs == 0:
        return 2
    elif zm_fs == 10 and digit_fs >0 and fh_fs >0:
        return 3
    elif zm_fs == 20 and digit_fs >0 and fh_fs >0:
        return 5
    else:
        return 0
#评分标准
def pf_st(str_check):
    lenth_fs = lenth_check(str_check)
    #print(lenth_fs)
    zm_fs = zm_check(str_check)
    #print(zm_fs)
    digit_fs = digit_check(str_check)
    #print(digit_fs)
    fh_fs = fh_check(str_check)
    #print(fh_fs)
    jl_fs = jl_check(str_check)
    #print(jl_fs)
    sum_fs = lenth_fs+zm_fs+digit_fs+fh_fs+jl_fs

    if sum_fs >= 70:
        if sum_fs >=90:
            print('VERY_SECURE')
        elif sum_fs >=80:
            print('SECURE')
        else:
            print('VERY_STRONG')
    elif sum_fs <= 60:
        if sum_fs ==0:
            print('VERY_WEAK')
        elif sum_fs <= 25:
            print('WEAK')
        elif sum_fs <=50:
            print('AVERAGE')
        else:
            print('STRONG')
if __name__ == '__main__':
    mm = input('输入密码:')
    pf_st(mm)
"""

#HJ81 题目标题：判断短字符串中的所有字符是否在长字符串中全部出现
"""
zfc = input('输入两个字符串,以空格隔开:')
zfc_list = zfc.split(' ')
if len(zfc_list[0]) > len(zfc_list[1]):
    max_zfc = zfc_list[0]
    min_zfc = zfc_list[1]
else:
    max_zfc = zfc_list[1]
    min_zfc = zfc_list[0]
if max_zfc.count(min_zfc)>0:
    print('true')
"""



"""
number = input().split('.')
if int(number[-1][0]) >= 5:
    print(int(number[0])+1)
else:
    print(number[0])
"""

"""
number = input()
new_number = ''
for i in range(len(number)-1,-1,-1):
    if number[i] not in new_number:
        new_number+=number[i]
print(new_number)
"""
"""
n = int(input('请输入要转换进制的数值：'))
# x = 2  # 转换为二进制，所以这里取x=2
b = []  # 存储余数
while True:  # 一直循环，商为0时利用break退出循环
    s = n // 2  # 商
    y = n % 2  # 余数
    b = b + [y]  # 每一个余数存储到b中
    print(b)
    if s == 0:
        break  # 余数为0时结束循环
    n = s
b.reverse()  # 使b中的元素反向排列
b = [str(i) for i in b ]
b = ['0b'] + b
print('该数字转换为二进制后是：')
print(''.join(b))
"""


empty_bottles = []
number = int(input())#输入行数
t = 1
while t <=3:
    empty_bottles.append(int(input()))
    t +=1
for empty_bottle in empty_bottles:
    drink = []
    empty_bottle = int(empty_bottle)
    y=0
    while empty_bottle >=3:
        # 获得商
        x = divmod(empty_bottle, 3)[0]
        # 获得余数
        y = divmod(empty_bottle, 3)[1]
        drink.append(x)
        empty_bottle = x + y
    if  empty_bottle == 2:
        drink.append(1)
    print(sum(drink),end='\n')