【华为机考题库学习】--算法篇(更新中……)

系列文章目录

---

前言

一、HJ1 字符串最后一个单词的长度

HJ1直击链接

描述：计算字符串最后一个单词的长度，单词以空格隔开，字符串长度小于5000。（注：字符串末尾不以空格为结尾）

input_str = input()
word = input_str.strip().split(' ')
print(len(word[-1]))

分析总结：

1. strip()
   strip()方法用于移除字符串头尾指定的字符(默认为空格或换行符)或字符序列，注意，该方法只能删除开头或结尾的字符，不能删除中间部分字符；

str.strip([chars])

参数	chars – 移除字符串头尾指定的字符序列。
返回值	返回移除字符串头尾指定的字符生成的新字符串。

2. split()

split()：拆分字符串。通过指定分隔符对字符串进行切片，并返回分割后的字符串列表(list)。
os.path.split()：按照路径将文件名和路径分割开。

str.split(str="",num=string.count(str))[n]
os.path.split('PATH')

参数说明：

• str：表示分隔符，默认为空格，但不能为空；若字符串中没有分割符，则把整个字符串作为列表的一个元素；
• num：表示分割次数，如果存在参数num，则分割成num+1个字符串，并且每一个字符串可以赋给新的变量；
• [n]：表示选取的第n个分片；
• PATH指一个文件的全路径作为参数，如果给出的是一个目录和文件名，则输出路径和文件名；如果给出的是一个目录名，则输出路径和空文件名；

3. len()
   如果我们想要知道一段字符串中有多少字符，或占多少个字节，我们可以使用len()函数

len(String)

二、HJ2 计算某字符出现的次数

HJ2 直击链接

描述：写出一个程序，接受一个由字母、数字和空格组成的字符串，和一个字符，然后输出输入字符串中该字符的出现次数。（不区分大小写字母）

input_str = input().lower()
char = input().lower()
print(input_str.count(char))

分析总结：

1. lower()
   将字符串中的所有大写字母转换为小写字母 ；

注意：lower()方法只对ASCLL编码，即’A-Z’有效，对于其它语言中把大写转换为小写的情况无效，只能使用casefold()函数；

三、HJ3 明明的随机数

HJ3 直击链接

描述：明明生成了NN个1到500之间的随机整数。请你删去其中重复的数字，即相同的数字只保留一个，把其余相同的数去掉，然后再把这些数从小到大排序，按照排好的顺序输出。

while True:
    try:
        line_num,num = int(input()),set()
        for i in range(line_num):
            num.add(int(input()))
        for j in sorted(list(num)):
            print(j)
    except:
        break

分析总结：

1. set()
   集合set是一个无序不重复序列，可以使用大括号{}或set()函数创建集合。

注意：创建一个空集合必须使用set()不能是大括号{}，因为{}是用来创建一个空字典；

2. sorted()
   sorted()函数：返回一个排序后的新序列，不改变原始序列；

sorted(iterable,*,key = None,reverse = False)

参数说明

• iterable：是可迭代的对象，从可迭代的项中返回一个新的排序列表。
• key：指定一个参数的函数，该函数会在每个元素排序前被调用，如key=abs，按绝对值大小排序；key指定的函数将作用于list的每一个元素上，并根据key指定的函数返回的结果进行排序；
• reverse：用来指定正向还是反向排序；如反向排序reverse=True;

四、HJ4 字符串分隔

HJ4 直击链接

描述：
输入一个字符串，请按长度为8拆分每个输入字符串并进行输出；
长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。

while True:
    try:
        input_str = input()
        while len(input_str)>8:
            print(input_str[:8])
            input_str=input_str[8:]
        print(input_str.ljust(8,"0"))
    except:
        break

分析总结：

1. str[:8]

python中的[1:]、[:-1]、[::-1]

解释：

• [1:]：获取从位置1开始后面的字符(默认首位为0)
• [:-1]：删除位置为-1的字符(也就是获取从位置0到位置-1之间的字符)
• [-1:]：获取位置-1的字符
• [::-1]：从最后一个元素到第一个元素复制一遍(也就是倒序)
• [:]：相当于完整复制一份str

str = 'asdkfasjdljlsdaslj'
while len(str)>8:
    print(str[:8])
    str = str[8:]
print(str.ljust(8,"0"))

2. ljust()

python字符串对齐方法，ljust()、rjust()、和center()；

ljust()方法的功能是向指定字符串的右侧填充指定字符，从而达到左对齐的目的；

str.ljust(width[,fillchar])

• str：表示要填充的字符串；
• width：表示包括str本身长度在内，字符串要占的总长度；
• fillchar：作为可选参数，用来指定填充字符串时所用的字符，默认为空格；

五、HJ5 进制转换

HJ5 直击链接

描述：

写出一个程序，接受一个十六进制的数，输出该数值的十进制表示

print(int(input(),base=16))

分析总结：

1. 进制转换

1、转2进制:bin
bin(int('ff',16))  #先转成10进制，再转成2进制
2、转8进制：oct
oct(0xf) #任何进制可以直接转8进制
3、转16进制：hex
hex(int('17',8)) #先转成10进制，再转成16进制

六、HJ6 质数因子

HJ6 直击链接

描述：

功能:输入一个正整数，按照从小到大的顺序输出它的所有质因子（重复的也要列举）（如180的质因子为2 2 3 3 5 ）

num = int(input())
def func(num):
    prime_num = 1
    for i in range(2,int(num**0.5+2)):
        if num%i == 0:
            prime_num = 0
            b = int(num/i)
            print(str(i),end=' ')
            func(b)
            break
    if prime_num == 1:
        print(str(num),end = ' ')
func(num)

分析总结：

1. range()
   range()函数可创建一个整数列表，一般用在for循环中；

range(start,stop[,step])

参数说明：

• start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
• stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
• step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)

七、HJ7 取近似值

HJ7 直击链接

描述：

写出一个程序，接受一个正浮点数值，输出该数值的近似整数值。如果小数点后数值大于等于 0.5 ,向上取整；小于 0.5 ，则向下取整。

num = float(input())
print(int(num) + 1 if num%1 >=0.5 else int(num))

八、HJ8 合并表记录

HJ8 直击链接

描述：

数据表记录包含表索引index和数值value（int范围的正整数），请对表索引相同的记录进行合并，即将相同索引的数值进行求和运算，输出按照index值升序进行输出。

b = {}
a = int(input())
c = set()
for i in range(a):
    contents = input().split(" ")
    key = int(contents[0])
    value = int(contents[1])
    if key not in c:
        c.add(key)
        b[key] = value
    else:
        b[key] = b[key] +value
result = sorted(b.keys(),reverse=False)
for key in result:
    print(key,b[key])

九、HJ9 提取不重复的整数

HJ9 直击链接

描述：
输入一个 int 型整数，按照从右向左的阅读顺序，返回一个不含重复数字的新的整数。保证输入的整数最后一位不是 0 。

num1 = input()
num1 = num1[::-1]
num2 = ''
for i in num1:
    if i not in num2:
        num2 = num2 + i
print(num2)

分析总结：

