前言：
多行数据需要输入的时候可以用下面的结构：
while True:
try:
n = int(input())
s = input().split()
num = []
for i in s:
num.append(int(i))
k = int(input())
print(num[n-k])
except:
break
输入两组数据：
1
8108
1
7
2542 4218 9064 4908 1526 6655 921
1一次输入两个数组时，可以用下面的输入方式：
n1 = int(input())
num1 = list(map(int, input().split()))
n2 = int(input())
num2 = list(map(int, input().split()))一、机试练习篇
1、简单题
HJ1 字符串最后一个单词的长度
描述
计算字符串最后一个单词的长度，单词以空格隔开，字符串长度小于5000。（注：字符串末尾不以空格为结尾）
输入描述：
输入一行，代表要计算的字符串，非空，长度小于5000。
输出描述：
输出一个整数，表示输入字符串最后一个单词的长度。
示例1：
输入：
hello nowcoder
输出：
8
说明：
最后一个单词为nowcoder，长度为8 实现代码：
s = input()
s_list = s.split(' ')
print(len(s_list[-1]))HJ2 计算某字符出现次数
描述
写出一个程序，接受一个由字母、数字和空格组成的字符串，和一个字符，然后输出输入字符串中该字符的出现次数。（不区分大小写字母）
数据范围： 1≤�≤1000 1≤n≤1000
输入描述：
第一行输入一个由字母、数字和空格组成的字符串，第二行输入一个字符（保证该字符不为空格）。
输出描述：
输出输入字符串中含有该字符的个数。（不区分大小写字母）
示例1
输入：
ABCabc
A
输出：
2实现代码：
s1 = input()
s2 = input()
count = 0
for i in s1:
if(s2.upper() == i.upper()):
count += 1
print(count)HJ4 字符串分隔
描述
•输入一个字符串，请按长度为8拆分每个输入字符串并进行输出；
•长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。
输入描述：
连续输入字符串(每个字符串长度小于等于100)
输出描述：
依次输出所有分割后的长度为8的新字符串
示例1:
输入：
abc
输出：
abc00000实现代码：
s = input()
while len(s) > 8:
print(s[:8]) # 循环迭代每次取前8位字符
s = s[8:] #将剩余的字符串取下备下次用
if len(s) != 0:
for i in range(8 - len(s)): # 最后不足8位用0补齐
s += "0"
print(s)HJ5 进制转换
描述
写出一个程序，接受一个十六进制的数，输出该数值的十进制表示。
数据范围：保证结果在 1≤�≤231−1 1≤n≤231−1
输入描述：
输入一个十六进制的数值字符串。
输出描述：
输出该数值的十进制字符串。不同组的测试用例用\n隔开。
示例1
输入：
0xAA
输出：
170实现代码：
num = input()
print(int(num, 16)) # int()函数可以将任何进制的数据转换为十进制数据
# print(bin(int(num, 16))) # bin()函数可以将十进制数据转换为二进制数据HJ6 质数因子
描述
功能:输入一个正整数，按照从小到大的顺序输出它的所有质因子（重复的也要列举）（如180的质因子为2 2 3 3 5 ）
数据范围： 1≤�≤2×109+14 1≤n≤2×109+14
输入描述：
输入一个整数
输出描述：
按照从小到大的顺序输出它的所有质数的因子，以空格隔开。
示例1
输入：
180
输出：
2 2 3 3 5实现代码：
from math import sqrt
num = int(input())
for i in range(2, int(sqrt(num)) + 1):
# if(num % i == 0):
while(num % i == 0):
num /= i
print(i, end=' ')#不换行输出
if(num != 1):
print(int(num))HJ7 取近似值
描述
写出一个程序，接受一个正浮点数值，输出该数值的近似整数值。如果小数点后数值大于等于 0.5 ,向上取整；小于 0.5 ，则向下取整。
数据范围：保证输入的数字在 32 位浮点数范围内
输入描述：
输入一个正浮点数值
输出描述：
输出该数值的近似整数值
示例1
输入：
5.5
输出：
6
说明：
0.5>=0.5，所以5.5需要向上取整为6 示例2
输入：
2.499
输出：
2
说明：
0.499<0.5，2.499向下取整为2 实现代码：
num = float(input())
small = num - int(num)
if(small >= 0.5):
print(int(num) + 1)
else:
print(int(num))HJ8 合并表记录
描述
数据表记录包含表索引index和数值value（int范围的正整数），请对表索引相同的记录进行合并，即将相同索引的数值进行求和运算，输出按照index值升序进行输出。
提示:
0 <= index <= 11111111
1 <= value <= 100000
输入描述：
先输入键值对的个数n（1 <= n <= 500）
接下来n行每行输入成对的index和value值，以空格隔开
输出描述：
输出合并后的键值对（多行）
示例1
输入：
4
0 1
0 2
1 2
3 4
输出：
0 3
1 2
3 4示例2
输入：
3
0 1
0 2
8 9
输出：
0 3
8 9实现代码：
num = int(input())
dic = {}
for i in range(num):
k, v = input().split() # 一行输入多个变量
k, v = int(k), int(v)
if k not in dic:
dic[k] = v
else:
dic[k] += v
for k, v in sorted(dic.items()):#dict按key升序遍历
print(k, v)
# dict按value升序遍历：
# for key,value in sorted(dic.items(),key=lambda x:x[1]):
# print(key,value)HJ9 提取不重复的整数
描述
输入一个 int 型整数，按照从右向左的阅读顺序，返回一个不含重复数字的新的整数。
保证输入的整数最后一位不是 0 。
数据范围： 1≤�≤108 1≤n≤108
输入描述：
输入一个int型整数
输出描述：
按照从右向左的阅读顺序，返回一个不含重复数字的新的整数
示例1
输入：
9876673
输出：
37689实现代码：
num = int(input())
res = []
while(num):
temp = num % 10
if(temp not in res):
res.append(temp)
num = int(num / 10)
for i in res:
print(i, end='')HJ10 字符个数统计
描述
编写一个函数，计算字符串中含有的不同字符的个数。字符在 ASCII 码范围内( 0~127 ，包括 0 和 127 )，换行表示结束符，不算在字符里。不在范围内的不作统计。多个相同的字符只计算一次
例如，对于字符串 abaca 而言，有 a、b、c 三种不同的字符，因此输出 3 。
数据范围： 1≤�≤500 1≤n≤500
输入描述：
输入一行没有空格的字符串。
输出描述：
输出 输入字符串 中范围在(0~127，包括0和127)字符的种数。
示例1
输入：
abc
输出：
3示例2
输入：
aaa
输出：
1实现代码：
s = input()
s_set = set()
for i in s:
if(i not in s_set):
s_set.add(i)
print(len(s_set))HJ11 数字颠倒
描述
输入一个整数，将这个整数以字符串的形式逆序输出
程序不考虑负数的情况，若数字含有0，则逆序形式也含有0，如输入为100，则输出为001
数据范围： 0≤�≤230−1 0≤n≤230−1
输入描述：
输入一个int整数
输出描述：
将这个整数以字符串的形式逆序输出
示例1
输入：
1516000
输出：
0006151示例2
输入：
0
输出：
0实现代码：
num = int(input())
if(num / 10 == 0):
print(num)
res = []
while(num):
temp = num % 10
res.append(temp)
num = int(num / 10)
for i in res:
print(i, end = '')HJ12 字符串反转
描述
接受一个只包含小写字母的字符串，然后输出该字符串反转后的字符串。（字符串长度不超过1000）
输入描述：
输入一行，为一个只包含小写字母的字符串。
输出描述：
输出该字符串反转后的字符串。
示例1
输入：
abcd
输出：
dcba实现代码：
s = input()
print(s[::-1])HJ13 句子逆序
描述
将一个英文语句以单词为单位逆序排放。例如“I am a boy”，逆序排放后为“boy a am I”
所有单词之间用一个空格隔开，语句中除了英文字母外，不再包含其他字符
数据范围：输入的字符串长度满足 1≤�≤1000 1≤n≤1000
注意本题有多组输入
输入描述：
输入一个英文语句，每个单词用空格隔开。保证输入只包含空格和字母。
输出描述：
得到逆序的句子
示例1
输入：
I am a boy
输出：
boy a am I示例2
输入：
nowcoder
输出：
nowcoder实现代码：
s = input().split(' ')
s.reverse()
print(' '.join(s))HJ14 字符串排序
描述
给定 n 个字符串，请对 n 个字符串按照字典序排列。
数据范围： 1≤�≤1000 1≤n≤1000 ，字符串长度满足 1≤���≤100 1≤len≤100
输入描述：
输入第一行为一个正整数n(1≤n≤1000),下面n行为n个字符串(字符串长度≤100),字符串中只含有大小写字母。
输出描述：
数据输出n行，输出结果为按照字典序排列的字符串。
示例1
输入：
9
cap
to
cat
card
two
too
up
boat
boot
输出：
boat
boot
cap
card
cat
to
too
two
up实现代码：
num = int(input())
dic = {}
for i in range(num):
s = input()
dic[i] = s
#sorted(dic.items(), key=lambda x:x[1])返回的是list的数组
for k, v in sorted(dic.items(), key=lambda x:x[1]):#按value值升序排列
print(v)HJ15 求int型正整数在内存中存储时1的个数
描述
输入一个 int 型的正整数，计算出该 int 型数据在内存中存储时 1 的个数。
数据范围：保证在 32 位整型数字范围内
输入描述：
输入一个整数（int类型）
输出描述：
这个数转换成2进制后，输出1的个数
示例1
输入：
5
输出：
2示例2
输入：
0
输出：
0实现代码：
num = int(input())
num_bit = bin(num)[2:]
print(num_bit.count('1'))HJ21 简单密码
描述
现在有一种密码变换算法。
九键手机键盘上的数字与字母的对应： 1--1， abc--2, def--3, ghi--4, jkl--5, mno--6, pqrs--7, tuv--8 wxyz--9, 0--0，把密码中出现的小写字母都变成九键键盘对应的数字，如：a 变成 2，x 变成 9.
而密码中出现的大写字母则变成小写之后往后移一位，如：X ，先变成小写，再往后移一位，变成了 y ，例外：Z 往后移是 a 。
数字和其它的符号都不做变换。
数据范围： 输入的字符串长度满足 1≤�≤100 1≤n≤100
输入描述：
输入一组密码，长度不超过100个字符。
输出描述：
输出密码变换后的字符串
示例1
输入：
YUANzhi1987
输出：
zvbo9441987实现代码：
s = input()
dic = {
"1": "1",
"a": "2",
"b": "2",
"c": "2",
"d": "3",
"e": "3",
"f": "3",
"g": "4",
"h": "4",
"i": "4",
"j": "5",
"k": "5",
"l": "5",
"m": "6",
"n": "6",
"o": "6",
"p": "7",
"q": "7",
"r": "7",
"s": "7",
"t": "8",
"u": "8",
"v": "8",
"w": "9",
"x": "9",
"y": "9",
"z": "9",
"0": "0",
}
res = ''
for i in s:
if(i.isupper()):
i = i.lower()
if(i != 'z'):
res += chr(ord(i) + 1)#得到字母的ASSIC码再将其后移一位
else:
res += 'a'#如果是最后一个字母'z',则循环到'a'
elif(i.islower()):
res += dic[i]
else:
res += i
print(res)HJ23 删除字符串中出现次数最少的字符
描述
实现删除字符串中出现次数最少的字符，若出现次数最少的字符有多个，则把出现次数最少的字符都删除。输出删除这些单词后的字符串，字符串中其它字符保持原来的顺序。
数据范围：输入的字符串长度满足 1≤�≤20 1≤n≤20 ，保证输入的字符串中仅出现小写字母
输入描述：
字符串只包含小写英文字母, 不考虑非法输入，输入的字符串长度小于等于20个字节。
输出描述：
删除字符串中出现次数最少的字符后的字符串。
示例1
输入：
aabcddd
输出：
aaddd实现代码：
s = input()
dic = {}
for i in s:
if i not in dic:
dic[i] = 1
else:
dic[i] += 1
min_count = min(dic.values()) # 找出出现次数最少的字母
s_del = []
for k in dic:
if dic[k] == min_count:
s = s.replace(k, "") # 用空字符替换掉出现次数最少的字符
print(s)HJ31 单词倒排
描述
对字符串中的所有单词进行倒排。
说明：
1、构成单词的字符只有26个大写或小写英文字母；
2、非构成单词的字符均视为单词间隔符；
3、要求倒排后的单词间隔符以一个空格表示；如果原字符串中相邻单词间有多个间隔符时，倒排转换后也只允许出现一个空格间隔符；
4、每个单词最长20个字母；
数据范围：字符串长度满足 1≤�≤10000 1≤n≤10000
输入描述：
输入一行，表示用来倒排的句子
输出描述：
输出句子的倒排结果
示例1
输入：
I am a student
输出：
student a am I示例2
输入：
$bo*y gi!r#l
输出：
l r gi y bo实现代码：
s = input()
for i in s:
if(i.islower() == False and i.isupper() == False):
s = s.replace(i, ' ')#用空格把冗余的字符去除
res = s.split(' ')
res.reverse()
print(' '.join(res))HJ34 图片整理
描述
Lily上课时使用字母数字图片教小朋友们学习英语单词，每次都需要把这些图片按照大小（ASCII码值从小到大）排列收好。请大家给Lily帮忙，通过代码解决。
Lily使用的图片使用字符"A"到"Z"、"a"到"z"、"0"到"9"表示。
数据范围：每组输入的字符串长度满足 1≤�≤1000 1≤n≤1000
输入描述：
一行，一个字符串，字符串中的每个字符表示一张Lily使用的图片。
输出描述：
Lily的所有图片按照从小到大的顺序输出
示例1
输入：
Ihave1nose2hands10fingers
输出：
0112Iaadeeefghhinnnorsssv实现代码：
s = input()
print(''.join(sorted(s)))HJ35 蛇形矩阵
蛇形矩阵是由1开始的自然数依次排列成的一个矩阵上三角形。
例如，当输入5时，应该输出的三角形为：
1 3 6 10 15
2 5 9 14
4 8 13
7 12
11输入描述：
输入正整数N（N不大于100）
输出描述：
输出一个N行的蛇形矩阵。
示例1
输入：
4
输出：
1 3 6 10
2 5 9
4 8
7实现代码：
num = int(input())
for i in range(1, num + 1):
step = i + 1# 每一行的步长
start = (i * (i - 1)) // 2 + 1# 每一行的第一个值
print(start, end = '')
for j in range(2, num+2-i):#每行输出多少个值
start += step
print('', start, end = '')
step += 1
print()#换行HJ37 统计每个月兔子的总数
描述
有一种兔子，从出生后第3个月起每个月都生一只兔子，小兔子长到第三个月后每个月又生一只兔子。
例子：假设一只兔子第3个月出生，那么它第5个月开始会每个月生一只兔子。
一月的时候有一只兔子，假如兔子都不死，问第n个月的兔子总数为多少？
数据范围：输入满足 1≤�≤31 1≤n≤31
输入描述：
输入一个int型整数表示第n个月
输出描述：
输出对应的兔子总数
示例1
输入：
3
输出：
2实现代码：
month = int(input())
n = month - 1
def fun(n):
if(n < 2):
return 1
else:
return fun(n-1) + fun(n-2)
print(fun(n))HJ40 统计字符
描述
输入一行字符，分别统计出包含英文字母、空格、数字和其它字符的个数。
数据范围：输入的字符串长度满足 1≤�≤1000 1≤n≤1000
输入描述：
输入一行字符串，可以有空格
输出描述：
统计其中英文字符，空格字符，数字字符，其他字符的个数
示例1
输入：
1qazxsw23 edcvfr45tgbn hy67uj m,ki89ol.\\/;p0-=\\][
输出：
26
3
10
12实现代码：
输入：
1qazxsw23 edcvfr45tgbn hy67uj m,ki89ol.\\/;p0-=\\][
输出：
26
3
10
12HJ54 表达式求值
描述
给定一个字符串描述的算术表达式，计算出结果值。
输入字符串长度不超过 100 ，合法的字符包括 ”+, -, *, /, (, )” ， ”0-9” 。
数据范围：运算过程中和最终结果均满足 ∣���∣≤231−1 ∣val∣≤231−1 ，即只进行整型运算，确保输入的表达式合法
输入描述：
输入算术表达式
输出描述：
计算出结果值
示例1
输入：
400+5
输出：
405实现代码：
print(eval(input()))HJ56 完全数计算
描述
完全数（Perfect number），又称完美数或完备数，是一些特殊的自然数。
它所有的真因子（即除了自身以外的约数）的和（即因子函数），恰好等于它本身。
例如：28，它有约数1、2、4、7、14、28，除去它本身28外，其余5个数相加，1+2+4+7+14=28。
输入n，请输出n以内(含n)完全数的个数。
数据范围： 1≤�≤5×105 1≤n≤5×105
输入描述：
输入一个数字n
输出描述：
输出不超过n的完全数的个数
示例1
输入：
1000
输出：
3实现代码：
from math import sqrt
num = int(input())
count = 0
for i in range(1, num+1):
sum = 0
for j in range(1, i):
if(i % j == 0):
sum += j
if(sum == i):
count += 1
print(count)HJ62 查找输入整数二进制中1的个数
输入一个正整数，计算它在二进制下的1的个数。
注意多组输入输出！！！！！！
数据范围： 1≤�≤231−1 1≤n≤231−1
输入描述：
输入一个整数
输出描述：
计算整数二进制中1的个数
示例1
输入：
5
输出：
2
说明：
5的二进制表示是101，有2个1 示例2
输入：
0
输出：
0实现代码：
x = int(input())
y = int(input())
s1 = bin(x)[2:]
s2 = bin(y)[2:]
print(s1.count('1'))
print(s2.count('1'))
HJ73 计算日期到天数转换
描述
根据输入的日期，计算是这一年的第几天。
保证年份为4位数且日期合法。
进阶：时间复杂度：�(�) O(n) ，空间复杂度：�(1) O(1)
输入描述：
输入一行，每行空格分割，分别是年，月，日
输出描述：
输出是这一年的第几天
示例1
输入：
2012 12 31
输出：
366示例2
输入：
1982 3 4
输出：
63实现代码：
s = input().split(' ')
y, m, d = int(s[0]), int(s[1]), int(s[2])
month = [31,28,31,30,31,30,31,31,30,31,30,31]
total_days = sum(month[:m-1]) + d
if(m > 2 and (y%4==0 and y%100!=0 or y%400==0)):#出现闰年的情况
total_days += 1
print(total_days)
HJ81 字符串字符匹配
描述
判断短字符串S中的所有字符是否在长字符串T中全部出现。
请注意本题有多组样例输入。
数据范围:1≤���(�),���(�)≤200 1≤len(S),len(T)≤200
进阶：时间复杂度：�(�) O(n) ，空间复杂度：�(�) O(n)
输入描述：
输入两个字符串。第一个为短字符串，第二个为长字符串。两个字符串均由小写字母组成。
输出描述：
如果短字符串的所有字符均在长字符串中出现过，则输出字符串"true"。否则输出字符串"false"。
示例1
输入：
bc
abc
输出：
true
说明：
其中abc含有bc，输出"true"实现代码：
s1 = list(set(input()))
s2 = list(set(input()))
for i in s1:
if i not in s2:
print("false")
break
# 直到最后一个字符都在s2里，那么我们称字符串匹配成功
if i == s1[-1] and i in s2:
print("true")
HJ84 统计大写字母个数
描述
找出给定字符串中大写字符(即'A'-'Z')的个数。
数据范围：字符串长度：1≤∣�∣≤250 1≤∣s∣≤250
字符串中可能包含空格或其他字符
进阶：时间复杂度：�(�) O(n) ，空间复杂度：�(�) O(n)
输入描述：
对于每组样例，输入一行，代表待统计的字符串
输出描述：
输出一个整数，代表字符串中大写字母的个数
示例1
输入：
A 1 0 1 1150175017(&^%&$vabovbaoadd 123#$%#%#O
输出：
2实现代码：
s = input()
cnt = 0
for i in s:
if(i.isupper()):
cnt += 1
print(cnt)HJ85 最长回文子串
描述
给定一个仅包含小写字母的字符串，求它的最长回文子串的长度。
所谓回文串，指左右对称的字符串。
所谓子串，指一个字符串删掉其部分前缀和后缀（也可以不删）的字符串
数据范围：字符串长度1≤�≤350 1≤s≤350
进阶：时间复杂度：�(�) O(n) ，空间复杂度：�(�) O(n)
输入描述：
输入一个仅包含小写字母的字符串
输出描述：
返回最长回文子串的长度
示例1
输入：
cdabbacc
输出：
4
说明：
abba为最长的回文子串 实现代码：
def isHuiWenStr(subStr:str):#判断当前子串是不是回文字符
start = 0
end = len(subStr) - 1
while(start < end):
if(subStr[start] != subStr[end]):
return False
start = start + 1
end = end - 1
return True
s = input()
if(len(s) < 2):
print(s)
maxLen = 1#记录最大回文字符长度
for i in range(len(s)-1):
for j in range(i + 1, len(s)):
if((j - i + 1) > maxLen and isHuiWenStr(s[i:j+1])):
maxLen = j - i + 1
print(maxLen)
HJ86 求最大连续bit数
描述
求一个int类型数字对应的二进制数字中1的最大连续数，例如3的二进制为00000011，最大连续2个1
数据范围：数据组数：1≤�≤5 1≤t≤5 ，1≤�≤500000 1≤n≤500000
进阶：时间复杂度：�(����) O(logn) ，空间复杂度：�(1) O(1)
输入描述：
输入一个int类型数字
输出描述：
输出转成二进制之后连续1的个数
示例1
输入：
200
输出：
2
说明：
200的二进制表示是11001000，最多有2个连续的1。 实现代码：
num = int(input())
s = bin(num)[2:]
res = 1
temp = 1
for i in range(len(s)):
if(s[i] == '1'):
for j in range(i + 1, len(s)):
if(s[i] == s[j]):
temp += 1
else:
break
res = max(res, temp)
temp = 1
print(res)HJ94 记票统计
描述
请实现一个计票统计系统。你会收到很多投票，其中有合法的也有不合法的，请统计每个候选人得票的数量以及不合法的票数。
（注：不合法的投票指的是投票的名字不存在n个候选人的名字中！！）
数据范围：每组输入中候选人数量满足 1≤�≤100 1≤n≤100 ，总票数量满足 1≤�≤100 1≤n≤100
输入描述：
第一行输入候选人的人数n，第二行输入n个候选人的名字（均为大写字母的字符串），第三行输入投票人的人数，第四行输入投票。
输出描述：
按照输入的顺序，每行输出候选人的名字和得票数量（以" : "隔开，注：英文冒号左右两边都有一个空格！），最后一行输出不合法的票数，格式为"Invalid : "+不合法的票数。
示例1
输入：
4
A B C D
8
A D E CF A GG A B
输出：
A : 3
B : 1
C : 0
D : 1
Invalid : 3
说明：
E CF GG三张票是无效的，所以Invalid的数量是3. 实现代码：
n1 = int(input())
s1 = input().split(" ")
n2 = int(input())
s2 = input().split(" ")
dic = {}
for i in s1:
dic[i] = 0
for k in dic:#统计票数
for i in s2:
if i == k:
dic[k] += 1
sum = 0
for k, v in dic.items():#统计总的有效票数
sum += v
dic.update({'Invalid': len(s2) - sum})#更新无效票数
for k, v in dic.items():
print(k, ":", v)
HJ96 表示数字
描述
将一个字符串中所有的整数前后加上符号“*”，其他字符保持不变。连续的数字视为一个整数。
数据范围：字符串长度满足 1≤�≤100 1≤n≤100
输入描述：
输入一个字符串
输出描述：
字符中所有出现的数字前后加上符号“*”，其他字符保持不变
示例1
输入：
Jkdi234klowe90a3
输出：
Jkdi*234*klowe*90*a*3*实现代码：
s = input()
res = ""
if s[0] in {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"}:
res = "*" + res
res += s[0]
else:
res += s[0]
for i in range(1, len(s)):
if (
s[i - 1] in {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"}
and s[i] not in {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"}
or s[i] in {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"}
and s[i - 1] not in {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"}
):
res += "*"
res += s[i]
else:
res += s[i]
if s[-1] in {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"}:
res += "*"
print(res)
HJ102 字符统计
描述
输入一个只包含小写英文字母和数字的字符串，按照不同字符统计个数由多到少输出统计结果，如果统计的个数相同，则按照ASCII码由小到大排序输出。
数据范围：字符串长度满足 1≤���(���)≤1000 1≤len(str)≤1000
输入描述：
一个只包含小写英文字母和数字的字符串。
输出描述：
一个字符串，为不同字母出现次数的降序表示。若出现次数相同，则按ASCII码的升序输出。
示例1
输入：
aaddccdc
输出：
cda
说明：
样例里，c和d出现3次，a出现2次，但c的ASCII码比d小，所以先输出c，再输出d，最后输出a.实现代码：
s = input()
dic = {}
for i in s:
if i not in dic:
dic[i] = 1
else:
dic[i] += 1
dic = sorted(dic.items(), key=lambda x: x[0]) # key先按字符ASCII排序
dic = sorted(dic, key=lambda x: x[1], reverse=True) # 按统计数目value排序，再按降序排列
for k, v in dic:
print("".join(k), end="")
HJ106 字符逆序
描述
将一个字符串str的内容颠倒过来，并输出。
数据范围：1≤���(���)≤10000 1≤len(str)≤10000
输入描述：
输入一个字符串，可以有空格
输出描述：
输出逆序的字符串
示例1
输入：
I am a student
输出：
tneduts a ma I示例2
输入：
nowcoder
输出：
redocwon实现代码：
s = input().split(' ')
s.reverse()
for i in s:
print(''.join(i[::-1]), end = ' ')HJ60 查找组成一个偶数最接近的两个素数
描述
任意一个偶数（大于2）都可以由2个素数组成，组成偶数的2个素数有很多种情况，本题目要求输出组成指定偶数的两个素数差值最小的素数对。
数据范围：输入的数据满足 4≤�≤1000 4≤n≤1000
输入描述：
输入一个大于2的偶数
输出描述：
从小到大输出两个素数
示例1
输入：
20
输出：
7
13示例2
输入：
4
输出：
2
2实现代码：
def prime(num): # 判断是否为素数
flag = True
for i in range(2, int(num ** 0.5) + 1):
if num % i == 0:
flag = False
break
return flag
n = int(input())
res = []
for i in range(2, int(n / 2 + 1)):#从中间像两边靠，最终结果就是距离最短的两个素数
if prime(i) and prime(n - i):
res = [i, n - i]
for j in res:
print(j)
HJ72 百钱买百鸡问题
描述
公元五世纪，我国古代数学家张丘建在《算经》一书中提出了“百鸡问题”：鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱一。百钱买百鸡，问鸡翁、鸡母、鸡雏各几何？
现要求你打印出所有花一百元买一百只鸡的方式。
输入描述：
输入任何一个整数，即可运行程序。
输出描述：
输出有数行，每行三个整数，分别代表鸡翁，母鸡，鸡雏的数量
示例1
输入：
1
输出：
0 25 75
4 18 78
8 11 81
12 4 84思路：
- 题目翻译之后的意思是，公鸡一只5元，母鸡一只3元，小鸡三只1元
- 用100元买100只鸡，给出所有的购买方案
实现代码：
while True:
try:
n = int(input())
for i in range(21):
for j in range(34):
for k in range(101):
if 5*i + 3*j + 1*k/3 == 100 and i + j + k == 100:
print(i, j, k)
except:
break
HJ76 尼科彻斯定理
描述
验证尼科彻斯定理，即：任何一个整数m的立方都可以写成m个连续奇数之和。
例如：
1^3=1
2^3=3+5
3^3=7+9+11
4^3=13+15+17+19
输入一个正整数m（m≤100），将m的立方写成m个连续奇数之和的形式输出。
数据范围：1≤�≤100 1≤m≤100
进阶：时间复杂度：�(�) O(m) ，空间复杂度：�(1) O(1)
输入描述：
输入一个int整数
输出描述：
输出分解后的string
示例1
输入：
6
输出：
31+33+35+37+39+41实现代码：
n = int(input())
for i in range(n*n*n):
if(n*i + n*(n-1) == n*n*n):#连续的n个奇数相加：i+(i+2)+...+(i+(n-1)*2) = n*i + n(n-1)
print(i, end='')
for j in range(1,n):#相等开始输出连续n-1个数字
print('+' + str(i + 2*j), end='')HJ80 整型数组合并
描述
题目标题：
将两个整型数组按照升序合并，并且过滤掉重复数组元素。
输出时相邻两数之间没有空格。
输入描述：
输入说明，按下列顺序输入：
1 输入第一个数组的个数
2 输入第一个数组的数值
3 输入第二个数组的个数
4 输入第二个数组的数值
输出描述：
输出合并之后的数组
示例1
输入：
3
1 2 5
4
-1 0 3 2
输出：
-101235实现代码：
n1 = int(input())
num1 = list(map(int, input().split()))
n2 = int(input())
num2 = list(map(int, input().split()))
res = set(num1 + num2)
res = sorted(res)
for i in res:
print(i, end="")
HJ91 走方格的方案数
描述
请计算n*m的棋盘格子（n为横向的格子数，m为竖向的格子数）从棋盘左上角出发沿着边缘线从左上角走到右下角，总共有多少种走法，要求不能走回头路，即：只能往右和往下走，不能往左和往上走。
注：沿棋盘格之间的边缘线行走
数据范围： 1≤�,�≤8 1≤n,m≤8
输入描述：
输入两个正整数n和m，用空格隔开。(1≤n,m≤8)
输出描述：
输出一行结果
示例1
输入：
2 2
输出：
6
实现代码：
def fun(x,y):
if(x == 0 or y == 0):
return 1
else:
return fun(x-1, y)+fun(x, y-1)
while True:
try:
n, m = map(int, input().split())
print(fun(n, m))
except:
break
HJ108 求最小公倍数
正整数A和正整数B 的最小公倍数是指 能被A和B整除的最小的正整数值，设计一个算法，求输入A和B的最小公倍数。
数据范围：1≤�,�≤100000 1≤a,b≤100000
输入描述：
输入两个正整数A和B。
输出描述：
输出A和B的最小公倍数。
示例1
输入：
5 7
输出：
35示例2
输入：
2 4
输出：
4思路：
实现代码：
def gcd(m, n):#最大公约数
if(n == 0):
return m
else:
return gcd(n, m % n)
def lcm(a, b):#最小公倍数
return (a * b) / gcd(a, b)
while True:
try:
A , B = map(int, input().split())
print(int(lcm(A, B)))
except:
breakHJ61 放苹果
描述
把m个同样的苹果放在n个同样的盘子里，允许有的盘子空着不放，问共有多少种不同的分法？
注意：如果有7个苹果和3个盘子，（5，1，1）和（1，5，1）被视为是同一种分法。
数据范围： 0≤m≤10 ， 1≤n≤10 。
输入描述：
输入两个int整数
输出描述：
输出结果，int型
示例1
输入：
7 3
输出：
8
实现代码：
def fun(m, n):#m个苹果放入n个盘子
# 如果没有苹果了或只有1个苹果，则方案数返回1；如果只有一个盘子了，剩下的苹果必须全放盘子里，因此也只剩下一种方案
if(m == 0 or m == 1 or n == 1):
return 1
#如果盘子数量多于苹果，说明必定有n-m个盘子会空着，因此必定的事情不会影响方案数
elif(m < n ):#当苹果m的个数小于盘子个数n时，最少有n-m空盘子，这些空盘子对结果没有影响，所在只要在意如何把m个苹果放入m个盘子里
return fun(m, m)
#如果苹果多，则要考虑盘子中是否要放苹果，如果空一个，则要递归(m,n-1)；如果不空，则相当于所有盘子都要放至少一个苹果，这个条件等价于所有盘子都少掉一个苹果的方案数
else:#当苹果m的个数超过盘子个数n时，分盘子有空的和盘子放满两种情况
return fun(m, n-1) + fun(m-n, n)
while True:
try:
m, n = map(int, input().split())
print(fun(m, n))
except:
break2、中等题
HJ26 字符串排序
描述
编写一个程序，将输入字符串中的字符按如下规则排序。
规则 1 ：英文字母从 A 到 Z 排列，不区分大小写。
如，输入： Type 输出： epTy
规则 2 ：同一个英文字母的大小写同时存在时，按照输入顺序排列。
如，输入： BabA 输出： aABb
规则 3 ：非英文字母的其它字符保持原来的位置。
如，输入： By?e 输出： Be?y
数据范围：输入的字符串长度满足 1≤�≤1000 1≤n≤1000
输入描述：
输入字符串
输出描述：
输出字符串
示例1
输入：
A Famous Saying: Much Ado About Nothing (2012/8).
输出：
A aaAAbc dFgghh: iimM nNn oooos Sttuuuy (2012/8).实现代码：
s = input()
s_char = []
res = ''
for i in s:#先筛选出来字母字符
if(i.isalpha()):
s_char.append(i)
# s_char.sort(key=lambda x: x.upper())
s_char.sort(key=lambda x:x.lower())#全转成小写再排序
j = 0
for i in s:
if(i.isalpha()):
res += s_char[j]
j += 1
else:
res += i
print(res)HJ92 在字符串中找出连续最长的数字串
描述
输入一个字符串，返回其最长的数字子串，以及其长度。若有多个最长的数字子串，则将它们全部输出（按原字符串的相对位置）
本题含有多组样例输入。
数据范围：字符串长度 1≤�≤200 1≤n≤200 ， 保证每组输入都至少含有一个数字
输入描述：
输入一个字符串。1<=len(字符串)<=200
输出描述：
输出字符串中最长的数字字符串和它的长度，中间用逗号间隔。如果有相同长度的串，则要一块儿输出（中间不要输出空格）。
示例1
输入：
abcd12345ed125ss123058789
a8a72a6a5yy98y65ee1r2
输出：
123058789,9
729865,2
说明：
样例一最长的数字子串为123058789，长度为9
样例二最长的数字子串有72,98,65，长度都为2 实现代码：
while True:
try:
s = input()
dic = {}
for i in s:
if i.isdigit() == False:
s = s.replace(i, " ")
res = s.split(" ")
for j in res:
dic[j] = len(j)
dic = sorted(dic.items(), key=lambda x: x[1], reverse=True) # 倒序排序最长的子串在第一个
maxLen = dic[0][1]
temp = ""
for k, v in dic:
if v == maxLen:
temp += k
# print(temp + "," + str(maxLen))
print(temp + ',', end='')
print(maxLen)
except:
break
