## 1. 题目描述
自守数是指一个数的平方的尾数等于该数自身的自然数。例如：25^2 = 625，76^2 = 5776，9376^2 = 87909376。请求出n(包括n)以内的自守数的个数
示例1:
```
输入：6
输出：4
说明：有0，1，5，6这四个自守数
```
## 2. Solution
```python
while True:
try:
count = 0
n = int(input())
for i in range(n+1):
res = i ** 2
if str(res).endswith(str(i)):
count += 1
print(count)
except:
break
```
## 1. 题目描述
将一个字符串中所有的整数前后加上符号“*”，其他字符保持不变。连续的数字视为一个整数。
数据范围：字符串长度满足$1 \le n \le 100 $
输入描述：输入一个字符串
输出描述：字符中所有出现的数字前后加上符号“*”，其他字符保持不变
示例1
```
输入：Jkdi234klowe90a3
输出：Jkdi*234*klowe*90*a*3*
```
## 2. Solution
```python
ss = re.sub('(\d+)', '*\g<1>*', input())
print(ss)
```
## 1. 题目描述
请计算n*m的棋盘格子（n为横向的格子数，m为竖向的格子数）从棋盘左上角出发沿着边缘线从左上角走到右下角，总共有多少种走法，要求不能走回头路，即：只能往右和往下走，不能往左和往上走。
示例1:
```
输入：2 2
输出：6
```
## 2. Solution
```python
m, n = list(map(int, input().split()))
# print(m, n)
dp = [[1] * (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][j-1] + dp[i-1][j]
print(dp[-1][-1])
```
## 1. 题目描述
输入一个int型整数，按照从右往左的阅读顺序，返回一个不含重复数字的新的整数，保证输入的整数最后一位不是0.
示例1:
```
输入：9876673
输出：37689
```
## 2. Solution
```python
num = str(input())[::-1]
res = []
for ch in num:
if ch not in res:
res.append(ch)
print("".join(res))
```
## 1. 题目描述
求一个int类型数字对应的二进制数字中1的最大连续数，例如3的二进制为00000011，最大连续2个1
数据范围：数据组数：1\le t\le 5\1≤*t*≤5 ，1\le n\le 500000\1≤*n*≤500000
进阶：时间复杂度：O(logn)\*O*(*l**o**g**n*) ，空间复杂度：O(1)\*O*(1)
示例1:
```
输入：200
输出：2
说明：200的二进制表示是11001000，最多有2个连续的1。
```
## 2. Solution
```python
while True:
try:
x = int(input())
byte_x = bin(x)[2:]
# set去重，去掉分割出来的空值，然后按照长度进行降序排序
lists = sorted(list(set(byte_x.split('0'))), key=lambda x:len(x),reverse=True)
print(len(lists[0]))
except:
break
```
## 1. 题目描述
判断短字符串S中的所有字符是否在长字符串T中全部出现。
请注意本题有多组样例输入。
数据范围:1\le len(S),len(T)\le200\1≤*l**e**n*(*S*),*l**e**n*(*T*)≤200
进阶：时间复杂度：O(n)\*O*(*n*) ，空间复杂度：O(n)\*O*(*n*)
### 输入描述：
输入两个字符串。第一个为短字符串，第二个为长字符串。两个字符串均由小写字母组成。
### 输出描述：
如果短字符串的所有字符均在长字符串中出现过，则输出字符串"true"。否则输出字符串"false"。
示例1:
```
输入：
bc
abc
输出：true
说明：其中abc含有bc，输出"true"
```
## 2. Solution
```python
while True:
try:
s1, s2 = set(input()), set(input())
if s1 & s2 == s1:
print('true')
else:
print('false')
except:
break
```
## 1. 题目描述
将两个整型数组按照升序合并，并且过滤掉重复数组元素。
输出时相邻两数之间没有空格。
示例1:
```
输入：
3
1 2 5
4
-1 0 3 2
输出：-101235
```
## 2. Solution
```python
while True:
try:
m, nums1, n, nums2 = input(), input().split(), input(), input().split()
s = map(str, sorted(map(int, set(nums1+nums2))))
print("".join(s))
except:
break
```
## 1. 题目描述
数据表记录包含表索引index和数值value，请对表索引相同的记录进行合并，即将相同索引的数值进行求和运算，输出按照index值升序进行输出。
示例1:
```
输入:
s4
0 1
0 2
1 2
3 4
输出：
0 3
1 2
3 4
```
## 2. Solution
```python
n = int(input())
dic = {}
for i in range(n):
line = input().split(' ')
key, value = int(line[0]), int(line[1])
dic[key] = dic.get(key, 0) + value
for each in sorted(dic):
print(each, dic[each])
## 1.题目描述
给定两个只包含小写字母的字符串，计算两个字符串的最大公共子串的长度。
注：子串的定义指一个字符串删掉其部分前缀和后缀（也可以不删）后形成的字符串。
示例1:
```
输入：
asdfas
werasdfaswer
输出：6
```
## 2. Solution
```python
s1, s2 = input(), input()
m, n = len(s1)+1, len(s2)+1
# print(s1, s2, m ,n)
dp = [[0] * (n) for _ in range(m)]
max_len = 0
for i in range(1, m):
for j in range(1, n):
if s1[i-1] == s2[j-1]:
dp[i][j] = dp[i-1][j-1] + 1
if max_len < dp[i][j]:
max_len = dp[i][j]
print(max_len)
```
## 1. 题目描述
根据输入的日期，计算是这一年的第几天。
保证年份为4位数且日期合法。
进阶：时间复杂度：O(n)\*O*(*n*) ，空间复杂度：O(1)\*O*(1)
### 输入描述：
输入一行，每行空格分割，分别是年，月，日
### 输出描述：
输出是这一年的第几天
示例1:
```
输入：2012 12 31
输出：366
```
## 2. Solution
```python
maps = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
maps2 = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
while True:
try:
date = list(map(int, input().split()))
year, month, day = date[0], date[1], date[2]
# 计算闰年的方式
if (year % 4 == 0 and year % 100 != 0) or year % 400 == 0:
res = sum(maps2[:month-1]) + day
else:
res = sum(maps[:month-1]) + day
print(res)
except:
break
```
## 1. 题目描述
公元五世纪，我国古代数学家张丘建在《算经》一书中提出了“百鸡问题”：鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱一。百钱买百鸡，问鸡翁、鸡母、鸡雏各几何？
现要求你打印出所有花一百元买一百只鸡的方式。
示例1:
```
输入：1
输出：
0 25 75
4 18 78
8 11 81
12 4 84
```
## 2. Solution
```python
a = input()
for i in range(100):
for j in range(100-i):
if 5 * i + 3 * j+ (100-i-j)/3 == 100:
print(i, j, 100-i-j)
```
## 1. 题目描述
接受一个正浮点数，输出该数值的近似整数值，如果小数点后数值大于等于0.5，向上取整；小于0.5则向下取整。
示例1:
```
输入：5.4
输出：6
```
示例2:
```
输入：5.4
输出：5
```
## 2. Solution
```python
n = float(input())
y = lambda x: int(x+0.5)
print(y(n))
```
## 3. Solution2
```python
def func(n):
a = int(n+0.5)
return a
b = float(input())
print(func(b))
```
## 1. 题目描述
如果A是个x行y列的矩阵，B是个y行z列的矩阵，把A和B相乘，其结果将是另一个x行z列的矩阵C。这个矩阵的每个元素是由下面的公式决定的
)
矩阵的大小不超过100*100
### 输入描述：
第一行包含一个正整数x，代表第一个矩阵的行数
第二行包含一个正整数y，代表第一个矩阵的列数和第二个矩阵的行数
第三行包含一个正整数z，代表第二个矩阵的列数
之后x行，每行y个整数，代表第一个矩阵的值
之后y行，每行z个整数，代表第二个矩阵的值
示例1:
```
输入：
2
3
2
1 2 3
3 2 1
1 2
2 1
3 3
输出：
14 13
10 11
说明：
1 2 3
3 2 1
乘以
1 2
2 1
3 3
等于
14 13
10 11
```
## 2. Solution
```python
while True:
try:
x = int(input())
y = int(input())
z = int(input())
A, B = [] ,[]
for i in range(x):
A.append(list(map(int, input().split())))
for j in range(y):
B.append(list(map(int, input().split())))
R = [[0 for k in range(z)] for i in range(x)]
for i in range(x):
for k in range(z):
for j in range(y):
R[i][k] += A[i][j] * B[j][k]
for i in range(x):
for k in range(z):
print(R[i][k], end=' ')
print()
except:
break
```
## 1.题目描述
给定一些同学的信息（名字，成绩）序列，请你将他们的信息按照成绩从高到低或从低到高的排列,相同成绩
都按先录入排列在前的规则处理。
例示：
jack 70
peter 96
Tom 70
smith 67
从高到低 成绩
peter 96
jack 70
Tom 70
smith 67
从低到高
smith 67
jack 70
Tom 70
peter 96
示例1:
```
输入：
3
0
fang 90
yang 50
ning 70
输出：
fang 90
ning 70
yang 50
```
## 2. Solution
```python
while True:
try:
n = int(input())
if input() == '0':
flag = True
else:
flag = False
ls = []
for i in range(n):
name, score = input().split()
ls.append((name, int(score)))
ls.sort(key=lambda x:x[1], reverse=flag)
for x in ls:
print(*x)
except:
break
```
## 1.题目描述
给出4个1-10的数字，通过加减乘除运算，得到数字为24就算胜利,除法指实数除法运算,运算符仅允许出现在两个数字之间,本题对数字选取顺序无要求，但每个数字仅允许使用一次，且需考虑括号运算
此题允许数字重复，如3 3 4 4为合法输入，此输入一共有两个3，但是每个数字只允许使用一次，则运算过程中两个3都被选取并进行对应的计算操作。
示例1:
```
输入：7 2 1 10
输出：true
```
## 2. Solution
```python
def helper(arr, item):
if len(arr) == 1:
return arr[0] == item
else:
for i in range(len(arr)):
m = arr[:i] + arr[i+1:]
n = arr[i]
if helper(m, item+n) or helper(m, item-n) or helper(m, item *n) or helper(m, item/n):
return True
return False
while True:
try:
if helper(list(map(int, input().split())), 24):
print('true')
else:
print('false')
except:
break
```
## 1. 题目描述
有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 |
为了简化输入，方便用户，以“最短唯一匹配原则”匹配（注：需从首字母开始进行匹配）：
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”
示例1:
```
输入：
reset
reset board
board add
board delet
reboot backplane
backplane abort
输出：
reset what
board fault
where to add
no board at all
impossible
install first
```
## 2. Solution
```python
import re
dic = {'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'
}
while True:
try:
res = []
s = input().split(' ')
for key, value in dic.items():
keyName = re.split(' ', key)
if len(s) == 1 and len(keyName) == 1:
if s[0] == keyName[0][:len(s[0])]:
res.append(value)
elif len(s) == 2 and len(keyName) == 2:
if s[0] == keyName[0][:len(s[0])] and s[1] == keyName[1][:len(s[1])]:
res.append(value)
if len(res) == 1:
print(res[0])
else:
print('unknown command')
except:
break
```
## 1. 题目描述
查找两个字符串a,b中的最长公共子串。若有多个，输出在较短串中最先出现的那个。
注：子串的定义：将一个字符串删去前缀和后缀（也可以不删）形成的字符串。请和“子序列”的概念分开！
示例1:
```
输入：
abcdefghijklmnop
abcsafjklmnopqrstuvw
输出：jklmnop
```
## 2. Solution
```python
while True:
try:
a, b = input(), input()
if len(a) > len(b):
a, b = b, a
res = ''
for i in range(0, len(a)):
for j in range(i+1, len(a)):
if a[i:j+1] in b and j-i+1 > len(res):
res = a[i:j+1]
print(res)
except:
break
```
## 1.题目描述
MP3 Player因为屏幕较小，显示歌曲列表的时候每屏只能显示几首歌曲，用户要通过上下键才能浏览所有的歌曲。为了简化处理，假设每屏只能显示4首歌曲，光标初始的位置为第1首歌。
现在要实现通过上下键控制光标移动来浏览歌曲列表，控制逻辑如下：
1. 歌曲总数<=4的时候，不需要翻页，只是挪动光标位置。
光标在第一首歌曲上时，按Up键光标挪到最后一首歌曲；光标在最后一首歌曲时，按Down键光标挪到第一首歌曲。
示例1:
```
输入：
10
UUUU
输出：
7 8 9 10
7
```
## 2. Solution
```python
mapping = {'U': -1, 'D': 1}
def run(n, seq):
index = 0
start, end = index, index+4
for s in seq:
index = index + mapping[s]
if index < 0:
index += n
start, end = max(n-4, 0), n
elif index >= n:
index -= n
start, end = 0, 4
if index < start:
start -= 1
end -= 1
elif index >= end:
start += 1
end += 1
window = list(range(start+1, end+1))
return window, index+1
n = int(input())
seq = input().strip()
a, b = run(n, seq)
print(" ".join(list(map(str, a))))
print(b)
```
## 1. 题目描述
一个 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 等等
示例1:
```
输入：
ACGT
2
输出：CG
说明：ACGT长度为2的子串有AC,CG,GT3个，其中AC和GT2个的GC-Ratio都为0.5，CG为1，故输出CG
```
## 2. 思路
巧用count()函数：str.count(sub, start=0, end=len(string))
sub为搜索的子字符串，start为字符串开始搜索的位置，end为字符串中结束搜索的位置
## 3. Solution
```python
while True:
try:
DNA = input()
length = int(input())
max_counts = 0
max_DNA = []
for i in range(len(DNA) - length + 1):
GC_counts = DNA.count('G', i, i+length) + DNA.count('C', i, i+length)
if GC_counts > max_counts:
max_counts = GC_counts
max_DNA = DNA[i:i+length]
print(max_DNA)
except:
break
```
## 1. 题目描述
把m个**同样**的苹果放在n个**同样**的盘子里，允许有的盘子空着不放，问共有多少种不同的分法？
注意：如果有7个苹果和3个盘子，（5，1，1）和（1，5，1）被视为是同一种分法。
示例1:
```
输入：7 3
输出：8
```
## 2. 思路（递归）
设f(m,n) 为m个苹果，n个盘子的放法数目，则先对n作讨论，
当n>m：必定有n-m个盘子永远空着，去掉它们对摆放苹果方法数目不产生影响。即if(n>m) f(m,n) = f(m,m)
当n<=m：不同的放法可以分成两类：
1、有至少一个盘子空着，即相当于`f(m,n) = f(m,n-1)`;
2、所有盘子都有苹果，相当于可以从每个盘子中拿掉一个苹果，不影响不同放法的数目，即`f(m,n) = f(m-n,n)`.
而总的放苹果的放法数目等于两者的和，即` f(m,n) =f(m,n-1)+f(m-n,n)`
递归出口条件说明：
当n=1时，所有苹果都必须放在一个盘子里，所以返回１；
当没有苹果可放时，定义为１种放法；
递归的两条路，第一条n会逐渐减少，终会到达出口`n==1`;
第二条m会逐渐减少，因为`n>m`时，我们会`return f(m,m)` 所以终会到达出口`m==0`．
## 3. Solution
```python
def count(m, n):
if m == 0 or n == 1:
return 1
elif n > m:
return count(m, m)
else:
return count(m, n-1) + count(m-n, n)
while True:
try:
apple, disk = list(map(int, input().split()))
print(count(apple, disk))
except:
break
```
## 1. 题目描述
任意一个偶数（大于2）都可以由2个素数组成，组成偶数的2个素数有很多种情况，本题目要求输出组成指定偶数的两个素数差值最小的素数对。
示例1:
```
输入：20
输出：7
13
```
## 2. Solution
```python
def judge(n):
for i in range(2, n):
if n % i == 0:
return False
return True
while True:
try:
n = int(input())
Min, pair = n, tuple()
for i in range(1, n):
j = n - i
if judge(i) and judge(j):
if abs(i-j) < Min:
pair = i, j
Min = abs(i-j)
print(pair[0])
print(pair[1])
except:
break
```
## 1. 题目描述
功能：输入一个正整数，按照从大到小的顺序输出它的所有质因子（重复的也要列举）
输入描述：输入一个整数
输出描述：按照从小到大的顺序输出它的所有质数的因子，以空格隔开
示例：
```
输入：180
输出：2 2 3 3 5
```
## 2. Solution
```python
import math
n = int(input())
for i in range(2, int(math.sqrt(n))+1):
if n % i == 0:
# end = ' '表示以空格隔开
print(i, end=' ')
n //= i
# 如果上面这个for循环没能够输出，则证明这个数本身就是一个质数，直接输出即可
if n > 2:
print(n)
```
## 1. 题目描述
完全数（Perfect number），又称完美数或完备数，是一些特殊的自然数。
它所有的真因子（即除了自身以外的约数）的和（即因子函数），恰好等于它本身。
例如：28，它有约数1、2、4、7、14、28，除去它本身28外，其余5个数相加，1+2+4+7+14=28。
输入n，请输出n以内(含n)完全数的个数。
示例1:
```
输入：1000
输出：3
```
## 2. Solution
```python
while True:
try:
n = int(input())
L = []
for i in range(1, n):
p = 0
for y in range(1, i):
if i % y == 0:
p += y
if i == p:
L.append(p)
print(len(L))
except:
break
```
## 1.题目描述
输出 1到n之间 的与 7 有关数字的个数。
一个数与7有关是指这个数是 7 的倍数，或者是包含 7 的数字（如 17 ，27 ，37 ... 70 ，71 ，72 ，73...）
示例1:
```
输入：20
输出：3
说明：输入20，1到20之间有关的数字包括7,14,17共3个
```
## 2. Solution
```python
while True:
try:
count = 0
n = int(input())
# 注意这个range的范围
for i in range(1, n+1):
if '7' in str(i) or i % 7 == 0:
count += 1
print(count)
except:
break
```
## 1. 题目描述
以上三角形的数阵，第一行只有一个数1，以下每行的每个数，是恰好是它上面的数、左上角数和右上角的数，3个数之和（如果不存在某个数，认为该数就是0）。
求第n行第一个偶数出现的位置。如果没有偶数，则输出-1。例如输入3,则输出2，输入4则输出3，输入2则输出-1。
示例1:
```
输入：4
输出：3
```
## 2. Solution
````python
while True:
try:
x = int(input())
if x == 1 or x == 2:
print(-1)
elif x % 2 == 1:
print(2)
elif x % 4 == 0:
print(3)
elif (x-2)% 4 == 0:
print(4)
except:
break
````
## 1. 题目描述
Levenshtein 距离，又称编辑距离，指的是两个字符串之间，由一个转换成另一个所需的最少编辑操作次数。许可的编辑操作包括**将一个字符替换成另一个字符，插入一个字符，删除一个字符**。编辑距离的算法是首先由俄国科学家 Levenshtein 提出的，故又叫 Levenshtein Distance 。
例如：
字符串A: abcdefg
字符串B: abcdef
通过增加或是删掉字符 ”g” 的方式达到目的。这两种方案都需要一次操作。把这个操作所需要的次数定义为两个字符串的距离。
要求：
给定任意两个字符串，写出一个算法计算它们的编辑距离。
示例：
```
输入：
abcdefg
abcdef
输出：1
```
## 2. Solution
```python
while True:
try:
word1, word2 = input(), input()
m, n = len(word1), len(word2)
dp = [[0] * (n+1) for _ in range(m+1)]
for i in range(1, m+1):
dp[i][0] = i
for j in range(1, n+1):
dp[0][j] = j
for i in range(1, m+1):
for j in range(1, n+1):
if word1[i-1] == word2[j-1]:
dp[i][j] = dp[i-1][j-1]
else:
dp[i][j] = min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1])+1
print(dp[-1][-1])
except:
break
```
## 1. 题目描述
输入一个单向链表，输出该链表中倒数第k个结点，链表的倒数第1个结点为链表的尾指针。
示例1:
```
输入：8
1 2 3 4 5 6 7 8
4
输出：5
```
## 2. Solution
```python
class ListNode:
def __init__(self, x):
self.val = x
self.next = None
while True:
try:
head = ListNode(-1)
count, num_list, k = int(input()), list(map(int, input().split())), int(input())
while k:
head.next = ListNode(num_list.pop())
head = head.next
k -= 1
print(head.val)
except:
break
```
## 1. 题目描述
写出一个程序，接受一个十六进制的数，输出该数值的十进制表示。
示例：
```
输入：0xAA
输出：170
```
## 2. Solution
```python
while True:
try:
input = input()
# int()函数，第一个参数为字符串，第二个参数为这个字符串是几进制的
print(int(input, 16))
except:
break
```
## 1.题目描述
输入一个单向链表和一个节点的值，从单向链表中删除等于该值的节点，删除后如果链表中无节点则返回空指针。
链表的值不能重复。
构造过程，例如输入一行数据为:
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
示例1:
```
输入：5 2 3 2 4 3 5 2 1 4 3
输出：2 5 4 1
说明：形成的链表为2->5->3->4->1
删掉节点3，返回的就是2->5->4->1
```
## 2. Solution
```python
while True:
try:
data = input().split()
head = data[1]
elements = data[2:-1]
delete = data[-1]
res = [head]
for i in range(0, len(elements), 2):
# element[i]是要插入的值
# element[i+1]是要插入的值的前一个值
value = elements[i]
index = res.index(elements[i+1]) + 1
res.insert(index, value)
res.remove(delete)
print(' '.join(res))
except:
break
```
## 1. 题目描述
输入一个字符串和一个整数k，截取字符串的前k个字符并输出
## 2. Solution
```python
x = input()
y = int(input())
print(x[:y])
```
## 1. 题目描述
输入一行字符，分别统计出包含英文字母、空格、数字和其它字符的个数。
数据范围：输入的字符串长度满足 1 \le n \le 1000 \1≤*n*≤1000
示例1:
```
输入：1qazxsw23 edcvfr45tgbn hy67uj m,ki89ol.\\/;p0-=\\][
输出：
26
3
10
12
```
## 2. Solution
```python
a = b = c = d = 0
while True:
try:
s = input().strip()
for ch in s:
if ch.isalpha():
a += 1
elif ch == ' ':
b += 1
elif ch.isnumeric():
c += 1
else:
d += 1
print(f"{a}\n{b}\n{c}\n{d}")
except:
break
```
## 1. 题目描述
+ 输入一个字符串，请按长度为8拆分每个输入字符串并进行输出；
+ 长度不是8整数倍的字符串，请在后面补数字0，空字符串不处理
输入描述：连续输入字符串（每个字符串长度小于等于100）
输出描述：依次输出所有分割后的长度为8的新字符串
示例：
```
输入：abc
输出：abc00000
```
## 2. Solution
```python
while True:
try:
strs = input()
length = len(strs)
for i in range(0, length, 8):
# print("{0:0<8s}".format(strs[i:i+8]))
# format中的`<`表示左对齐，`:0`表示不足以0作为填充，数字8表示最长长度为8
print("{:0<8}".format(strs[i:i+8]))
except:
break
```
## 1. 题目描述
有一种兔子，从出生后第3个月起每个月都生一只兔子，小兔子长到第三个月后每个月又生一只兔子。
例子：假设一只兔子第3个月出生，那么它第5个月开始会每个月生一只兔子。
一月的时候有一只兔子，假如兔子都不死，问第n个月的兔子总数为多少？
> 实际上，这题是递归问题，斐波那契数列问题
示例1:
```
输入：3
输出：2
```
## 2. Solution
```python
while True:
try:
month = int(input())
n = month - 1
def func(n):
if n < 2:
return 1
else:
return func(n-1) + func(n-2)
print(func(n))
except:
break
```
## 1.题目描述
有一种技巧可以对数据进行加密，它使用一个单词作为它的密匙。下面是它的工作原理：首先，选择一个单词作为密匙，如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。
请实现下述接口，通过指定的密匙和明文得到密文。
## 2. Solution
```python
def strings_passwd(key,strings):
a = 'abcdefghijklmnopqrstuvwxyz'
a = [_ for _ in a]
d = a[:]
b = set(key)
# 这里使用sorted排序，是因为set去重后，原有的顺序被打乱了，需要通过sorted(b, key=key.index)来恢复原来的顺序（去重后的）
c = list(sorted(b,key=key.index))
# print(c)
for i in c :
d.remove(i)
e = c + d
f = []
for i in strings:
f.append(e[a.index(i)])
return ''.join(_ for _ in f)
key = input().strip()
strings = input().strip()
print(strings_passwd(key,strings))
```
## 1. 题目描述
蛇形矩阵是由1开始的自然数依次排列成的一个矩阵上三角形。
例如，当输入5时，应该输出的三角形为：
1 3 6 10 15
2 5 9 14
4 8 13
7 12
11
## 2. Solution
```python
n = int(input().strip())
for i in range(1, n+1):
for j in range(i, n+1):
print(int(((j+j**2)/2)-i+1),end=' ')
print()
```
## 1.题目描述
Lily上课时使用字母数字图片教小朋友们学习英语单词，每次都需要把这些图片按照大小（ASCII码值从小到大）排列收好。请大家给Lily帮忙，通过代码解决。
Lily使用的图片使用字符"A"到"Z"、"a"到"z"、"0"到"9"表示。
示例1:
```
输入：Ihave1nose2hands10fingers
输出：0112Iaadeeefghhinnnorsssv
```
## 2. Solution
```python
print("".join(sorted(input())))
```
## 1. 题目描述
Catcher是MCA国的情报员，他工作时发现敌国会用一些对称的密码进行通信，比如像这些ABBA，ABA，A，123321，但是他们有时会在开始或结束时加入一些无关的字符以防止别国破解。比如进行下列变化 ABBA->12ABBA,ABA->ABAKK,123321->51233214 。因为截获的串太长了，而且存在多种可能的情况（abaaab可看作是aba,或baaab的加密形式），Cathcer的工作量实在是太大了，他只能向电脑高手求助，你能帮Catcher找出最长的有效密码串吗？
> 这题实质上就是求最长回文串的长度
示例1:
```
输入： ABBA
输出： 4
```
## 2. Solution
```python
while True:
try:
s = input()
def palindrome(s, l, r):
while l >= 0 and r < len(s) and s[l] == s[r]:
l -= 1
r += 1
return s[l+1:r]
res = 0
for i in range(len(s)):
s1 = palindrome(s, i, i)
s2 = palindrome(s, i, i+1)
res = res if res > len(s1) else len(s1)
res = res if res > len(s2) else len(s2)
print(res)
except:
break
```
## 1. 题目描述
对字符串中的所有单词进行倒排。
说明：
1、构成单词的字符只有26个大写或小写英文字母；
2、非构成单词的字符均视为单词间隔符；
3、要求倒排后的单词间隔符以一个空格表示；如果原字符串中相邻单词间有多个间隔符时，倒排转换后也只允许出现一个空格间隔符；
4、每个单词最长20个字母；
示例1:
```
输入：$bo*y gi!r#l
输出：l r gi y bo
```
## 2. Solution
```python
s = input()
res = ""
for i in s:
if i.isalnum():
res += i
else:
res += ' '
res = res.lstrip().split()
print(" ".join(res[::-1]))
```
## 1. 题目描述
明明生成了N个1到500之间的随机整数，请你删去其中重复的数字，即相同的数字只保留一个，把其余相同的数去掉，然后再把这些数从小到大排序，按照排好的顺序输出。
输入描述：
第一行先输入随机整数的个数N。接下来的N行每行输入一个整数，代表明明生成的随机数。
示例：
```
输入：3
2
2
1
输出：1
2
说明：输入解释：第一个数字3，即这个小样例的个数为N=3，说明用计算机生成了3个1到500之间的随机整数，接下来每行一个随机数字，共3行，也即这3个随机数字为：2、2、1.
```
## 2. Solution
```python
while True:
try:
n = input()
res = []
for i in range(int(n)):
res.append(int(input()))
unique = list(set(res))
unique.sort()
for i in unique:
print(i)
except:
break
```
## 1. 题目描述
对输入的字符串进行加解密，并输出。
加密方法为：
当内容是英文字母时则用该英文字母的后一个字母替换，同时字母变换大小写,如字母a时则替换为B；字母Z时则替换为a；
当内容是数字时则把该数字加1，如0替换1，1替换2，9替换0；
其他字符不做变化。
解密方法为加密的逆过程。
示例1:
```
输入：
abcdefg
BCDEFGH
输出：
BCDEFGH
abcdefg
```
## 2. Solution
```python
def check(a, b):
L1 = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
L2 = "BCDEFGHIJKLMNOPQRSTUVWXYZAbcdefghijklmnopqrstuvwxyza1234567890"
res = ""
if b == 1:
for i in a:
res += L2[L1.index(i)]
elif b == -1:
for i in a:
res += L1[L2.index(i)]
return res
while True:
try:
print(check(input(), 1))
print(check(input(), -1))
except:
break
```
## 1. 题目描述
定义一个单词的“兄弟单词”为：交换该单词字母顺序（注：可以交换任意次），而不添加、删除、修改原有的字母就能生成的单词。
兄弟单词要求和原来的单词不同。例如： ab 和 ba 是兄弟单词。 ab 和 ab 则不是兄弟单词。
现在给定你 n 个单词，另外再给你一个单词 x ，让你寻找 x 的兄弟单词里，按字典序排列后的第 k 个单词是什么？
注意：字典中可能有重复单词。
示例1:
```
输入：6 cab ad abcd cba abc bca abc 1
输出：3
bca
说明：abc的兄弟单词有cab cba bca，所以输出3
经字典序排列后，变为bca cab cba，所以第1个字典序兄弟单词为bca
```
## 2. Solution
```python
while True:
try:
s = input().split()
n, words, pattern, k = s[0], s[1:-2], s[-2], int(s[-1])
count = 0
res = []
for w in words:
# 不要使用set()函数，而是要使用sorted()函数
if sorted(w) == sorted(pattern) and w != pattern:
count += 1
res.append(w)
print(count)
sorted_words = sorted(res)
print(sorted_words[k-1])
except:
break
```
## 1. 题目描述
编写一个程序，将输入字符串中的字符按如下规则排序。
规则 1 ：英文字母从 A 到 Z 排列，不区分大小写。
如，输入： Type 输出： epTy
规则 2 ：同一个英文字母的大小写同时存在时，按照输入顺序排列。
如，输入： BabA 输出： aABb
规则 3 ：非英文字母的其它字符保持原来的位置。
如，输入： By?e 输出： Be?y
示例1:
```
输入：A Famous Saying: Much Ado About Nothing (2012/8).
输出：A aaAAbc dFgghh: iimM nNn oooos Sttuuuy (2012/8).
```
## 2. Solution
```python
while True:
try:
letter = input()
letter_list = sorted([i for i in letter if i.isalpha()], key=lambda x:x.lower())
res = ""
index = 0
for i in range(len(letter)):
if letter[i].isalpha():
res += letter_list[index]
index += 1
else:
res += letter[i]
print(res)
except:
break
```
## 1. 题目描述
一组输入整数序列I和一组规则整数序列R，I和R序列的第一个整数为序列的个数（个数不包含第一个整数）；整数范围为0~(2^31)-1，序列个数不限
### 输出描述：
从R依次中取出R<i>，对I进行处理，找到满足条件的I：
I整数对应的数字需要连续包含R<i>对应的数字。比如R<i>为23，I为231，那么I包含了R<i>，条件满足 。
按R<i>从小到大的顺序:
(1)先输出R<i>；
(2)再输出满足条件的I的个数；
(3)然后输出满足条件的I在I序列中的位置索引(从0开始)；
(4)最后再输出I。
附加条件：
(1)R<i>需要从小到大排序。相同的R<i>只需要输出索引小的以及满足条件的I，索引大的需要过滤掉
(2)如果没有满足条件的I，对应的R<i>不用输出
(3)最后需要在输出序列的第一个整数位置记录后续整数序列的个数(不包含“个数”本身)
示例：
```
输入：
15 123 456 786 453 46 7 5 3 665 453456 745 456 786 453 123
5 6 3 6 3 0
输出：
30 3 6 0 123 3 453 7 3 9 453456 13 453 14 123 6 7 1 456 2 786 4 46 8 665 9 453456 11 456 12 786
说明：
将序列R：5,6,3,6,3,0（第一个5表明后续有5个整数）排序去重后，可得0,3,6。
序列I没有包含0的元素。
序列I中包含3的元素有：I[0]的值为123、I[3]的值为453、I[7]的值为3、I[9]的值为453456、I[13]的值为453、I[14]的值为123。
序列I中包含6的元素有：I[1]的值为456、I[2]的值为786、I[4]的值为46、I[8]的值为665、I[9]的值为453456、I[11]的值为456、I[12]的值为786。
最后按题目要求的格式进行输出即可。
```
## 2. Solution
```python
while True:
try:
a = input().split()[1:]
# split() --> set去重 --> int化 --> sorted排序 --> str字符化
b = map(str, sorted(map(int, set(input().split()[1:]))))
totalNum = 0
res = ''
for num in b:
singleRes, count = "", 0
for i, v in enumerate(a):
if num in v:
singleRes += str(i) + " " + v + " "
# 这里加2
totalNum += 2
count += 1
if count:
singleRes = num + " " + str(count) + " " + singleRes
totalNum += 2
res += singleRes
print((str(totalNum) + " " + res).rstrip())
except:
break
```
## 1. 题目描述
N 位同学站成一排，音乐老师要请最少的同学出列，使得剩下的 K 位同学排成合唱队形。
设K*K*位同学从左到右依次编号为 1，2…，K ，他们的身高分别为T_1,T_2,…,T_K*T*1,*T*2,…,*T**K* ，若存在i(1\leq i\leq K)*i*(1≤*i*≤*K*) 使得T_1<T_2<......<T_{i-1}<T_i*T*1<*T*2<......<*T**i*−1<*T**i* 且 T_i>T_{i+1}>......>T_K*T**i*>*T**i*+1>......>*T**K*，则称这K*K*名同学排成了合唱队形。
通俗来说，能找到一个同学，他的两边的同学身高都依次严格降低的队形就是合唱队形。
例子：
123 124 125 123 121 是一个合唱队形
123 123 124 122不是合唱队形，因为前两名同学身高相等，不符合要求
123 122 121 122不是合唱队形，因为找不到一个同学，他的两侧同学身高递减。
你的任务是，已知所有N位同学的身高，计算最少需要几位同学出列，可以使得剩下的同学排成合唱队形。
示例1:
```
输入：
8
186 186 150 200 160 130 197 200
输出：4
说明：由于不允许改变队列元素的先后顺序，所以最终剩下的队列应该为186 200 160 130或150 200 160 130
```
## 2. Solution
```python
# 动态规划
def lengthOfLIS(lst):
dp = [1] * len(lst)
for i in range(len(lst)):
for j in range(i):
if lst[i] > lst[j]:
dp[i] = max(dp[i], dp[j] + 1)
return dp # 每人左边可以站的人数
while True:
try:
n, heights = int(input()), list(map(int, input().split()))
# dp1:每人左边可以站的人数，dp2:每人右边可以站的人数
dp1, dp2 = lengthOfLIS(heights), lengthOfLIS(heights[::-1])[::-1]
# 这里要使用zip()，不然速度上可能过不去
print(n - max(i+j-1 for i, j in zip(dp1, dp2)))
except:
break
```
## 1. 题目描述
删除字符串中出现次数最少的字符，若出现次数最少的字符为多个，则把出现次数最少的字符都删除。输出删除这些单词后的字符串。
示例1:
```
输入：aabcddd
输出：aaddd
```
## 2. Solution
```python
while True:
try:
s = input()
dic, res = {}, ''
for c in s:
if c not in dic:
dic[c] = 1
else:
dic[c] += 1
# 直接利用min()函数来求字典中value的最小值
Min = min(dic.values())
for c in s:
if dic[c] != Min:
res += c
print(res)
except:
break
```
## 1.题目描述
某商店规定：三个空汽水瓶可以换一瓶汽水，允许向老板借空汽水瓶（但是必须要归还）。
小张手上有n个空汽水瓶，她想知道自己最多可以喝到多少瓶汽水。
示例1:
```
输入：
3
10
81
0
输出：
1
5
40
说明：
样例 1 解释：用三个空瓶换一瓶汽水，剩一个空瓶无法继续交换
样例 2 解释：用九个空瓶换三瓶汽水，剩四个空瓶再用三个空瓶换一瓶汽水，剩两个空瓶，向老板借一个空瓶再用三个空瓶换一瓶汽水喝完得一个空瓶还给老板
```
## 2. Solution
```python
while True:
n = int(input())
if n == 0:
break
print(n // 2)
```
## 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.
而密码中出现的大写字母则变成小写之后往后移一位，如：X ，先变成小写，再往后移一位，变成了 y ，例外：Z 往后移是 a 。
数字和其它的符号都不做变换。
示例1:
```
输入：YUANzhi1987
输出：zvbo9441987
```
## 2. Solution
```python
while True:
try:
A = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
B = '22233344455566677778889999bcdefghijklmnopqrstuvwxyza0123456789'
list1, list2 = [i for i in A], [i for i in B]
c = []
a = input()
for i in a:
# 当为字母和数字的时候，来作密码转换
if i in list1:
# 使用了index()函数，来作为映射
c.append(list2[list1.index(i)])
# 非字母和数字，则不做改变
else:
c.append(i)
print("".join(c))
except:
break
``
## 1. 题目描述
写出一个程序，接受一个由字符、数字和空格组成的字符串，和一个字符，然后输出输入字符串中该字符出现的次数。
示例：
```
输入：ABCabc
A
输出：2
```
## 2. Solution
```python
import sys
str1 = input.lower()
str2 = input.lower()
print(str1.count(str2))
## 1. 题目描述
开发一个简单错误记录功能小模块，能够记录出错的代码所在的文件名称和行号。
处理：
1、 记录最多8条错误记录，循环记录，最后只用输出最后出现的八条错误记录。对相同的错误记录只记录一条，但是**错误计数增加。最后一个斜杠后面的带后缀名的部分（保留最后16位）和行号完全匹配的记录才做算是**相同的错误记录。
2、 超过16个字符的文件名称，只记录文件的最后有效16个字符；
3、 输入的文件可能带路径，记录文件名称不能带路径。**也就是说，哪怕不同路径下的文件，如果它们的名字的后16个字符相同，也被视为相同的错误记录**
4、循环记录时，只以第一次出现的顺序为准，后面重复的不会更新它的出现时间，仍以第一次为准
示例1:
```
输入：
D:\zwtymj\xccb\ljj\cqzlyaszjvlsjmkwoqijggmybr 645
E:\je\rzuwnjvnuz 633
C:\km\tgjwpb\gy\atl 637
F:\weioj\hadd\connsh\rwyfvzsopsuiqjnr 647
E:\ns\mfwj\wqkoki\eez 648
D:\cfmwafhhgeyawnool 649
E:\czt\opwip\osnll\c 637
G:\nt\f 633
F:\fop\ywzqaop 631
F:\yay\jc\ywzqaop 631
D:\zwtymj\xccb\ljj\cqzlyaszjvlsjmkwoqijggmybr 645
输出：
rzuwnjvnuz 633 1
atl 637 1
rwyfvzsopsuiqjnr 647 1
eez 648 1
fmwafhhgeyawnool 649 1
c 637 1
f 633 1
ywzqaop 631 2
说明：
由于D:\cfmwafhhgeyawnool 649的文件名长度超过了16个字符，达到了17，所以第一个字符'c'应该被忽略。
记录F:\fop\ywzqaop 631和F:\yay\jc\ywzqaop 631由于文件名和行号相同，因此被视为同一个错误记录，哪怕它们的路径是不同的。
由于循环记录时，只以第一次出现的顺序为准，后面重复的不会更新它的出现时间，仍以第一次为准，所以D:\zwtymj\xccb\ljj\cqzlyaszjvlsjmkwoqijggmybr 645不会被记录。
```
## 2. Solution
```python
lists = []
dic = {}
while True:
try:
msg = input().split()
msg[0] = msg[0].split('\\')[-1]
# 把文件名和数字合在一起，作为dic的键
msg = ' '.join([msg[0][-16:], msg[1]])
# 判断dic的键中是否存在msg
if msg not in dic.keys():
lists.append(msg)
dic[msg] = 1
else:
dic[msg] += 1
except:
break
# 打印最后的8个
for item in lists[-8:]:
print(item, dic[item])
```
## 1. 题目描述
开发一个坐标计算工具，A表示向左移动，D表示向右移动，W表示向上移动，S表示向下移动。从`(0, 0)`点开始移动，从输入字符串里面读取一些坐标，并将最终输入结果输出到文件里面。其中坐标里面有一些非法的，例如：AA10，A1A，YAD之类。
示例1:
```
输入：A10;S20;W10;D30;X;A1A;B10A11;;A10;
输出：10,-10
```
## 2. Solution
```python
strs = input().split(';')
x, y = 0, 0
for i in strs:
# 限制长度在2和3之间
if 2 <= len(i) <= 3:
# 限制以字母开头且后面跟着的是数字
if i[0] in ['A', 'D', 'W', 'S'] and i[1:].isdigit():
if i[0] == 'A':
x -= int(i[1:])
if i[0] == 'D':
x += int(i[1:])
if i[0] == 'W':
y += int(i[1:])
if i[0] == 'S':
y -= int(i[1:])
print(f"{x},{y}")
```
## 1. 题目描述
输入一个int型正整数，计算出该int型数据在内存中存储1的个数
示例1:
```
输入：5
输出：2
```
## 2. Solution
```python
n = int(input())
print(bin(n).count('1'))
```
## 1. 题目描述
给定n个字符串，请对n个字符串按照字典序进行排列
示例1:
```
输入：
9
cap
to
cat
card
two
too
up
boat
boot
输出：
boat
boot
cap
card
cat
to
too
two
up
```
## 2. Solution
```python
n = int(input())
res = []
for i in range(n):
word = input()
res.append(word)
res = sorted(res)
for w in res:
print(w)
```
## 1. 题目描述
将一个英语语句以单词为单位逆序排放，所有单词之间用一个空格隔开。
示例1:
```
输入：I am a boy
输出：boy a am I
```
## 2. Solution
```python
words = input().split(' ')[::-1]
print(" ".join(words))
```
## 1. 题目描述
接受一个只包含小谢字母的字符串，然后输出该字符串反转后的字符串。
示例1:
```
输入：abcd
输出：dcba
```
## 2. Solution
```python
print(input()[::-1])
```
## 1. 题目描述
输入一个整数，将这个整数以字符串的形式逆序输出。
示例：
```
输入：15160000
输出：00006151
```
## 2. Solution
```python
n = input()[::-1]
print(n)
```
## 1. 题目描述
正整数A和正整数B 的最小公倍数是指 能被A和B整除的最小的正整数值，设计一个算法，求输入A和B的最小公倍数。
数据范围：1 \le a,b \le 100000 \1≤*a*,*b*≤100000
示例1:
```
输入：5 7
输出：35
```
## 2. Solution
```python
while True:
try:
a, b = list(map(int, input().split()))
if a < b:
a, b = b, a
# range范围为[a, a*b+1]间隔为a
for i in range(a, a*b+1, a):
if i % b == 0:
print(i)
break
except:
break
```
## 1.题目描述
输入 n 个整型数，统计其中的负数个数并求所有非负数的平均值，结果保留一位小数，如果没有非负数，则平均值为0
本题有多组输入数据，输入到文件末尾。
示例1:
```
输入：
-13
-4
-7
输出：
3
0.0
```
## 2. Solution
```python
l1, l2 = [], []
while True:
try:
n = int(input())
if n > 0:
l1.append(n)
if n < 0:
l2.append(n)
except:
break
print(len(l2))
if sum(l1) == 0:
print(0.0)
else:
print(round(sum(l1)/len(l1), 1))
```
## 1.题目描述
输入一个只包含小写英文字母和数字的字符串，按照不同字符统计个数由多到少输出统计结果，如果统计的个数相同，则按照ASCII码由小到大排序输出。
示例1:
```
输入：aaddccdc
输出：cda
说明：样例里，c和d出现3次，a出现2次，但c的ASCII码比d小，所以先输出c，再输出d，最后输出a.
```
## 2. Solution
```python
while True:
try:
a = input()
s = sorted(set(a))
ss = sorted(s, key=lambda x: a.count(x), reverse=True)
print(''.join(ss))
except:
break
```
## 1. 题目描述
编写一个函数，计算字符串中含有不同字符的个数。
示例1:
```
输入：abc
输出：3
```
## 2. Solution
```python
strs = input()
print(len(set(strs)))
```
## 1. 题目描述
计算字符串最后一个单词的长度，单词以空格隔开，字符串长度小于5000。（注：字符串末尾不以空格为结尾）
示例：
```
输入：hello nowcoder
输出：8
说明：最后一个单词为nowcoder，长度为8
```
## Solution
```python
import sys
str = input()
arr = str.split(" ")
print(len(arr[-1]))
```
#华为##OD##机试#
华为主管面130人在聊
查看7道真题和解析