num = 'xzbdrswzmdwr'
print(num[::-1]) #倒序
#result:rwdmzwsrdbzx

十、HJ10 字符个数统计

HJ10 直击链接

描述：

编写一个函数，计算字符串中含有的不同字符的个数。字符在 ASCII 码范围内( 0~127 ，包括 0 和 127 )，换行表示结束符，不算在字符里。不在范围内的不作统计。多个相同的字符只计算一次

import sys
a = sys.stdin.readline().strip()

words = ''
for i in a:
    if i not in words and ord(i)>=0 and ord(i)<=127:
        words += i
print(len(words))

分析总结：

1、sys.stdin.readline()

之前在python中输入都是使用input()，但是后面大家都在使用sys.stdin.readline()；python3中，sys.stdin.readline()可以实现标准输入，需要调用sys库，sys.stdin是一个标准化输入的方法，其中默认输入的格式是字符串，如果是int,float类型则需要强制转换；

• n = int(sys.stdin.readline().strip(‘\n’)) #strip(‘\n’)表示以\n分隔，否则输出是“字符串+\n”的形式
• sn = sys.stdin.readline().strip()#若是多输入，strip()默认是以空格分隔，返回一个包含多个字符串的list。
• sn = list(map(int,sn.split())) #如果要强制转换成int等类型，可以调用map()函数。

注意默认输入的是字符串（注意这里的strip(‘\n’)表示以\n分隔，否则输出是“字符串+\n”的形式 ）,如果是多个输入，strip()默认是以空格分隔，返回的是一个包含多个字符串的list，如果要强制转换成int等类型，可以调用map()函数。

提示：sys.stdin.readline( )会将标准输入全部获取，包括末尾的’\n’，input()会把‘\n’忽略.

python3中sys.stdin与input的区别

input()方法和stdin()类似，不同的是input()括号内可以直接填写说明文字。

2、ord()

ord()函数是python中的一个库函数，用于从给定字符值中获取数字值；以一个字符串(Unicode字符)作为参数，返回对应的ASCLL数值，与chr()函数相反；

print(ord('a'))  #97
print(chr(97))  #4

十一、HJ11 数字颠倒

HJ11 直击链接

描述：
输入一个整数，将这个整数以字符串的形式逆序输出
程序不考虑负数的情况，若数字含有0，则逆序形式也含有0，如输入为100，则输出为001

import sys
num = sys.stdin.readline()
str(num)
print(num[::-1])

十二、HJ12 字符串反转

HJ12 直击链接

描述：

接受一个只包含小写字母的字符串，然后输出该字符串反转后的字符串。（字符串长度不超过1000）

def backword(str1):
    slen = len(str1)
    sstr = ""
    for i in range(slen):
        sstr = sstr + str1[slen-i-1]
    return sstr
input_str = input()
if input_str.isalpha() and input_str.islower():
    print(backword(input_str))

分析总结：

• isalpha() 判断是不是字母
• islower() 判断是不是小写

十三、HJ13 句子逆序

HJ13 直击链接

描述：

将一个英文语句以单词为单位逆序排放。例如“I am a boy”，逆序排放后为“boy a am I”

所有单词之间用一个空格隔开，语句中除了英文字母外，不再包含其他字符

def func():
    try:
        sentence_list = input().strip().split(' ')
        sentence_list.reverse()
        print(' '.join(sentence_list))
    except:
        pass
if __name__=='__main__':
    func()

输入：I am a boy
输出：boy a am I

十四、HJ14 字符串排序

HJ14 直击链接

描述：

给定 n 个字符串，请对 n 个字符串按照字典序排列。

import sys
num = int(sys.stdin.readline().strip())
ll=list()
for i in range(num):
    ll.append(sys.stdin.readline().strip())
ll.sort(key=str)
for item in ll:
    print(item)

输入：
9
cap
to
cat
card
two
too
up
boat
boot
输出：
boat
boot
cap
card
cat
to
too
two
up

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

HJ15 直击链接

描述：

输入一个 int 型的正整数，计算出该 int 型数据在内存中存储时 1 的个数。

print(bin(int(input())).count('1'))

输入：5
输出：2

十六、HJ16 购物单

十七、HJ17 坐标移动

HJ17 直击链接

描述：
开发一个坐标计算工具， A表示向左移动，D表示向右移动，W表示向上移动，S表示向下移动。从（0,0）点开始移动，从输入字符串里面读取一些坐标，并将最终输入结果输出到输出文件里面。

string = input()
str_list = string.split(';')
d = {}
for item in str_list:
    if len(item) > 1 and item[0] in list('ADSW') and item[1:].isdecimal():
        d[item[0]] = d.get(item[0],0) + int(item[1:])
x,y = (d['D']-d['A']),(d['W']-d['S'])
print('%d,%d'%(x,y))

输入：A10;S20;W10;D30;X;A1A;B10A11;;A10;
输出：10,-10

分析总结：

• d = {} #空字典
• isdecimal() :是python中内置方法，用于检查字符串是否仅包含十进制字符，十进制字符包含从0到9的所有数字；
• d.get()：

1、d.get(‘key’,value):如果字典中存在关键字key，则返回关键字对应的值；如果字典中不存在关键字，则返回value的值，一般默认为None，也可返回指定value的值；

2、get()函数利用键来获取值

print(dict[key])

但是这种方法当字典中不存在该键时会返回keyError类型错误，此时可以用get()函数获取值

print(dict.get(key))

利用get()函数操作时 ，当字典中不存在输入的键时会返回一个None；

3、利用字典统计列表中元素出现的次数

str_list = ['A10','W20','A10']
d = {}
for i in str_list:
    d[i] = d.get(i,0) + 1

    #赋值语句代码等价于
    #d[i] = 0
    #d[i] = d[i] + 1

print(d) #{'A10': 2, 'W20': 1}

get()函数在这里有两个参数，第一个是确定要分配值的键，第二个是拟定给键分配的一个初值，但实际要给键赋值仍需get赋值语句，比如说我们现在添加这个语句到代码中：

d.get('W20',10)

拟定初值语句本身对结果是没有影响的，因为并没有实际的对键进行语句操作；
注：get()函数作为键赋值语句（非拟定赋值语句）时只有第一次是有效的，比如get()函数在第一次对’A10’这个键使用get赋值语句后下次再使用get赋值语句时，键的值仍为第一次赋值运算后的结果；

str_list = ['A10','W20','A10']
d = {}
for i in str_list:
    d[i] = d.get(i,0) + 1 
    '''
    赋值语句代码等价于
    d[i] = 0
    d[i] = d[i] + 1
    '''
d['A10'] = d.get('A10',10) #功能同前一条代码执行到第二次时的
print(d)  #{'A10': 2, 'W20': 1}

d[i] = d.get(i,0)+1,这行代码从逻辑上讲执行了两次；
第一次：d[i] = d.get(i,0)+1 这里：i=‘A10’
此时get语句的功能为赋初值，即把键’A10’的初值置为0然后加1
第二次：d[i] = d.get(i,0)+1 这里：i=‘A10’
因为get语句已经作为赋值语句出现过一次了，因此此时再执行这条语句时，赋值功能已经无效了，也就是get语句里第二个参数对’A10’这个键已经无效了，此时get语句的功能可等价为：

d[i] = d.get(i)+1

输出结果和之前的一样；

十八、HJ18 识别有效的IP地址和掩码并进行分类统计

十九、HJ19 简单错误记录

二十、HJ20 密码验证合格程序

HJ20 直击链接

描述：
密码要求:
1.长度超过8位
2.包括大小写字母.数字.其它符号,以上四种至少三种
3.不能有长度大于2的包含公共元素的子串重复 （注：其他符号不含空格或换行）

while True:
    try:
        line = input()
        a = 0
        b = 0
        c = 0
        d = 0
        flag = True
        for i in line:
            if i.isdigit():
                a = 1
            elif i.islower():
                b = 1
            elif i.isupper():
                c = 1
            else:
                d = 1
        for j in range(len(line)-3):
            if line.count(line[j:j+3])>1:
                flag=False
        if len(line)>8 and (a+b+c+d)>=3 and flag:
            print("OK")
        else:
            print("NG")
    except:
        break

输入：dfsgsfsdfs
输出：NG
输入：021Abc9000
输出：OK
输入：021Abc9Abc1
输出：NG
输入：021ABC9000
输出：NG
输入：021$bc9000
输出：OK

分析总结：

• flag：这个变量名常常用于命名旗标变量或哨兵变量，这种变量的作用体现在帮助进行条件判断中，常常使用Int类型变量中的0、1或布尔类型变量中的false(0)、true(1)来表示。
• s为字符串
  s.isalnum() 所有字符都是数字或者字母
  s.isalpha() 所有字符都是字母
  s.isdigit() 所有字符都是数字
  s.islower() 所有字符都是小写
  s.isupper() 所有字符都是大写
  s.istitle() 所有单词都是首字母大写，像标题
  s.isspace() 所有字符都是空白字符、\t、\n、\r

二十一、HJ21 简单密码

HJ21 直击链接

现在有一种密码变换算法。
1、九键手机键盘上的数字与字母的对应： 1–1， abc–2, def–3, ghi–4, jkl–5, mno–6, pqrs–7, tuv–8 wxyz–9, 0–0，把密码中出现的小写字母都变成九键键盘对应的数字，如：a 变成 2，x 变成 9.
2、而密码中出现的大写字母则变成小写之后往后移一位，如：X ，先变成小写，再往后移一位，变成了 y ，例外：Z 往后移是 a 。
3、数字和其它的符号都不做变换。

while True:
    e = []
    try:
        s = list(input())
        for i in s:
            if i >="A" and i <="Z":
                t = chr((ord(i)+33))
                if t>'z':
                    t='a'
                e.append(t)
            elif i>="a" and i <="c":
                 e.append('2')
            elif i>="d" and i <="f":
                 e.append('3')
            elif i>="g" and i <="i":
                 e.append('4')
            elif i>="j" and i <="l":
                 e.append('5')
            elif i>="m" and i <="o":
                 e.append('6')
            elif i>="p" and i <="s":
                 e.append('7')
            elif i>="t" and i <="v":
                 e.append('8')
            elif i>="w" and i <="z":
                 e.append('9')
            else:
                e.append(i)
        print("".join(e))
    except:
        break

输入：YUANzhi1987
输出：zvbo9441987

二十二、HJ22 汽水瓶

HJ22 直击链接

描述：
某商店规定：三个空汽水瓶可以换一瓶汽水，允许向老板借空汽水瓶（但是必须要归还）。
小张手上有n个空汽水瓶，她想知道自己最多可以喝到多少瓶汽水。

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

输入：3
输出：1
输入：10
输出：5
输入：81
输出：40

分析总结：

• //
  在python中‘/’表示浮点整除法，返回浮点结果，也就是结果为浮点数；而’//'表示整数除法，返回大于结果的一个最大的整数，意思是向下取整；

二十三、HJ23 删除字符中出现次数最少的字符

HJ23 直击链接

描述：
实现删除字符串中出现次数最少的字符，若出现次数最少的字符有多个，则把出现次数最少的字符都删除。输出删除这些单词后的字符串，字符串中其它字符保持原来的顺序。

while True:
    try:
        a = list(input())
        b = list(set(a))
        c = []
        for i in b:
            c.append(a.count(i))
        for i in range(len(c)):
            if c[i] == min(c):
                while b[i] in a:a.remove(b[i])
        print("".join(a))
    except:
        break

输入：aabcddd
输出：aaddd

二十四、HJ24 合唱队

二十五、HJ25 数据分类处理

二十六、HJ26 字符串排序

HJ26 直击链接

描述：

编写一个程序，将输入字符串中的字符按如下规则排序。
规则 1 ：英文字母从 A 到 Z 排列，不区分大小写。
如，输入： Type 输出： epTy
规则 2 ：同一个英文字母的大小写同时存在时，按照输入顺序排列。
如，输入： BabA 输出： aABb
规则 3 ：非英文字母的其它字符保持原来的位置。
如，输入： By?e 输出： Be?y

while True:
    try:
        a=input()
        #构造两个列表，一个列表用来放全字母的字符串2，另外一个列表取出来
        char=[] #构造一个列表用来存放字符串
        res=[False]*len(a)#构造一个列表用来记住非字母的位置
        for i,v in enumerate(a):
            if v.isalpha(): #如果全是字母则放入char中
                char.append(v)
            else:
                res[i]=v
        #然后对char进行排序
        char.sort(key=lambda c:c.lower())
        #重构,在res中的false项中放入char
        for i,v in enumerate(res):
            if not v:
                res[i]=char[0]
                char.pop(0)
        print(''.join(res))        
    except:
        break

输入：A Famous Saying: Much Ado About Nothing (2012/8).
输出：A aaAAbc dFgghh: iimM nNn oooos Sttuuuy (2012/8).
输入：jdfakksjdgaskdlf
输出：aadddffgjjkkklss

分析总结：

• enumerate()：是python的内置函数，在字典上是枚举，列举的意思；enumerate参数可遍历/可迭代的对象如列表，字符串；多用于for循环中得到计数，利用它可同时获得索引和值，即需要的index和value值；

示例1：

a = [1,2,3,4,5]
for index,value in enumerate(a):
	print('%s,%s'%(index,value))

0,1
1,2
2,3
3,4
4,5

示例2：指定索引从1开始

a = [1,2,3,4,5]
for index,value in enumerate(a,1):
	print('%s,%s'%(index,value))

1,1
2,2
3,3
4,4
5,5

补充：如果要统计文件的行数，可以用

count = len(open(filepath,'r').readlines())

这种方法简单，但比较慢，文件过大不能工作；可以用：

count = 0
for index,line in enumerate(open(filepath,'r')):
	count += 1

• pop()

列表list.pop(obj=list[-1])
pop()用于删除并返回列表中的一个元素（默认为最后一个元素）
备注：obj：要删除并返回的列表元素

字典dict.pop(key[,default])
pop()用于删除字典中给定的key及对应的value，返回被删除key对应的value，key值必须给出。给定的key值不在字典中时，返回default值。
备注：
1）key:需要删除的key值（不给出会报错）
2）default:若没有字典中key值，返回default值（给定的key值不在字典中时必须设置，否则会报错）

二十七、HJ27 查找兄弟单词

HJ27 直击链接

描述：
定义一个单词的“兄弟单词”为：交换该单词字母顺序（注：可以交换任意次），而不添加、删除、修改原有的字母就能生成的单词。
兄弟单词要求和原来的单词不同。例如： ab 和 ba 是兄弟单词。 ab 和 ab 则不是兄弟单词。
现在给定你 n 个单词，另外再给你一个单词 x ，让你寻找 x 的兄弟单词里，按字典序排列后的第 k 个单词是什么？
注意：字典中可能有重复单词。

while True:
    try:
        ss = input().split()
        n = int(ss[0])
        dict = ss[1:n+1]
        s = ss[-2]
        m = int(ss[-1])
        a = []
        for i in dict:
            if len(i) == len(s) and i != s and sorted(i) == sorted(s):
                a.append(i)
        print(len(a))
        if a and m <= len(a):
            print(sorted(a)[m-1])
    except:
        break

输入：3 abc bca cab abc 1
输出：
2
bca

二十八、HJ28 素数伴侣

二十九、HJ29 字符串加解密

HJ29 直击链接

描述：

对输入的字符串进行加解密，并输出。
加密方法为：
当内容是英文字母时则用该英文字母的后一个字母替换，同时字母变换大小写,如字母a时则替换为B；字母Z时则替换为a；
当内容是数字时则把该数字加1，如0替换1，1替换2，9替换0；
其他字符不做变化。
解密方法为加密的逆过程。

while True:
    try:
        a = input()
        b = input()
        m = []
        n = []
        for c in a:
            c = str(c)
            if c == 'Z':
                c = 'a'
            elif c == 'z':
                c = 'A'
            elif c.islower():
                c = chr(ord(c)+1).upper()
            elif c.isupper():
                c = chr(ord(c)+1).lower()
            elif c == '9':
                c = '0'
            elif c.isdigit():
                c = str(int(c) + 1)
            m.append(c)
        print(''.join(m))
        for c in b:
            c = str(c)
            if c == 'a':
                c = 'Z'
            elif c == 'A':
                c = 'z'
            elif c.islower():
                c = chr(ord(c.upper())-1)
            elif c.isupper():
                c = chr(ord(c.lower())-1)
            elif c == '0':
                c = '9'
            elif c.isdigit():
                c = str(int(c) - 1)
            n.append(c)
        print(''.join(n))
    except:
        break

输入：
abcdefg
BCDEFGH
输出：
BCDEFGH
abcdefg
输入：
askdfjla123
fjaldja444
输出：
BTLEGKMB234
EIZKCIZ333

三十、HJ30 字符串合并处理

三十一、HJ31 字符串合并处理

HJ31 直击链接

描述：
对字符串中的所有单词进行倒排。
说明：
1、构成单词的字符只有26个大写或小写英文字母；
2、非构成单词的字符均视为单词间隔符；
3、要求倒排后的单词间隔符以一个空格表示；如果原字符串中相邻单词间有多个间隔符时，倒排转换后也只允许出现一个空格间隔符；
4、每个单词最长20个字母；

while True:
    try:
        out_arr = []
        in_arr = input()
        for i in in_arr:
            if not i.isalpha():
                in_arr = in_arr.replace(i,' ')
        for j in in_arr.split():
            out_arr.append(j)
        print(" ".join(out_arr[::-1]))
    except:
        break

输入：I am a boy
输出：boy a am I

三十二、HJ32 密码截取

HJ32 直击链接

描述：
Catcher是MCA国的情报员，他工作时发现敌国会用一些对称的密码进行通信，比如像这些ABBA，ABA，A，123321，但是他们有时会在开始或结束时加入一些无关的字符以防止别国破解。比如进行下列变化 ABBA->12ABBA,ABA->ABAKK,123321->51233214　。因为截获的串太长了，而且存在多种可能的情况（abaaab可看作是aba,或baaab的加密形式），Cathcer的工作量实在是太大了，他只能向电脑高手求助，你能帮Catcher找出最长的有效密码串吗？

while True:
    try:
        s = input()
        n = len(s)
        single_center, double_center = [1]*n, [0]*n
        for i in range(1,n):
            j = 0
            while j < min(i, n-i-1):
                j += 1
                if s[i-j]==s[i+j]:
                    single_center[i] += 2
                else:
                    break
        for i in range(1,n-1):
            j = 0
            flag = True
            while j < min(i, n-i-2):
                j += 1
                if s[i] == s[i+1]:
                    if flag:
                        double_center[i] = 2
                        flag = False
                    if s[i-j] == s[i+1+j]:
                        double_center[i] += 2
                    else:
                        break
                else:
                    break
        print(max(max(single_center), max(double_center)))
    except:
        break

三十三、HJ33 整数与IP地址间的转换

HJ33 直击链接

描述：

原理：ip地址的每段可以看成是一个0-255的整数，把每段拆分成一个二进制形式组合起来，然后把这个二进制数转变成
一个长整数。

while True:
    try:
        a=list(map(int,input().split('.')))
        b=int(input())
        c=''
        for i in a:
            s=bin(i)[2:]
            while (len(s)<8):
                s='0'+s
            c += s
        print(int(c,2))
        b=bin(b)[2:]
        while (len(b)<32):
            b= '0'+b
        print(str(int(b[0:8],2))+'.'+str(int(b[8:16],2))+'.'+str(int(b[16:24],2))+'.'+str(int(b[24:32],2)))
    except:
        break

输入：
10.0.3.193
167969729
输出：
167773121
10.3.3.193

三十四、HJ34 图片整理

HJ34 直击链接

描述：

Lily上课时使用字母数字图片教小朋友们学习英语单词，每次都需要把这些图片按照大小（ASCII码值从小到大）排列收好。请大家给Lily帮忙，通过代码解决。
Lily使用的图片使用字符"A"到"Z"、“a"到"z”、"0"到"9"表示。

while True:
    try:
        print(''.join(sorted(input())))
    except:
        break

输入：Ihave1nose2hands10fingers
输出：0112Iaadeeefghhinnnorsssv

三十五、HJ35 蛇形矩阵

HJ35 直击链接

描述：

蛇形矩阵是由1开始的自然数依次排列成的一个矩阵上三角形。

例如，当输入5时，应该输出的三角形为：

1 3 6 10 15
2 5 9 14
4 8 13
7 12
11

while True:
    try:
        num = int(input())
        for i in range(num):
            if i == 0:
                res = [(x+2)*(x+1)//2 for x in range(num)]
            else:
                res = [x - 1 for x in res[1:]]
            print(' '.join(map(str,res)))
    except:
        break

输入：4
输出：
1 3 6 10
2 5 9
4 8
7

三十六、HJ36 字符串加密

HJ36 字符串加密

描述：
有一种技巧可以对数据进行加密，它使用一个单词作为它的密匙。下面是它的工作原理：首先，选择一个单词作为密匙，如TRAILBLAZERS。如果单词中包含有重复的字母，只保留第1个，将所得结果作为新字母表开头，并将新建立的字母表中未出现的字母按照正常字母表顺序加入新字母表。如下所示：
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
T R A I L B Z E S C D F G H J K M N O P Q U V W X Y (实际需建立小写字母的字母表，此字母表仅为方便演示）
上面其他用字母表中剩余的字母填充完整。在对信息进行加密时，信息中的每个字母被固定于顶上那行，并用下面那行的对应字母一一取代原文的字母(字母字符的大小写状态应该保留)。因此，使用这个密匙， Attack AT DAWN (黎明时攻击)就会被加密为Tpptad TP ITVH。
请实现下述接口，通过指定的密匙和明文得到密文。

while True:
    try:
        s = str(input().strip())
        jiami = str(input().strip())
        new_key = ''
        for i in s:
            if i.lower() not in new_key:
                new_key += i
        std = 'abcdefghijklmnopqrstuvwxyz'
        old = ''
        for i in std:
            if i not in new_key:
                old += i
        new_s = new_key + old
        dic = {}
        for i,j in zip(std,new_s):
            dic[i] = j
        res = ''
        for i in jiami:
            if i.islower():
                res += dic[i]
            elif i.isupper():
                res += str(dic[o]).upper()
            else:
                res += i
        print(res)
    except:
        break

输入：
nihao
ni
输出：
le

三十七、HJ37 统计每个月兔子的总数

HJ37 直击链接

描述：

有一种兔子，从出生后第3个月起每个月都生一只兔子，小兔子长到第三个月后每个月又生一只兔子。
例子：假设一只兔子第3个月出生，那么它第5个月开始会每个月生一只兔子。
一月的时候有一只兔子，假如兔子都不死，问第n个月的兔子总数为多少？

while True:
    try:
        n = int(input())
        num = 0
        num1 = 0
        num2 = 0
        for i in range(n):
            num += num2
            num2 = num1
            if num==0 and num2 == 0:
                num1 = 1
            elif num==0 and num2 == 1:
                num1 = 0
            else:
                num1 = num
        print(num+num1+num2)
         
    except:
        break

输入：3
输出：2

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

HJ38 直击链接

描述：

假设一个球从任意高度自由落下，每次落地后反跳回原高度的一半; 再落下, 求它在第5次落地时，共经历多少米?第5次反弹多高？

while 1:
    try:
        num = int(input())
        print(num*2.875)
        print((num/32))
    except:
        break

输入：1
输出：
2.875
0.03125

三十九、HJ39 判断两个IP是否属于同一子网

HJ39 直击链接

四十、HJ40 统计字符

HJ40 直击链接

描述：
输入一行字符，分别统计出包含英文字母、空格、数字和其它字符的个数。

while True:
    try:
        sentence = input()
        word, space, digit, other = 0, 0, 0, 0
        for i in sentence:
            if i.isalpha():
                word += 1
            elif i == ' ':
                space += 1
            elif i.isdigit():
                digit += 1
            else:
                other += 1
        print(word)
        print(space)
        print(digit)
        print(other)
    except:
        break

输入：1qazxsw23 edcvfr45tgbn hy67uj m,ki89ol.\\/;p0-=\\][
输出：
26
3
10
12

四十一、HJ41 称砝码

HJ41 直击链接

描述：
现有n种砝码，重量互不相等，分别为 m1,m2,m3…mn ；
每种砝码对应的数量为 x1,x2,x3…xn 。现在要用这些砝码去称物体的重量(放在同一侧)，问能称出多少种不同的重量。
注：
称重重量包括 0

四十二、HJ42 学英语

四十三、HJ43 迷宫问题

HJ43 直击链接

四十四、HJ44 Sudoku

四十五、HJ45 名字的漂亮度

HJ45 直击链接

描述：

给出一个字符串，该字符串仅由小写字母组成，定义这个字符串的“漂亮度”是其所有字母“漂亮度”的总和。
每个字母都有一个“漂亮度”，范围在1到26之间。没有任何两个不同字母拥有相同的“漂亮度”。字母忽略大小写。

给出多个字符串，计算每个字符串最大可能的“漂亮度”。

while True:
    try:
        a = int(input())
        s = []
        for i in range(0,a):
            s.append(input().lower())
        for each in s:
            sum1 = 0
            c = 26
            count = []
            for i in list(set(each)):
                count.append(each.count(i))
                count = sorted(count,reverse=1)
            for i in count:
                sum1 +=int(i)*c
                c -=1
            print(sum1)
    except:
        break

输入：
2
ruozhu
qingcheng
输出：
146
212

四十六、HJ46 截取字符串

HJ46 直击链接

描述：
输入一个字符串和一个整数K，截取字符串的前k个字符并输出

while True:
    try:
        s,n = input().split()
        n = int(n)
        if s[n-1].isalpha():
            print(s[:n])
        else:
            print(s[:n-1])
    except:
        break

输入：
fkaslalsa
2
输出：
fk

四十八、HJ48 从单向链表中删除指定值的节点

HJ48 直击链接

描述：
输入一个单向链表和一个节点的值，从单向链表中删除等于该值的节点，删除后如果链表中无节点则返回空指针。

链表的值不能重复。

构造过程，例如输入一行数据为:
6 2 1 2 3 2 5 1 4 5 7 2 2
则第一个参数6表示输入总共6个节点，第二个参数2表示头节点值为2，剩下的2个一组表示第2个节点值后面插入第1个节点值，为以下表示:
1 2 表示为
2->1
链表为2->1

3 2表示为
2->3
链表为2->3->1

5 1表示为
1->5
链表为2->3->1->5

4 5表示为
5->4
链表为2->3->1->5->4

7 2表示为
2->7
链表为2->7->3->1->5->4

最后的链表的顺序为 2 7 3 1 5 4

最后一个参数为2，表示要删掉节点为2的值
删除 结点 2

则结果为 7 3 1 5 4

while True:
    try:
        string = list(map(int, input().split()))
        link = []  # 链表
        link.append(string[1])  # 表头
        for i in range(1, string[0]):
            link.insert(link.index(string[2*i+1]) + 1, string[2*i])
        
        link.remove(string[-1])
        print(' '.join(map(str, link)))
    except:
        break

输入：6 2 1 2 3 2 5 1 4 5 7 2 2
输出：7 3 1 5 4

五十、HJ50 四则运算

HJ50 直击链接

描述：
输入一个表达式（用字符串表示），求这个表达式的值。
保证字符串中的有效字符包括[‘0’-‘9’],‘+’,‘-’, ‘*’,‘/’ ,‘(’， ‘)’,‘[’, ‘]’,‘{’ ,‘}’。且表达式一定合法。

print(eval(input().replace('{','(').replace('}',')').replace('[','(').replace(']',')')))

输入：3+2*{1+2*[-4/(8-6)+7]}
输出：25.0

五十一、HJ51 输出单向链表中倒数第k个节点

HJ51 直击链接

描述：
输入一个单向链表，输出该链表中倒数第k个结点，链表的倒数第1个结点为链表的尾指针。

while True:
    try:
        num = int(input())
        in_st = input().strip()
        k = int(input())
        mi_st = in_st.split(' ')
        if k == 0:
            print(0)
        else:
            print(mi_st[num-k])
    except:
        break

五十二、HJ52 计算字符串的编辑距离

HJ52 直击链接

描述：

Levenshtein 距离，又称编辑距离，指的是两个字符串之间，由一个转换成另一个所需的最少编辑操作次数。许可的编辑操作包括将一个字符替换成另一个字符，插入一个字符，删除一个字符。编辑距离的算法是首先由俄国科学家 Levenshtein 提出的，故又叫 Levenshtein Distance 。

例如：

字符串A: abcdefg

字符串B: abcdef

通过增加或是删掉字符 ”g” 的方式达到目的。这两种方案都需要一次操作。把这个操作所需要的次数定义为两个字符串的距离。

要求：

给定任意两个字符串，写出一个算法计算它们的编辑距离。

五十三、HJ53 杨辉三角的变形

HJ53 直击链接

描述：
第一行只有一个数1，以下每行的每个数，是恰好是它上面的数、左上角数和右上角的数，3个数之和（如果不存在某个数，认为该数就是0）。

求第n行第一个偶数出现的位置。如果没有偶数，则输出-1。例如输入3,则输出2，输入4则输出3，输入2则输出-1。

while True:
    try:
        n = int(input())
        res = 1
        if n <=2:
            res = -1
        elif n%2 == 1:
            res = 2
        elif n%4 ==0:
            res = 3
        else:
            res = 4
        print(res)
    except:
        break

五十四、HJ54 表达式求值

HJ54 直击链接

描述：
给定一个字符串描述的算术表达式，计算出结果值；

while True:
    try:
        n = input()
        print(eval(n))
    except:
        break

输入：3*5
输出：15

分析总结：

在Python中eval()函数的语法格式为：

eval(expression, globals=None, locals=None)

注意后面还有globals参数和locals参数。eval()函数用于执行一个字符串表达式，并且返回该表达式的值，与eval相近的有exec函数；

• expression :表达式，上面提到的evel函数用于执行一个字符串表达式，表达式的内容放在此处；
• globals：该部分必须是字典，当定义了globals参数之后eval函数的作用域就会被限定在globals;
• locals：该参数掌控局部的命名空间，功能与globals类同，不过当参数冲突时，会执行locals处的参数；

例如：

expression参数示例：

a = 10;
print(eval("a + 1")) #output:11

解析：因为此处没有指定globals和locals，所以直接执行expression部分内容；

globals参数示例：

a = 10;
g = {'a':4}
print(eval("a + 1",g)) #output:5

解析：因为指定了globals，所以在expression部分的作用域就是globals指定的字典范围内，所以此时a=10被屏蔽，取用字典中的值；

locals参数示例：

a = 10
b = 20
c = 30 
g = {'a':6,'b':8}
t = {'b':100,'c':10}
print(eval('a+b+c',g,t))  #output：116

解析：当globals和locals中都有参数b的取值时，取用locals中的值；

注意：eval函数非常方便，我们可以使用一行代码实现计算器的功能：

print(eval(input('请输入：')))

但是因为它具有可以将字符串转换成表达式的特性，所以它也就可以去执行系统命令。这样很容易被用来执行系统命令，删除关键系统文件；

五十五、HJ55 挑7

HJ55 直击链接

描述：
输出1到n之间的与7有关数字的个数，一个数与7有关是指这个数是 7 的倍数，或者是包含 7 的数字（如 17 ，27 ，37 … 70 ，71 ，72 ，73…）

N = 30000
M = len(str(N))-2
def getCountOfSeven(n):
    sevenList = []
    for i in range(7,n+1,7):
        sevenList.append(i)
    for i in range(7,n+1,10):
        sevenList.append(i)
    for a in [10**i for i in range(M)]:
        for flag in [(80+100*j)*a for j in range(N//(100*a))]:
            tmp = n+1 if n < flag else flag
            for i in range(flag-10*a,tmp):
                sevenList.append(i)
    sevenList = list(set(sevenList))
    return len(sevenList)

while True:
    try:
        print(getCountOfSeven(int(input().strip())))
    except:
        break

输入：20
输出：3

五十六、HJ56 完全数计算

HJ56 直击链接

描述：

完全数（Perfect number），又称完美数或完备数，是一些特殊的自然数。

它所有的真因子（即除了自身以外的约数）的和（即因子函数），恰好等于它本身。

例如：28，它有约数1、2、4、7、14、28，除去它本身28外，其余5个数相加，1+2+4+7+14=28。

输入n，请输出n以内(含n)完全数的个数。

while True:
    try:
        a = int(input())
        print(len(list(filter(lambda x: x<a,[6,28,496,8128]))))  #33550336
    except:
        break

输入：1000
输出：3

分析总结：

filter()函数的简介和语法：

filter()函数用于过滤序列，过滤掉不符合条件的元素，返回符合条件的元素组成新列表。
序列中的每个元素作为参数传递给函数进行判断，返回True或者False，最后将返回的True的元素放到新表中。（返回True保留，返回False排除，最终返回一个包含所有被保留元素的迭代器）

filter(function,iterable)
function :判断函数
iterable :可迭代对象

filter()用法实例：

1. 筛选出序列中为奇数的元素：

def is_odd(n):
    return n%2 == 1
a = list(filter(is_odd,[1,2,3,4,5,6,7,8,9,10]))
print(a) #output:[1, 3, 5, 7, 9]

2. filter()经常和lambda一起用：

筛选出长度为奇数的字符串：

a = filter(lambda x: len(x) % 2 ==1,['a','ununtu','windows','python','stars','xz','mac'])
b = list(a)
print(b) #output：['a', 'windows', 'stars', 'mac']

过滤掉列表中的数字0：

list_num = [0,1,2,3,4,5,6,7,8,9,0]
print(list(filter(lambda x: x,list_num)))

过滤掉列表中大写或小写：

list_word = ['A','ununtu','windows','python','stars','XZ','MAC']
print(list(filter(lambda x: x.isupper(),list_word))) #['A', 'XZ', 'MAC']
print(list(filter(lambda x: x.islower(),list_word))) #['ununtu', 'windows', 'python', 'stars']

3. 迭代器仅可使用一次的问题

和map函数一样，filter函数在python3中返回一个惰性计算的filter对象或迭代器，我们不能通过访问index访问filter对象的元素，也不能得到它的长度；

def is_odd(n):
    return n%2 == 1
a = filter(is_odd,[1,2,3,4,5,6,7,8,9,10])
print(a)
print(list(a))
print(list(a))

<filter object at 0x000001BEAB6D8198>
[1, 3, 5, 7, 9]
[]

4. 规避这个惰性计算的问题，赋值的时候直接用list进行转换一下：

def is_odd(n):
    return n%2 == 1
a = list(filter(is_odd,[1,2,3,4,5,6,7,8,9,10]))
print(a)
print(list(a))
print(list(a))

[1, 3, 5, 7, 9]
[1, 3, 5, 7, 9]
[1, 3, 5, 7, 9]

map()函数

map(处理函数，可迭代对象)
map()依次对可迭代对象中的每个元素调用处理函数，最终返回一个包含所有被处理过后的元素的迭代器。

list_word = ['A','ununtu','windows','python','stars','XZ','MAC']
print(list(map(lambda x: x.upper(),list_word)))
print(list(map(lambda x: x.lower(),list_word)))

['A', 'UNUNTU', 'WINDOWS', 'PYTHON', 'STARS', 'XZ', 'MAC']
['a', 'ununtu', 'windows', 'python', 'stars', 'xz', 'mac']

五十七、HJ57 高精度整数加法

HJ57 直击链接

描述：

输入两个用字符串 str 表示的整数，求它们所表示的数之和。

while True:
    try:
        x1 = int(input())
        x2 = int(input())
        y = x1+x2
        print(y)
    except:
        break

输入：
1231323
546546
输出：
1777869

五十八、HJ58 输入n个整数，输出其中最小的k个

HJ58 直击链接

描述：

输入n个整数，找出其中最小的k个整数并按升序输出

while True:
    try:
        x1,x2 = map(int,input().split(' '))
        num = list(map(int,input().split()))
        num.sort()
        print(" ".join(map(str,num[:x2])))
    except:
        break

输入：
5 2
1 2 5 8 9 6 4
输出：
1 2

分析总结：

map()函数

map是python内置函数，会根据提供的函数对指定的序列做映射
map()函数的格式是：
map(function,iterable)
第一个参数接受一个函数名，后面的参数接受一个或多个可迭代的序列，返回的是一个集合，把函数依次作用在list中的每一个元素上，得到一个新的list并返回。注意：map不改变原list，而是返回一个新的list。

示例1：

def square(x):
    return x**2
new_list = list(map(square,[1,2,3,4,5]))
print(new_list) #output:[1, 4, 9, 16, 25]

示例2：
通过使用lambda匿名函数的方法使用map()函数

new_list = list(map(lambda x, y: x+y,[1,3,5,7,9],[2,4,6,8,10]))
print(new_list) #output:[3, 7, 11, 15, 19]

示例3：
通过lambda函数使返回值是一个元组

new_list = list(map(lambda x, y :(x**y,x+y),[2,4,6],[3,2,1]))
print(new_list) #output:[(8, 5), (16, 6), (6, 7)]

五十九、HJ59 找出字符串中第一个只出现一次的字符

HJ59 直击链接

描述：

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

while True:
    try:
        x = input()
        for i in x:
            if x.count(i)==1:
                print(i)
                break
            else:
                print(-1)
    except:
        break

输入：ljsdkflaksj
输出：
-1
-1
-1
d

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

HJ60 直击链接

描述：
任意一个偶数（大于2）都可以由2个素数组成，组成偶数的2个素数有很多种情况，本题目要求输出组成指定偶数的两个素数差值最小的素数对。

while True:
    try:
        def zhishu(x):
            for i in range(2,x//2+1):
                if x%i == 0:
                    return False
                    break
            else:
                return True
        n = int(input().strip())
        list1 = []
        for i in range(n//2,n):
            if zhishu(i) and zhishu(n-i):
                list1.append(i)
                list1.append(n-i)
            else:
                continue
        print(list1[1])
        print(list1[0])
    except:
        break

输入：20
输出：
7
13

六十一、HJ61 放苹果

HJ61 直击链接

描述：
把m个同样的苹果放在n个同样的盘子里，允许有的盘子空着不放，问共有多少种不同的分法？
注意：如果有7个苹果和3个盘子，（5，1，1）和（1，5，1）被视为是同一种分法。

def f(m,n):
    if m == 0 or n == 1:
        return 1
    if m < n:
        return f(m, m)
    else:
        return (f(m, n-1)+f(m-n, n))
while True:
    try:
        m,n = map(int,input().split())
        print(f(m,n))
        
    except:
        break

输入：7 3
输出：8

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

HJ62 直击链接

描述：

输入一个正整数，计算它在二进制下的1的个数。
注意多组输入输出！！！！！！

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

输入：5
输出：2

分析总结：

进制表示：

• 十进制：直接表示–10
• 二进制：前缀–0B1010
• 八进制：前缀–0O12
• 十六进制：前缀–0XA

十进制转其它进制：

十进制转二进制：bin(10)
十进制转八进制：oct(10)
十进制转十六进制：hex(10)

由于不同编译环境中转换为16进制后，16进制中的字母可能用小写或者大写表示，如果和需要的表示有出入，可以用ord()函数先将字母转换为ASCLL编号，再根据大小写编号大小关系加上32或者减去32，转为小写或者大写对应的字母编号，最后通过chr()函数将编号转换为字母

其它进制转十进制：

使用int(String,num)解决，string为其它进制的表示，num为进制数。

• 二进制转十进制：int(“1010”,2)
• 八进制转十进制：int(“0o12”,8)
• 十六进制转十进制：int(“0xa”,16)

可以带前缀，也可以不带；

需要十进制中转的进制转换：

该转换使用十进制中转：
二转八：（二转十，再转八）–oct(int(“1010”,2))
八转十六：（八转十，再转十六）–hex(int(“12”,8))

六十三、HJ63 DNA序列

HJ63 直击链接

描述：

一个 DNA 序列由 A/C/G/T 四个字母的排列组合组成。 G 和 C 的比例（定义为 GC-Ratio ）是序列中 G 和 C 两个字母的总的出现次数除以总的字母数目（也就是序列长度）。在基因工程中，这个比例非常重要。因为高的 GC-Ratio 可能是基因的起始点。

给定一个很长的 DNA 序列，以及限定的子串长度 N ，请帮助研究人员在给出的 DNA 序列中从左往右找出 GC-Ratio 最高且长度为 N 的第一个子串。
DNA序列为 ACGT 的子串有: ACG , CG , CGT 等等，但是没有 AGT ， CT 等等

while True:
    try:
        a = input()
        n = int(input())
        g = 0
        index = 0
        for i in range(0,len(a)-n+1):
            GC = a.count('G',i,i+n) + a.count('C',i,i+n)
            if GC > g:
                g = GC
                index = i
        print(a[index:index+n])
    except:
        break

输入：
AACTGTGCACGACCTGA
5
输出：
GCACG

六十四、HJ64 MP3光标位置

HJ64 直击链接

描述：
MP3 Player因为屏幕较小，显示歌曲列表的时候每屏只能显示几首歌曲，用户要通过上下键才能浏览所有的歌曲。为了简化处理，假设每屏只能显示4首歌曲，光标初始的位置为第1首歌。
现在要实现通过上下键控制光标移动来浏览歌曲列表，控制逻辑如下：
歌曲总数<=4的时候，不需要翻页，只是挪动光标位置。
光标在第一首歌曲上时，按Up键光标挪到最后一首歌曲；光标在最后一首歌曲时，按Down键光标挪到第一首歌曲。

while True:
    try:
        num = int(input())
        command = input()
        head,tail,i = 1,4,1
        if(num <= 4):
            for ci in command:
                if(ci == 'U'):
                    if i == 1:
                        i = num
                    else:
                        i -= 1
                else:
                    if i == num:
                        i = 1
                    else:
                        i += 1
            head,tail = 1,num
        else:
            for ci in command:
                if(ci == "U"):
                    if i == 1:
                        i = num
                        head,tail = num - 3,num
                    else:
                        i -= 1
                        if i < head:
                            head,tail = i,i+3
                else:
                    if i ==num:
                        i = 1
                        head,tail = 1,4
                    else:
                        i += 1
                        if i > tail:
                            head,tail = i - 3,i
        ans = list(range(head,tail + 1))
        print(' '.join(str(j) for j in ans))
        print(i)
    except:
        break

输入：
10
UUUU
输出：
7 8 9 10
7

六十五、HJ65 查找两个字符串a,b中的最长公共子串

HJ65 直击链接

描述：
查找两个字符串a,b中的最长公共子串。若有多个，输出在较短串中最先出现的那个。
注：子串的定义：将一个字符串删去前缀和后缀（也可以不删）形成的字符串。请和“子序列”的概念分开！

while True:
    try:
        str1 = input()
        str2 = input()
        n = 0
        s = ''
        if len(str1)>len(str2):
            str1,str2 = str2,str1
        for i in range(len(str1)+1):
            if str1[i-n:i] in str2:
                s = str1[i-n:i]
                n += 1
        print(s)
    except:
        break

输入：
abcdefghijklmnop
abcsafjklmnopqrstuvw
输出：
jklmnop

六十六、HJ66 配置文件恢复

HJ66 直击链接

描述：
有6条配置命令，它们执行的结果分别是：

命 令	执 行
reset	reset what
reset board	board fault
board add	where to add
board delete	no board at all
reboot backplane	impossible
backplane abort	install first
he he	unknown command

注意：he he不是命令。

为了简化输入，方便用户，以“最短唯一匹配原则”匹配（注：需从首字母开始进行匹配）：

1. 若只输入一字串，则只匹配一个关键字的命令行。例如输入：r，根据该规则，匹配命令reset，执行结果为：reset what；输入：res，根据该规则，匹配命令reset，执行结果为：reset what；
2. 若只输入一字串，但匹配命令有两个关键字，则匹配失败。例如输入：reb，可以找到命令reboot backpalne，但是该命令有两个关键词，所有匹配失败，执行结果为：unknown command
3. 若输入两字串，则先匹配第一关键字，如果有匹配，继续匹配第二关键字，如果仍不唯一，匹配失败。
   例如输入：r b，找到匹配命令reset board 和 reboot backplane，执行结果为：unknown command。
   例如输入：b a，无法确定是命令board add还是backplane abort，匹配失败。
4. 若输入两字串，则先匹配第一关键字，如果有匹配，继续匹配第二关键字，如果唯一，匹配成功。例如输入：bo a，确定是命令board add，匹配成功。
5. 若输入两字串，第一关键字匹配成功，则匹配第二关键字，若无匹配，失败。例如输入：b addr，无法匹配到相应的命令，所以执行结果为：unknow command。
6. 若匹配失败，打印“unknown command”

注意：有多组输入。

import sys

for line in sys.stdin:
    cmds = line.strip().split()
    cmd_set = ['reset', 'reset board', 'board add', 'board delete', 
              'reboot backplane', 'backplane abort', 'he he']
    ops = ['reset what', 'board fault', 'where to add', 'no board at all', 
          'impossible', 'install first', 'unknown command']
    flg = False
    if len(cmds) == 1:
        if cmd_set[0].startswith(cmds[0]):
            print(ops[0])
        else:
            print(ops[-1])
    else:
        for i in range(1, len(cmd_set)):
            tmp_cmd = cmd_set[i].split()
            if tmp_cmd[0].startswith(cmds[0]) and tmp_cmd[1].startswith(cmds[1]):
                print(ops[i])
                flg = True
                break
        if not flg: print(ops[-1])

bo a
where to add
bo d
no board at all
re
reset what
re b
board fault

六十七、HJ67 24点游戏算法

HJ67 直击链接

描述：
给出4个1-10的数字，通过加减乘除运算，得到数字为24就算胜利,除法指实数除法运算,运算符仅允许出现在两个数字之间,本题对数字选取顺序无要求，但每个数字仅允许使用一次，且需考虑括号运算
此题允许数字重复，如3 3 4 4为合法输入，此输入一共有两个3，但是每个数字只允许使用一次，则运算过程中两个3都被选取并进行对应的计算操作。

import sys 

def func(nums, tar):
    if len(nums) == 1: 
        return nums[0] == tar
    for i in range(len(nums)):
        nums = nums[1:] + [nums[0]]
        if func(nums[1:], tar+nums[0]) or func(nums[1:], tar-nums[0]) or func(nums[1:], tar*nums[0]) or func(nums[1:], tar/nums[0]):
            return True
    return False

for line in sys.stdin:
    nums = list(map(int, line.strip().split()))
    print(str(func(nums, 24)).lower())

输入：
7 4 1 10
输出：
false

六十八、HJ68 成绩排序

HJ68 直击链接

描述
给定一些同学的信息（名字，成绩）序列，请你将他们的信息按照成绩从高到低或从低到高的排列,相同成绩，都按先录入排列在前的规则处理。

示例：

jack	70
peter	96
Tom	70
smith	67

从高到低 成绩

peter	96
jack	70
Tom	70
smith	67

从低到高

smith	67
jack	70
Tom	70
peter	96

注：0代表从高到低，1代表从低到高

while True:
    try:
        num = int(input())
        flag = False if int(input().strip()) == 1 else True
        out = []
        for i in range(num):
            info = input().split()
            out.append((info[0], int(info[1])))
        for j in sorted(out, key = lambda x:x[1], reverse = flag):
            print(j[0], j[1])

    except:
        break

3
0
xz 98
zw 96
yq 94
xz 98
zw 96
yq 94
3
1
xz 98
zw 96
yq 94
yq 94
zw 96
xz 98

六十九、HJ69 矩阵乘法

HJ69 直击链接

七十、HJ70 矩阵乘法计算量估算

七十一、HJ71 字符串通配符

HJ71 直击链接

描述
问题描述：在计算机中，通配符一种特殊语法，广泛应用于文件搜索、数据库、正则表达式等领域。现要求各位实现字符串通配符的算法。
要求：
实现如下2个通配符：
：匹配0个或以上的字符（注：能被和?匹配的字符仅由英文字母和数字0到9组成，下同）
？：匹配1个字符

注意：匹配时不区分大小写。

import re 

while True:
    try:
        a,b = input().strip().lower(),input().strip().lower()
        a = a.replace('?','\w{1}').replace('.','\.').replace('*','\w*')
        c = re.findall(a,b)
        if b in c and len(c)==1:
            print('true')
        else:
            print('false')
    except:
        break

输出：

z
zz
false

七十二、HJ72 百钱买百鸡问题

HJ72 直击链接

描述
公元五世纪，我国古代数学家张丘建在《算经》一书中提出了“百鸡问题”：鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱一。百钱买百鸡，问鸡翁、鸡母、鸡雏各几何？
现要求你打印出所有花一百元买一百只鸡的方式。

---

总结

分享：
创作，在很多时候不是全凭经验就能完成的。创作的生命是如此寂寞，但伟大的作品终究不会寂寞。